@cspell/cspell-tools 9.5.0 → 9.6.1

package/dist/compiler/readers/readTextFile.d.ts

@@ -1,3 +0,0 @@
-export declare function readTextFile(filename: string): Promise<string>;
-export declare function readTextFileLines(filename: string): Promise<string[]>;
-//# sourceMappingURL=readTextFile.d.ts.map

package/dist/compiler/readers/readTextFile.js

@@ -1,20 +0,0 @@
-import assert from 'node:assert';
-import { Buffer } from 'node:buffer';
-import { promises as fs } from 'node:fs';
-import { decompress } from '../../gzip/index.js';
-const isGzFile = /\.gz$/;
-export function readTextFile(filename) {
-    const content = fs
-        .readFile(filename)
-        .then(async (buffer) => (isGzFile.test(filename) ? decompress(buffer) : buffer))
-        .then((buffer) => (assertIsBuffer(buffer), buffer.toString('utf8')));
-    return content;
-}
-export async function readTextFileLines(filename) {
-    const content = await readTextFile(filename);
-    return content.split('\n');
-}
-function assertIsBuffer(value) {
-    assert(Buffer.isBuffer(value));
-}
-//# sourceMappingURL=readTextFile.js.map

package/dist/compiler/readers/regHunspellFile.d.ts

@@ -1,2 +0,0 @@
-export declare const regHunspellFile: RegExp;
-//# sourceMappingURL=regHunspellFile.d.ts.map

package/dist/compiler/readers/regHunspellFile.js

@@ -1,2 +0,0 @@
-export const regHunspellFile = /\.(dic|aff)$/i;
-//# sourceMappingURL=regHunspellFile.js.map

package/dist/compiler/readers/textFileReader.d.ts

@@ -1,3 +0,0 @@
-import type { BaseReader } from './ReaderOptions.js';
-export declare function textFileReader(filename: string): Promise<BaseReader>;
-//# sourceMappingURL=textFileReader.d.ts.map

package/dist/compiler/readers/textFileReader.js

@@ -1,11 +0,0 @@
-import { readTextFile } from './readTextFile.js';
-export async function textFileReader(filename) {
-    const content = await readTextFile(filename);
-    const words = content.split('\n').map((s) => s.trim());
-    return {
-        type: 'TextFile',
-        size: words.length,
-        lines: words,
-    };
-}
-//# sourceMappingURL=textFileReader.js.map

package/dist/compiler/readers/trieFileReader.d.ts

@@ -1,3 +0,0 @@
-import type { DictionaryReader } from './ReaderOptions.js';
-export declare function trieFileReader(filename: string): Promise<DictionaryReader>;
-//# sourceMappingURL=trieFileReader.d.ts.map

package/dist/compiler/readers/trieFileReader.js

@@ -1,16 +0,0 @@
-import { importTrie, Trie } from 'cspell-trie-lib';
-import { readTextFileLines } from './readTextFile.js';
-export async function trieFileReader(filename) {
-    const trieRoot = importTrie(await readTextFileLines(filename));
-    const trie = new Trie(trieRoot);
-    const words = trie.words();
-    return {
-        type: 'Trie',
-        get size() {
-            return trie.size();
-        },
-        lines: words,
-        hasWord: (word, caseSensitive) => trie.hasWord(word, caseSensitive),
-    };
-}
-//# sourceMappingURL=trieFileReader.js.map

package/dist/compiler/splitCamelCaseIfAllowed.d.ts

@@ -1,5 +0,0 @@
-import type { AllowedSplitWordsCollection } from './WordsCollection.js';
-export declare const regExpSpaceOrDash: RegExp;
-export declare const regExpIsNumber: RegExp;
-export declare function splitCamelCaseIfAllowed(word: string, allowedWords: AllowedSplitWordsCollection, keepCase: boolean, compoundPrefix: string, minCompoundLength: number): string[];
-//# sourceMappingURL=splitCamelCaseIfAllowed.d.ts.map

package/dist/compiler/splitCamelCaseIfAllowed.js

@@ -1,65 +0,0 @@
-import { isSingleLetter, splitCamelCaseWord } from './text.js';
-export const regExpSpaceOrDash = /[- ]+/g;
-export const regExpIsNumber = /^\d+$/;
-export function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, minCompoundLength) {
-    const split = [...splitCamelCase(word)];
-    if (split.length == 1)
-        return adjustCases(split, allowedWords, keepCase);
-    const missing = split.some((w) => isUnknown(w, allowedWords));
-    if (missing)
-        return [word];
-    const wordIndexes = calcWordIndex(word, split);
-    const adjusted = adjustCases(split, allowedWords, keepCase);
-    return !compoundPrefix
-        ? adjusted
-        : adjusted.map((w, i) => {
-            const { px, sx } = wordIndexes[i];
-            const canCompound = w.length >= minCompoundLength;
-            const lc = w.toLowerCase();
-            const p = canCompound && isSingleLetter(px) ? compoundPrefix : '';
-            const s = canCompound && isSingleLetter(sx) ? compoundPrefix : '';
-            if (lc.length < 4 || allowedWords.has(w, true))
-                return p + w + s;
-            return p + lc + s;
-        });
-}
-function adjustCases(words, allowedWords, keepCase) {
-    return words.map((w) => adjustCase(w, allowedWords, keepCase));
-}
-function adjustCase(word, allowedWords, keepCase) {
-    const lc = word.toLowerCase();
-    if (!allowedWords.has(lc, true))
-        return word;
-    if (lc === word)
-        return word;
-    if (word.slice(1).toLowerCase() === word.slice(1))
-        return lc;
-    if (!keepCase && word.toUpperCase() === word)
-        return word.toLowerCase();
-    return word;
-}
-function isUnknown(word, allowedWords) {
-    if (word === 'ERROR') {
-        return !allowedWords.has(word, false);
-    }
-    return !allowedWords.has(word, false);
-}
-function splitCamelCase(word) {
-    const splitWords = splitCamelCaseWord(word).filter((word) => !regExpIsNumber.test(word));
-    // We only want to preserve this: "New York" and not "Namespace DNSLookup"
-    if (splitWords.length > 1 && regExpSpaceOrDash.test(word)) {
-        return splitWords.flatMap((w) => w.split(regExpSpaceOrDash));
-    }
-    return splitWords;
-}
-function calcWordIndex(word, words) {
-    let i = 0;
-    return words.map((w) => {
-        const j = word.indexOf(w, i);
-        const k = j + w.length;
-        const wIndex = { word: w, i: j, px: word[j - 1] || '', sx: word[k] || '' };
-        i = k;
-        return wIndex;
-    });
-}
-//# sourceMappingURL=splitCamelCaseIfAllowed.js.map

package/dist/compiler/streamSourceWordsFromFile.d.ts

@@ -1,3 +0,0 @@
-import type { SourceReaderOptions } from './SourceReader.js';
-export declare function streamSourceWordsFromFile(filename: string, options: SourceReaderOptions): Promise<Iterable<string>>;
-//# sourceMappingURL=streamSourceWordsFromFile.d.ts.map

package/dist/compiler/streamSourceWordsFromFile.js

@@ -1,6 +0,0 @@
-import { createSourceReader } from './SourceReader.js';
-export async function streamSourceWordsFromFile(filename, options) {
-    const reader = await createSourceReader(filename, options);
-    return reader.words;
-}
-//# sourceMappingURL=streamSourceWordsFromFile.js.map

package/dist/compiler/text.d.ts

@@ -1,10 +0,0 @@
-/**
- * Split camelCase words into an array of strings.
- */
-export declare function splitCamelCaseWord(word: string): string[];
-/**
- * Split camelCase words into an array of strings, try to fix English words.
- */
-export declare function splitCamelCaseWordAutoStem(word: string): string[];
-export declare function isSingleLetter(c: string): boolean;
-//# sourceMappingURL=text.d.ts.map

package/dist/compiler/text.js

@@ -1,28 +0,0 @@
-// cSpell:ignore ings ning gimuy
-const regExUpperSOrIng = /(\p{Lu}+'?(?:s|ing|ies|es|ings|ed|ning))(?!\p{Ll})/gu;
-const regExSplitWords = /([\p{Ll}])([\p{Lu}])/gu;
-const regExSplitWords2 = /(\p{Lu})(\p{Lu}\p{Ll})/gu;
-const regExpIsLetter = /^\p{L}\p{M}{0,2}$/u;
-/**
- * Split camelCase words into an array of strings.
- */
-export function splitCamelCaseWord(word) {
-    const pass1 = word.replaceAll(regExSplitWords, '$1|$2');
-    const pass2 = pass1.replaceAll(regExSplitWords2, '$1|$2');
-    const pass3 = pass2.replaceAll(/[\d_]+/g, '|');
-    return pass3.split('|').filter((a) => !!a);
-}
-/**
- * Split camelCase words into an array of strings, try to fix English words.
- */
-export function splitCamelCaseWordAutoStem(word) {
-    return splitCamelCaseWord(word.replaceAll(regExUpperSOrIng, tailToLowerCase));
-}
-function tailToLowerCase(word) {
-    const letters = [...word];
-    return letters[0] + letters.slice(1).join('').toLowerCase();
-}
-export function isSingleLetter(c) {
-    return regExpIsLetter.test(c);
-}
-//# sourceMappingURL=text.js.map

package/dist/compiler/wordListCompiler.d.ts

@@ -1,21 +0,0 @@
-import type { CompileOptions } from './CompileOptions.js';
-import { WordListCompiler } from './CompilerDefinitions.js';
-export declare function compileWordListToTarget(lines: Iterable<string>, destFilename: string, options: CompileOptions): Promise<void>;
-export declare function createWordListCompiler(options: CompileOptions): WordListCompiler;
-declare function removeDuplicates(words: Iterable<string>): Iterable<string>;
-export declare function createTargetFile(destFilename: string, seq: Iterable<string> | string, compress?: boolean): Promise<void>;
-export interface TrieOptions {
-    base?: number | undefined;
-    trie3?: boolean | undefined;
-    trie4?: boolean | undefined;
-}
-export interface CompileTrieOptions extends CompileOptions, TrieOptions {
-}
-export declare function compileTrieToTarget(words: Iterable<string>, destFilename: string, options: CompileTrieOptions): Promise<void>;
-export declare function createTrieCompiler(options: TrieOptions): WordListCompiler;
-export declare const __testing__: {
-    wordListHeader: string;
-    removeDuplicates: typeof removeDuplicates;
-};
-export {};
-//# sourceMappingURL=wordListCompiler.d.ts.map

package/dist/compiler/wordListCompiler.js

@@ -1,205 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import * as path from 'node:path';
-import { opAppend, opMap, pipe } from '@cspell/cspell-pipe/sync';
-import * as Trie from 'cspell-trie-lib';
-import { getLogger } from './logger.js';
-import { normalizeTargetWords } from './wordListParser.js';
-import { writeTextToFile } from './writeTextToFile.js';
-const mkdirp = async (p) => {
-    await mkdir(p, { recursive: true });
-};
-// Indicate that a word list has already been processed.
-const wordListHeader = `
-# cspell-tools: keep-case no-split`;
-const wordListHeaderLines = wordListHeader.split('\n').map((a) => a.trim());
-export async function compileWordListToTarget(lines, destFilename, options) {
-    const compiler = createWordListCompiler(options);
-    return createTargetFile(destFilename, compiler(lines));
-}
-export function createWordListCompiler(options) {
-    return (lines) => {
-        const finalLines = normalize(lines, options);
-        const directives = options.dictionaryDirectives ?? [];
-        const directivesLines = directives.map((a) => `# cspell-dictionary: ${a}`);
-        return pipe([...wordListHeaderLines, ...directivesLines, ''], opAppend(finalLines), opMap((a) => a + '\n'));
-    };
-}
-function normalize(lines, options) {
-    const filter = normalizeTargetWords(options);
-    const cleanLines = options.removeDuplicates ? removeDuplicates(lines) : lines;
-    const iter = pipe(cleanLines, filter);
-    if (!options.sort)
-        return iter;
-    const result = new Set(iter);
-    return [...result].sort();
-}
-function stripCompoundAFix(word) {
-    return word.replaceAll('*', '').replaceAll('+', '');
-}
-function* removeDuplicates(words) {
-    const wordSet = new Set(words);
-    const wordForms = new Map();
-    for (const word of wordSet) {
-        const lc = stripCompoundAFix(word.toLowerCase());
-        const forms = wordForms.get(lc) ?? [];
-        forms.push(word);
-        wordForms.set(lc, forms);
-    }
-    for (const forms of wordForms.values()) {
-        if (forms.length <= 1) {
-            yield* forms;
-            continue;
-        }
-        const mForms = removeDuplicateForms(forms);
-        // if (forms.some((a) => /^[*+]?col[*+]?$/.test(a))) {
-        //     console.warn('Found col %o', { forms, mForms });
-        // }
-        if (mForms.size <= 1) {
-            for (const form of mForms.values()) {
-                yield* form;
-            }
-            continue;
-        }
-        // Handle upper / lower mix.
-        const words = [...mForms.keys()];
-        const lc = words[0].toLowerCase();
-        const lcForm = mForms.get(lc);
-        if (!lcForm) {
-            for (const form of mForms.values()) {
-                yield* form;
-            }
-            continue;
-        }
-        mForms.delete(lc);
-        const sLcForms = new Set(lcForm);
-        yield* lcForm;
-        if (sLcForms.has('*' + lc + '*'))
-            continue;
-        for (const forms of mForms.values()) {
-            for (const form of forms) {
-                if (sLcForms.has(form.toLowerCase()))
-                    continue;
-                yield form;
-            }
-        }
-    }
-}
-/**
- * solo
- * optional_prefix*
- * optional_suffix*
- * required_prefix+
- * required_suffix+
- */
-var Flags;
-(function (Flags) {
-    Flags[Flags["base"] = 0] = "base";
-    Flags[Flags["none"] = 1] = "none";
-    Flags[Flags["both"] = 2] = "both";
-    Flags[Flags["pfx"] = 4] = "pfx";
-    Flags[Flags["sfx"] = 8] = "sfx";
-    Flags[Flags["all"] = 15] = "all";
-})(Flags || (Flags = {}));
-function applyFlags(word, flags) {
-    if (flags === Flags.none)
-        return [word];
-    if (flags === Flags.all)
-        return ['*' + word + '*'];
-    if (flags === Flags.both)
-        return ['+' + word + '+'];
-    if (flags === Flags.pfx)
-        return [word + '+'];
-    if (flags === Flags.sfx)
-        return ['+' + word];
-    if (flags === (Flags.none | Flags.sfx))
-        return ['*' + word];
-    if (flags === (Flags.none | Flags.pfx))
-        return [word + '*'];
-    if (flags === (Flags.none | Flags.pfx | Flags.sfx))
-        return [word + '*', '*' + word];
-    if (flags === (Flags.none | Flags.both)) {
-        // the "correct" answer is [word, '+' + word + '+']
-        // but practically it makes sense to allow all combinations.
-        return ['*' + word + '*'];
-    }
-    if (flags === (Flags.none | Flags.both | Flags.sfx))
-        return [word, '+' + word + '*'];
-    if (flags === (Flags.none | Flags.both | Flags.pfx))
-        return [word, '*' + word + '+'];
-    if (flags === (Flags.both | Flags.pfx))
-        return ['*' + word + '+'];
-    if (flags === (Flags.both | Flags.sfx))
-        return ['+' + word + '*'];
-    if (flags === (Flags.both | Flags.pfx | Flags.sfx))
-        return ['+' + word + '*', '*' + word + '+'];
-    return ['+' + word, word + '+'];
-}
-function removeDuplicateForms(forms) {
-    function flags(word, flag = 0) {
-        const canBePrefix = word.endsWith('*');
-        const mustBePrefix = !canBePrefix && word.endsWith('+');
-        const isPrefix = canBePrefix || mustBePrefix;
-        const canBeSuffix = word.startsWith('*');
-        const mustBeSuffix = !canBeSuffix && word.startsWith('+');
-        const isSuffix = canBeSuffix || mustBeSuffix;
-        if (canBePrefix && canBeSuffix)
-            return flag | Flags.all;
-        if (mustBePrefix && mustBeSuffix)
-            return flag | Flags.both;
-        if (!isPrefix && !isSuffix)
-            return flag | Flags.none;
-        flag |= isPrefix && !isSuffix ? Flags.pfx : 0;
-        flag |= isSuffix && !isPrefix ? Flags.sfx : 0;
-        flag |= canBePrefix && !mustBeSuffix ? Flags.none : 0;
-        flag |= canBeSuffix && !mustBePrefix ? Flags.none : 0;
-        return flag;
-    }
-    const m = new Map();
-    for (const form of forms) {
-        const k = stripCompoundAFix(form);
-        m.set(k, flags(form, m.get(k)));
-    }
-    return new Map([...m.entries()].map(([form, flag]) => {
-        return [form, applyFlags(form, flag)];
-    }));
-}
-export async function createTargetFile(destFilename, seq, compress) {
-    const rel = path.relative(process.cwd(), destFilename).replaceAll(path.sep, '/');
-    const log = getLogger();
-    log(`Writing to file ${rel}${compress ? '.gz' : ''}`);
-    const destDir = path.dirname(destFilename);
-    await mkdirp(destDir);
-    await writeTextToFile(destFilename, seq, compress);
-}
-export async function compileTrieToTarget(words, destFilename, options) {
-    await createTrieTarget(destFilename, options)(words);
-}
-function createTrieTarget(destFilename, options) {
-    return async (words) => {
-        await createTargetFile(destFilename, createTrieCompiler(options)(words));
-        const log = getLogger();
-        log(`Done writing to file ${path.basename(destFilename)}`);
-    };
-}
-export function createTrieCompiler(options) {
-    return (words) => {
-        const log = getLogger();
-        log('Reading Words into Trie');
-        const base = options.base ?? 32;
-        const version = options.trie4 ? 4 : options.trie3 ? 3 : 1;
-        const root = Trie.buildTrie(words).root;
-        log('Reduce duplicate word endings');
-        const trie = Trie.consolidate(root);
-        log('Trie compilation complete');
-        return Trie.serializeTrie(trie, {
-            base,
-            comment: 'Built by cspell-tools.',
-            version,
-        });
-    };
-}
-export const __testing__ = {
-    wordListHeader,
-    removeDuplicates,
-};
-//# sourceMappingURL=wordListCompiler.js.map

package/dist/compiler/wordListParser.d.ts

@@ -1,61 +0,0 @@
-import { type Operator } from '@cspell/cspell-pipe/sync';
-import type { CompileOptions } from './CompileOptions.js';
-import type { AllowedSplitWordsCollection } from './WordsCollection.js';
-export declare function normalizeTargetWords(options: CompileOptions): Operator<string>;
-export interface ParseFileOptions {
-    /**
-     * Preserve case
-     * @default true
-     */
-    keepCase?: boolean | undefined;
-    /**
-     * Tell the parser to split into words along spaces.
-     * @default false
-     */
-    split?: boolean | undefined;
-    /**
-     * When splitting tells the parser to output both the split and non-split versions of the line.
-     * @default false
-     */
-    splitKeepBoth?: boolean | undefined;
-    /**
-     * Use legacy splitting.
-     * @default false
-     */
-    legacy?: boolean | undefined;
-    allowedSplitWords: AllowedSplitWordsCollection;
-    /**
-     * Words that have been split using the `allowedSplitWords` are added to the dictionary as compoundable words.
-     * These words are prefixed / suffixed with `*`.
-     * @default undefined
-     */
-    storeSplitWordsAsCompounds: boolean | undefined;
-    /**
-     * Controls the minimum length of a compound word when storing words using `storeSplitWordsAsCompounds`.
-     * The compound words are prefixed / suffixed with `*`, to allow them to be combined with other compound words.
-     * If the length is too low, then the dictionary will consider many misspelled words as correct.
-     * @default 4
-     */
-    minCompoundLength: number | undefined;
-}
-type ParseFileOptionsRequired = Required<ParseFileOptions>;
-export declare const defaultParseDictionaryOptions: ParseFileOptionsRequired;
-export declare const cSpellToolDirective = "cspell-tools:";
-export declare const setOfCSpellDirectiveFlags: string[];
-/**
- * Normalizes a dictionary words based upon prefix / suffixes.
- * Case insensitive versions are also generated.
- * @param options - defines prefixes used when parsing lines.
- * @returns words that have been normalized.
- */
-export declare function createParseFileLineMapper(options?: Partial<ParseFileOptions>): Operator<string>;
-/**
- * Normalizes a dictionary words based upon prefix / suffixes.
- * Case insensitive versions are also generated.
- * @param lines - one word per line
- * @param _options - defines prefixes used when parsing lines.
- * @returns words that have been normalized.
- */
-export declare function parseFileLines(lines: Iterable<string> | string, options: ParseFileOptions): Iterable<string>;
-export {};
-//# sourceMappingURL=wordListParser.d.ts.map

package/dist/compiler/wordListParser.js

@@ -1,184 +0,0 @@
-import { opCombine, opCombine as opPipe, opFilter, opMap } from '@cspell/cspell-pipe/sync';
-import { createDictionaryLineParser } from 'cspell-trie-lib';
-import { uniqueFilter } from 'hunspell-reader';
-import { defaultCompileSourceOptions } from '../config/configDefaults.js';
-import { legacyLineToWords } from './legacyLineToWords.js';
-import { splitCamelCaseIfAllowed } from './splitCamelCaseIfAllowed.js';
-export function normalizeTargetWords(options) {
-    const lineParser = createDictionaryLineParser({
-        stripCaseAndAccents: options.generateNonStrict,
-        stripCaseAndAccentsOnForbidden: true,
-        keepOptionalCompoundCharacter: true,
-    });
-    const operations = [
-        opFilter((a) => !!a),
-        lineParser,
-        options.sort ? createInlineBufferedSort(10_000) : undefined,
-        opFilter(uniqueFilter(10_000)),
-        options.filter ? opFilter(options.filter) : undefined,
-    ].filter(isDefined);
-    return opCombine(...operations);
-}
-function isDefined(v) {
-    return v !== undefined;
-}
-function createInlineBufferedSort(bufferSize = 1000) {
-    function* inlineBufferedSort(lines) {
-        const buffer = [];
-        for (const line of lines) {
-            buffer.push(line);
-            if (buffer.length >= bufferSize) {
-                buffer.sort();
-                yield* buffer;
-                buffer.length = 0;
-            }
-        }
-        buffer.sort();
-        yield* buffer;
-    }
-    return inlineBufferedSort;
-}
-const commentCharacter = '#';
-const _defaultOptions = {
-    keepCase: true,
-    legacy: false,
-    split: false,
-    splitKeepBoth: false,
-    // splitSeparator: regExpSplit,
-    allowedSplitWords: { has: () => true, size: 0 },
-    storeSplitWordsAsCompounds: defaultCompileSourceOptions.storeSplitWordsAsCompounds,
-    minCompoundLength: defaultCompileSourceOptions.minCompoundLength,
-};
-export const defaultParseDictionaryOptions = Object.freeze(_defaultOptions);
-export const cSpellToolDirective = 'cspell-tools:';
-export const setOfCSpellDirectiveFlags = ['no-split', 'split', 'keep-case', 'no-keep-case', 'legacy'];
-/**
- * Normalizes a dictionary words based upon prefix / suffixes.
- * Case insensitive versions are also generated.
- * @param options - defines prefixes used when parsing lines.
- * @returns words that have been normalized.
- */
-export function createParseFileLineMapper(options) {
-    const _options = options || _defaultOptions;
-    const { splitKeepBoth = _defaultOptions.splitKeepBoth, allowedSplitWords = _defaultOptions.allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength = _defaultOptions.minCompoundLength, } = _options;
-    let { legacy = _defaultOptions.legacy } = _options;
-    let { split = _defaultOptions.split, keepCase = legacy ? false : _defaultOptions.keepCase } = _options;
-    const compoundFix = storeSplitWordsAsCompounds ? '+' : '';
-    function isString(line) {
-        return typeof line === 'string';
-    }
-    function trim(line) {
-        return line.trim();
-    }
-    function removeComments(line) {
-        const idx = line.indexOf(commentCharacter);
-        if (idx < 0)
-            return line;
-        const idxDirective = line.indexOf(cSpellToolDirective, idx);
-        if (idxDirective >= 0) {
-            const flags = line
-                .slice(idxDirective)
-                .split(/[\s,;]/g)
-                .map((s) => s.trim())
-                .filter((a) => !!a);
-            for (const flag of flags) {
-                switch (flag) {
-                    case 'split': {
-                        split = true;
-                        break;
-                    }
-                    case 'no-split': {
-                        split = false;
-                        break;
-                    }
-                    case 'keep-case': {
-                        keepCase = true;
-                        legacy = false;
-                        break;
-                    }
-                    case 'no-keep-case': {
-                        keepCase = false;
-                        break;
-                    }
-                    case 'legacy': {
-                        keepCase = false;
-                        legacy = true;
-                        break;
-                    }
-                }
-            }
-        }
-        return line.slice(0, idx).trim();
-    }
-    function filterEmptyLines(line) {
-        return !!line;
-    }
-    const regNonWordOrDigit = /[^\p{L}\p{M}'\w-]+/giu;
-    function splitLine(line) {
-        line = line.replace(/#.*/, ''); // remove comment
-        line = line.trim();
-        line = line.replaceAll(/\bU\+[0-9A-F]{4}\b/gi, '|'); // Remove Unicode Definitions
-        line = line.replaceAll(/\\U[0-9A-F]{4}/gi, '|'); // Remove Unicode Definitions
-        line = line.replaceAll(regNonWordOrDigit, '|');
-        line = line.replaceAll(/'(?=\|)/g, ''); // remove trailing '
-        line = line.replace(/'$/, ''); // remove trailing '
-        line = line.replaceAll(/(?<=\|)'/g, ''); // remove leading '
-        line = line.replace(/^'/, ''); // remove leading '
-        line = line.replaceAll(/\s*\|\s*/g, '|'); // remove spaces around |
-        line = line.replaceAll(/[|]+/g, '|'); // reduce repeated |
-        line = line.replace(/^\|/, ''); // remove leading |
-        line = line.replace(/\|$/, ''); // remove trailing |
-        const lines = line
-            .split('|')
-            .map((a) => a.trim())
-            .filter((a) => !!a)
-            .filter((a) => !/^[0-9_-]+$/.test(a)) // pure numbers and symbols
-            .filter((a) => !/^0[xo][0-9A-F]+$/i.test(a)); // c-style hex/octal digits
-        return lines;
-    }
-    function splitWordIntoWords(word) {
-        return splitCamelCaseIfAllowed(word, allowedSplitWords, keepCase, compoundFix, minCompoundLength);
-    }
-    function* splitWords(lines) {
-        for (const line of lines) {
-            if (legacy) {
-                yield* legacyLineToWords(line, keepCase, allowedSplitWords);
-                continue;
-            }
-            if (split) {
-                const words = splitLine(line);
-                yield* !allowedSplitWords.size ? words : words.flatMap((word) => splitWordIntoWords(word));
-                if (!splitKeepBoth)
-                    continue;
-            }
-            yield line.replaceAll(/["]/g, '');
-        }
-    }
-    function* unique(lines) {
-        const known = new Set();
-        for (const line of lines) {
-            if (known.has(line))
-                continue;
-            known.add(line);
-            yield line;
-        }
-    }
-    function* splitLines(paragraphs) {
-        for (const paragraph of paragraphs) {
-            yield* paragraph.split('\n');
-        }
-    }
-    const processLines = opPipe(opFilter(isString), splitLines, opMap(removeComments), splitWords, opMap(trim), opFilter(filterEmptyLines), unique);
-    return processLines;
-}
-/**
- * Normalizes a dictionary words based upon prefix / suffixes.
- * Case insensitive versions are also generated.
- * @param lines - one word per line
- * @param _options - defines prefixes used when parsing lines.
- * @returns words that have been normalized.
- */
-export function parseFileLines(lines, options) {
-    return createParseFileLineMapper(options)(typeof lines === 'string' ? [lines] : lines);
-}
-//# sourceMappingURL=wordListParser.js.map