@cspell/cspell-tools 6.11.1 → 6.13.0

package/dist/compiler/readTextFile.js

@@ -0,0 +1,45 @@
+"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.readTextFileLines = exports.readTextFile = void 0;
+const fs_1 = require("fs");
+const util_1 = require("util");
+const zlib = __importStar(require("zlib"));
+const gunzip = (0, util_1.promisify)(zlib.gunzip);
+const isGzFile = /\.gz$/;
+function readTextFile(filename) {
+    const content = fs_1.promises
+        .readFile(filename)
+        .then((buffer) => (isGzFile.test(filename) ? gunzip(buffer) : buffer))
+        .then((buffer) => buffer.toString('utf8'));
+    return content;
+}
+exports.readTextFile = readTextFile;
+async function readTextFileLines(filename) {
+    const content = await readTextFile(filename);
+    return content.split('\n');
+}
+exports.readTextFileLines = readTextFileLines;
+//# sourceMappingURL=readTextFile.js.map

package/dist/compiler/wordListCompiler.d.ts

@@ -1,20 +1,5 @@
-import { Sequence } from 'gensequence';
-import * as Trie from 'cspell-trie-lib';
-export declare type Logger = (message?: any, ...optionalParams: any[]) => void;
-export declare function setLogger(logger?: Logger): void;
-declare type Normalizer = (lines: Sequence<string>) => Sequence<string>;
-export declare function legacyNormalizeWords(lines: Sequence<string>): Sequence<string>;
-export declare function legacyLineToWords(line: string): Sequence<string>;
-export interface CompileOptions {
-    skipNormalization: boolean | undefined;
-    splitWords: boolean | undefined;
-    keepRawCase: boolean;
-    sort: boolean;
-    legacy: boolean | undefined;
-}
-declare function createNormalizer(options: CompileOptions): Normalizer;
-export declare function compileWordList(lines: Sequence<string>, destFilename: string, options: CompileOptions): Promise<void>;
-export declare function createWordListTarget(destFilename: string): (seq: Sequence<string>) => Promise<void>;
+import { CompileOptions } from './CompileOptions';
+export declare function compileWordList(lines: Iterable<string>, destFilename: string, options: CompileOptions): Promise<void>;
 export interface TrieOptions {
     base?: number;
     trie3?: boolean;
@@ -22,23 +7,8 @@ export interface TrieOptions {
 }
 export interface CompileTrieOptions extends CompileOptions, TrieOptions {
 }
-export declare const consolidate: typeof Trie.consolidate;
-export declare function compileTrie(words: Sequence<string>, destFilename: string, options: CompileTrieOptions): Promise<void>;
-export declare function createTrieTarget(destFilename: string, options: TrieOptions): (words: Sequence<string>) => Promise<void>;
-/**
- * Splits a line of text into words, but does not split words.
- * @param line text line to split.
- * @returns array of words
- * @example `readline.clearLine(stream, dir)` => ['readline', 'clearLine', 'stream', 'dir']
- * @example `New York` => ['New', 'York']
- * @example `don't` => [`don't`]
- * @example `Event: 'SIGCONT'` => ['Event', 'SIGCONT']
- */
-declare function splitLine(line: string): string[];
+export declare function compileTrie(words: Iterable<string>, destFilename: string, options: CompileTrieOptions): Promise<void>;
 export declare const __testing__: {
-    splitLine: typeof splitLine;
-    createNormalizer: typeof createNormalizer;
     wordListHeader: string;
 };
-export {};
 //# sourceMappingURL=wordListCompiler.d.ts.map

package/dist/compiler/wordListCompiler.js

@@ -23,168 +23,51 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.createTrieTarget = exports.compileTrie = exports.consolidate = exports.createWordListTarget = exports.compileWordList = exports.legacyLineToWords = exports.legacyNormalizeWords = exports.setLogger = void 0;
-const gensequence_1 = require("gensequence");
-const Text = __importStar(require("./text"));
-const path = __importStar(require("path"));
-const fs_extra_1 = require("fs-extra");
+exports.__testing__ = exports.compileTrie = exports.compileWordList = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
 const Trie = __importStar(require("cspell-trie-lib"));
+const fs_extra_1 = require("fs-extra");
+const path = __importStar(require("path"));
 const fileWriter_1 = require("./fileWriter");
-const util_1 = require("hunspell-reader/dist/util");
-const inlineSettings_1 = require("./inlineSettings");
-const regNonWordOrSpace = /[^\p{L}\p{M}' ]+/giu;
-const regNonWordOrDigit = /[^\p{L}\p{M}'\w-]+/giu;
-const regExpSpaceOrDash = /[- ]+/g;
-const regExpRepeatChars = /(.)\1{4,}/i;
+const logger_1 = require("./logger");
+const wordListParser_1 = require("./wordListParser");
 // 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());
-let log = defaultLogger;
-function setLogger(logger) {
-    log = logger ?? defaultLogger;
-}
-exports.setLogger = setLogger;
-function defaultLogger(message, ...optionalParams) {
-    console.log(message, ...optionalParams);
-}
-function legacyNormalizeWords(lines) {
-    return lines.concatMap((line) => legacyLineToWords(line));
-}
-exports.legacyNormalizeWords = legacyNormalizeWords;
-function legacyLineToWords(line) {
-    // Remove punctuation and non-letters.
-    const filteredLine = line.replace(regNonWordOrSpace, '|');
-    const wordGroups = filteredLine.split('|');
-    const words = (0, gensequence_1.genSequence)(wordGroups)
-        .concatMap((a) => [a, ...a.split(regExpSpaceOrDash)])
-        .concatMap((a) => splitCamelCase(a))
-        .map((a) => a.trim())
-        .filter((a) => !!a)
-        .filter((s) => !regExpRepeatChars.test(s))
-        .map((a) => a.toLowerCase());
-    return words;
-}
-exports.legacyLineToWords = legacyLineToWords;
-function splitCamelCase(word) {
-    const splitWords = Text.splitCamelCaseWord(word);
-    // We only want to preserve this: "New York" and not "Namespace DNSLookup"
-    if (splitWords.length > 1 && regExpSpaceOrDash.test(word)) {
-        return (0, gensequence_1.genSequence)(splitWords).concatMap((w) => w.split(regExpSpaceOrDash));
-    }
-    return splitWords;
-}
-function createNormalizer(options) {
-    const { skipNormalization = false, splitWords, keepRawCase, legacy } = options;
-    if (skipNormalization) {
-        return (lines) => lines;
-    }
-    const lineProcessor = legacy ? legacyLineToWords : splitWords ? splitLine : noSplit;
-    const wordMapper = keepRawCase ? mapWordIdentity : mapWordToDictionaryEntries;
-    const initialState = {
-        inlineSettings: {},
-        lineProcessor,
-        wordMapper,
-    };
-    const fnNormalizeLines = (lines) => normalizeWordListSeq(lines, initialState)
-        .filter((a) => !!a)
-        .pipe(createInlineBufferedSort())
-        .filter((0, util_1.uniqueFilter)(10000));
-    return fnNormalizeLines;
-}
 async function compileWordList(lines, destFilename, options) {
-    const normalizer = createNormalizer(options);
-    const seq = normalizer(lines);
-    const header = (0, gensequence_1.genSequence)(wordListHeaderLines);
-    const finalSeq = header.concat(options.sort ? (0, gensequence_1.genSequence)(sort(seq)) : seq);
+    const filter = (0, wordListParser_1.normalizeTargetWords)(options);
+    const finalSeq = (0, sync_1.pipe)(wordListHeaderLines, (0, sync_1.opAppend)((0, sync_1.pipe)(lines, filter)));
     return createWordListTarget(destFilename)(finalSeq);
 }
 exports.compileWordList = compileWordList;
 function createWordListTarget(destFilename) {
     const target = createTarget(destFilename);
-    return (seq) => target(seq.map((a) => a + '\n'));
+    return (seq) => target((0, sync_1.pipe)(seq, (0, sync_1.opMap)((a) => a + '\n')));
 }
-exports.createWordListTarget = createWordListTarget;
 function createTarget(destFilename) {
     const destDir = path.dirname(destFilename);
     const pDir = (0, fs_extra_1.mkdirp)(destDir);
     return async (seq) => {
         await pDir;
-        return (0, fileWriter_1.writeSeqToFile)(seq, destFilename);
+        await (0, fileWriter_1.writeSeqToFile)(seq, destFilename);
     };
 }
-function mapWordToDictionaryEntries(w) {
-    return Trie.parseDictionaryLines([w]);
-}
-function mapWordIdentity(w) {
-    return [w];
-}
-function normalizeWordListSeq(lines, initialState) {
-    return (0, gensequence_1.genSequence)(normalizeWordListGen(lines, initialState));
-}
-function* normalizeWordListGen(lines, initialState) {
-    let state = initialState;
-    for (let line of lines) {
-        line = line.normalize('NFC');
-        state = adjustState(state, line);
-        for (const word of state.lineProcessor(line)) {
-            const w = word.trim();
-            if (!w)
-                continue;
-            yield* state.wordMapper(w);
-        }
-    }
-}
-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;
-}
-function adjustState(state, line) {
-    const inlineSettings = (0, inlineSettings_1.extractInlineSettings)(line);
-    if (!inlineSettings)
-        return state;
-    const r = { ...state };
-    r.inlineSettings = { ...r.inlineSettings, ...inlineSettings };
-    r.wordMapper =
-        inlineSettings.keepRawCase === undefined
-            ? r.wordMapper
-            : inlineSettings.keepRawCase
-                ? mapWordIdentity
-                : mapWordToDictionaryEntries;
-    r.lineProcessor = inlineSettings.split === undefined ? r.lineProcessor : inlineSettings.split ? splitLine : noSplit;
-    return r;
-}
-function sort(words) {
-    return [...words].sort();
-}
-exports.consolidate = Trie.consolidate;
 async function compileTrie(words, destFilename, options) {
-    const normalizer = createNormalizer(options);
-    await createTrieTarget(destFilename, options)(normalizer(words));
+    await createTrieTarget(destFilename, options)(words);
 }
 exports.compileTrie = compileTrie;
 function createTrieTarget(destFilename, options) {
     const target = createTarget(destFilename);
     return async (words) => {
+        const log = (0, logger_1.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 = (0, exports.consolidate)(root);
+        const trie = Trie.consolidate(root);
         log(`Writing to file ${path.basename(destFilename)}`);
         await target(Trie.serializeTrie(trie, {
             base,
@@ -194,46 +77,7 @@ function createTrieTarget(destFilename, options) {
         log(`Done writing to file ${path.basename(destFilename)}`);
     };
 }
-exports.createTrieTarget = createTrieTarget;
-/**
- * Splits a line of text into words, but does not split words.
- * @param line text line to split.
- * @returns array of words
- * @example `readline.clearLine(stream, dir)` => ['readline', 'clearLine', 'stream', 'dir']
- * @example `New York` => ['New', 'York']
- * @example `don't` => [`don't`]
- * @example `Event: 'SIGCONT'` => ['Event', 'SIGCONT']
- */
-function splitLine(line) {
-    line = line.replace(/#.*/, ''); // remove comment
-    line = line.trim();
-    line = line.replace(/\bU\+[0-9A-F]+\b/gi, '|'); // Remove Unicode Definitions
-    line = line.replace(regNonWordOrDigit, '|');
-    line = line.replace(/'(?=\|)/g, ''); // remove trailing '
-    line = line.replace(/'$/, ''); // remove trailing '
-    line = line.replace(/(?<=\|)'/g, ''); // remove leading '
-    line = line.replace(/^'/, ''); // remove leading '
-    line = line.replace(/\s*\|\s*/g, '|'); // remove spaces around |
-    line = line.replace(/[|]+/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) => !a.match(/^[0-9_-]+$/)) // pure numbers and symbols
-        .filter((a) => !a.match(/^[ux][0-9A-F]*$/i)) // hex digits
-        .filter((a) => !a.match(/^0[xo][0-9A-F]*$/i)); // c-style hex/octal digits
-    return lines;
-}
-function noSplit(line) {
-    line = line.replace(/#.*/, ''); // remove comment
-    line = line.trim();
-    return !line ? [] : [line];
-}
 exports.__testing__ = {
-    splitLine: splitLine,
-    createNormalizer,
     wordListHeader,
 };
 //# sourceMappingURL=wordListCompiler.js.map

package/dist/compiler/wordListParser.d.ts

@@ -0,0 +1,46 @@
+import { type Operator } from '@cspell/cspell-pipe/sync';
+import { CompileOptions } from './CompileOptions';
+export declare function normalizeTargetWords(options: CompileOptions): Operator<string>;
+export interface ParseFileOptions {
+    /**
+     * Preserve case
+     * @default true
+     */
+    keepCase?: boolean;
+    /**
+     * 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;
+}
+declare 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?: Partial<ParseFileOptions>): Iterable<string>;
+export {};
+//# sourceMappingURL=wordListParser.d.ts.map

package/dist/compiler/wordListParser.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFileLines = exports.createParseFileLineMapper = exports.setOfCSpellDirectiveFlags = exports.cSpellToolDirective = exports.defaultParseDictionaryOptions = exports.normalizeTargetWords = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const cspell_trie_lib_1 = require("cspell-trie-lib");
+const util_1 = require("hunspell-reader/dist/util");
+const legacyLineToWords_1 = require("./legacyLineToWords");
+function normalizeTargetWords(options) {
+    const lineParser = (0, cspell_trie_lib_1.createDictionaryLineParser)({ stripCaseAndAccents: options.generateNonStrict });
+    const operations = [
+        (0, sync_1.opFilter)((a) => !!a),
+        lineParser,
+        options.sort ? createInlineBufferedSort(10000) : undefined,
+        (0, sync_1.opFilter)((0, util_1.uniqueFilter)(10000)),
+    ].filter(isDefined);
+    return (0, sync_1.opCombine)(...operations);
+}
+exports.normalizeTargetWords = normalizeTargetWords;
+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,
+};
+exports.defaultParseDictionaryOptions = Object.freeze(_defaultOptions);
+exports.cSpellToolDirective = 'cspell-tools:';
+exports.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.
+ */
+function createParseFileLineMapper(options) {
+    const _options = options || _defaultOptions;
+    const { splitKeepBoth = _defaultOptions.splitKeepBoth } = _options;
+    let { legacy = _defaultOptions.legacy } = _options;
+    let { split = _defaultOptions.split, keepCase = legacy ? false : _defaultOptions.keepCase } = _options;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    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(exports.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.replace(/\bU\+[0-9A-F]+\b/gi, '|'); // Remove Unicode Definitions
+        line = line.replace(regNonWordOrDigit, '|');
+        line = line.replace(/'(?=\|)/g, ''); // remove trailing '
+        line = line.replace(/'$/, ''); // remove trailing '
+        line = line.replace(/(?<=\|)'/g, ''); // remove leading '
+        line = line.replace(/^'/, ''); // remove leading '
+        line = line.replace(/\s*\|\s*/g, '|'); // remove spaces around |
+        line = line.replace(/[|]+/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) => !a.match(/^[0-9_-]+$/)) // pure numbers and symbols
+            .filter((a) => !a.match(/^[ux][0-9A-F]*$/i)) // hex digits
+            .filter((a) => !a.match(/^0[xo][0-9A-F]*$/i)); // c-style hex/octal digits
+        return lines;
+    }
+    function* splitWords(lines) {
+        for (const line of lines) {
+            if (legacy) {
+                yield* (0, legacyLineToWords_1.legacyLineToWords)(line, keepCase);
+                continue;
+            }
+            if (split) {
+                yield* splitLine(line);
+                if (!splitKeepBoth)
+                    continue;
+            }
+            yield line.replace(/["]/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 = (0, sync_1.opCombine)((0, sync_1.opFilter)(isString), splitLines, (0, sync_1.opMap)(removeComments), splitWords, (0, sync_1.opMap)(trim), (0, sync_1.opFilter)(filterEmptyLines), unique);
+    return processLines;
+}
+exports.createParseFileLineMapper = createParseFileLineMapper;
+/**
+ * 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.
+ */
+function parseFileLines(lines, options) {
+    return createParseFileLineMapper(options)(typeof lines === 'string' ? [lines] : lines);
+}
+exports.parseFileLines = parseFileLines;
+//# sourceMappingURL=wordListParser.js.map

package/dist/compiler/writeTextToFile.d.ts

@@ -0,0 +1,3 @@
+export declare function writeTextToFile(filename: string, data: string): Promise<void>;
+export declare function writeTextLinesToFile(filename: string, lines: Iterable<string>): Promise<void>;
+//# sourceMappingURL=writeTextToFile.d.ts.map

package/dist/compiler/writeTextToFile.js

@@ -0,0 +1,44 @@
+"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.writeTextLinesToFile = exports.writeTextToFile = void 0;
+const fs_1 = require("fs");
+const util_1 = require("util");
+const zlib = __importStar(require("zlib"));
+const gzip = (0, util_1.promisify)(zlib.gzip);
+const isGzFile = /\.gz$/;
+async function writeTextToFile(filename, data) {
+    const useGz = isGzFile.test(filename);
+    const buf = Buffer.from(data, 'utf-8');
+    const buffer = useGz ? await gzip(buf) : buf;
+    await fs_1.promises.writeFile(filename, buffer);
+}
+exports.writeTextToFile = writeTextToFile;
+function writeTextLinesToFile(filename, lines) {
+    const data = Array.isArray(lines) ? lines.join('') : [...lines].join('');
+    return writeTextToFile(filename, data);
+}
+exports.writeTextLinesToFile = writeTextLinesToFile;
+//# sourceMappingURL=writeTextToFile.js.map