n2words 1.23.1 → 2.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2024 Wael TELLAT
+Copyright (c) 2018-2025 Wael TELLAT
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,94 +1,352 @@
 # n2words
 
-[![CI](https://github.com/forzagreen/n2words/actions/workflows/test.yml/badge.svg)](https://github.com/forzagreen/n2words/actions/workflows/test.yml)
-[![Coverage Status](https://coveralls.io/repos/github/forzagreen/n2words/badge.svg?branch=main)](https://coveralls.io/github/forzagreen/n2words?branch=main)
-[![npm](https://img.shields.io/npm/v/n2words.svg)](https://npmjs.com/package/n2words)
-[![npm](https://img.shields.io/npm/dw/n2words)](https://npmjs.com/package/n2words)
-[![jsDelivr](https://data.jsdelivr.com/v1/package/npm/n2words/badge)](https://www.jsdelivr.com/package/npm/n2words)
+[![CI](https://github.com/forzagreen/n2words/actions/workflows/ci.yml/badge.svg)](https://github.com/forzagreen/n2words/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/coveralls/github/forzagreen/n2words)](https://coveralls.io/github/forzagreen/n2words)
+[![npm version](https://img.shields.io/npm/v/n2words)](https://npmjs.com/package/n2words)
+[![npm provenance](https://img.shields.io/badge/npm-provenance-blue)](https://www.npmjs.com/package/n2words)
+[![Bundle size](https://img.shields.io/bundlephobia/minzip/n2words)](https://bundlephobia.com/package/n2words)
+[![npm downloads](https://img.shields.io/npm/dw/n2words)](https://npmjs.com/package/n2words)
+[![jsDelivr](https://img.shields.io/jsdelivr/npm/hm/n2words)](https://www.jsdelivr.com/package/npm/n2words)
 
-__n2words__ converts numerical numbers into written ones, supports [28 languages](https://github.com/forzagreen/n2words#supported-languages), and has zero dependencies.
+**Convert numbers to words in 48 languages with zero dependencies.**
 
-## Example
+## Why n2words?
 
-```js
-n2words(123)   // 'one hundred and twenty-three'
-n2words(-1.5)  // 'minus one point five'
+- **Maximum Language Coverage** — 48 languages including European, Asian, Middle Eastern, and regional variants
+- **Zero Dependencies** — Pure JavaScript with no external runtime dependencies
+- **Universal Compatibility** — Works in Node.js, browsers (via CDN), and all modern bundlers
+- **Type-Safe** — Full TypeScript support with generated `.d.ts` declarations
+- **Production Ready** — Comprehensive test coverage (unit, integration, browser, type checking)
+- **BigInt Support** — Handle arbitrarily large numbers without precision loss
+- **Flexible Input** — Accepts `number`, `bigint`, or `string` inputs
+- **Tree-Shakable** — Import only the languages you need (~2-5 KB gzipped per language)
+- **Browser Tested** — Verified in Chromium, Firefox, and WebKit via automated tests
 
-n2words(123, {lang: 'fr'})  // 'cent vingt-trois'
-n2words(123, {lang: 'es'})  // 'ciento veintitrés'
-n2words(123, {lang: 'ar'})  // 'مائة وثلاثة وعشرون'
-```
+## Contents
 
-See the [Wiki](https://github.com/forzagreen/n2words/wiki) for examples and advanced usage like [importing only specific languages](https://github.com/forzagreen/n2words/wiki/Importing-only-specific-languages).
+- [Quick Start](#quick-start)
+- [Usage](#usage) — ESM, CommonJS, Browser (UMD)
+- [Type Safety](#type-safety) — TypeScript support
+- [Supported Languages](#supported-languages-48) — 48 languages with options
+- [Browser Compatibility](#browser-compatibility) — Chrome 67+, Firefox 68+, Safari 14+, Edge 79+
+- [Performance & Bundle Size](#performance--bundle-size) — Tree-shaking and benchmarks
+- [Examples](#examples) — Basic, gender agreement, language-specific features
+- [Documentation](#documentation) — Guides and API reference
+- [Contributing](#contributing) — How to contribute
+- [License](#license)
 
-## Install
+## Quick Start
 
-```sh
+```bash
 npm install n2words
 ```
 
+```js
+import { EnglishConverter, SpanishConverter, ArabicConverter } from 'n2words'
+
+EnglishConverter(123)                       // 'one hundred and twenty-three'
+SpanishConverter(123)                       // 'ciento veintitrés'
+ArabicConverter(1, { gender: 'feminine' })  // 'واحدة' (with options)
+```
+
 ## Usage
 
-### ESM
+**ESM (Node.js, modern bundlers):**
 
 ```js
-import n2words from 'n2words'
+import { EnglishConverter } from 'n2words'
 ```
 
-### CommonJS ([dynamic import](https://nodejs.org/api/esm.html#import-expressions))
+**CommonJS (Node.js):**
+
+n2words is an ES module. For CommonJS environments, use dynamic import with Promises:
 
 ```js
-import('n2words').then(({default: n2words}) => {
-    n2words(100)
+// Promise-based
+import('n2words').then(({ EnglishConverter }) => {
+  console.log(EnglishConverter(42))  // 'forty-two'
 })
+
+// Or use async function
+async function convertNumber(num) {
+  const { EnglishConverter } = await import('n2words')
+  return EnglishConverter(num)
+}
 ```
 
-### Browser
+**Browser (UMD via CDN):**
 
 ```html
-<script src="./n2words.js"></script>
+<!-- All languages (~23KB gzipped) -->
+<script src="https://cdn.jsdelivr.net/npm/n2words/dist/n2words.js"></script>
+<script>
+  n2words.EnglishConverter(42)  // 'forty-two'
+</script>
+
+<!-- Individual languages (~2KB gzipped each) - load only what you need -->
+<script src="https://cdn.jsdelivr.net/npm/n2words/dist/EnglishConverter.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/n2words/dist/SpanishConverter.js"></script>
 <script>
-    n2words(100)
+  n2words.EnglishConverter(42)   // 'forty-two'
+  n2words.SpanishConverter(123)  // 'ciento veintitrés'
 </script>
 ```
 
-n2words is also available on [jsDelivr](https://www.jsdelivr.com/package/npm/n2words).
-
-## Supported Languages
-
-- `en` (English, default)
-- `ar` (Arabic)
-- `az` (Azerbaijani)
-- `cz` (Czech)
-- `dk` (Danish)
-- `de` (German)
-- `es` (Spanish)
-- `fr` (French)
-- `fr-BE` (French (Belgium))
-- `fa` (Farsi)
-- `he` (Hebrew)
-- `hr` (Croatian)
-- `hu` (Hungarian)
-- `id` (Indonesian)
-- `it` (Italian)
-- `ko` (Korean)
-- `lt` (Lithuanian)
-- `lv` (Latvian)
-- `nl` (Dutch)
-- `no` (Norwegian)
-- `pl` (Polish)
-- `pt` (Portuguese)
-- `ru` (Russian)
-- `sr` (Serbian)
-- `tr` (Turkish)
-- `uk` (Ukrainian)
-- `vi` (Vietnamese)
-- `zh` (Chinese)
+## Type Safety
+
+Full TypeScript support via JSDoc annotations and generated type definitions - works in both JavaScript and TypeScript projects with IntelliSense and type checking:
+
+```typescript
+import { EnglishConverter, ArabicConverter, SimplifiedChineseConverter } from 'n2words'
+import type { NumericValue, ArabicOptions } from 'n2words'
+
+// All converters accept: number | bigint | string
+EnglishConverter(42)       // ✓ number → 'forty-two'
+EnglishConverter('123')    // ✓ string → 'one hundred and twenty-three'
+EnglishConverter(100n)     // ✓ BigInt → 'one hundred'
+
+// Language-specific options with type checking
+ArabicConverter(1, { gender: 'feminine' })  // ✓ 'واحدة' (feminine form)
+ArabicConverter(1, { invalid: true })       // ✗ TypeScript error: invalid property
+
+SimplifiedChineseConverter(123, { formal: false })  // ✓ '一百二十三' (common style)
+SimplifiedChineseConverter(123, { formal: 'yes' })  // ✗ TypeScript error: wrong type
+```
+
+**Type Definitions:**
+
+n2words includes TypeScript declaration files (`.d.ts`) generated from JSDoc annotations:
+
+- **Source**: JSDoc annotations in JavaScript source files
+- **Generated**: TypeScript declarations built via `tsc` during package preparation
+- **Included**: Published to npm with the package (no separate `@types` package needed)
+- **Validated**: Comprehensive type tests ensure correctness
+
+**Exported Types:**
+
+- `NumericValue` - Accepted input types: `number | bigint | string`
+- Language-specific option types (e.g., `ArabicOptions`, `SimplifiedChineseOptions`, `DutchOptions`, etc.)
+
+## Supported Languages (48)
+
+Language codes follow [IETF BCP 47](https://tools.ietf.org/html/bcp47) standards.
+
+| Code      | Language            | Options | Code      | Language            | Options |
+| --------- | ------------------- | ------- | --------- | ------------------- | ------- |
+| `ar`      | Arabic              | ✓       | `az`      | Azerbaijani         |         |
+| `bn`      | Bengali             |         | `cs`      | Czech               | ✓       |
+| `da`      | Danish              | ✓       | `de`      | German              |         |
+| `el`      | Greek               |         | `en`      | English             |         |
+| `es`      | Spanish             | ✓       | `fa`      | Persian             |         |
+| `fil`     | Filipino            |         | `fr`      | French              | ✓       |
+| `fr-BE`   | Belgian French      | ✓       | `gu`      | Gujarati            |         |
+| `hbo`     | Biblical Hebrew     | ✓       | `he`      | Modern Hebrew       | ✓       |
+| `hi`      | Hindi               |         | `hr`      | Croatian            | ✓       |
+| `hu`      | Hungarian           |         | `id`      | Indonesian          |         |
+| `it`      | Italian             |         | `ja`      | Japanese            |         |
+| `kn`      | Kannada             |         | `ko`      | Korean              |         |
+| `lt`      | Lithuanian          | ✓       | `lv`      | Latvian             | ✓       |
+| `mr`      | Marathi             |         | `ms`      | Malay               |         |
+| `nb`      | Norwegian Bokmål    |         | `nl`      | Dutch               | ✓       |
+| `pa`      | Punjabi             |         | `pl`      | Polish              | ✓       |
+| `pt`      | Portuguese          |         | `ro`      | Romanian            | ✓       |
+| `ru`      | Russian             | ✓       | `sr-Cyrl` | Serbian Cyrillic    | ✓       |
+| `sr-Latn` | Serbian Latin       | ✓       | `sv`      | Swedish             |         |
+| `sw`      | Swahili             |         | `ta`      | Tamil               |         |
+| `te`      | Telugu              |         | `th`      | Thai                |         |
+| `tr`      | Turkish             | ✓       | `uk`      | Ukrainian           | ✓       |
+| `ur`      | Urdu                |         | `vi`      | Vietnamese          |         |
+| `zh-Hans` | Chinese Simplified  | ✓       | `zh-Hant` | Chinese Traditional | ✓       |
+
+### Language Options
+
+21 languages support additional options. Common options include:
+
+**`gender`** (`'masculine'` | `'feminine'`) - 13 languages
+Arabic, Biblical Hebrew, Croatian, Czech, Latvian, Lithuanian, Polish, Romanian, Russian, Serbian (both scripts), Spanish, Ukrainian
+
+**`formal`** (`boolean`) - 2 languages
+Simplified Chinese, Traditional Chinese - Toggle between formal/financial and common numerals
+
+**Other options:**
+
+- Dutch: `includeOptionalAnd`, `accentOne`, `noHundredPairing`
+- French/French Belgium: `withHyphenSeparator`
+- Hebrew (Modern & Biblical): `andWord`
+- Turkish: `dropSpaces`
+- Danish: `ordFlag` (ordinal numbers)
+- Arabic: `negativeWord` (custom negative word)
+
+[See complete options reference →](docs/ARCHITECTURE.md#language-specific-options)
+
+## Browser Compatibility
+
+**Minimum Requirements** (due to BigInt):
+
+- **Node.js**: 20 or above
+- **Browsers**: Chrome 67+, Firefox 68+, Safari 14+, Edge 79+ (desktop + mobile)
+- **Global Coverage**: ~86% of all users worldwide
+
+**Note**: BigInt is a hard requirement and cannot be polyfilled. Older browsers are not supported.
+
+**Build options:**
+
+- **Browser CDN**: Use `dist/n2words.js` (pre-built UMD, tested in real browsers)
+- **Node.js/Bundlers**: Use `lib/` source (ES modules, tree-shakable)
+
+[See detailed compatibility guide →](COMPATIBILITY.md)
+
+## Performance & Bundle Size
+
+### Bundle Size Comparison
+
+| Import Strategy              | Bundle Size (Minified) | Gzipped  | Languages Included |
+| ---------------------------- | ---------------------- | -------- | ------------------ |
+| All languages (UMD)          | ~92 KB                 | ~23 KB   | All 48             |
+| Single language (UMD)        | ~4-6 KB                | ~2 KB    | 1                  |
+| Tree-shaken (ESM, 1 lang)    | ~4-5 KB                | ~2 KB    | 1                  |
+| Tree-shaken (ESM, 3 langs)   | ~12-15 KB              | ~4-5 KB  | 3                  |
+| Tree-shaken (ESM, 10 langs)  | ~40-50 KB              | ~12-15 KB| 10                 |
+
+### Performance Characteristics
+
+- **Fast**: Sub-millisecond conversion for most numbers
+- **Efficient**: Zero dependencies, minimal memory footprint
+- **BigInt support**: Handles arbitrarily large numbers without precision loss
+- **Memory-efficient**: ~2 KB overhead per language when tree-shaken
+
+**Tree-shaking example:**
+
+```js
+// Import only what you need - bundler only includes used languages
+import { EnglishConverter, SpanishConverter } from 'n2words'
+// Final bundle: ~4-5 KB gzipped (only English + Spanish + core)
+```
+
+**Run benchmarks:**
+
+```bash
+npm run bench:perf    # Performance benchmarks (ops/sec)
+npm run bench:memory  # Memory usage benchmarks
+```
+
+## Examples
+
+### Basic Conversions
+
+```js
+import { EnglishConverter } from 'n2words'
+
+// Basic numbers
+EnglishConverter(0)        // 'zero'
+EnglishConverter(42)       // 'forty-two'
+EnglishConverter(1000000)  // 'one million'
+
+// Decimals & negatives
+EnglishConverter(3.14)     // 'three point one four'
+EnglishConverter(-42)      // 'minus forty-two'
+
+// Large numbers & BigInt
+EnglishConverter(1234567890)        // 'one billion two hundred and thirty-four million five hundred and sixty-seven thousand eight hundred and ninety'
+EnglishConverter(123456789012345n)  // Works with arbitrarily large integers
+```
+
+### Gender Agreement
+
+```js
+import { SpanishConverter, ArabicConverter, RussianConverter } from 'n2words'
+
+// Spanish: masculine vs feminine
+SpanishConverter(1)                       // 'uno' (masculine, default)
+SpanishConverter(1, { gender: 'feminine' })  // 'una'
+SpanishConverter(21)                      // 'veintiuno' (masculine)
+SpanishConverter(21, { gender: 'feminine' }) // 'veintiuna'
+
+// Arabic: rich gender system
+ArabicConverter(1)                       // 'واحد' (masculine, default)
+ArabicConverter(1, { gender: 'feminine' })  // 'واحدة'
+
+// Russian: gender for numerals
+RussianConverter(1)                       // 'один' (masculine, default)
+RussianConverter(1, { gender: 'feminine' })  // 'одна'
+```
+
+### Language-Specific Features
+
+```js
+import {
+  SimplifiedChineseConverter,
+  TraditionalChineseConverter,
+  JapaneseConverter,
+  DutchConverter,
+  FrenchConverter
+} from 'n2words'
+
+// Chinese: formal (financial) vs common numerals
+SimplifiedChineseConverter(123)                  // '壹佰贰拾叁' (formal, default)
+SimplifiedChineseConverter(123, { formal: false }) // '一百二十三' (common)
+
+TraditionalChineseConverter(456)                  // '肆佰伍拾陸' (formal, default)
+TraditionalChineseConverter(456, { formal: false }) // '四百五十六' (common)
+
+// Japanese: digit-by-digit decimals
+JapaneseConverter(3.14)  // '三点一四'
+
+// Dutch: flexible formatting
+DutchConverter(123)                              // 'honderddrieëntwintig' (default compound)
+DutchConverter(101, { includeOptionalAnd: true })  // 'honderdeneen' (with optional "en")
+DutchConverter(1)                                // 'één' (accented, default)
+DutchConverter(1, { accentOne: false })           // 'een' (unaccented)
+
+// French: selective hyphens vs all hyphens
+FrenchConverter(123)                              // 'cent vingt-trois' (default)
+FrenchConverter(123, { withHyphenSeparator: true }) // 'cent-vingt-trois' (all hyphens)
+```
+
+### Input Flexibility
+
+```js
+import { EnglishConverter } from 'n2words'
+
+// Multiple input types
+EnglishConverter(42)      // number → 'forty-two'
+EnglishConverter('42')    // string → 'forty-two'
+EnglishConverter(42n)     // BigInt → 'forty-two'
+
+// Decimal strings
+EnglishConverter('3.14')  // 'three point one four'
+EnglishConverter('.5')    // 'zero point five'
+
+// Negative strings
+EnglishConverter('-42')   // 'minus forty-two'
+
+// Large BigInts (no precision loss)
+EnglishConverter(999999999999999999999999n)  // Accurate conversion
+```
+
+## Documentation
+
+- **[Compatibility Guide](COMPATIBILITY.md)** - Browser and Node.js compatibility
+- **[Contributing Guide](CONTRIBUTING.md)** - How to contribute and add languages
+- **[Architecture Guide](docs/ARCHITECTURE.md)** - Implementation patterns and options reference
+- **[Code of Conduct](CODE_OF_CONDUCT.md)** - Community standards
 
 ## Contributing
 
-__This library is in active development.__ We want to improve the design and process for language contributors and add more languages. Bug reports and feature requests are also beneficial!
+We welcome contributions! Add a new language or improve existing ones:
+
+```bash
+npm run lang:add <code>         # Scaffold a new language (BCP 47 code)
+npm run lang:validate -- <code> # Validate implementation
+npm test                        # Run full test suite
+```
+
+Also welcome: bug reports, feature requests, documentation improvements, and language enhancements.
+
+Please read our [Code of Conduct](CODE_OF_CONDUCT.md) before contributing.
+
+**[See full contributing guide →](CONTRIBUTING.md)**
 
 ## License
 
-[MIT](https://github.com/forzagreen/n2words/blob/main/LICENSE)
+[MIT](./LICENSE) © Wael TELLAT, Tyler Vigario & contributors

package/dist/ArabicConverter.js

@@ -0,0 +1,3 @@
+/*! n2words/ArabicConverter v2.0.0 | MIT License | github.com/forzagreen/n2words */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{})}(this,function(e){"use strict";class t{#e={};negativeWord="";decimalSeparatorWord="";zeroWord="";wordSeparator=" ";usePerDigitDecimals=!1;get options(){return this.#e}toWords(e,t,r){const s=[];return e&&s.push(this.negativeWord),s.push(this.integerToWords(t)),r&&(s.push(this.decimalSeparatorWord),s.push(...this.decimalDigitsToWords(r))),s.join(this.wordSeparator)}integerToWords(e){throw new Error("integerToWords() must be implemented by subclass")}setOptions(e={},t={}){this.#e={...e,...t}}decimalIntegerToWords(e){return this.integerToWords(e)}decimalDigitsToWords(e){const t=[];let r=0;for(;r<e.length&&"0"===e[r];)t.push(this.zeroWord),r++;const s=e.slice(r);if(!s)return t;if(this.usePerDigitDecimals)for(const e of s)t.push(this.decimalIntegerToWords(BigInt(e)));else t.push(this.decimalIntegerToWords(BigInt(s)));return t}}function r(e){const[t,r]=e.toLowerCase().split("e"),s=parseInt(r,10),n=t.indexOf("."),i=-1===n?t:t.slice(0,n)+t.slice(n+1),o=(-1===n?t.length:n)+s;return o>=i.length?i+"0".repeat(o-i.length):o<=0?"0."+"0".repeat(-o)+i:i.slice(0,o)+"."+i.slice(o)}const s=(n=class extends t{negativeWord="ناقص";decimalSeparatorWord="فاصلة";zeroWord="صفر";tensWords=["عشرون","ثلاثون","أربعون","خمسون","ستون","سبعون","ثمانون","تسعون"];hundredsWords=["","مائة","مئتان","ثلاثمائة","أربعمائة","خمسمائة","ستمائة","سبعمائة","ثمانمائة","تسعمائة"];scaleWords=["مائة","ألف","مليون","مليار","تريليون","كوادريليون","كوينتليون","سكستيليون"];scaleAppendedWords=["","ألفاً","مليوناً","ملياراً","تريليوناً","كوادريليوناً","كوينتليوناً","سكستيليوناً"];scalePluralWords=["","آلاف","ملايين","مليارات","تريليونات","كوادريليونات","كوينتليونات","سكستيليونات"];dualWords=["مئتان","ألفان","مليونان","ملياران","تريليونان","كوادريليونان","كوينتليونان","سكستيليونان"];dualAppendedWords=["مئتا","ألفا","مليونا","مليارا","تريليونا","كوادريليونا","كوينتليونا","سكستيليونا"];ones={masculine:["واحد","اثنان","ثلاثة","أربعة","خمسة","ستة","سبعة","ثمانية","تسعة","عشرة","أحد عشر","اثنا عشر","ثلاثة عشر","أربعة عشر","خمسة عشر","ستة عشر","سبعة عشر","ثمانية عشر","تسعة عشر"],feminine:["واحدة","اثنتان","ثلاث","أربع","خمس","ست","سبع","ثمان","تسع","عشر","إحدى عشرة","اثنتا عشرة","ثلاث عشرة","أربع عشرة","خمس عشرة","ست عشرة","سبع عشرة","ثماني عشرة","تسع عشرة"]};constructor(e={}){super(),this.setOptions({gender:"masculine"},e),void 0!==e.negativeWord&&(this.negativeWord=e.negativeWord)}get selectedOnes(){return this.ones["feminine"===this.options.gender?"feminine":"masculine"]}segmentToWords(e,t,r){const s=e%100,n=e/100,i=Math.trunc(n);let o="";if(i>0)if(0===s&&2===i)o=this.dualWords[0];else{const e=this.hundredsWords[i];e&&(o=e,0!==s&&(o+=" و"))}if(s>0)if(s<20)if(2===s&&0===i&&t>0){const s=Number(r),n=Math.trunc(Math.log10(s));o=n%3==0&&r===BigInt(2*Math.pow(10,n))?2===e?this.dualWords[t]:this.dualAppendedWords[t]:this.dualWords[t]}else o+=1===s&&t>0?this.scaleWords[t]:this.selectedOnes[s-1];else{const e=s%10,t=Math.trunc(s/10)-2;e>0&&(o+=this.selectedOnes[e-1],o+=" و"),o+=this.tensWords[t]}return o}integerToWords(e){if(0n===e)return this.zeroWord;let t=e,r=0,s="";for(;t>0n;){const n=Number(t%1000n);if(t/=1000n,n>0){const t=this.segmentToWords(n,r,e);t&&(r>0&&(s&&(s=" و"+s),n>2)&&(s=1==n%100?this.scaleWords[r]+" "+s:n>=3&&n<=10?this.scalePluralWords[r]+" "+s:(s?this.scaleAppendedWords[r]:this.scaleWords[r])+" "+s),s=t+" "+s)}r++}return s.replace(/\s+/g," ").trim()}},function(e,t){if(void 0!==t&&!function(e){if(null===e||"object"!=typeof e)return!1;const t=Object.getPrototypeOf(e);return t===Object.prototype||null===t}(t))throw new TypeError("options must be a plain object if provided");const{isNegative:s,integerPart:i,decimalPart:o}=function(e){const t=typeof e;if("bigint"===t)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"!==t&&"string"!==t)throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${t}`);const s="number"===t?function(e){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");const t=e.toString();return t.includes("e")||t.includes("E")?r(t):t}(e):function(e){const t=e.trim();if(0===t.length)throw new Error(`Invalid number format: "${e}"`);if(Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?r(t):t}(e);return function(e){const t="-"===e[0];t&&(e=e.slice(1));const r=e.indexOf(".");if(-1===r)return{isNegative:t,integerPart:BigInt(e)};const s=e.slice(0,r)||"0",n=e.slice(r+1);return{isNegative:t,integerPart:BigInt(s),decimalPart:n}}(s)}(e);return new n(t).toWords(s,i,o)});var n;e.ArabicConverter=s});
+//# sourceMappingURL=ArabicConverter.js.map

package/dist/ArabicConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArabicConverter.js","sources":["../lib/classes/abstract-language.js","../lib/n2words.js","../lib/languages/ar.js"],"sourcesContent":["/**\n * Abstract base class for language converters.\n *\n * This class provides the framework for converting numbers to words in any language.\n * It handles the common conversion flow while delegating language-specific logic to subclasses.\n *\n * ## Responsibilities\n *\n * - Receives pre-validated and normalized input from the public API (n2words.js)\n * - Handles negative number prefixing via `negativeWord`\n * - Converts decimals via `decimalDigitsToWords()`, preserving leading zeros\n * - Delegates integer conversion to `integerToWords()` (implemented by subclasses)\n *\n * ## Required Subclass Implementation\n *\n * Subclasses MUST provide:\n * - `integerToWords(integerPart)` - Core conversion logic (abstract method)\n * - `negativeWord` - Word preceding negative numbers (e.g., \"minus\"))\n * - `zeroWord` - Word for the digit 0 (e.g., \"zero\")\n * - `decimalSeparatorWord` - Word between whole and decimal parts (e.g., \"point\")\n *\n * ## Optional Overrides\n *\n * Subclasses MAY override:\n * - `wordSeparator` - Character(s) between words (default: space, empty for CJK languages)\n * - `usePerDigitDecimals` - Enable per-digit decimal mode (default: false)\n * - `decimalIntegerToWords()` - Custom decimal conversion (e.g., Romanian masculine forms)\n * - `decimalDigitsToWords()` - Complete decimal conversion override\n * - `toWords()` - Override to capture integerPart for context-dependent rules (e.g., Czech)\n *\n * ## Input Contract\n *\n * Input validation and normalization happen at the public API boundary (n2words.js).\n * This class assumes it receives clean, pre-processed data via `toWords()`.\n *\n * @abstract\n */\nexport class AbstractLanguage {\n  // ============================================================================\n  // Private Fields\n  // ============================================================================\n\n  /**\n   * Private storage for options.\n   * @type {Object}\n   */\n  #options = {}\n\n  // ============================================================================\n  // Required Properties (subclasses must define)\n  // ============================================================================\n\n  /**\n   * Word that precedes negative numbers (e.g., \"minus\", \"negative\", \"moins\").\n   * @type {string}\n   */\n  negativeWord = ''\n\n  /**\n   * Word that separates integer and decimal parts (e.g., \"point\", \"virgule\", \"comma\").\n   * @type {string}\n   */\n  decimalSeparatorWord = ''\n\n  /**\n   * Word representation for the digit 0 (e.g., \"zero\", \"zéro\", \"null\").\n   * Used for zero values and leading zeros in decimals.\n   * @type {string}\n   */\n  zeroWord = ''\n\n  // ============================================================================\n  // Optional Properties (subclasses may override)\n  // ============================================================================\n\n  /**\n   * Character(s) used to separate words in the output.\n   *\n   * Defaults to a single space. Set to empty string for languages without\n   * word separators (e.g., Japanese, Thai, Chinese).\n   *\n   * @type {string}\n   */\n  wordSeparator = ' '\n\n  /**\n   * Whether to convert decimal digits individually rather than grouped.\n   *\n   * - `false` (default): Leading zeros preserved, remaining digits grouped as a number\n   *   - Example: \"05\" → [\"zero\", \"five\"], \"14\" → [\"fourteen\"]\n   *   - Used by: English, Spanish, French, German, etc.\n   *\n   * - `true`: Each digit converted separately\n   *   - Example: \"05\" → [\"zero\", \"five\"], \"14\" → [\"one\", \"four\"]\n   *   - Used by: Japanese, Thai, Tamil, Telugu, Greek, Hebrew, Filipino\n   *\n   * @type {boolean}\n   */\n  usePerDigitDecimals = false\n\n  // ============================================================================\n  // Public Accessors\n  // ============================================================================\n\n  /**\n   * Read-only access to options set via `setOptions()`.\n   * @type {Object}\n   */\n  get options () {\n    return this.#options\n  }\n\n  // ============================================================================\n  // Public Methods\n  // ============================================================================\n\n  /**\n   * Converts pre-normalized numeric components to words.\n   *\n   * This is the main entry point called by the public API (makeConverter in n2words.js).\n   * It assembles the final word representation from the provided components.\n   *\n   * **Caller contract (enforced by makeConverter):**\n   * - `integerPart` is a non-negative BigInt (>= 0n)\n   * - `decimalPart` is a string of digits only (no sign, no decimal point)\n   * - `isNegative` reflects the original input sign\n   *\n   * **Conversion flow:**\n   * 1. Prepend negative word if applicable\n   * 2. Convert integer part via `integerToWords()`\n   * 3. If decimals present: append separator and decimal words\n   * 4. Join all parts with `wordSeparator`\n   *\n   * Subclasses needing access to the integer part during decimal conversion\n   * (e.g., for context-dependent separator words) should override this\n   * method to cache the value before calling super.toWords().\n   *\n   * @public\n   * @param {boolean} isNegative Whether the original number was negative\n   * @param {bigint} integerPart The integer part (always non-negative)\n   * @param {string} [decimalPart] - Decimal digits if present (e.g., \"14\" for 3.14)\n   * @returns {string} The localized cardinal string\n   */\n  toWords (isNegative, integerPart, decimalPart) {\n    const words = []\n\n    if (isNegative) words.push(this.negativeWord)\n\n    words.push(this.integerToWords(integerPart))\n\n    if (decimalPart) {\n      words.push(this.decimalSeparatorWord)\n      words.push(...this.decimalDigitsToWords(decimalPart))\n    }\n\n    return words.join(this.wordSeparator)\n  }\n\n  // ============================================================================\n  // Abstract Methods (subclasses must implement)\n  // ============================================================================\n\n  /**\n   * Converts a BigInt integer part to its cardinal word representation.\n   *\n   * This is the core template method that subclasses MUST implement to provide\n   * language-specific number conversion logic.\n   *\n   * @abstract\n   * @param {bigint} integerPart The integer part to convert (always >= 0n)\n   * @returns {string} The cardinal representation in the target language\n   * @throws {Error} If not implemented by subclass\n   */\n  integerToWords (integerPart) {\n    throw new Error('integerToWords() must be implemented by subclass')\n  }\n\n  // ============================================================================\n  // Protected Methods (subclasses may override or call)\n  // ============================================================================\n\n  /**\n   * Sets options by merging language defaults with user-provided options.\n   *\n   * Merges defaults first, then user options (later keys override earlier ones).\n   * Stores the result in the private `#options` field, accessible via the\n   * read-only `options` getter.\n   *\n   * @protected\n   * @param {Object} [defaults={}] - Default option values for the language\n   * @param {Object} [userOptions={}] - Runtime options supplied by the caller\n   *\n   * @example\n   * constructor(options = {}) {\n   *   super()\n   *   this.setOptions({ gender: 'masculine' }, options)\n   * }\n   */\n  setOptions (defaults = {}, userOptions = {}) {\n    this.#options = {\n      ...defaults,\n      ...userOptions\n    }\n  }\n\n  /**\n   * Converts an integer to words in decimal context.\n   *\n   * By default, delegates to `integerToWords()`. Override this method\n   * when decimal conversion requires different behavior than integer conversion.\n   *\n   * Called with:\n   * - Single digits (0-9) when `usePerDigitDecimals = true`\n   * - Grouped numbers when `usePerDigitDecimals = false`\n   *\n   * **Use cases for overriding:**\n   * - Romanian: Decimals always use masculine forms regardless of gender option\n   * - Languages with different plural/gender rules for decimal vs integer parts\n   *\n   * @protected\n   * @param {bigint} integerPart The integer to convert (single digit or grouped)\n   * @returns {string} The word representation for use in decimal context\n   */\n  decimalIntegerToWords (integerPart) {\n    return this.integerToWords(integerPart)\n  }\n\n  /**\n   * Converts decimal fractional digits into an array of words.\n   *\n   * Leading zeros are always preserved individually. The remaining digits\n   * are converted based on `usePerDigitDecimals`:\n   *\n   * - `false` (default): Remaining digits grouped as a single number\n   *   - \"05\" → [\"zero\", \"five\"], \"14\" → [\"fourteen\"]\n   *\n   * - `true`: Each remaining digit converted separately\n   *   - \"05\" → [\"zero\", \"five\"], \"14\" → [\"one\", \"four\"]\n   *\n   * @protected\n   * @param {string} decimalPart Decimal digits as string (e.g., \"05\" for 3.05)\n   * @returns {string[]} Array of word tokens for the fractional part\n   */\n  decimalDigitsToWords (decimalPart) {\n    const words = []\n\n    // Always preserve leading zeros individually\n    let i = 0\n    while (i < decimalPart.length && decimalPart[i] === '0') {\n      words.push(this.zeroWord)\n      i++\n    }\n\n    const remainder = decimalPart.slice(i)\n    if (!remainder) return words\n\n    // Convert remainder: per-digit or as single number\n    if (this.usePerDigitDecimals) {\n      for (const char of remainder) {\n        words.push(this.decimalIntegerToWords(BigInt(char)))\n      }\n    } else {\n      words.push(this.decimalIntegerToWords(BigInt(remainder)))\n    }\n\n    return words\n  }\n}\n","/**\n * n2words - Convert numbers to words in multiple languages\n *\n * This file is the main entry point for the n2words library.\n * It exports converter functions for all supported languages.\n *\n * ## For Contributors\n *\n * When adding a new language, this file must be updated in THREE sections:\n * 1. Language Imports - Add import statement (alphabetically sorted)\n * 2. Language Converters - Create converter with makeConverter() (alphabetically sorted)\n * 3. Exports - Add to export list (alphabetically sorted)\n *\n * Use the scaffolding tool to automate this process:\n *   npm run lang:add <language-code>\n *\n * ## Public API Structure\n *\n * Each language exports a converter function:\n *   - Name: `{LanguageName}Converter` (e.g., EnglishConverter, SpanishConverter)\n *   - Signature: `(value: NumericValue, options?: Options) => string`\n *   - Input: number, bigint, or string (numeric strings only)\n *   - Output: Words representing the number in the target language\n *\n * Languages without options use signature: `(value: NumericValue) => string`\n * Languages with options define a typedef (e.g., ArabicOptions) and use: `(value: NumericValue, options?: ArabicOptions) => string`\n *\n * @module n2words\n */\n\n// ============================================================================\n// Language Imports\n// ============================================================================\n\nimport { Arabic } from './languages/ar.js'\nimport { Azerbaijani } from './languages/az.js'\nimport { Bangla } from './languages/bn.js'\nimport { Czech } from './languages/cs.js'\nimport { Danish } from './languages/da.js'\nimport { German } from './languages/de.js'\nimport { Greek } from './languages/el.js'\nimport { English } from './languages/en.js'\nimport { Spanish } from './languages/es.js'\nimport { Persian } from './languages/fa.js'\nimport { Filipino } from './languages/fil.js'\nimport { French } from './languages/fr.js'\nimport { FrenchBelgium } from './languages/fr-BE.js'\nimport { Gujarati } from './languages/gu.js'\nimport { Hebrew } from './languages/he.js'\nimport { BiblicalHebrew } from './languages/hbo.js'\nimport { Hindi } from './languages/hi.js'\nimport { Croatian } from './languages/hr.js'\nimport { Hungarian } from './languages/hu.js'\nimport { Indonesian } from './languages/id.js'\nimport { Italian } from './languages/it.js'\nimport { Japanese } from './languages/ja.js'\nimport { Kannada } from './languages/kn.js'\nimport { Korean } from './languages/ko.js'\nimport { Lithuanian } from './languages/lt.js'\nimport { Latvian } from './languages/lv.js'\nimport { Marathi } from './languages/mr.js'\nimport { Malay } from './languages/ms.js'\nimport { Dutch } from './languages/nl.js'\nimport { NorwegianBokmal } from './languages/nb.js'\nimport { Punjabi } from './languages/pa.js'\nimport { Polish } from './languages/pl.js'\nimport { Portuguese } from './languages/pt.js'\nimport { Romanian } from './languages/ro.js'\nimport { Russian } from './languages/ru.js'\nimport { SerbianCyrillic } from './languages/sr-Cyrl.js'\nimport { SerbianLatin } from './languages/sr-Latn.js'\nimport { Swedish } from './languages/sv.js'\nimport { Swahili } from './languages/sw.js'\nimport { Tamil } from './languages/ta.js'\nimport { Telugu } from './languages/te.js'\nimport { Thai } from './languages/th.js'\nimport { Turkish } from './languages/tr.js'\nimport { Ukrainian } from './languages/uk.js'\nimport { Urdu } from './languages/ur.js'\nimport { Vietnamese } from './languages/vi.js'\nimport { SimplifiedChinese } from './languages/zh-Hans.js'\nimport { TraditionalChinese } from './languages/zh-Hant.js'\n\n// ============================================================================\n// Type Definitions\n// ============================================================================\n//\n// This section defines TypeScript-compatible JSDoc types for:\n// - NumericValue: The input types accepted by all converters\n// - {Language}Options: Optional configuration for languages that support it\n//\n// Keep options typedefs alphabetically sorted for maintainability.\n// ============================================================================\n\n/**\n * Numeric value that can be converted to words.\n * Accepts number, bigint, or numeric string representations.\n * @typedef {number | bigint | string} NumericValue\n */\n\n/**\n * @typedef {Object} ArabicOptions\n * @property {string} [negativeWord] Word for negative numbers\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} BiblicalHebrewOptions\n * @property {string} [andWord='ו'] Conjunction character (typically 'ו' for and)\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} CroatianOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} CzechOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} DanishOptions\n * @property {boolean} [ordFlag=false] Enable ordinal number conversion\n */\n\n/**\n * @typedef {Object} DutchOptions\n * @property {boolean} [includeOptionalAnd=false] Include optional \"en\" separator\n * @property {boolean} [noHundredPairing=false] Disable hundred-pairing (e.g., \"twelve hundred\" becomes \"one thousand two hundred\")\n * @property {boolean} [accentOne=true] Use accented \"één\" for one\n */\n\n/**\n * @typedef {Object} FrenchOptions\n * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds\n */\n\n/**\n * @typedef {Object} FrenchBelgiumOptions\n * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds\n */\n\n/**\n * @typedef {Object} HebrewOptions\n * @property {string} [andWord='ו'] Conjunction character (typically 'ו' for and)\n */\n\n/**\n * @typedef {Object} LatvianOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} LithuanianOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} PolishOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} RomanianOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} RussianOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} SerbianCyrillicOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} SerbianLatinOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} SimplifiedChineseOptions\n * @property {boolean} [formal=true] Use formal/financial numerals (壹贰叁) vs. common numerals (一二三)\n */\n\n/**\n * @typedef {Object} SpanishOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n/**\n * @typedef {Object} TraditionalChineseOptions\n * @property {boolean} [formal=true] Use formal/financial numerals (壹貳參) vs. common numerals (一二三)\n */\n\n/**\n * @typedef {Object} TurkishOptions\n * @property {boolean} [dropSpaces=false] Remove spaces between words if true\n */\n\n/**\n * @typedef {Object} UkrainianOptions\n * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms\n */\n\n// ============================================================================\n// Converter Factory\n// ============================================================================\n//\n// makeConverter() is a factory function that creates converter functions from\n// language classes. It provides a consistent functional API for all languages:\n//\n//   const result = EnglishConverter(42)                      // \"forty-two\"\n//   const result = ArabicConverter(1, {gender: 'feminine'})  // \"واحدة\"\n//\n// This design:\n// - Hides class instantiation details from public API\n// - Ensures each conversion uses a fresh instance\n// - Maintains immutability (no shared state between conversions)\n// ============================================================================\n\n/**\n * Creates a converter function for a language class.\n *\n * This factory handles all input validation and normalization at the public API\n * boundary, then delegates to the language class with pre-processed data.\n *\n * @template {Object} [TOptions={}]\n * @param {new (options?: TOptions) => { toWords: (isNegative: boolean, integerPart: bigint, decimalPart?: string) => string }} LanguageClass - Language class constructor\n * @returns {(value: NumericValue, options?: TOptions) => string} Converter function\n */\nfunction makeConverter (LanguageClass) {\n  /**\n   * @param {NumericValue} value\n   * @param {TOptions} [options]\n   * @returns {string}\n   */\n  return function convertToWords (value, options) {\n    if (options !== undefined && !isPlainObject(options)) {\n      throw new TypeError('options must be a plain object if provided')\n    }\n\n    const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n    return new LanguageClass(options).toWords(isNegative, integerPart, decimalPart)\n  }\n}\n\n// ============================================================================\n// Input Parsing Utilities\n// ============================================================================\n\n/**\n * @typedef {Object} ParsedNumericValue\n * @property {boolean} isNegative - Whether the value is negative\n * @property {bigint} integerPart - The absolute integer part\n * @property {string} [decimalPart] - The decimal digits (without the point)\n */\n\n/**\n * Parses and validates a numeric value into its components.\n * Handles number, string, and bigint inputs uniformly.\n *\n * @param {NumericValue} value The value to parse\n * @returns {ParsedNumericValue} The parsed components\n * @throws {TypeError} If value is not a valid numeric type\n * @throws {Error} If value is not a valid number format\n */\nfunction parseNumericValue (value) {\n  const type = typeof value\n\n  // BigInt: simplest case - no decimals, no scientific notation\n  if (type === 'bigint') {\n    return value < 0n\n      ? { isNegative: true, integerPart: -value }\n      : { isNegative: false, integerPart: value }\n  }\n\n  // Reject invalid types early\n  if (type !== 'number' && type !== 'string') {\n    throw new TypeError(\n      `Invalid value type: expected number, string, or bigint, received ${type}`\n    )\n  }\n\n  // Convert to normalized string\n  const str = type === 'number'\n    ? numberToString(value)\n    : stringToNormalizedForm(value)\n\n  return parseNumericString(str)\n}\n\n/**\n * Converts a JavaScript number to a decimal string.\n * Handles special cases: Infinity, NaN, and scientific notation.\n *\n * @param {number} value The number to convert\n * @returns {string} Decimal string representation\n * @throws {Error} If value is not finite\n */\nfunction numberToString (value) {\n  if (!Number.isFinite(value)) {\n    throw new Error('Number must be finite (NaN and Infinity are not supported)')\n  }\n\n  const str = value.toString()\n\n  // Expand scientific notation (used for values >= 1e21 or < 1e-6)\n  if (str.includes('e') || str.includes('E')) {\n    return expandScientificNotation(str)\n  }\n\n  return str\n}\n\n/**\n * Validates and normalizes a string numeric input.\n *\n * @param {string} value The string to validate\n * @returns {string} Trimmed and validated string\n * @throws {Error} If string is empty or not a valid number format\n */\nfunction stringToNormalizedForm (value) {\n  const trimmed = value.trim()\n\n  if (trimmed.length === 0) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n\n  // Validate by attempting conversion (handles edge cases like \"1e21\", \"-.5\", etc.)\n  if (Number.isNaN(Number(trimmed))) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n\n  // Expand scientific notation if present\n  if (trimmed.includes('e') || trimmed.includes('E')) {\n    return expandScientificNotation(trimmed)\n  }\n\n  return trimmed\n}\n\n/**\n * Parses a normalized numeric string into its components.\n *\n * @param {string} str A normalized decimal string (no scientific notation)\n * @returns {ParsedNumericValue} The parsed components\n */\nfunction parseNumericString (str) {\n  // Extract sign\n  const isNegative = str[0] === '-'\n  if (isNegative) {\n    str = str.slice(1)\n  }\n\n  // Split into integer and decimal parts\n  const dotIndex = str.indexOf('.')\n  if (dotIndex === -1) {\n    return { isNegative, integerPart: BigInt(str) }\n  }\n\n  const integerStr = str.slice(0, dotIndex) || '0'\n  const decimalPart = str.slice(dotIndex + 1)\n\n  return { isNegative, integerPart: BigInt(integerStr), decimalPart }\n}\n\n/**\n * Expands scientific notation to decimal form.\n * JavaScript uses scientific notation for values >= 1e21 or < 1e-6.\n *\n * @param {string} str String possibly in scientific notation (e.g., \"1e+21\")\n * @returns {string} Decimal form (e.g., \"1000000000000000000000\")\n */\nfunction expandScientificNotation (str) {\n  const [mantissa, expStr] = str.toLowerCase().split('e')\n  const exp = parseInt(expStr, 10)\n\n  // Extract digits and determine original decimal position\n  const dotIndex = mantissa.indexOf('.')\n  const digits = dotIndex === -1\n    ? mantissa\n    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)\n  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex\n\n  // Calculate new decimal position after applying exponent\n  const newDotPosition = integerLength + exp\n\n  if (newDotPosition >= digits.length) {\n    // Pure integer: pad with trailing zeros\n    return digits + '0'.repeat(newDotPosition - digits.length)\n  }\n\n  if (newDotPosition <= 0) {\n    // Pure decimal: pad with leading zeros after decimal point\n    return '0.' + '0'.repeat(-newDotPosition) + digits\n  }\n\n  // Mixed: insert decimal point at new position\n  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)\n}\n\n/**\n * Checks if a value is a plain object (not null, array, or other object types).\n *\n * @param {*} value Value to check\n * @returns {boolean} True if value is a plain object\n */\nfunction isPlainObject (value) {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\n// ============================================================================\n// Language Converters\n// ============================================================================\n//\n// Each converter is created using makeConverter() with explicit type annotations.\n//\n// Pattern for languages WITHOUT options:\n//   const LanguageConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Language))\n//\n// Pattern for languages WITH options:\n//   const LanguageConverter = /** @type {(value: NumericValue, options?: LanguageOptions) => string} */ (makeConverter(Language))\n//\n// IMPORTANT: Keep converters alphabetically sorted by converter name.\n// ============================================================================\n\nconst ArabicConverter = /** @type {(value: NumericValue, options?: ArabicOptions) => string} */ (makeConverter(Arabic))\nconst AzerbaijaniConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Azerbaijani))\nconst BanglaConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Bangla))\nconst BiblicalHebrewConverter = /** @type {(value: NumericValue, options?: BiblicalHebrewOptions) => string} */ (makeConverter(BiblicalHebrew))\nconst CroatianConverter = /** @type {(value: NumericValue, options?: CroatianOptions) => string} */ (makeConverter(Croatian))\nconst CzechConverter = /** @type {(value: NumericValue, options?: CzechOptions) => string} */ (makeConverter(Czech))\nconst DanishConverter = /** @type {(value: NumericValue, options?: DanishOptions) => string} */ (makeConverter(Danish))\nconst DutchConverter = /** @type {(value: NumericValue, options?: DutchOptions) => string} */ (makeConverter(Dutch))\nconst EnglishConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(English))\nconst FilipinoConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Filipino))\nconst FrenchConverter = /** @type {(value: NumericValue, options?: FrenchOptions) => string} */ (makeConverter(French))\nconst FrenchBelgiumConverter = /** @type {(value: NumericValue, options?: FrenchBelgiumOptions) => string} */ (makeConverter(FrenchBelgium))\nconst GermanConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(German))\nconst GreekConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Greek))\nconst GujaratiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Gujarati))\nconst HebrewConverter = /** @type {(value: NumericValue, options?: HebrewOptions) => string} */ (makeConverter(Hebrew))\nconst HindiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Hindi))\nconst HungarianConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Hungarian))\nconst IndonesianConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Indonesian))\nconst ItalianConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Italian))\nconst JapaneseConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Japanese))\nconst KannadaConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Kannada))\nconst KoreanConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Korean))\nconst LatvianConverter = /** @type {(value: NumericValue, options?: LatvianOptions) => string} */ (makeConverter(Latvian))\nconst LithuanianConverter = /** @type {(value: NumericValue, options?: LithuanianOptions) => string} */ (makeConverter(Lithuanian))\nconst MalayConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Malay))\nconst MarathiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Marathi))\nconst NorwegianBokmalConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(NorwegianBokmal))\nconst PersianConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Persian))\nconst PolishConverter = /** @type {(value: NumericValue, options?: PolishOptions) => string} */ (makeConverter(Polish))\nconst PortugueseConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Portuguese))\nconst PunjabiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Punjabi))\nconst RomanianConverter = /** @type {(value: NumericValue, options?: RomanianOptions) => string} */ (makeConverter(Romanian))\nconst RussianConverter = /** @type {(value: NumericValue, options?: RussianOptions) => string} */ (makeConverter(Russian))\nconst SerbianCyrillicConverter = /** @type {(value: NumericValue, options?: SerbianCyrillicOptions) => string} */ (makeConverter(SerbianCyrillic))\nconst SerbianLatinConverter = /** @type {(value: NumericValue, options?: SerbianLatinOptions) => string} */ (makeConverter(SerbianLatin))\nconst SimplifiedChineseConverter = /** @type {(value: NumericValue, options?: SimplifiedChineseOptions) => string} */ (makeConverter(SimplifiedChinese))\nconst SpanishConverter = /** @type {(value: NumericValue, options?: SpanishOptions) => string} */ (makeConverter(Spanish))\nconst SwahiliConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Swahili))\nconst SwedishConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Swedish))\nconst TamilConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Tamil))\nconst TeluguConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Telugu))\nconst ThaiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Thai))\nconst TraditionalChineseConverter = /** @type {(value: NumericValue, options?: TraditionalChineseOptions) => string} */ (makeConverter(TraditionalChinese))\nconst TurkishConverter = /** @type {(value: NumericValue, options?: TurkishOptions) => string} */ (makeConverter(Turkish))\nconst UkrainianConverter = /** @type {(value: NumericValue, options?: UkrainianOptions) => string} */ (makeConverter(Ukrainian))\nconst UrduConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Urdu))\nconst VietnameseConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Vietnamese))\n\n// ============================================================================\n// Exports\n// ============================================================================\n//\n// All converter functions are exported for public use.\n//\n// IMPORTANT: Keep exports alphabetically sorted for maintainability.\n// ============================================================================\n\nexport {\n  ArabicConverter,\n  AzerbaijaniConverter,\n  BanglaConverter,\n  BiblicalHebrewConverter,\n  CroatianConverter,\n  CzechConverter,\n  DanishConverter,\n  DutchConverter,\n  EnglishConverter,\n  FilipinoConverter,\n  FrenchConverter,\n  FrenchBelgiumConverter,\n  GermanConverter,\n  GreekConverter,\n  GujaratiConverter,\n  HebrewConverter,\n  HindiConverter,\n  HungarianConverter,\n  IndonesianConverter,\n  ItalianConverter,\n  JapaneseConverter,\n  KannadaConverter,\n  KoreanConverter,\n  LatvianConverter,\n  LithuanianConverter,\n  MalayConverter,\n  MarathiConverter,\n  NorwegianBokmalConverter,\n  PersianConverter,\n  PolishConverter,\n  PortugueseConverter,\n  PunjabiConverter,\n  RomanianConverter,\n  RussianConverter,\n  SerbianCyrillicConverter,\n  SerbianLatinConverter,\n  SimplifiedChineseConverter,\n  SpanishConverter,\n  SwahiliConverter,\n  SwedishConverter,\n  TamilConverter,\n  TeluguConverter,\n  ThaiConverter,\n  TraditionalChineseConverter,\n  TurkishConverter,\n  UkrainianConverter,\n  UrduConverter,\n  VietnameseConverter\n}\n","import { AbstractLanguage } from '../classes/abstract-language.js'\n\n/**\n * Arabic language converter.\n *\n * Supports:\n * - Gender agreement (masculine/feminine forms)\n * - Complex pluralization (singular/dual/plural)\n * - Traditional Arabic number naming conventions\n * - Right-to-left text orientation\n */\nexport class Arabic extends AbstractLanguage {\n  negativeWord = 'ناقص'\n  decimalSeparatorWord = 'فاصلة'\n  zeroWord = 'صفر'\n\n  tensWords = ['عشرون', 'ثلاثون', 'أربعون', 'خمسون', 'ستون', 'سبعون', 'ثمانون', 'تسعون']\n  hundredsWords = ['', 'مائة', 'مئتان', 'ثلاثمائة', 'أربعمائة', 'خمسمائة', 'ستمائة', 'سبعمائة', 'ثمانمائة', 'تسعمائة']\n\n  // Magnitude words with three forms: singular, appended (tanween), plural\n  scaleWords = ['مائة', 'ألف', 'مليون', 'مليار', 'تريليون', 'كوادريليون', 'كوينتليون', 'سكستيليون']\n  scaleAppendedWords = ['', 'ألفاً', 'مليوناً', 'ملياراً', 'تريليوناً', 'كوادريليوناً', 'كوينتليوناً', 'سكستيليوناً']\n  scalePluralWords = ['', 'آلاف', 'ملايين', 'مليارات', 'تريليونات', 'كوادريليونات', 'كوينتليونات', 'سكستيليونات']\n\n  // Dual forms (Arabic has singular, dual, plural)\n  dualWords = ['مئتان', 'ألفان', 'مليونان', 'ملياران', 'تريليونان', 'كوادريليونان', 'كوينتليونان', 'سكستيليونان']\n  dualAppendedWords = ['مئتا', 'ألفا', 'مليونا', 'مليارا', 'تريليونا', 'كوادريليونا', 'كوينتليونا', 'سكستيليونا']\n\n  // Gender-specific number words (1-19)\n  ones = {\n    masculine: [\n      'واحد', 'اثنان', 'ثلاثة', 'أربعة', 'خمسة', 'ستة', 'سبعة', 'ثمانية', 'تسعة', 'عشرة',\n      'أحد عشر', 'اثنا عشر', 'ثلاثة عشر', 'أربعة عشر', 'خمسة عشر', 'ستة عشر', 'سبعة عشر', 'ثمانية عشر', 'تسعة عشر'\n    ],\n    feminine: [\n      'واحدة', 'اثنتان', 'ثلاث', 'أربع', 'خمس', 'ست', 'سبع', 'ثمان', 'تسع', 'عشر',\n      'إحدى عشرة', 'اثنتا عشرة', 'ثلاث عشرة', 'أربع عشرة', 'خمس عشرة', 'ست عشرة', 'سبع عشرة', 'ثماني عشرة', 'تسع عشرة'\n    ]\n  }\n\n  constructor (options = {}) {\n    super()\n\n    this.setOptions({\n      gender: 'masculine'\n    }, options)\n\n    // Allow custom negativeWord via options\n    if (options.negativeWord !== undefined) {\n      this.negativeWord = options.negativeWord\n    }\n  }\n\n  /** Selects masculine or feminine number forms based on options. */\n  get selectedOnes () {\n    return this.ones[this.options.gender === 'feminine' ? 'feminine' : 'masculine']\n  }\n\n  /** Converts a 3-digit segment (0-999) to Arabic words with gender/plural rules. */\n  segmentToWords (groupNumber, groupLevel, fullNumber) {\n    const tens = groupNumber % 100\n    const hundredsRaw = groupNumber / 100\n    const hundreds = Math.trunc(hundredsRaw)\n    let returnValue = ''\n\n    // Process hundreds\n    if (hundreds > 0) {\n      if (tens === 0 && hundreds === 2) {\n        returnValue = this.dualWords[0]\n      } else {\n        const hundredsWord = this.hundredsWords[hundreds]\n        if (hundredsWord) {\n          returnValue = hundredsWord\n          if (tens !== 0) {\n            returnValue += ' و'\n          }\n        }\n      }\n    }\n\n    // Process tens and ones\n    if (tens > 0) {\n      if (tens < 20) { // 1 -> 19\n        if (tens === 2 && hundreds === 0 && groupLevel > 0) {\n          // Cache expensive log10 calculation\n          const numValue = Number(fullNumber)\n          const pow = Math.trunc(Math.log10(numValue))\n          if (pow % 3 === 0 && fullNumber === BigInt(2 * Math.pow(10, pow))) {\n            returnValue = groupNumber === 2 ? this.dualWords[groupLevel] : this.dualAppendedWords[groupLevel]\n          } else {\n            returnValue = this.dualWords[groupLevel]\n          }\n        } else if (tens === 1 && groupLevel > 0) {\n          returnValue += this.scaleWords[groupLevel]\n        } else {\n          returnValue += this.selectedOnes[tens - 1]\n        }\n      } else { // 20 -> 99\n        const ones = tens % 10\n        const tensIndex = Math.trunc(tens / 10) - 2\n\n        if (ones > 0) {\n          returnValue += this.selectedOnes[ones - 1]\n          returnValue += ' و'\n        }\n        returnValue += this.tensWords[tensIndex]\n      }\n    }\n\n    return returnValue\n  }\n\n  /** Converts integer part to Arabic words by processing 3-digit groups. */\n  integerToWords (integerPart) {\n    if (integerPart === 0n) {\n      return this.zeroWord\n    }\n    let temp = integerPart\n    let group = 0\n    let result = ''\n\n    // Process each group of 3 digits (right to left)\n    while (temp > 0n) {\n      const numberToProcess = Number(temp % 1000n)\n      temp = temp / 1000n\n\n      if (numberToProcess > 0) {\n        const groupDescription = this.segmentToWords(numberToProcess, group, integerPart)\n\n        if (groupDescription) {\n          // Add group name for thousands, millions, etc.\n          if (group > 0) {\n            if (result) {\n              result = ' و' + result\n            }\n\n            if (numberToProcess > 2) {\n              const remainder = numberToProcess % 100\n              if (remainder === 1) {\n                result = this.scaleWords[group] + ' ' + result\n              } else if (numberToProcess >= 3 && numberToProcess <= 10) {\n                result = this.scalePluralWords[group] + ' ' + result\n              } else {\n                result = (result ? this.scaleAppendedWords[group] : this.scaleWords[group]) + ' ' + result\n              }\n            }\n          }\n\n          // Add group description (prepend for RTL)\n          result = groupDescription + ' ' + result\n        }\n      }\n\n      group++\n    }\n\n    return result.replace(/\\s+/g, ' ').trim()\n  }\n}\n"],"names":["AbstractLanguage","options","negativeWord","decimalSeparatorWord","zeroWord","wordSeparator","usePerDigitDecimals","this","toWords","isNegative","integerPart","decimalPart","words","push","integerToWords","decimalDigitsToWords","join","Error","setOptions","defaults","userOptions","decimalIntegerToWords","i","length","remainder","slice","char","BigInt","expandScientificNotation","str","mantissa","expStr","toLowerCase","split","exp","parseInt","dotIndex","indexOf","digits","newDotPosition","repeat","ArabicConverter","LanguageClass","tensWords","hundredsWords","scaleWords","scaleAppendedWords","scalePluralWords","dualWords","dualAppendedWords","ones","masculine","feminine","constructor","super","gender","undefined","selectedOnes","segmentToWords","groupNumber","groupLevel","fullNumber","tens","hundredsRaw","hundreds","Math","trunc","returnValue","hundredsWord","numValue","Number","pow","log10","tensIndex","temp","group","result","numberToProcess","groupDescription","replace","trim","value","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","type","isFinite","toString","includes","numberToString","trimmed","isNaN","stringToNormalizedForm","integerStr","parseNumericString","parseNumericValue"],"mappings":"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"}

package/dist/AzerbaijaniConverter.js

@@ -0,0 +1,3 @@
+/*! n2words/AzerbaijaniConverter v2.0.0 | MIT License | github.com/forzagreen/n2words */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{})}(this,function(e){"use strict";class t{#e={};negativeWord="";decimalSeparatorWord="";zeroWord="";wordSeparator=" ";usePerDigitDecimals=!1;get options(){return this.#e}toWords(e,t,n){const r=[];return e&&r.push(this.negativeWord),r.push(this.integerToWords(t)),n&&(r.push(this.decimalSeparatorWord),r.push(...this.decimalDigitsToWords(n))),r.join(this.wordSeparator)}integerToWords(e){throw new Error("integerToWords() must be implemented by subclass")}setOptions(e={},t={}){this.#e={...e,...t}}decimalIntegerToWords(e){return this.integerToWords(e)}decimalDigitsToWords(e){const t=[];let n=0;for(;n<e.length&&"0"===e[n];)t.push(this.zeroWord),n++;const r=e.slice(n);if(!r)return t;if(this.usePerDigitDecimals)for(const e of r)t.push(this.decimalIntegerToWords(BigInt(e)));else t.push(this.decimalIntegerToWords(BigInt(r)));return t}}class n extends t{scaleWords;wordForScale(e){const t=this.scaleWords.find(t=>t[0]===e);return t?.[1]}decomposeInteger(e){const t=[];let n=e;do{const e=this.scaleWords.find(e=>n>=e[0]);if(!e)break;const r=0n===n?1n:n/e[0];1n===r?t.push({[this.wordForScale(1n)]:1n}):t.push(this.decomposeInteger(r)),t.push({[e[1]]:e[0]}),n=0n===n?0n:n%e[0]}while(n>0n);return t}reduceWordSets(e){for(;e.length>1;){const[t,n,...r]=e;if(!Array.isArray(t)&&!Array.isArray(n)){const i=this.combineWordSets(t,n);e=r.length>0?[i,r]:[i];continue}const i=e.map(e=>Array.isArray(e)?1===e.length?e[0]:this.reduceWordSets(e):e);e=i}return e[0]}combineWordSets(e,t){throw new Error("combineWordSets() must be implemented by subclass")}finalizeWords(e){return e.trimEnd()}integerToWords(e){const t=this.decomposeInteger(e),n=this.reduceWordSets(t),r=Object.keys(n)[0];return this.finalizeWords(r)}}class r extends n{combineWordSets(e,t){const[[n,r]]=Object.entries(e),[[i,o]]=Object.entries(t);if(1n===r&&(o<=100n||1000n===o))return t;const s=o>r?r*o:r+o;return{[`${n}${this.wordSeparator}${i}`]:s}}}function i(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const o=(s=class extends r{negativeWord="mənfi";decimalSeparatorWord="nöqtə";zeroWord="sıfır";scaleWords=[[1000000000000000000n,"kentilyon"],[1000000000000000n,"katrilyon"],[1000000000000n,"trilyon"],[1000000000n,"milyar"],[1000000n,"milyon"],[1000n,"min"],[100n,"yüz"],[90n,"doxsan"],[80n,"səksən"],[70n,"yetmiş"],[60n,"altmış"],[50n,"əlli"],[40n,"qırx"],[30n,"otuz"],[20n,"iyirmi"],[10n,"on"],[9n,"doqquz"],[8n,"səkkiz"],[7n,"yeddi"],[6n,"altı"],[5n,"beş"],[4n,"dörd"],[3n,"üç"],[2n,"iki"],[1n,"bir"],[0n,"sıfır"]]},function(e,t){if(void 0!==t&&!function(e){if(null===e||"object"!=typeof e)return!1;const t=Object.getPrototypeOf(e);return t===Object.prototype||null===t}(t))throw new TypeError("options must be a plain object if provided");const{isNegative:n,integerPart:r,decimalPart:o}=function(e){const t=typeof e;if("bigint"===t)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"!==t&&"string"!==t)throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${t}`);const n="number"===t?function(e){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");const t=e.toString();return t.includes("e")||t.includes("E")?i(t):t}(e):function(e){const t=e.trim();if(0===t.length)throw new Error(`Invalid number format: "${e}"`);if(Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?i(t):t}(e);return function(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}(n)}(e);return new s(t).toWords(n,r,o)});var s;e.AzerbaijaniConverter=o});
+//# sourceMappingURL=AzerbaijaniConverter.js.map