hunspell-reader 8.7.0 → 8.8.0

package/dist/IterableHunspellReaderLegacy.js

@@ -1,9 +1,10 @@
-import * as fs from 'fs/promises';
+import * as fs from 'node:fs/promises';
 import { genSequence } from 'gensequence';
 import pkgIconvLite from 'iconv-lite';
 import { parseAffFileToAffLegacy } from './affReader.js';
 import { filterOrderedList } from './util.js';
 const { decode } = pkgIconvLite;
+// eslint-disable-next-line unicorn/text-encoding-identifier-case
 const defaultEncoding = 'UTF-8';
 export class IterableHunspellReaderLegacy {
     src;

package/dist/aff.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { affFlag } from './affConstants.js';
 import { Converter } from './converter.js';
 import { filterOrderedList, groupByField, isDefined } from './util.js';
@@ -81,13 +81,7 @@ export class Aff {
         const { flags } = affWord;
         const subRules = this.affData.getRulesForAffSubstitution(sub);
         const rules = joinRules(affWord.rules, subRules);
-        let word;
-        if (sub.type === 'S') {
-            word = stripped + sub.attach;
-        }
-        else {
-            word = sub.attach + stripped;
-        }
+        const word = sub.type === 'S' ? stripped + sub.attach : sub.attach + stripped;
         return this.affData.toAffixWord(affWord, word, flags, rules);
     }
     #applySubstitution(affWord, subs) {
@@ -338,12 +332,14 @@ class AffData {
     }
     #splitRules(rules) {
         switch (this.affFlagType) {
-            case 'long':
-                return [...new Set(rules.replace(/(..)/g, '$1//').split('//').slice(0, -1))];
-            case 'num':
+            case 'long': {
+                return [...new Set(rules.replaceAll(/(..)/g, '$1//').split('//').slice(0, -1))];
+            }
+            case 'num': {
                 return [...new Set(rules.split(','))];
+            }
         }
-        return [...new Set(rules.split(''))];
+        return [...new Set(rules)];
     }
     #processAffInfo(affInfo) {
         const { AF = [], SFX = [], PFX = [] } = affInfo;
@@ -384,12 +380,9 @@ class AffData {
         const fx = sfx || pfx;
         if (fx) {
             const affFx = this.#mapFx(fx);
-            if (affFx.type === 'P') {
-                return { id, idx: index, type: 'P', flags: 0, fx: affFx };
-            }
-            else {
-                return { id, idx: index, type: 'S', flags: 0, fx: affFx };
-            }
+            return affFx.type === 'P'
+                ? { id, idx: index, type: 'P', flags: 0, fx: affFx }
+                : { id, idx: index, type: 'S', flags: 0, fx: affFx };
         }
         return { id, idx: index, type: 'F', flags: flags || 0 };
     }
@@ -438,10 +431,12 @@ export function toAffFlagType(FLAG) {
         return 'char';
     switch (FLAG) {
         case 'long':
-        case 'num':
+        case 'num': {
             return FLAG;
-        default:
+        }
+        default: {
             throw new Error(`Unexpected FLAG value: ${FLAG}`);
+        }
     }
 }
 //# sourceMappingURL=aff.js.map

package/dist/affLegacy.js

@@ -1,5 +1,5 @@
+import * as util from 'node:util';
 import * as GS from 'gensequence';
-import * as util from 'util';
 import { affFlag, flagToLongStringMap, flagToStringMap } from './affConstants.js';
 import { Converter } from './converter.js';
 import { filterOrderedList, isDefined } from './util.js';
@@ -127,7 +127,7 @@ export class Aff {
     }
     getMatchingRules(rules) {
         const { AF = [] } = this.affInfo;
-        const idx = regExpIsNumber.test(rules) ? parseInt(rules, 10) : -1;
+        const idx = regExpIsNumber.test(rules) ? Number.parseInt(rules, 10) : -1;
         const rulesToSplit = AF[idx] || rules;
         return this.separateRules(rulesToSplit)
             .map((key) => this.rules.get(key))
@@ -135,10 +135,12 @@ export class Aff {
     }
     joinRules(rules) {
         switch (this.affInfo.FLAG) {
-            case 'long':
+            case 'long': {
                 return rules.join('');
-            case 'num':
+            }
+            case 'num': {
                 return rules.join(',');
+            }
         }
         return rules.join('');
     }
@@ -152,12 +154,14 @@ export class Aff {
     }
     #separateRules(rules) {
         switch (this.affInfo.FLAG) {
-            case 'long':
-                return [...new Set(rules.replace(/(..)/g, '$1//').split('//').slice(0, -1))];
-            case 'num':
+            case 'long': {
+                return [...new Set(rules.replaceAll(/(..)/g, '$1//').split('//').slice(0, -1))];
+            }
+            case 'num': {
                 return [...new Set(rules.split(','))];
+            }
         }
-        return [...new Set(rules.split(''))];
+        return [...new Set(rules)];
     }
     get iConv() {
         return this._iConv;
@@ -182,11 +186,10 @@ export function processRules(affInfo) {
     const pfxRules = [...(affInfo.PFX || [])]
         .map(([, pfx]) => pfx)
         .map((pfx) => ({ id: pfx.id, type: 'pfx', pfx }));
-    const flagRules = [
-        ...GS.sequenceFromObject(affInfo)
-            .filter(([key, value]) => !!affFlag[key] && !!value)
-            .map(([key, value]) => ({ id: value, type: 'flag', flags: affFlag[key] })),
-    ];
+    const flagRules = GS.sequenceFromObject(affInfo)
+        .filter(([key, value]) => !!affFlag[key] && !!value)
+        .map(([key, value]) => ({ id: value, type: 'flag', flags: affFlag[key] }))
+        .toArray();
     const rules = [...sfxRules, ...pfxRules, ...flagRules].reduce((acc, rule) => {
         acc.set(rule.id, rule);
         return acc;
@@ -205,7 +208,7 @@ export function logAffWord(affWord, message) {
 export function affWordToColoredString(affWord) {
     return util
         .inspect({ ...affWord, flags: flagsToString(affWord.flags) }, { showHidden: false, depth: 5, colors: true })
-        .replace(/(\s|\n|\r)+/g, ' ');
+        .replaceAll(/(\s|\n|\r)+/g, ' ');
 }
 /* istanbul ignore next */
 export function flagsToString(flags) {

package/dist/affReader.js

@@ -1,5 +1,6 @@
-import assert from 'assert';
-import { readFile } from 'fs/promises';
+/* eslint-disable unicorn/text-encoding-identifier-case */
+import assert from 'node:assert';
+import { readFile } from 'node:fs/promises';
 import { decode as decodeHtmlEntities } from 'html-entities';
 import pkgIconvLite from 'iconv-lite';
 import { Aff } from './aff.js';
@@ -129,7 +130,7 @@ function parseAffixCreation(line) {
     const fx = {
         id: flag,
         type: line.option === 'SFX' ? 'SFX' : 'PFX',
-        combinable: !!combinable.match(yesRegex),
+        combinable: !!yesRegex.test(combinable),
         count,
         extra,
         substitutionSets: new Map(),
@@ -181,7 +182,7 @@ function fixMatch(type, match) {
 function affixMatchToRegExpString(match) {
     if (match === '0')
         return '';
-    return match.replace(/([\\\-?*])/g, '\\$1');
+    return match.replaceAll(/([\\\-?*])/g, '\\$1');
 }
 function collectFx() {
     let value;
@@ -196,8 +197,8 @@ function collectFx() {
 const asPfx = collectFx;
 const asSfx = collectFx;
 const asString = () => collectPrimitive((v) => v, '');
-const asBoolean = () => collectPrimitive((v) => !!parseInt(v), '1');
-const asNumber = () => collectPrimitive(parseInt, '0');
+const asBoolean = () => collectPrimitive((v) => !!Number.parseInt(v), '1');
+const asNumber = () => collectPrimitive(Number.parseInt, '0');
 function collectPrimitive(map, defaultValue = '') {
     let primitive;
     function getValue() {
@@ -323,7 +324,7 @@ export async function parseAffFile(filename, encoding = UTF8) {
     return affInfo;
 }
 function convertHtmlEntities(line, index) {
-    if (line.indexOf('&') < 0)
+    if (!line.includes('&'))
         return line;
     const fixed = decodeHtmlEntities(line);
     if (fixed !== line) {

package/dist/affToDicInfo.js

@@ -23,13 +23,13 @@ function extractAlphabet(aff, locale) {
     ];
     const setOfLetters = new Set(sources
         .filter(isDefined)
-        .flatMap((a) => a)
+        .flat()
         .map((a) => a.normalize())
         .flatMap((a) => [...a, ...a.toLocaleLowerCase(locale), ...a.toLocaleUpperCase(locale)])
         .map((a) => a.trim())
         .filter((a) => !!a));
-    const alphabet = [...setOfLetters].sort().join('').replace(/\P{L}/gu, '');
-    const accents = new Set(alphabet.normalize('NFD').replace(/\P{M}/gu, ''));
+    const alphabet = [...setOfLetters].sort().join('').replaceAll(/\P{L}/gu, '');
+    const accents = new Set(alphabet.normalize('NFD').replaceAll(/\P{M}/gu, ''));
     return { locale, alphabet, accents };
 }
 function isDefined(a) {

package/dist/app.js

@@ -1,5 +1,5 @@
+import { readFileSync } from 'node:fs';
 import { program } from 'commander';
-import { readFileSync } from 'fs';
 import { getCommand as getDictInfoCommand } from './commandDictInfo.js';
 import { getCommand as commandWords } from './commandWords.js';
 const pkgRaw = readFileSync(new URL('../package.json', import.meta.url), 'utf8');

package/dist/commandDictInfo.js

@@ -16,7 +16,7 @@ async function action(hunspellFile, locale) {
     const affFile = baseFile + '.aff';
     const aff = await parseAffFile(affFile);
     const info = affToDicInfo(aff, locale);
-    const rawJson = JSON.stringify(info, null, 2);
+    const rawJson = JSON.stringify(info, undefined, 2);
     console.log(escapeUnicodeCode(rawJson));
 }
 //# sourceMappingURL=commandDictInfo.js.map

package/dist/commandWords.js

@@ -1,12 +1,12 @@
 // cSpell:ignore findup
+import { createWriteStream, openSync, writeSync } from 'node:fs';
 import { Command } from 'commander';
-import { createWriteStream, openSync, writeSync } from 'fs';
 import { genSequence } from 'gensequence';
 import { asAffWord } from './affLegacy.js';
 import { IterableHunspellReaderLegacy } from './IterableHunspellReaderLegacy.js';
 import { iterableToStream } from './iterableToStream.js';
 import { batch, uniqueFilter } from './util.js';
-const uniqueHistorySize = 500000;
+const uniqueHistorySize = 500_000;
 let logStream = process.stderr;
 export function getCommand() {
     const commander = new Command('words');
@@ -31,7 +31,7 @@ export function getCommand() {
 }
 function notify(message, newLine = true) {
     message = message + (newLine ? '\n' : '');
-    logStream.write(message, 'utf-8');
+    logStream.write(message, 'utf8');
 }
 function yesNo(value) {
     return value ? 'Yes' : 'No';
@@ -138,7 +138,7 @@ async function actionPrime(hunspellDicFilename, options) {
     const callback = showProgress
         ? () => {
             current++;
-            !(current % reportProgressRate) && process.stderr.write(calcProgress(), 'utf-8');
+            !(current % reportProgressRate) && process.stderr.write(calcProgress(), 'utf8');
         }
         : () => {
             /* void */

package/dist/converter.js

@@ -3,7 +3,7 @@ export class Converter {
     _match;
     _map;
     constructor(convList) {
-        const match = convList.map(({ from }) => from.replace(regexSpecialCharacters, '\\$&')).join('|');
+        const match = convList.map(({ from }) => from.replaceAll(regexSpecialCharacters, '\\$&')).join('|');
         this._match = new RegExp(match, 'g');
         this._map = Object.create(null);
         convList.reduce((map, { from, to }) => {

package/dist/iterableToStream.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import * as stream from 'stream';
+import * as stream from 'node:stream';
 export type Streamable = string | Buffer;
 export type IterableLike<T> = Iterable<T> | IterableIterator<T>;
 /**

package/dist/iterableToStream.js

@@ -1,9 +1,9 @@
-import * as stream from 'stream';
+import * as stream from 'node:stream';
 /**
  * Transform an iterable into a node readable stream.
  */
-export function iterableToStream(src, options = { encoding: 'utf8' }) {
-    return new ReadableObservableStream(src, options);
+export function iterableToStream(src, options) {
+    return new ReadableObservableStream(src, options ?? { encoding: 'utf8' });
 }
 class ReadableObservableStream extends stream.Readable {
     _source;
@@ -18,6 +18,9 @@ class ReadableObservableStream extends stream.Readable {
             this.iter = this._source[Symbol.iterator]();
         }
         if (this.done) {
+            // See: https://nodejs.org/api/stream.html#readablepushchunk-encoding
+            // Pushing null means the stream is done.
+            // eslint-disable-next-line unicorn/no-null
             this.push(null);
             return;
         }
@@ -31,6 +34,9 @@ class ReadableObservableStream extends stream.Readable {
             if (r.value !== null && r.value !== undefined) {
                 this.push(r.value);
             }
+            // See: https://nodejs.org/api/stream.html#readablepushchunk-encoding
+            // Pushing null means the stream is done.
+            // eslint-disable-next-line unicorn/no-null
             this.push(null);
         }
     }

package/dist/textUtils.js

@@ -11,15 +11,19 @@ function replaceWithUnicode(substring) {
     const start = 0x20;
     const end = 0x7a;
     let val = '';
-    for (let i = 0; i < substring.length; ++i) {
-        const char = substring[i];
-        const code = char.charCodeAt(0);
+    for (const char of substring) {
+        const code = char.codePointAt(0) || 0;
         if (code >= start && code <= end) {
             val += char;
             continue;
         }
-        const hex = '0000' + code.toString(16);
-        val += code < 256 ? '\\x' + hex.slice(-2) : '\\u' + hex.slice(-4);
+        for (let i = 0; i < char.length; i += 1) {
+            // Use charCodeAt to get the value because JSON does not handle \u{10000} correctly.
+            // eslint-disable-next-line unicorn/prefer-code-point
+            const code = char.charCodeAt(i);
+            const hex = code.toString(16).toUpperCase().padStart(4, '0');
+            val += code < 256 ? '\\x' + hex.slice(-2) : hex.length === 4 ? '\\u' + hex : '\\u{' + hex + '}';
+        }
     }
     return val;
 }
@@ -44,7 +48,7 @@ export function toRange(letters, minLength = 4) {
             return;
         }
         for (let code = begin + 1; code < end; code += 1) {
-            chars.push(String.fromCharCode(code));
+            chars.push(String.fromCodePoint(code));
         }
     }
     function pushRange() {
@@ -52,9 +56,8 @@ export function toRange(letters, minLength = 4) {
         chars.push(endChar);
         endChar = '';
     }
-    for (let i = 0; i < letters.length; ++i) {
-        const letter = letters[i];
-        const code = letter.charCodeAt(0);
+    for (const letter of letters) {
+        const code = letter.codePointAt(0) || 0;
         if (code - end === 1) {
             end = code;
             endChar = letter;
@@ -72,6 +75,6 @@ export function removeAccents(text) {
     return removeLooseAccents(text.normalize('NFD'));
 }
 export function removeLooseAccents(text) {
-    return text.replace(/\p{M}/gu, '');
+    return text.replaceAll(/\p{M}/gu, '');
 }
 //# sourceMappingURL=textUtils.js.map

package/dist/util.js

@@ -1,5 +1,5 @@
 export function hrTimeToSeconds([seconds, nanoseconds]) {
-    return seconds + nanoseconds / 1000000000;
+    return seconds + nanoseconds / 1_000_000_000;
 }
 export function uniqueFilter(historySize, key = (a) => a) {
     const f0 = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hunspell-reader",
-  "version": "8.7.0",
+  "version": "8.8.0",
   "description": "A library for reading Hunspell Dictionary Files",
   "bin": "bin.js",
   "type": "module",
@@ -44,8 +44,8 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/hunspell-reader#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "^8.7.0",
-    "@cspell/cspell-types": "^8.7.0",
+    "@cspell/cspell-pipe": "^8.8.0",
+    "@cspell/cspell-types": "^8.8.0",
     "commander": "^12.0.0",
     "gensequence": "^7.0.0",
     "html-entities": "^2.5.2",
@@ -54,5 +54,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "5318079ed11fe77e981287ecf1c40d6f28dd91ed"
+  "gitHead": "a42bce675c00cb2d51809b3ae3894119ea4f5ce7"
 }