@cspell/cspell-tools 9.5.0 → 9.6.1

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+//#region src/config/config.d.ts
+
+interface BTrieOptions {
+  /** compress the resulting file */
+  compress?: boolean | undefined;
+  /** optimize the trie into a DAWG */
+  optimize?: boolean | undefined;
+  /** use a string table to reduce size */
+  useStringTable?: boolean | undefined;
+}
+//#endregion
+//#region src/compiler/bTrie.d.ts
+interface GenerateBTrieOptions extends BTrieOptions {
+  /** output directory */
+  output?: string;
+}
+//#endregion
+//#region src/bTrie.d.ts
+declare function generateBTrie(files: string[], options: GenerateBTrieOptions): Promise<void>;
+//#endregion
+//#region src/build.d.ts
+interface BuildOptions {
+  /** Optional path to config file */
+  config?: string | undefined;
+  /** Used to resolve relative paths in the config. */
+  root?: string | undefined;
+  /** Current working directory */
+  cwd?: string | undefined;
+  /** Conditional build based upon the targets matching the `checksum.txt` file. */
+  conditional?: boolean;
+}
+declare function build(targets: string[] | undefined, options: BuildOptions): Promise<void>;
+//#endregion
+export { build, generateBTrie };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { l as generateBTrie, t as build } from "./build-OgMPaXPZ.mjs";
+
+export { build, generateBTrie };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspell/cspell-tools",
-  "version": "9.5.0",
+  "version": "9.6.1",
   "description": "Tools to assist with the development of cSpell",
   "publishConfig": {
     "access": "public",
@@ -13,10 +13,11 @@
     "cspell-tools-cli": "bin.mjs"
   },
   "scripts": {
-    "build": "pnpm run build-schema && pnpm run compile",
+    "build": "pnpm run build-schema && pnpm run compile && pnpm build:check",
     "build-schema": "ts-json-schema-generator --no-top-ref --path src/config/config.ts --type RunConfig --validation-keywords deprecated  -o  ./cspell-tools.config.schema.json",
-    "compile": "tsc -p tsconfig.esm.json",
-    "watch": "tsc -p tsconfig.esm.json -w",
+    "compile": "tsdown",
+    "build:check": "tsc -p .",
+    "watch": "tsdown -w",
     "clean-build": "pnpm run clean && pnpm run build",
     "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
     "coverage": "vitest run --coverage",
@@ -37,7 +38,7 @@
   ],
   "exports": {
     ".": {
-      "import": "./dist/app.js"
+      "import": "./dist/index.mjs"
     },
     "./bin": {
       "import": "./bin.mjs"
@@ -63,12 +64,12 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-tools#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "9.5.0",
+    "@cspell/cspell-pipe": "9.6.1",
     "commander": "^14.0.2",
     "cosmiconfig": "9.0.0",
-    "cspell-trie-lib": "9.5.0",
+    "cspell-trie-lib": "9.6.1",
     "glob": "^13.0.0",
-    "hunspell-reader": "9.5.0",
+    "hunspell-reader": "9.6.1",
     "yaml": "^2.8.2"
   },
   "engines": {
@@ -79,5 +80,5 @@
     "ts-json-schema-generator": "^2.4.0"
   },
   "module": "bin.mjs",
-  "gitHead": "4407eed11650481d9037e5a1d53488a93ff4b66d"
+  "gitHead": "666fb79096d25c53af9519cad07030e7aca597e1"
 }

package/dist/AppOptions.d.ts

@@ -1,31 +0,0 @@
-export interface CompileCommonAppOptions {
-    output?: string | undefined;
-    compress: boolean;
-    /**
-     * @deprecated Use maxDepth
-     */
-    max_depth?: string | undefined;
-    maxDepth?: string | undefined;
-    merge?: string | undefined;
-    experimental?: string[] | undefined;
-    split?: boolean | undefined;
-    sort?: boolean | undefined;
-    keepRawCase?: boolean | undefined;
-    trie?: boolean | undefined;
-    trie3?: boolean | undefined;
-    trie4?: boolean | undefined;
-    trieBase?: string | undefined;
-    listFile?: string[] | undefined;
-    useLegacySplitter?: boolean | undefined;
-    /** Indicate that a config file should be created instead of building. */
-    init?: boolean | undefined;
-}
-export interface CompileAppOptions extends CompileCommonAppOptions {
-    sort: boolean;
-    keepRawCase: boolean;
-}
-export interface CompileTrieAppOptions extends CompileCommonAppOptions {
-    trie3: boolean;
-    trie4: boolean;
-}
-//# sourceMappingURL=AppOptions.d.ts.map

package/dist/AppOptions.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AppOptions.js.map

package/dist/FeatureFlags/FeatureFlags.d.ts

@@ -1,34 +0,0 @@
-export interface FeatureFlag {
-    name: string;
-    description: string;
-}
-type FlagTypes = string | boolean;
-/**
- * Feature Flags are used to turn on/off features.
- * These are primarily used before a feature has been fully released.
- */
-export declare class FeatureFlags {
-    private flags;
-    private flagValues;
-    constructor(flags?: FeatureFlag[]);
-    register(flag: FeatureFlag): this;
-    register(name: string, description: string): this;
-    registerFeatures(flags: FeatureFlag[]): this;
-    getFlag(flag: string): FlagTypes | undefined;
-    getFlagBool(flag: string): boolean | undefined;
-    setFlag(flag: string, value?: FlagTypes): this;
-    getFlagInfo(flag: string): FeatureFlag | undefined;
-    getFlags(): FeatureFlag[];
-    getFlagValues(): Map<string, FlagTypes>;
-    reset(): this;
-    help(): string;
-    fork(): FeatureFlags;
-}
-export declare class UnknownFeatureFlagError extends Error {
-    readonly flag: string;
-    constructor(flag: string);
-}
-export declare function getSystemFeatureFlags(): FeatureFlags;
-export declare function createFeatureFlags(): FeatureFlags;
-export {};
-//# sourceMappingURL=FeatureFlags.d.ts.map

package/dist/FeatureFlags/FeatureFlags.js

@@ -1,94 +0,0 @@
-let systemFeatureFlags;
-/**
- * Feature Flags are used to turn on/off features.
- * These are primarily used before a feature has been fully released.
- */
-export class FeatureFlags {
-    flags;
-    flagValues = new Map();
-    constructor(flags = []) {
-        this.flags = new Map(flags.map((f) => [f.name, f]));
-    }
-    register(flagOrName, description) {
-        if (typeof flagOrName === 'string') {
-            return this.register({ name: flagOrName, description: description || '' });
-        }
-        this.flags.set(flagOrName.name, flagOrName);
-        return this;
-    }
-    registerFeatures(flags) {
-        flags.forEach((flag) => this.register(flag));
-        return this;
-    }
-    getFlag(flag) {
-        return this.flagValues.get(flag);
-    }
-    getFlagBool(flag) {
-        return toBool(this.getFlag(flag));
-    }
-    setFlag(flag, value = true) {
-        if (!this.flags.has(flag)) {
-            throw new UnknownFeatureFlagError(flag);
-        }
-        this.flagValues.set(flag, toBool(value) ?? value);
-        return this;
-    }
-    getFlagInfo(flag) {
-        return this.flags.get(flag);
-    }
-    getFlags() {
-        return [...this.flags.values()];
-    }
-    getFlagValues() {
-        return new Map(this.flagValues);
-    }
-    reset() {
-        this.flagValues.clear();
-        return this;
-    }
-    help() {
-        const flags = [{ name: 'Name', description: 'Description' }, ...this.flags.values()].sort((a, b) => a.name < b.name ? -1 : 1);
-        const nameColWidth = flags.map((f) => f.name.length).reduce((a, b) => Math.max(a, b), 0) + 1;
-        const entries = flags.map((f) => `- ${f.name}${' '.repeat(nameColWidth - f.name.length)} ${f.description}`);
-        const text = `Valid Flags:\n${entries.join('\n')}`;
-        return text;
-    }
-    fork() {
-        const fork = new FeatureFlags([...this.flags.values()]);
-        for (const [key, value] of this.flagValues) {
-            fork.flagValues.set(key, value);
-        }
-        return fork;
-    }
-}
-export class UnknownFeatureFlagError extends Error {
-    flag;
-    constructor(flag) {
-        super(`Unknown feature flag: ${flag}`);
-        this.flag = flag;
-    }
-}
-export function getSystemFeatureFlags() {
-    return systemFeatureFlags || (systemFeatureFlags = createFeatureFlags());
-}
-export function createFeatureFlags() {
-    return new FeatureFlags();
-}
-const boolValues = {
-    0: false,
-    1: true,
-    f: false,
-    false: false,
-    n: false,
-    no: false,
-    t: true,
-    true: true,
-    y: true,
-    yes: true,
-};
-function toBool(value) {
-    if (typeof value !== 'string')
-        return value;
-    return boolValues[value.toLowerCase()];
-}
-//# sourceMappingURL=FeatureFlags.js.map

package/dist/FeatureFlags/index.d.ts

@@ -1,3 +0,0 @@
-export { FeatureFlag, FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags.js';
-export { parseFlags } from './parseFlags.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/FeatureFlags/index.js

@@ -1,3 +0,0 @@
-export { FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags.js';
-export { parseFlags } from './parseFlags.js';
-//# sourceMappingURL=index.js.map

package/dist/FeatureFlags/parseFlags.d.ts

@@ -1,3 +0,0 @@
-import type { FeatureFlags } from './FeatureFlags.js';
-export declare function parseFlags(ff: FeatureFlags, flags: string[]): FeatureFlags;
-//# sourceMappingURL=parseFlags.d.ts.map

package/dist/FeatureFlags/parseFlags.js

@@ -1,20 +0,0 @@
-import { UnknownFeatureFlagError } from './FeatureFlags.js';
-const splitFlag = /[:=]/;
-const leadingEql = /^=/;
-export function parseFlags(ff, flags) {
-    for (const flag of flags) {
-        const [name, value] = flag.replace(leadingEql, '').split(splitFlag, 2);
-        try {
-            ff.setFlag(name, value);
-        }
-        catch (e) {
-            if (e instanceof UnknownFeatureFlagError) {
-                console.error(e.message);
-                console.error(ff.help());
-            }
-            throw e;
-        }
-    }
-    return ff;
-}
-//# sourceMappingURL=parseFlags.js.map

package/dist/app.d.ts

@@ -1,4 +0,0 @@
-import type { Command } from 'commander';
-import type { FeatureFlags } from './FeatureFlags/index.js';
-export declare function run(program: Command, argv: string[], flags?: FeatureFlags): Promise<void>;
-//# sourceMappingURL=app.d.ts.map

package/dist/app.js

@@ -1,86 +0,0 @@
-// For large dictionaries, it is necessary to increase the memory limit.
-import { readFileSync } from 'node:fs';
-import { CommanderError, Option } from 'commander';
-import { build } from './build.js';
-import { processCompileAction } from './compile.js';
-import * as compiler from './compiler/index.js';
-import { logWithTimestamp } from './compiler/logWithTimestamp.js';
-import { gzip, OSFlags } from './gzip/index.js';
-import { reportCheckChecksumFile, reportChecksumForFiles, updateChecksumForFiles } from './shasum/shasum.js';
-import { toError } from './util/errors.js';
-const npmPackageRaw = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
-const npmPackage = JSON.parse(npmPackageRaw);
-compiler.setLogger(logWithTimestamp);
-function collect(value, previous) {
-    return [...previous, value];
-}
-function addCompileOptions(compileCommand) {
-    return compileCommand
-        .option('-o, --output <path>', 'Specify the output directory, otherwise files are written back to the same location.')
-        .option('-n, --no-compress', 'By default the files are Gzipped, this will turn off GZ compression.')
-        .option('-m, --max_depth <limit>', 'Maximum depth to apply suffix rules.')
-        .option('-M, --merge <target>', 'Merge all files into a single target file (extensions are applied)')
-        .option('--split', 'Split each line', undefined)
-        .option('--no-split', 'Treat each line as a dictionary entry, do not split')
-        .option('--use-legacy-splitter', 'Do not use legacy line splitter logic.')
-        .option('--keep-raw-case', 'Do not normalize words before adding them to dictionary.')
-        .option('-x, --experimental <flag>', 'Experimental flags, used for testing new concepts. Flags: compound', collect, [])
-        .option('--trie3', 'Use file format trie3', false)
-        .option('--trie4', 'Use file format trie4', false)
-        .option('--trie-base <number>', 'Advanced: Set the trie base number. A value between 10 and 36')
-        .option('--list-file <filename...>', 'Path to a file that contains the list of files to compile. A list file contains one file per line.')
-        .option('--init', 'Create a build command `cspell-tools.config.yaml` file based upon the options given instead of building.');
-}
-export async function run(program, argv, flags) {
-    async function handleGzip(files) {
-        try {
-            await gzip(files, OSFlags.Unix);
-        }
-        catch (error) {
-            const err = toError(error);
-            program.error(err.message);
-        }
-    }
-    async function shasum(files, options) {
-        const report = options.check
-            ? await reportCheckChecksumFile(options.check, files, options)
-            : options.update
-                ? await updateChecksumForFiles(options.update, files, options)
-                : await reportChecksumForFiles(files, options);
-        console.log('%s', report.report);
-        if (!report.passed) {
-            throw new CommanderError(1, 'Failed Checksum', 'One or more files had issues.');
-        }
-    }
-    program.exitOverride();
-    program.version(npmPackage.version);
-    addCompileOptions(program.command('compile [src...]').description('Compile words into a cspell dictionary files.'))
-        .option('--trie', 'Compile into a trie file.', false)
-        .option('--no-sort', 'Do not sort the result')
-        .action((src, options) => {
-        return processCompileAction(src, options, flags);
-    });
-    addCompileOptions(program
-        .command('compile-trie [src...]')
-        .description('Compile words lists or Hunspell dictionary into trie files used by cspell.\nAlias of `compile --trie`')).action((src, options) => {
-        return processCompileAction(src, { ...options, trie: true }, flags);
-    });
-    program
-        .command('build [targets...]')
-        .description('Build the targets defined in the run configuration.')
-        .option('-c, --config <path to run configuration>', 'Specify the run configuration file.')
-        .option('--conditional', 'Conditional build.')
-        .option('-r, --root <directory>', 'Specify the run directory')
-        .action(build);
-    program.command('gzip <files...>').description('GZip files while keeping the original.').action(handleGzip);
-    program
-        .command('shasum [files...]')
-        .description('Calculate the checksum for files.')
-        .option('--list-file <list-file.txt...>', 'Specify one or more files that contain paths of files to check.')
-        .option('-c, --check <checksum.txt>', 'Verify the checksum of files against those stored in the checksum.txt file.')
-        .addOption(new Option('-u, --update <checksum.txt>', 'Update checksums found in the file.').conflicts('--check'))
-        .option('-r, --root <root>', 'Specify the root to use for relative paths. The current working directory is used by default.')
-        .action(shasum);
-    await program.parseAsync(argv);
-}
-//# sourceMappingURL=app.js.map

package/dist/build.d.ts

@@ -1,12 +0,0 @@
-export interface BuildOptions {
-    /** Optional path to config file */
-    config?: string | undefined;
-    /** Used to resolve relative paths in the config. */
-    root?: string | undefined;
-    /** Current working directory */
-    cwd?: string | undefined;
-    /** Conditional build based upon the targets matching the `checksum.txt` file. */
-    conditional?: boolean;
-}
-export declare function build(targets: string[] | undefined, options: BuildOptions): Promise<void>;
-//# sourceMappingURL=build.d.ts.map

package/dist/build.js

@@ -1,36 +0,0 @@
-import * as path from 'node:path';
-import { cosmiconfig } from 'cosmiconfig';
-import { compile } from './compiler/index.js';
-import { normalizeConfig } from './config/index.js';
-const moduleName = 'cspell-tools';
-const searchPlaces = [
-    `${moduleName}.config.json`,
-    `${moduleName}.config.yaml`,
-    `${moduleName}.config.yml`,
-    'package.json',
-];
-export async function build(targets, options) {
-    const allowedTargets = new Set(targets || []);
-    function filter(target) {
-        return !allowedTargets.size || allowedTargets.has(target.name);
-    }
-    const searchDir = path.resolve(options.root || options.cwd || '.');
-    const explorer = cosmiconfig(moduleName, {
-        searchPlaces,
-        stopDir: searchDir,
-        transform: normalizeConfig,
-    });
-    const config = await (options.config ? explorer.load(options.config) : explorer.search(searchDir));
-    if (!config?.config) {
-        console.error('root: %s', options.root);
-        throw 'cspell-tools.config not found.';
-    }
-    const configDir = path.dirname(config.filepath);
-    const buildInfo = normalizeRequest(config.config, path.resolve(configDir, options.root || configDir));
-    await compile(buildInfo, { filter, cwd: options.cwd, conditionalBuild: options.conditional || false });
-}
-function normalizeRequest(buildInfo, root) {
-    const { rootDir = root, targets = [], checksumFile } = buildInfo;
-    return { rootDir: path.resolve(rootDir), targets, checksumFile };
-}
-//# sourceMappingURL=build.js.map

package/dist/compile.d.ts

@@ -1,5 +0,0 @@
-import type { CompileCommonAppOptions } from './AppOptions.js';
-import type { FeatureFlags } from './FeatureFlags/index.js';
-export declare const configFileHeader: string;
-export declare function processCompileAction(src: string[], options: CompileCommonAppOptions, featureFlags: FeatureFlags | undefined): Promise<void>;
-//# sourceMappingURL=compile.d.ts.map

package/dist/compile.js

@@ -1,41 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { opConcatMap, pipe } from '@cspell/cspell-pipe/sync';
-import YAML from 'yaml';
-import { compile } from './compiler/compile.js';
-import { createCompileRequest } from './compiler/createCompileRequest.js';
-import { configFileSchemaURL } from './config/config.js';
-import { getSystemFeatureFlags, parseFlags } from './FeatureFlags/index.js';
-import { globP } from './util/globP.js';
-getSystemFeatureFlags().register('compound', 'Enable compound dictionary sources.');
-const defaultConfigFile = 'cspell-tools.config.yaml';
-export const configFileHeader = `# yaml-language-server: $schema=${configFileSchemaURL}\n\n`;
-export async function processCompileAction(src, options, featureFlags) {
-    const ff = featureFlags || getSystemFeatureFlags();
-    parseFlags(ff, options.experimental || []);
-    return useCompile(src, options);
-}
-async function useCompile(src, options) {
-    console.log('Compile:\n output: %s\n compress: %s\n files:\n  %s', options.output || 'default', options.compress ? 'true' : 'false', src.join('\n  '));
-    if (options.listFile && options.listFile.length) {
-        console.log(' list files:\n  %s', options.listFile.join('\n  '));
-    }
-    console.log('\n\n');
-    const globResults = await Promise.all(src.map((s) => globP(s)));
-    const sources = [
-        ...pipe(globResults, opConcatMap((a) => a)),
-    ];
-    const request = createCompileRequest(sources, options);
-    return options.init ? initConfig(request) : compile(request);
-}
-async function initConfig(runConfig) {
-    const { $schema = configFileSchemaURL, ...cfg } = runConfig;
-    const config = { $schema, ...cfg };
-    const content = configFileHeader + YAML.stringify(config, undefined, 2);
-    console.log('Writing config file: %s', defaultConfigFile);
-    await writeFile(defaultConfigFile, content);
-    console.log(`Init complete.
-To build, use:
-  cspell-tools-cli build
-`);
-}
-//# sourceMappingURL=compile.js.map

package/dist/compiler/CompileOptions.d.ts

@@ -1,35 +0,0 @@
-export interface CompileOptions {
-    /**
-     * Sort the words in the resulting dictionary.
-     * Does not apply to `trie` based formats.
-     */
-    sort: boolean;
-    /**
-     * Generate lower case / accent free versions of words.
-     */
-    generateNonStrict: boolean;
-    /**
-     * Optional filter function to filter out words.
-     * @param word the word to test
-     * @returns `true` to keep the word, `false` to exclude it.
-     */
-    filter?: ((word: string) => boolean) | undefined;
-    /**
-     * Injects `cspell-dictionary` directives into the dictionary header.
-     *
-     * Example:
-     *
-     * ```ini
-     * # cspell-dictionary: no-generate-alternatives
-     * ```
-     *
-     */
-    dictionaryDirectives?: string[] | undefined;
-    /**
-     * Remove duplicate words, favor lower case words over mixed case words.
-     * Combine compound prefixes where possible.
-     * @default false
-     */
-    removeDuplicates?: boolean | undefined;
-}
-//# sourceMappingURL=CompileOptions.d.ts.map

package/dist/compiler/CompileOptions.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=CompileOptions.js.map

package/dist/compiler/CompilerDefinitions.d.ts

@@ -1,2 +0,0 @@
-export type WordListCompiler = (srcWords: Iterable<string>) => Iterable<string>;
-//# sourceMappingURL=CompilerDefinitions.d.ts.map

package/dist/compiler/CompilerDefinitions.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=CompilerDefinitions.js.map

package/dist/compiler/Reader.d.ts

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

package/dist/compiler/Reader.js

@@ -1,24 +0,0 @@
-import { readHunspellFiles } from './readers/readHunspellFiles.js';
-import { regHunspellFile } from './readers/regHunspellFile.js';
-import { textFileReader } from './readers/textFileReader.js';
-import { trieFileReader } from './readers/trieFileReader.js';
-// Readers first match wins
-const readers = [
-    { test: /\.trie\b/, method: trieFileReader },
-    { test: regHunspellFile, method: readHunspellFiles },
-];
-function findMatchingReader(filename, options) {
-    for (const reader of readers) {
-        if (reader.test.test(filename)) {
-            return reader.method(filename, options);
-        }
-    }
-    return textFileReader(filename);
-}
-export async function createReader(filename, options) {
-    const baseReader = await findMatchingReader(filename, options);
-    return Object.assign(baseReader, {
-        [Symbol.iterator]: () => baseReader.lines[Symbol.iterator](),
-    });
-}
-//# sourceMappingURL=Reader.js.map

package/dist/compiler/SourceReader.d.ts

@@ -1,28 +0,0 @@
-import type { AllowedSplitWordsCollection } from './WordsCollection.js';
-export interface SourceReaderOptions {
-    /**
-     * Max Hunspell recursive depth.
-     */
-    maxDepth?: number | undefined;
-    /**
-     * split words if necessary.
-     */
-    splitWords: boolean;
-    /**
-     * Indicate that it is an unformatted file and needs to be cleaned
-     * before processing. Applies only to text file sources.
-     * @default false
-     */
-    legacy?: boolean | undefined;
-    keepCase?: boolean | undefined;
-    allowedSplitWords: AllowedSplitWordsCollection;
-    storeSplitWordsAsCompounds: boolean | undefined;
-    minCompoundLength?: number | undefined;
-}
-export type AnnotatedWord = string;
-export interface SourceReader {
-    size: number;
-    words: Iterable<AnnotatedWord>;
-}
-export declare function createSourceReader(filename: string, options: SourceReaderOptions): Promise<SourceReader>;
-//# sourceMappingURL=SourceReader.d.ts.map

package/dist/compiler/SourceReader.js

@@ -1,44 +0,0 @@
-import { createReader } from './Reader.js';
-import { parseFileLines } from './wordListParser.js';
-export async function createSourceReader(filename, options) {
-    const reader = await createReader(filename, options);
-    if (reader.type !== 'TextFile') {
-        return {
-            words: splitLines(reader.lines, options),
-            get size() {
-                return reader.size;
-            },
-        };
-    }
-    return textFileReader(reader, options);
-}
-function splitLines(lines, options) {
-    if (!options.splitWords)
-        return lines;
-    function* split() {
-        const regNonWordOrDigit = /[^\p{L}\p{M}'\w-]+/giu;
-        for (const line of lines) {
-            const words = line.split(regNonWordOrDigit);
-            yield* words;
-        }
-    }
-    return split();
-}
-async function textFileReader(reader, options) {
-    const { legacy, splitWords: split, allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength } = options;
-    const parseOptions = {
-        legacy,
-        split,
-        splitKeepBoth: undefined,
-        keepCase: undefined,
-        allowedSplitWords,
-        storeSplitWordsAsCompounds,
-        minCompoundLength,
-    };
-    const words = [...parseFileLines(reader.lines, parseOptions)];
-    return {
-        size: words.length,
-        words,
-    };
-}
-//# sourceMappingURL=SourceReader.js.map

package/dist/compiler/WordsCollection.d.ts

@@ -1,20 +0,0 @@
-export interface WordsCollection {
-    size: number;
-    has(words: string, caseSensitive: boolean): boolean;
-    type?: string;
-}
-/**
- * Collection of words to be allowed after splitting.
- */
-export interface AllowedSplitWordsCollection extends WordsCollection {
-    type?: 'AllowedSplitWordsCollection';
-}
-export declare const defaultAllowedSplitWords: AllowedSplitWordsCollection;
-/**
- * Collection of words to be excluded.
- */
-export interface ExcludeWordsCollection extends WordsCollection {
-    type?: 'ExcludeWordsCollection';
-}
-export declare const defaultExcludeWordsCollection: ExcludeWordsCollection;
-//# sourceMappingURL=WordsCollection.d.ts.map