cspell-dictionary 6.9.0 → 6.10.0

package/dist/util/resolveFile.js

@@ -1,127 +0,0 @@
-"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;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveFile = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const resolve_from_1 = __importDefault(require("resolve-from"));
-const os = __importStar(require("os"));
-const resolve_global_1 = __importDefault(require("resolve-global"));
-const testNodeModules = /^node_modules\//;
-/**
- * Resolve filename to absolute paths.
- * It tries to look for local files as well as node_modules
- * @param filename an absolute path, relative path, `~` path, or a node_module.
- * @param relativeTo absolute path
- */
-function resolveFile(filename, relativeTo) {
-    filename = filename.replace(/^~/, os.homedir());
-    const steps = [
-        { filename, fn: tryUrl },
-        { filename, fn: tryNodeResolve },
-        { filename: path.resolve(relativeTo, filename), fn: tryResolveExists },
-        { filename: path.resolve(filename), fn: tryResolveExists },
-        { filename, fn: tryNodeResolveDefaultPaths },
-        { filename, fn: tryResolveFrom },
-        { filename: filename.replace(testNodeModules, ''), fn: tryResolveFrom },
-        { filename, fn: tryResolveGlobal },
-    ];
-    for (const step of steps) {
-        const r = step.fn(step.filename, relativeTo);
-        if (r.found)
-            return r;
-    }
-    return { filename: path.resolve(relativeTo, filename), relativeTo, found: false };
-}
-exports.resolveFile = resolveFile;
-const isUrlRegExp = /^\w+:\/\//i;
-/**
- * Check to see if it is a URL.
- * Note: URLs are absolute!
- * @param filename - url string
- * @returns ResolveFileResult
- */
-function tryUrl(filename, relativeTo) {
-    if (isUrlRegExp.test(filename)) {
-        return { filename, relativeTo: undefined, found: true };
-    }
-    if (isUrlRegExp.test(relativeTo)) {
-        const url = new URL(filename, relativeTo);
-        return { filename: url.href, relativeTo, found: true };
-    }
-    return { filename, relativeTo: undefined, found: false };
-}
-function tryNodeResolveDefaultPaths(filename) {
-    try {
-        const r = require.resolve(filename);
-        return { filename: r, relativeTo: undefined, found: true };
-    }
-    catch (_) {
-        return { filename, relativeTo: undefined, found: false };
-    }
-}
-function tryNodeResolve(filename, relativeTo) {
-    const home = os.homedir();
-    function calcPaths(p) {
-        const paths = [p];
-        // Do not progress towards the root if it is a relative filename.
-        if (filename.startsWith('.') &&
-            (filename.startsWith('./') || filename.startsWith('.' + path.sep) || filename.startsWith('..'))) {
-            return paths;
-        }
-        for (; p && path.dirname(p) !== p && p !== home; p = path.dirname(p)) {
-            paths.push(p);
-        }
-        return paths;
-    }
-    const paths = calcPaths(path.resolve(relativeTo));
-    try {
-        const r = require.resolve(filename, { paths });
-        return { filename: r, relativeTo, found: true };
-    }
-    catch (_) {
-        return { filename, relativeTo, found: false };
-    }
-}
-function tryResolveGlobal(filename) {
-    const r = resolve_global_1.default.silent(filename);
-    return { filename: r || filename, relativeTo: undefined, found: !!r };
-}
-function tryResolveExists(filename) {
-    return { filename, relativeTo: undefined, found: fs.existsSync(filename) };
-}
-function tryResolveFrom(filename, relativeTo) {
-    try {
-        return { filename: (0, resolve_from_1.default)(relativeTo, filename), relativeTo, found: true };
-    }
-    catch (error) {
-        // Failed to resolve a relative module request
-        return { filename: filename, relativeTo, found: false };
-    }
-}
-//# sourceMappingURL=resolveFile.js.map

package/dist/util/search.d.ts

@@ -1,6 +0,0 @@
-/**
- * Search for an item in a sorted array.
- * The value returned is either the position of the item or where it should be inserted.
- */
-export declare function binarySearch<T>(arr: Array<T>, item: T, leftOffset?: number, rightOffset?: number): number;
-//# sourceMappingURL=search.d.ts.map

package/dist/util/search.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.binarySearch = void 0;
-/**
- * Search for an item in a sorted array.
- * The value returned is either the position of the item or where it should be inserted.
- */
-function binarySearch(arr, item, leftOffset, rightOffset) {
-    let left = Math.max(leftOffset ?? 0, 0);
-    let right = Math.min(rightOffset ?? arr.length, arr.length);
-    while (left < right) {
-        const pos = (left + right) >> 1;
-        if (arr[pos] < item) {
-            left = pos + 1;
-        }
-        else {
-            right = pos;
-        }
-    }
-    return left;
-}
-exports.binarySearch = binarySearch;
-//# sourceMappingURL=search.js.map

package/dist/util/textRegex.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=textRegex.d.ts.map

package/dist/util/textRegex.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=textRegex.js.map

package/dist/util/timer.d.ts

@@ -1,26 +0,0 @@
-export interface Timer {
-    /** Start / restart the timer. */
-    start(): void;
-    /**
-     * Calculate the amount of time in ms since the
-     * timer was created / started.
-     */
-    elapsed(): number;
-    /**
-     * Calculate the amount of time in ms since the
-     * end of the last lap.
-     */
-    lap(): number;
-}
-export declare function createTimer(hrTimeFn?: HRTimeFn): Timer;
-export declare type HRTimeFn = (time?: HRTime) => HRTime;
-export declare type HRTime = [number, number];
-export declare function toMilliseconds(t: HRTime): number;
-export declare function polyHrTime(time?: HRTime): HRTime;
-export interface LapRecorder {
-    times: [name: string, lapTime: number, totalTime: number][];
-    lap(name: string): void;
-    report(): string[];
-}
-export declare function createLapRecorder(): LapRecorder;
-//# sourceMappingURL=timer.d.ts.map

package/dist/util/timer.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLapRecorder = exports.polyHrTime = exports.toMilliseconds = exports.createTimer = void 0;
-const _hrTime = process?.hrtime || polyHrTime;
-function createTimer(hrTimeFn = _hrTime) {
-    let start = hrTimeFn();
-    let lastLap = 0;
-    function elapsed() {
-        return toMilliseconds(hrTimeFn(start));
-    }
-    return {
-        start() {
-            start = hrTimeFn();
-            lastLap = 0;
-        },
-        elapsed,
-        lap() {
-            const now = elapsed();
-            const diff = now - lastLap;
-            lastLap = now;
-            return diff;
-        },
-    };
-}
-exports.createTimer = createTimer;
-function toMilliseconds(t) {
-    return (t[0] + t[1] * 1e-9) * 1000;
-}
-exports.toMilliseconds = toMilliseconds;
-function polyHrTime(time) {
-    const now = Date.now() - (time ? toMilliseconds(time) : 0);
-    const inSeconds = now * 1.0e-3;
-    const s = Math.floor(inSeconds);
-    const n = (inSeconds - s) * 1.0e9;
-    return [s, n];
-}
-exports.polyHrTime = polyHrTime;
-function createLapRecorder() {
-    const timer = createTimer();
-    const times = [];
-    let lapTime = 0;
-    function lap(name) {
-        const now = timer.elapsed();
-        const diff = now - lapTime;
-        times.push([name, diff, now]);
-        lapTime = diff;
-    }
-    function report() {
-        return times.map(([name, time]) => `${name}: ${time.toFixed(2)}`);
-    }
-    return {
-        times,
-        lap,
-        report,
-    };
-}
-exports.createLapRecorder = createLapRecorder;
-//# sourceMappingURL=timer.js.map

package/dist/util/util.test copy.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=util.test%20copy.d.ts.map

package/dist/util/util.test copy.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const clean_1 = require("./clean");
-describe('Validate util', () => {
-    test('tests clean up obj', () => {
-        const obj = {
-            a: undefined,
-            b: 1,
-            c: true,
-            d: undefined,
-            e: 'str',
-        };
-        const cleanObj = (0, clean_1.clean)(obj);
-        expect([...Object.keys(cleanObj)]).toEqual(['b', 'c', 'e']);
-    });
-});
-//# sourceMappingURL=util.test%20copy.js.map

package/dist/util/wordSplitter.d.ts

@@ -1,46 +0,0 @@
-import type { TextOffset } from '@cspell/cspell-types';
-export declare type IsValidWordFn = (word: TextOffset) => boolean;
-export interface SplitResult {
-    /** Original line passed to the split function */
-    line: TextOffset;
-    /** Starting point of processing - Original offset passed to the split function */
-    offset: number;
-    /** The span of text that was split */
-    text: TextOffset;
-    /** The collection of words that `text` was split into */
-    words: TextOffsetWithValid[];
-    /** the offset at which the split stopped */
-    endOffset: number;
-}
-export interface LineSegment {
-    line: TextOffset;
-    relStart: number;
-    relEnd: number;
-}
-export interface TextOffsetWithValid extends TextOffset {
-    isFound: boolean;
-}
-export interface SplitOptions extends WordBreakOptions {
-}
-export declare function split(line: TextOffset, offset: number, isValidWord: IsValidWordFn, options?: SplitOptions): SplitResult;
-declare type BreakPairs = readonly number[];
-interface PossibleWordBreak {
-    /** offset from the start of the string */
-    offset: number;
-    /**
-     * break pairs (start, end)
-     * (the characters between the start and end are removed)
-     * With a pure break, start === end.
-     */
-    breaks: BreakPairs[];
-}
-export declare type SortedBreaks = PossibleWordBreak[];
-interface WordBreakOptions {
-    optionalWordBreakCharacters?: string;
-}
-declare function generateWordBreaks(line: LineSegment, options: WordBreakOptions): SortedBreaks;
-export declare const __testing__: {
-    generateWordBreaks: typeof generateWordBreaks;
-};
-export {};
-//# sourceMappingURL=wordSplitter.d.ts.map

package/dist/util/wordSplitter.js

@@ -1,326 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.split = void 0;
-const PairingHeap_1 = require("./PairingHeap");
-const regexHelper_1 = require("./regexHelper");
-const textRegex_1 = require("./textRegex");
-const ignoreBreak = Object.freeze([]);
-function split(line, offset, isValidWord, options = {}) {
-    const relWordToSplit = findNextWordText({ text: line.text, offset: offset - line.offset });
-    const lineOffset = line.offset;
-    const requested = new Map();
-    if (!relWordToSplit.text) {
-        const text = rebaseTextOffset(relWordToSplit);
-        return {
-            line,
-            offset,
-            text: text,
-            words: [],
-            endOffset: text.offset + text.text.length,
-        };
-    }
-    const lineSegment = {
-        line,
-        relStart: relWordToSplit.offset,
-        relEnd: relWordToSplit.offset + relWordToSplit.text.length,
-    };
-    const possibleBreaks = generateWordBreaks(lineSegment, options);
-    if (!possibleBreaks.length) {
-        const text = rebaseTextOffset(relWordToSplit);
-        return {
-            line,
-            offset,
-            text: text,
-            words: [{ ...text, isFound: isValidWord(text) }],
-            endOffset: text.offset + text.text.length,
-        };
-    }
-    function rebaseTextOffset(relText) {
-        return {
-            ...relText,
-            offset: relText.offset + lineOffset,
-        };
-    }
-    function has(word) {
-        const i = word.offset;
-        const j = word.text.length;
-        let v = i + (j << 20);
-        if (i < 1 << 20 && j < 1 << 11) {
-            const b = requested.get(v);
-            if (b !== undefined)
-                return b;
-        }
-        else {
-            v = -1;
-        }
-        const r = isValidWord(rebaseTextOffset(word));
-        if (v >= 0) {
-            requested.set(v, r);
-        }
-        return r;
-    }
-    // Add a dummy break at the end to avoid needing to check for last break.
-    possibleBreaks.push({
-        offset: lineSegment.relEnd,
-        breaks: [ignoreBreak],
-    });
-    const result = {
-        line,
-        offset,
-        text: rebaseTextOffset(relWordToSplit),
-        words: splitIntoWords(lineSegment, possibleBreaks, has).map(rebaseTextOffset),
-        endOffset: lineOffset + lineSegment.relEnd,
-    };
-    return result;
-}
-exports.split = split;
-function findNextWordText({ text, offset }) {
-    const reg = new RegExp(textRegex_1.regExWordsAndDigits);
-    reg.lastIndex = offset;
-    const m = reg.exec(text);
-    if (!m) {
-        return {
-            text: '',
-            offset: offset + text.length,
-        };
-    }
-    return {
-        text: m[0],
-        offset: m.index,
-    };
-}
-function generateWordBreaks(line, options) {
-    const camelBreaks = genWordBreakCamel(line);
-    const symbolBreaks = genSymbolBreaks(line);
-    const optionalBreaks = genOptionalWordBreaks(line, options.optionalWordBreakCharacters);
-    return mergeSortedBreaks(...camelBreaks, ...symbolBreaks, ...optionalBreaks);
-}
-function offsetRegEx(reg, offset) {
-    const r = new RegExp(reg);
-    r.lastIndex = offset;
-    return r;
-}
-function genWordBreakCamel(line) {
-    const breaksCamel1 = [];
-    const text = line.line.text.slice(0, line.relEnd);
-    // lower,Upper: camelCase -> camel|Case
-    for (const m of text.matchAll(offsetRegEx(textRegex_1.regExSplitWords, line.relStart))) {
-        if (m.index === undefined)
-            break;
-        const i = m.index + 1;
-        breaksCamel1.push({
-            offset: m.index,
-            breaks: [[i, i], ignoreBreak],
-        });
-    }
-    const breaksCamel2 = [];
-    // cspell:ignore ERRORC
-    // Upper,Upper,lower: ERRORCodes -> ERROR|Codes, ERRORC|odes
-    for (const m of text.matchAll(offsetRegEx(textRegex_1.regExSplitWords2, line.relStart))) {
-        if (m.index === undefined)
-            break;
-        const i = m.index + m[1].length;
-        const j = i + 1;
-        breaksCamel2.push({
-            offset: m.index,
-            breaks: [[i, i], [j, j], ignoreBreak],
-        });
-    }
-    return [breaksCamel1, breaksCamel2];
-}
-function calcBreaksForRegEx(line, reg, calcBreak) {
-    const sb = [];
-    const text = line.line.text.slice(0, line.relEnd);
-    for (const m of text.matchAll(offsetRegEx(reg, line.relStart))) {
-        const b = calcBreak(m);
-        if (b) {
-            sb.push(b);
-        }
-    }
-    return sb;
-}
-function genOptionalWordBreaks(line, optionalBreakCharacters) {
-    function calcBreaks(m) {
-        const i = m.index;
-        if (i === undefined)
-            return;
-        const j = i + m[0].length;
-        return {
-            offset: i,
-            breaks: [
-                [i, j],
-                ignoreBreak,
-            ],
-        };
-    }
-    const breaks = [
-        calcBreaksForRegEx(line, textRegex_1.regExDanglingQuote, calcBreaks),
-        calcBreaksForRegEx(line, textRegex_1.regExTrailingEndings, calcBreaks),
-    ];
-    if (optionalBreakCharacters) {
-        const regex = new RegExp(`[${(0, regexHelper_1.escapeRegEx)(optionalBreakCharacters)}]`, 'gu');
-        breaks.push(calcBreaksForRegEx(line, regex, calcBreaks));
-    }
-    return breaks;
-}
-function genSymbolBreaks(line) {
-    function calcBreaks(m) {
-        const i = m.index;
-        if (i === undefined)
-            return;
-        const j = i + m[0].length;
-        return {
-            offset: i,
-            breaks: [
-                [i, j],
-                [i, i],
-                [j, j],
-                ignoreBreak,
-            ],
-        };
-    }
-    return [
-        calcBreaksForRegEx(line, textRegex_1.regExPossibleWordBreaks, calcBreaks),
-        calcBreaksForRegEx(line, /\d+/g, calcBreaks),
-        calcBreaksForRegEx(line, textRegex_1.regExEscapeCharacters, calcBreaks),
-    ];
-}
-function splitIntoWords(lineSeg, breaks, has) {
-    const maxIndex = lineSeg.relEnd;
-    const maxAttempts = 1000;
-    const knownPathsByIndex = new Map();
-    /**
-     * Create a set of possible candidate to consider
-     * @param p - prev candidate that lead to this one
-     * @param i - offset within the string
-     * @param bi - current index into the set of breaks
-     * @param currentCost - current cost accrued
-     */
-    function makeCandidates(p, i, bi, currentCost) {
-        const len = maxIndex;
-        while (bi < breaks.length && breaks[bi].offset < i) {
-            bi += 1;
-        }
-        if (bi >= breaks.length) {
-            return [];
-        }
-        const br = breaks[bi];
-        function c(bp) {
-            const d = bp.length < 2 ? len - i : (bp[0] - i) * 0.5 + len - bp[1];
-            const ec = currentCost + d;
-            return {
-                p,
-                i,
-                bi,
-                bp,
-                c: currentCost,
-                ec,
-                text: undefined,
-            };
-        }
-        return br.breaks.map(c);
-    }
-    function toTextOffset(text, offset) {
-        const valid = has({ text, offset });
-        return {
-            text,
-            offset,
-            isFound: valid,
-        };
-    }
-    function compare(a, b) {
-        return a.ec - b.ec || b.i - a.i;
-    }
-    function pathToWords(node) {
-        const results = [];
-        for (let p = node; p; p = p.n) {
-            if (p.text) {
-                results.push(p.text);
-            }
-        }
-        return results;
-    }
-    function addToKnownPaths(candidate, path) {
-        for (let can = candidate; can !== undefined; can = can.p) {
-            const t = can.text;
-            const i = can.i;
-            const cost = (!t || t.isFound ? 0 : t.text.length) + (path?.c ?? 0);
-            const exitingPath = knownPathsByIndex.get(i);
-            // Keep going only if this is a better candidate than the existing path
-            if (exitingPath && exitingPath.c <= cost) {
-                return undefined;
-            }
-            const node = {
-                n: path,
-                i,
-                c: cost,
-                text: t,
-            };
-            knownPathsByIndex.set(i, node);
-            path = node;
-        }
-        return path;
-    }
-    let maxCost = lineSeg.relEnd - lineSeg.relStart;
-    const candidates = new PairingHeap_1.PairingHeap(compare);
-    const text = lineSeg.line.text;
-    candidates.concat(makeCandidates(undefined, lineSeg.relStart, 0, 0));
-    let attempts = 0;
-    let bestPath;
-    while (maxCost && candidates.length && attempts++ < maxAttempts) {
-        /** Best Candidate Index */
-        const best = candidates.dequeue();
-        if (!best || best.c >= maxCost) {
-            continue;
-        }
-        // Does it have a split?
-        if (best.bp.length) {
-            // yes
-            const i = best.bp[0];
-            const j = best.bp[1];
-            const t = i > best.i ? toTextOffset(text.slice(best.i, i), best.i) : undefined;
-            const cost = !t || t.isFound ? 0 : t.text.length;
-            const mc = maxIndex - j;
-            best.c += cost;
-            best.ec = best.c + mc;
-            best.text = t;
-            const possiblePath = knownPathsByIndex.get(j);
-            if (possiblePath) {
-                // We found a known apply to candidate
-                const f = addToKnownPaths(best, possiblePath);
-                bestPath = !bestPath || (f && f.c < bestPath.c) ? f : bestPath;
-            }
-            else if (best.c < maxCost) {
-                const c = makeCandidates(t ? best : best.p, j, best.bi + 1, best.c);
-                candidates.concat(c);
-            }
-        }
-        else {
-            // It is a pass through
-            const c = makeCandidates(best.p, best.i, best.bi + 1, best.c);
-            candidates.concat(c);
-            if (!c.length) {
-                const t = maxIndex > best.i ? toTextOffset(text.slice(best.i, maxIndex), best.i) : undefined;
-                const cost = !t || t.isFound ? 0 : t.text.length;
-                best.c += cost;
-                best.ec = best.c;
-                best.text = t;
-                const segText = t || best.p?.text || toTextOffset('', best.i);
-                const can = t ? { ...best, text: segText } : { ...best, ...best.p, text: segText };
-                const f = addToKnownPaths(can, undefined);
-                bestPath = !bestPath || (f && f.c < bestPath.c) ? f : bestPath;
-            }
-        }
-        if (bestPath && bestPath.c < maxCost) {
-            maxCost = bestPath.c;
-        }
-    }
-    return pathToWords(bestPath);
-}
-function mergeSortedBreaks(...maps) {
-    return [].concat(...maps).sort((a, b) => a.offset - b.offset);
-}
-exports.__testing__ = {
-    generateWordBreaks,
-};
-//# sourceMappingURL=wordSplitter.js.map