@cspell/cspell-tools 6.12.0 → 6.13.1

package/dist/build.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const cosmiconfig_1 = require("cosmiconfig");
+const compiler_1 = require("./compiler");
+const config_1 = require("./config");
+const path = __importStar(require("path"));
+const moduleName = 'cspell-tools';
+const searchPlaces = [
+    `${moduleName}.config.json`,
+    `${moduleName}.config.yaml`,
+    `${moduleName}.config.yml`,
+    'package.json',
+];
+async function build(targets, options) {
+    const allowedTargets = new Set(targets || []);
+    function filter(target) {
+        return !targets || allowedTargets.has(target.name);
+    }
+    if (options.root) {
+        process.chdir(path.resolve(options.root));
+    }
+    const explorer = (0, cosmiconfig_1.cosmiconfig)(moduleName, {
+        searchPlaces,
+        stopDir: path.resolve('.'),
+        transform: config_1.normalizeConfig,
+    });
+    const config = await (options.config ? explorer.load(options.config) : explorer.search('.'));
+    if (!config?.config) {
+        console.error('root: %s', options.root);
+        throw 'cspell-tools.config not found.';
+    }
+    await (0, compiler_1.compile)(config.config, { filter });
+}
+exports.build = build;
+//# sourceMappingURL=build.js.map

package/dist/compile.d.ts

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

package/dist/compile.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processCompileAction = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const FeatureFlags_1 = require("./FeatureFlags");
+const compile_1 = require("./compiler/compile");
+const createCompileRequest_1 = require("./compiler/createCompileRequest");
+const globP_1 = require("./compiler/globP");
+(0, FeatureFlags_1.getSystemFeatureFlags)().register('compound', 'Enable compound dictionary sources.');
+async function processCompileAction(src, options, featureFlags) {
+    const ff = featureFlags || (0, FeatureFlags_1.getSystemFeatureFlags)();
+    (0, FeatureFlags_1.parseFlags)(ff, options.experimental);
+    return useCompile(src, options);
+}
+exports.processCompileAction = processCompileAction;
+async function useCompile(src, options) {
+    console.log('Compile:\n output: %s\n compress: %s\n files:\n  %s \n\n', options.output || 'default', options.compress ? 'true' : 'false', src.join('\n  '));
+    const globResults = await Promise.all(src.map((s) => (0, globP_1.globP)(s)));
+    const sources = [
+        ...(0, sync_1.pipe)(globResults, (0, sync_1.opConcatMap)((a) => a)),
+    ];
+    return (0, compile_1.compile)((0, createCompileRequest_1.createCompileRequest)(sources, options));
+}
+//# sourceMappingURL=compile.js.map

package/dist/compiler/CompileOptions.d.ts

@@ -0,0 +1,12 @@
+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;
+}
+//# sourceMappingURL=CompileOptions.d.ts.map

package/dist/compiler/CompileOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=CompileOptions.js.map

package/dist/compiler/Reader.d.ts

@@ -1,23 +1,28 @@
-import { Sequence } from 'gensequence';
 export interface ReaderOptions {
-    useAnnotation?: boolean;
+    /**
+     * Max Hunspell recursive depth.
+     */
     maxDepth?: number;
+    /**
+     * 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;
+    keepCase?: boolean;
 }
 export declare type AnnotatedWord = string;
 interface BaseReader {
     size: number;
-    annotatedWords: () => Sequence<AnnotatedWord>;
-    rawWords: () => Sequence<string>;
+    words: Iterable<AnnotatedWord>;
 }
-export interface Reader extends BaseReader {
-    [Symbol.iterator]: () => Sequence<string>;
+export interface Reader extends BaseReader, Iterable<string> {
 }
 export declare function createReader(filename: string, options: ReaderOptions): Promise<Reader>;
-export declare function createArrayReader(lines: string[]): BaseReader;
 export declare function readHunspellFiles(filename: string, options: ReaderOptions): Promise<BaseReader>;
-declare function _stripCaseAndAccents(words: Iterable<AnnotatedWord>): Generator<AnnotatedWord>;
-export declare const __testing__: {
-    _stripCaseAndAccents: typeof _stripCaseAndAccents;
-};
 export {};
 //# sourceMappingURL=Reader.d.ts.map

package/dist/compiler/Reader.js

@@ -23,16 +23,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.readHunspellFiles = exports.createArrayReader = exports.createReader = void 0;
-const gensequence_1 = require("gensequence");
-const HR = __importStar(require("hunspell-reader"));
-const fs = __importStar(require("fs-extra"));
+exports.readHunspellFiles = exports.createReader = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
 const cspell_trie_lib_1 = require("cspell-trie-lib");
-const zlib = __importStar(require("zlib"));
+const HR = __importStar(require("hunspell-reader"));
+const readTextFile_1 = require("./readTextFile");
+const wordListParser_1 = require("./wordListParser");
 const regHunspellFile = /\.(dic|aff)$/i;
 // cspell:word dedupe
 const DEDUPE_SIZE = 1000;
-const regExMatchComments = /\s*(#|\/\/).*/;
 // Readers first match wins
 const readers = [
     { test: /\.trie\b/, method: trieFileReader },
@@ -49,115 +48,66 @@ function findMatchingReader(filename, options) {
 async function createReader(filename, options) {
     const baseReader = await findMatchingReader(filename, options);
     return Object.assign(baseReader, {
-        [Symbol.iterator]: options.useAnnotation ? baseReader.annotatedWords : baseReader.rawWords,
+        [Symbol.iterator]: () => baseReader.words[Symbol.iterator](),
     });
 }
 exports.createReader = createReader;
-function createArrayReader(lines) {
-    const rawWords = () => (0, gensequence_1.genSequence)(lines);
-    const annotatedWords = () => (0, gensequence_1.genSequence)(lines).pipe(_mapText, dedupeAndSort);
-    return {
-        size: lines.length,
-        annotatedWords,
-        rawWords,
-    };
-}
-exports.createArrayReader = createArrayReader;
 async function readHunspellFiles(filename, options) {
     const dicFile = filename.replace(regHunspellFile, '.dic');
     const affFile = filename.replace(regHunspellFile, '.aff');
     const reader = await HR.IterableHunspellReader.createFromFiles(affFile, dicFile);
     reader.maxDepth = options.maxDepth !== undefined ? options.maxDepth : reader.maxDepth;
-    const normalizeAndDedupe = gensequence_1.operators.pipe(_stripCaseAndAccents, dedupeAndSort);
-    const rawWords = () => reader.seqWords();
+    const words = (0, sync_1.pipe)(reader.seqAffWords(), _mapAffWords, dedupeAndSort);
     return {
         size: reader.dic.length,
-        annotatedWords() {
-            return reader.seqAffWords().pipe(_mapAffWords, normalizeAndDedupe);
-        },
-        rawWords,
+        words,
     };
 }
 exports.readHunspellFiles = readHunspellFiles;
 async function trieFileReader(filename) {
-    const trieRoot = (0, cspell_trie_lib_1.importTrie)(await readTextFile(filename));
+    const trieRoot = (0, cspell_trie_lib_1.importTrie)(await (0, readTextFile_1.readTextFileLines)(filename));
     const trie = new cspell_trie_lib_1.Trie(trieRoot);
-    const rawWords = () => trie.words();
+    const words = trie.words();
     return {
         get size() {
             return trie.size();
         },
-        annotatedWords: rawWords,
-        rawWords,
+        words,
     };
 }
-function readTextFile(filename) {
-    const lines = fs
-        .readFile(filename)
-        .then((buffer) => (/\.gz$/.test(filename) ? zlib.gunzipSync(buffer) : buffer))
-        .then((buffer) => buffer.toString('utf8'))
-        .then((content) => content.split(/\r?\n/g));
-    return lines;
-}
-async function textFileReader(filename, _options) {
-    const lines = await readTextFile(filename);
-    return createArrayReader(lines);
-}
-const _mapText = gensequence_1.operators.pipe(_comments, _compoundBegin, _compoundEnd, _stripCaseAndAccents);
-function* _comments(lines) {
-    for (const line of lines) {
-        const w = line.replace(regExMatchComments, '').trim();
-        if (w)
-            yield w;
-    }
-}
-function* _compoundEnd(lines) {
-    for (const line of lines) {
-        if (line[0] !== cspell_trie_lib_1.OPTIONAL_COMPOUND_FIX) {
-            yield line;
-            continue;
-        }
-        const w = line.slice(1);
-        yield w;
-        yield cspell_trie_lib_1.COMPOUND_FIX + w;
-    }
-}
-function* _compoundBegin(lines) {
-    for (const line of lines) {
-        if (line[line.length - 1] !== cspell_trie_lib_1.OPTIONAL_COMPOUND_FIX) {
-            yield line;
-            continue;
-        }
-        const w = line.slice(0, -1);
-        yield w;
-        yield w + cspell_trie_lib_1.COMPOUND_FIX;
-    }
-}
-function* _stripCaseAndAccents(words) {
-    for (const word of words) {
-        // Words are normalized to the compact format: e + ` => è
-        yield word.normalize();
-        // covert to lower case and strip accents.
-        const n = word.toLowerCase().normalize('NFD').replace(/\p{M}/gu, '');
-        // All words are added for case-insensitive searches.
-        // It is a space / speed trade-off. In this case, speed is more important.
-        yield cspell_trie_lib_1.CASE_INSENSITIVE_PREFIX + n;
-    }
+async function textFileReader(filename, options) {
+    const content = await (0, readTextFile_1.readTextFile)(filename);
+    const words = [...(0, wordListParser_1.parseFileLines)(content, { legacy: options.legacy, split: options.splitWords })];
+    return {
+        size: words.length,
+        words,
+    };
 }
+// function* _stripCaseAndAccents(words: Iterable<AnnotatedWord>): Iterable<AnnotatedWord> {
+//     for (const word of words) {
+//         // Words are normalized to the compact format: e + ` => è
+//         yield word.normalize();
+//         // covert to lower case and strip accents.
+//         const n = word.toLowerCase().normalize('NFD').replace(/\p{M}/gu, '');
+//         // All words are added for case-insensitive searches.
+//         // It is a space / speed trade-off. In this case, speed is more important.
+//         yield CASE_INSENSITIVE_PREFIX + n;
+//     }
+// }
 function* dedupeAndSort(words) {
-    const buffer = [];
-    function sortDedupeClear() {
-        const s = new Set(buffer.sort());
-        buffer.length = 0;
-        return s;
+    const buffer = new Set();
+    function flush() {
+        const result = [...buffer].sort();
+        buffer.clear();
+        return result;
     }
     for (const word of words) {
-        buffer.push(word);
-        if (buffer.length >= DEDUPE_SIZE) {
-            yield* sortDedupeClear();
+        buffer.add(word);
+        if (buffer.size >= DEDUPE_SIZE) {
+            yield* flush();
         }
     }
-    yield* sortDedupeClear();
+    yield* flush();
 }
 function* _mapAffWords(affWords) {
     const hasSpecial = /[~+!]/;
@@ -183,7 +133,4 @@ function* _mapAffWords(affWords) {
         }
     }
 }
-exports.__testing__ = {
-    _stripCaseAndAccents,
-};
 //# sourceMappingURL=Reader.js.map

package/dist/compiler/compile.d.ts

@@ -0,0 +1,11 @@
+import { CompileRequest, CompileSourceOptions, Target } from '../config';
+interface CompileOptions {
+    /**
+     * Optional filter function to filter targets.
+     */
+    filter?: (target: Target) => boolean;
+}
+export declare function compile(request: CompileRequest, options?: CompileOptions): Promise<void>;
+export declare function compileTarget(target: Target, options: CompileSourceOptions, rootDir: string): Promise<void>;
+export {};
+//# sourceMappingURL=compile.d.ts.map

package/dist/compiler/compile.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTarget = exports.compile = void 0;
+const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const operators_1 = require("@cspell/cspell-pipe/operators");
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const iterateWordsFromFile_1 = require("./iterateWordsFromFile");
+const logWithTimestamp_1 = require("./logWithTimestamp");
+const readTextFile_1 = require("./readTextFile");
+const wordListCompiler_1 = require("./wordListCompiler");
+const wordListParser_1 = require("./wordListParser");
+async function compile(request, options) {
+    const { targets } = request;
+    // console.log('Request: %o', request);
+    const rootDir = path.resolve(request.rootDir || '.');
+    const targetOptions = {
+        sort: request.sort,
+        generateNonStrict: request.generateNonStrict,
+    };
+    for (const target of targets) {
+        const keep = options?.filter?.(target) ?? true;
+        if (!keep)
+            continue;
+        const adjustedTarget = { ...targetOptions, ...target };
+        await compileTarget(adjustedTarget, request, rootDir);
+    }
+    (0, logWithTimestamp_1.logWithTimestamp)(`Complete.`);
+}
+exports.compile = compile;
+async function compileTarget(target, options, rootDir) {
+    (0, logWithTimestamp_1.logWithTimestamp)(`Start compile: ${target.name}`);
+    // console.log('Target: %o', target);
+    const { format, sources, trieBase, sort = true, generateNonStrict = false } = target;
+    const targetDirectory = path.resolve(rootDir, target.targetDirectory ?? process.cwd());
+    const generateNonStrictTrie = target.generateNonStrict ?? true;
+    const name = normalizeTargetName(target.name);
+    const useTrie = format.startsWith('trie');
+    const filename = resolveTarget(name, targetDirectory, useTrie, target.compress ?? false);
+    const filesToProcessAsync = (0, cspell_pipe_1.pipeAsync)(readSourceList(sources, rootDir), (0, operators_1.opMapAsync)((src) => readFileSource(src, options)), (0, operators_1.opAwaitAsync)());
+    const filesToProcess = await (0, cspell_pipe_1.toArray)(filesToProcessAsync);
+    const normalizer = (0, wordListParser_1.normalizeTargetWords)({ sort: useTrie || sort, generateNonStrict });
+    const action = useTrie
+        ? async (words, dst) => {
+            return (0, wordListCompiler_1.compileTrie)((0, sync_1.pipe)(words, normalizer), dst, {
+                base: trieBase,
+                sort: false,
+                trie3: format === 'trie3',
+                trie4: format === 'trie4',
+                generateNonStrict: generateNonStrictTrie,
+            });
+        }
+        : async (words, dst) => {
+            return (0, wordListCompiler_1.compileWordList)((0, sync_1.pipe)(words, normalizer), dst, { sort, generateNonStrict });
+        };
+    await processFiles(action, filesToProcess, filename);
+    (0, logWithTimestamp_1.logWithTimestamp)(`Done compile: ${target.name}`);
+}
+exports.compileTarget = compileTarget;
+function rel(filePath) {
+    return path.relative(process.cwd(), filePath);
+}
+async function processFiles(action, filesToProcess, mergeTarget) {
+    const toProcess = filesToProcess;
+    const dst = mergeTarget;
+    const words = (0, sync_1.pipe)(toProcess, (0, sync_1.opMap)((ftp) => {
+        const { src } = ftp;
+        (0, logWithTimestamp_1.logWithTimestamp)('Process "%s" to "%s"', rel(src), rel(dst));
+        return ftp;
+    }), (0, sync_1.opConcatMap)(function* (ftp) {
+        yield* ftp.words;
+        (0, logWithTimestamp_1.logWithTimestamp)('Done processing %s', rel(ftp.src));
+    })
+    // opMap((a) => (console.warn(a), a))
+    );
+    await action(words, dst);
+    (0, logWithTimestamp_1.logWithTimestamp)('Done "%s"', rel(dst));
+}
+function resolveTarget(name, directory, useTrie, useGzCompress) {
+    const ext = ((useTrie && '.trie') || '.txt') + ((useGzCompress && '.gz') || '');
+    const filename = name + ext;
+    return path.resolve(directory, filename);
+}
+function readSourceList(sources, rootDir) {
+    async function* mapSrc() {
+        for (const src of sources) {
+            if ((0, config_1.isFilePath)(src)) {
+                yield { filename: path.resolve(rootDir, src) };
+                continue;
+            }
+            if ((0, config_1.isFileSource)(src)) {
+                yield { ...src, filename: path.resolve(rootDir, src.filename) };
+                continue;
+            }
+            if ((0, config_1.isFileListSource)(src)) {
+                const { listFile, ...rest } = src;
+                const absListFile = path.resolve(rootDir, listFile);
+                const listFileDir = path.dirname(absListFile);
+                const files = await readFileList(absListFile);
+                for (const filename of files) {
+                    yield { ...rest, filename: path.resolve(listFileDir, filename) };
+                }
+            }
+        }
+    }
+    return mapSrc();
+}
+async function readFileList(fileList) {
+    const content = await (0, readTextFile_1.readTextFile)(fileList);
+    return content
+        .split('\n')
+        .map((a) => a.trim())
+        .filter((a) => !!a);
+}
+async function readFileSource(fileSource, sourceOptions) {
+    const { filename, keepRawCase = sourceOptions.keepRawCase || false, split = sourceOptions.split || false, maxDepth, } = fileSource;
+    const legacy = split === 'legacy';
+    const splitWords = legacy ? false : split;
+    // console.warn('fileSource: %o,\n targetOptions %o, \n opt: %o', fileSource, targetOptions, opt);
+    const readerOptions = { maxDepth, legacy, splitWords, keepCase: keepRawCase };
+    (0, logWithTimestamp_1.logWithTimestamp)(`Reading ${path.basename(filename)}`);
+    const stream = await (0, iterateWordsFromFile_1.streamWordsFromFile)(filename, readerOptions);
+    (0, logWithTimestamp_1.logWithTimestamp)(`Done reading ${path.basename(filename)}`);
+    const f = {
+        src: filename,
+        words: stream,
+    };
+    return f;
+}
+function normalizeTargetName(name) {
+    return name.replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, '').replace(/[^\p{L}\p{M}.\w\\/-]/gu, '_');
+}
+//# sourceMappingURL=compile.js.map

package/dist/compiler/createCompileRequest.d.ts

@@ -0,0 +1,4 @@
+import { CompileCommonAppOptions } from '../AppOptions';
+import { CompileRequest } from '../config';
+export declare function createCompileRequest(sources: string[], options: CompileCommonAppOptions): CompileRequest;
+//# sourceMappingURL=createCompileRequest.d.ts.map

package/dist/compiler/createCompileRequest.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompileRequest = void 0;
+const path = __importStar(require("path"));
+function createCompileRequest(sources, options) {
+    const { max_depth, maxDepth, experimental = [], split, keepRawCase, useLegacySplitter } = options;
+    const targets = calcTargets(sources, options);
+    const generateNonStrict = experimental.includes('compound') || undefined;
+    const req = {
+        targets,
+        generateNonStrict,
+        maxDepth: parseNumber(maxDepth) ?? parseNumber(max_depth),
+        split: useLegacySplitter ? 'legacy' : split,
+        /**
+         * Do not generate lower case / accent free versions of words.
+         * @default false
+         */
+        keepRawCase,
+    };
+    return req;
+}
+exports.createCompileRequest = createCompileRequest;
+function calcTargets(sources, options) {
+    const { merge, output = '.' } = options;
+    const format = calcFormat(options);
+    if (merge) {
+        const target = {
+            name: merge,
+            targetDirectory: output,
+            compress: options.compress,
+            format,
+            sources,
+            sort: options.sort,
+            trieBase: parseNumber(options.trieBase),
+        };
+        return [target];
+    }
+    const targets = sources.map((source) => {
+        const name = toTargetName(path.basename(source));
+        const target = {
+            name,
+            targetDirectory: output,
+            compress: options.compress,
+            format,
+            sources: [source],
+            sort: options.sort,
+            trieBase: parseNumber(options.trieBase),
+        };
+        return target;
+    });
+    return targets;
+}
+function calcFormat(options) {
+    return (options.trie4 && 'trie4') || (options.trie3 && 'trie3') || (options.trie && 'trie') || 'plaintext';
+}
+function toTargetName(sourceFile) {
+    return path.basename(sourceFile).replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, '');
+}
+function parseNumber(s) {
+    const n = parseInt(s ?? '');
+    return isNaN(n) ? undefined : n;
+}
+//# sourceMappingURL=createCompileRequest.js.map

package/dist/compiler/fileWriter.d.ts

@@ -1,4 +1,3 @@
-import { Sequence } from 'gensequence';
-export { writeToFile, writeToFileIterableP, writeToFileIterable } from 'cspell-io';
-export declare function writeSeqToFile(seq: Sequence<string>, outFile: string): Promise<void>;
+export { writeTextLinesToFile as writeToFileIterableP } from './writeTextToFile';
+export declare function writeSeqToFile(seq: Iterable<string>, outFile: string): Promise<void>;
 //# sourceMappingURL=fileWriter.d.ts.map

package/dist/compiler/fileWriter.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeSeqToFile = exports.writeToFileIterable = exports.writeToFileIterableP = exports.writeToFile = void 0;
-const cspell_io_1 = require("cspell-io");
-var cspell_io_2 = require("cspell-io");
-Object.defineProperty(exports, "writeToFile", { enumerable: true, get: function () { return cspell_io_2.writeToFile; } });
-Object.defineProperty(exports, "writeToFileIterableP", { enumerable: true, get: function () { return cspell_io_2.writeToFileIterableP; } });
-Object.defineProperty(exports, "writeToFileIterable", { enumerable: true, get: function () { return cspell_io_2.writeToFileIterable; } });
+exports.writeSeqToFile = exports.writeToFileIterableP = void 0;
+const writeTextToFile_1 = require("./writeTextToFile");
+var writeTextToFile_2 = require("./writeTextToFile");
+Object.defineProperty(exports, "writeToFileIterableP", { enumerable: true, get: function () { return writeTextToFile_2.writeTextLinesToFile; } });
 function writeSeqToFile(seq, outFile) {
-    return (0, cspell_io_1.writeToFileIterableP)(outFile, seq);
+    return (0, writeTextToFile_1.writeTextLinesToFile)(outFile, seq);
 }
 exports.writeSeqToFile = writeSeqToFile;
 //# sourceMappingURL=fileWriter.js.map

package/dist/compiler/globP.d.ts

@@ -0,0 +1,2 @@
+export declare function globP(pattern: string): Promise<string[]>;
+//# sourceMappingURL=globP.d.ts.map

package/dist/compiler/globP.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globP = void 0;
+const glob_1 = __importDefault(require("glob"));
+const util_1 = require("util");
+const pGlob = (0, util_1.promisify)(glob_1.default);
+function globP(pattern) {
+    // Convert windows separators.
+    pattern = pattern.replace(/\\/g, '/');
+    return pGlob(pattern);
+}
+exports.globP = globP;
+//# sourceMappingURL=globP.js.map

package/dist/compiler/index.d.ts

@@ -1,2 +1,5 @@
-export * from './wordListCompiler';
+export { compileWordList, compileTrie } from './wordListCompiler';
+export { type Logger, setLogger } from './logger';
+export { compile, compileTarget } from './compile';
+export type { CompileRequest, CompileTargetOptions, RunConfig } from '../config';
 //# sourceMappingURL=index.d.ts.map