@cspell/cspell-tools 7.0.0-alpha.1 → 7.0.0

package/bin.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
-'use strict';
+import { program, CommanderError } from 'commander';
+import { run } from './dist/app.js';
 
-const app = require('./dist/app');
-const program = require('commander');
-
-app.run(program, process.argv).catch((e) => {
-    if (!(e instanceof program.CommanderError)) {
+run(program, process.argv).catch((e) => {
+    if (!(e instanceof CommanderError)) {
         console.log(e);
+    } else {
+        console.log(e.message);
     }
     process.exitCode = 1;
 });

package/cspell-tools.config.schema.json

@@ -195,6 +195,11 @@
     }
   },
   "properties": {
+    "$schema": {
+      "default": "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/packages/cspell-tools/cspell-tools.config.schema.json",
+      "description": "Url to JSON Schema",
+      "type": "string"
+    },
     "allowedSplitWords": {
       "anyOf": [
         {
@@ -209,6 +214,13 @@
       ],
       "description": "Words in the `allowedSplitWords` are considered correct and can be used as a basis for splitting compound words.\n\nIf entries can be split so that all the words in the entry are allowed, then only the individual words are added, otherwise the entire entry is added. This is to prevent misspellings in CamelCase words from being introduced into the dictionary."
     },
+    "checksumFile": {
+      "description": "Path to checksum file. `true` - defaults to `./checksum.txt`.",
+      "type": [
+        "string",
+        "boolean"
+      ]
+    },
     "generateNonStrict": {
       "default": true,
       "description": "Generate lower case / accent free versions of words.",

package/dist/AppOptions.d.ts

@@ -7,7 +7,7 @@ export interface CompileCommonAppOptions {
     max_depth?: string;
     maxDepth?: string;
     merge?: string;
-    experimental: string[];
+    experimental?: string[];
     split?: boolean;
     sort?: boolean;
     keepRawCase?: boolean;
@@ -15,7 +15,10 @@ export interface CompileCommonAppOptions {
     trie3?: boolean;
     trie4?: boolean;
     trieBase?: string;
+    listFile?: string[];
     useLegacySplitter?: boolean;
+    /** Indicate that a config file should be created instead of building. */
+    init?: boolean;
 }
 export interface CompileAppOptions extends CompileCommonAppOptions {
     sort: boolean;

package/dist/AppOptions.js

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

package/dist/FeatureFlags/FeatureFlags.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFeatureFlags = exports.getSystemFeatureFlags = exports.UnknownFeatureFlagError = exports.FeatureFlags = void 0;
 let systemFeatureFlags;
 /**
  * Feature Flags are used to turn on/off features.
  * These are primarily used before a feature has been fully released.
  */
-class FeatureFlags {
+export class FeatureFlags {
     constructor(flags = []) {
         this.flagValues = new Map();
         this.flags = new Map(flags.map((f) => [f.name, f]));
@@ -63,22 +60,18 @@ class FeatureFlags {
         return fork;
     }
 }
-exports.FeatureFlags = FeatureFlags;
-class UnknownFeatureFlagError extends Error {
+export class UnknownFeatureFlagError extends Error {
     constructor(flag) {
         super(`Unknown feature flag: ${flag}`);
         this.flag = flag;
     }
 }
-exports.UnknownFeatureFlagError = UnknownFeatureFlagError;
-function getSystemFeatureFlags() {
+export function getSystemFeatureFlags() {
     return systemFeatureFlags || (systemFeatureFlags = createFeatureFlags());
 }
-exports.getSystemFeatureFlags = getSystemFeatureFlags;
-function createFeatureFlags() {
+export function createFeatureFlags() {
     return new FeatureFlags();
 }
-exports.createFeatureFlags = createFeatureFlags;
 const boolValues = {
     0: false,
     1: true,

package/dist/FeatureFlags/index.d.ts

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

package/dist/FeatureFlags/index.js

@@ -1,10 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFlags = exports.UnknownFeatureFlagError = exports.getSystemFeatureFlags = exports.FeatureFlags = void 0;
-var FeatureFlags_1 = require("./FeatureFlags");
-Object.defineProperty(exports, "FeatureFlags", { enumerable: true, get: function () { return FeatureFlags_1.FeatureFlags; } });
-Object.defineProperty(exports, "getSystemFeatureFlags", { enumerable: true, get: function () { return FeatureFlags_1.getSystemFeatureFlags; } });
-Object.defineProperty(exports, "UnknownFeatureFlagError", { enumerable: true, get: function () { return FeatureFlags_1.UnknownFeatureFlagError; } });
-var parseFlags_1 = require("./parseFlags");
-Object.defineProperty(exports, "parseFlags", { enumerable: true, get: function () { return parseFlags_1.parseFlags; } });
+export { FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags.js';
+export { parseFlags } from './parseFlags.js';
 //# sourceMappingURL=index.js.map

package/dist/FeatureFlags/parseFlags.d.ts

@@ -1,3 +1,3 @@
-import type { FeatureFlags } from './FeatureFlags';
+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,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFlags = void 0;
-const FeatureFlags_1 = require("./FeatureFlags");
+import { UnknownFeatureFlagError } from './FeatureFlags.js';
 const splitFlag = /[:=]/;
 const leadingEql = /^=/;
-function parseFlags(ff, flags) {
+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 FeatureFlags_1.UnknownFeatureFlagError) {
+            if (e instanceof UnknownFeatureFlagError) {
                 console.error(e.message);
                 console.error(ff.help());
             }
@@ -20,5 +17,4 @@ function parseFlags(ff, flags) {
     }
     return ff;
 }
-exports.parseFlags = parseFlags;
 //# sourceMappingURL=parseFlags.js.map

package/dist/app.d.ts

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

package/dist/app.js

@@ -1,38 +1,16 @@
-"use strict";
 // For large dictionaries, it is necessary to increase the memory limit.
-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.run = void 0;
-const path = __importStar(require("path"));
-const build_1 = require("./build");
-const compile_1 = require("./compile");
-const compiler = __importStar(require("./compiler"));
-const logWithTimestamp_1 = require("./compiler/logWithTimestamp");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const npmPackage = require(path.join(__dirname, '..', 'package.json'));
-compiler.setLogger(logWithTimestamp_1.logWithTimestamp);
+import { CommanderError, Option } from 'commander';
+import { readFileSync } from 'fs';
+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 } 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.concat([value]);
 }
@@ -49,29 +27,60 @@ function addCompileOptions(compileCommand) {
         .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('--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.');
 }
-async function run(program, argv, flags) {
+export async function run(program, argv, flags) {
+    async function handleGzip(files) {
+        try {
+            await gzip(files);
+        }
+        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.'))
+    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 (0, compile_1.processCompileAction)(src, options, flags);
+        return processCompileAction(src, options, flags);
     });
     addCompileOptions(program
-        .command('compile-trie <src...>')
+        .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 (0, compile_1.processCompileAction)(src, { ...options, trie: true }, flags);
+        return processCompileAction(src, { ...options, trie: true }, flags);
     });
     program
-        .command('build [targets]')
+        .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_1.build);
+        .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);
 }
-exports.run = run;
 //# sourceMappingURL=app.js.map

package/dist/build.d.ts

@@ -1,7 +1,12 @@
 export interface BuildOptions {
     /** Optional path to config file */
-    config?: string;
-    root?: string;
+    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,33 +1,7 @@
-"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 path = __importStar(require("path"));
-const compiler_1 = require("./compiler");
-const config_1 = require("./config");
+import { cosmiconfig } from 'cosmiconfig';
+import * as path from 'path';
+import { compile } from './compiler/index.js';
+import { normalizeConfig } from './config/index.js';
 const moduleName = 'cspell-tools';
 const searchPlaces = [
     `${moduleName}.config.json`,
@@ -35,25 +9,28 @@ const searchPlaces = [
     `${moduleName}.config.yml`,
     'package.json',
 ];
-async function build(targets, options) {
+export 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));
+        return !allowedTargets.size || allowedTargets.has(target.name);
     }
-    const explorer = (0, cosmiconfig_1.cosmiconfig)(moduleName, {
+    const searchDir = path.resolve(options.root || options.cwd || '.');
+    const explorer = cosmiconfig(moduleName, {
         searchPlaces,
-        stopDir: path.resolve('.'),
-        transform: config_1.normalizeConfig,
+        stopDir: searchDir,
+        transform: normalizeConfig,
     });
-    const config = await (options.config ? explorer.load(options.config) : explorer.search('.'));
+    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.';
     }
-    await (0, compiler_1.compile)(config.config, { filter });
+    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 };
 }
-exports.build = build;
 //# sourceMappingURL=build.js.map

package/dist/compile.d.ts

@@ -1,4 +1,5 @@
-import type { CompileCommonAppOptions } from './AppOptions';
-import type { FeatureFlags } from './FeatureFlags';
+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,24 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processCompileAction = void 0;
-const sync_1 = require("@cspell/cspell-pipe/sync");
-const compile_1 = require("./compiler/compile");
-const createCompileRequest_1 = require("./compiler/createCompileRequest");
-const globP_1 = require("./compiler/globP");
-const FeatureFlags_1 = require("./FeatureFlags");
-(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);
+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);
 }
-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)));
+    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 = [
-        ...(0, sync_1.pipe)(globResults, (0, sync_1.opConcatMap)((a) => a)),
+        ...pipe(globResults, opConcatMap((a) => a)),
     ];
-    return (0, compile_1.compile)((0, createCompileRequest_1.createCompileRequest)(sources, options));
+    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, null, 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.js

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

package/dist/compiler/Reader.d.ts

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

package/dist/compiler/Reader.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReader = exports.regHunspellFile = void 0;
-const readHunspellFiles_1 = require("./readers/readHunspellFiles");
-const textFileReader_1 = require("./readers/textFileReader");
-const trieFileReader_1 = require("./readers/trieFileReader");
-exports.regHunspellFile = /\.(dic|aff)$/i;
+import { readHunspellFiles } from './readers/readHunspellFiles.js';
+import { textFileReader } from './readers/textFileReader.js';
+import { trieFileReader } from './readers/trieFileReader.js';
+export const regHunspellFile = /\.(dic|aff)$/i;
 // Readers first match wins
 const readers = [
-    { test: /\.trie\b/, method: trieFileReader_1.trieFileReader },
-    { test: exports.regHunspellFile, method: readHunspellFiles_1.readHunspellFiles },
+    { test: /\.trie\b/, method: trieFileReader },
+    { test: regHunspellFile, method: readHunspellFiles },
 ];
 function findMatchingReader(filename, options) {
     for (const reader of readers) {
@@ -16,13 +13,12 @@ function findMatchingReader(filename, options) {
             return reader.method(filename, options);
         }
     }
-    return (0, textFileReader_1.textFileReader)(filename);
+    return textFileReader(filename);
 }
-async function createReader(filename, options) {
+export async function createReader(filename, options) {
     const baseReader = await findMatchingReader(filename, options);
     return Object.assign(baseReader, {
         [Symbol.iterator]: () => baseReader.lines[Symbol.iterator](),
     });
 }
-exports.createReader = createReader;
 //# sourceMappingURL=Reader.js.map

package/dist/compiler/SourceReader.d.ts

@@ -1,4 +1,4 @@
-import type { AllowedSplitWordsCollection } from './WordsCollection';
+import type { AllowedSplitWordsCollection } from './WordsCollection.js';
 export interface SourceReaderOptions {
     /**
      * Max Hunspell recursive depth.

package/dist/compiler/SourceReader.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSourceReader = void 0;
-const Reader_1 = require("./Reader");
-const wordListParser_1 = require("./wordListParser");
-async function createSourceReader(filename, options) {
-    const reader = await (0, Reader_1.createReader)(filename, options);
+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: reader.lines,
@@ -15,10 +12,9 @@ async function createSourceReader(filename, options) {
     }
     return textFileReader(reader, options);
 }
-exports.createSourceReader = createSourceReader;
 async function textFileReader(reader, options) {
     const { legacy, splitWords: split, allowedSplitWords } = options;
-    const words = [...(0, wordListParser_1.parseFileLines)(reader, { legacy, split, allowedSplitWords })];
+    const words = [...parseFileLines(reader, { legacy, split, allowedSplitWords })];
     return {
         size: words.length,
         words,

package/dist/compiler/WordsCollection.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultExcludeWordsCollection = exports.defaultAllowedSplitWords = void 0;
-exports.defaultAllowedSplitWords = Object.freeze({ size: 0, has: () => true });
-exports.defaultExcludeWordsCollection = Object.freeze({ size: 0, has: () => false });
+export const defaultAllowedSplitWords = Object.freeze({ size: 0, has: () => true });
+export const defaultExcludeWordsCollection = Object.freeze({ size: 0, has: () => false });
 //# sourceMappingURL=WordsCollection.js.map

package/dist/compiler/compile.d.ts

@@ -1,11 +1,25 @@
-import type { CompileRequest, CompileSourceOptions, Target } from '../config';
+import type { CompileRequest, CompileSourceOptions as CompileSourceConfig, Target } from '../config/index.js';
 interface CompileOptions {
     /**
      * Optional filter function to filter targets.
      */
     filter?: (target: Target) => boolean;
+    /**
+     * The current working directory. Defaults to process.cwd()
+     */
+    cwd?: string;
+    /**
+     * `true` - only build if files do not match checksum.
+     */
+    conditionalBuild: boolean;
 }
 export declare function compile(request: CompileRequest, options?: CompileOptions): Promise<void>;
-export declare function compileTarget(target: Target, options: CompileSourceOptions, rootDir: string): Promise<void>;
+interface CompileTargetOptions {
+    rootDir: string;
+    cwd: string | undefined;
+    conditional: boolean;
+    checksumFile: string | undefined;
+}
+export declare function compileTarget(target: Target, options: CompileSourceConfig, compileOptions: CompileTargetOptions): Promise<string[]>;
 export {};
 //# sourceMappingURL=compile.d.ts.map