cspell-dictionary 6.9.0

package/dist/util/logger.js

@@ -0,0 +1,46 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = exports.setLogger = exports.log = exports.logWarning = exports.logError = void 0;
+let _logger = console;
+/**
+ * See `Console.error`
+ */
+function logError(...args) {
+    _logger.error(...args);
+}
+exports.logError = logError;
+/**
+ * See `Console.warn`
+ */
+function logWarning(...args) {
+    _logger.warn(...args);
+}
+exports.logWarning = logWarning;
+/**
+ * See `Console.log`
+ */
+function log(...args) {
+    _logger.log(...args);
+}
+exports.log = log;
+/**
+ * Set the global cspell-lib logger
+ * @param logger - a logger like `console`
+ * @returns the old logger.
+ */
+function setLogger(logger) {
+    const oldLogger = _logger;
+    _logger = logger;
+    return oldLogger;
+}
+exports.setLogger = setLogger;
+/**
+ * Get the current cspell-lib logger.
+ * @returns the current logger.
+ */
+function getLogger() {
+    return _logger;
+}
+exports.getLogger = getLogger;
+//# sourceMappingURL=logger.js.map

package/dist/util/memorizerWeak.d.ts

@@ -0,0 +1,6 @@
+export declare function memorizerWeak<T, K extends object>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
+export declare function memorizerWeak<T, K0 extends object, K1 extends object>(fn: (...p: [K0, K1]) => T): (...p: [K0, K1]) => T;
+export declare function memorizerWeak<T, K0 extends object, K1 extends object, K2 extends object>(fn: (...p: [K0, K1, K2]) => T): (...p: [K0, K1, K2]) => T;
+export declare function memorizerWeak<T, K0 extends object, K1 extends object, K2 extends object, K3 extends object>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
+export declare function memorizerWeak<T, K0 extends object>(fn: (...p: [K0]) => T): (...p: [K0]) => T;
+//# sourceMappingURL=memorizerWeak.d.ts.map

package/dist/util/memorizerWeak.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memorizerWeak = void 0;
+// prettier-ignore
+function memorizerWeak(fn) {
+    const r = {};
+    function find(p) {
+        let n = r;
+        for (const k of p) {
+            if (!n)
+                break;
+            n = n.c?.get(k);
+        }
+        return n;
+    }
+    function set(p, v) {
+        let n = r;
+        for (const k of p) {
+            const c = n.c?.get(k);
+            if (c) {
+                n = c;
+                continue;
+            }
+            const r = {};
+            n.c = n.c || new WeakMap();
+            n.c.set(k, r);
+            n = r;
+        }
+        n.v = v;
+    }
+    return (...p) => {
+        const f = find(p);
+        if (f && 'v' in f) {
+            return f.v;
+        }
+        const v = fn(...p);
+        set(p, v);
+        return v;
+    };
+}
+exports.memorizerWeak = memorizerWeak;
+//# sourceMappingURL=memorizerWeak.js.map

package/dist/util/regexHelper.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Escape a string so it can be used as an exact match within a RegExp.
+ * @param s - string to escape
+ * @returns - the escaped string.
+ */
+export declare function escapeRegEx(s: string): string;
+//# sourceMappingURL=regexHelper.d.ts.map

package/dist/util/regexHelper.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegEx = void 0;
+/**
+ * Escape a string so it can be used as an exact match within a RegExp.
+ * @param s - string to escape
+ * @returns - the escaped string.
+ */
+function escapeRegEx(s) {
+    return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+}
+exports.escapeRegEx = escapeRegEx;
+//# sourceMappingURL=regexHelper.js.map

package/dist/util/repMap.d.ts

@@ -0,0 +1,4 @@
+import type { ReplaceMap } from '@cspell/cspell-types';
+export declare type ReplaceMapper = (src: string) => string;
+export declare function createMapper(repMap: ReplaceMap): ReplaceMapper;
+//# sourceMappingURL=repMap.d.ts.map

package/dist/util/repMap.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMapper = void 0;
+const regexHelper_1 = require("./regexHelper");
+function createMapper(repMap) {
+    const filteredMap = repMap.filter(([match, _]) => !!match);
+    if (!filteredMap.length) {
+        return (a) => a;
+    }
+    const regExStr = filteredMap
+        .map(([from, _]) => from)
+        // make sure it compiles into a regex
+        .map((s) => {
+        try {
+            // fix up any nested ()
+            const r = s.match(/\(/) ? s.replace(/\((?=.*\))/g, '(?:').replace(/\(\?:\?/g, '(?') : s;
+            new RegExp(r);
+            s = r;
+        }
+        catch (err) {
+            return (0, regexHelper_1.escapeRegEx)(s);
+        }
+        return s;
+    })
+        .map((s) => `(${s})`)
+        .join('|');
+    const regEx = new RegExp(regExStr, 'g');
+    const values = repMap.filter(([match, _]) => !!match).map(([_, into]) => into);
+    function resolve(m, ...matches) {
+        const index = matches.findIndex((a) => !!a);
+        return 0 <= index && index < values.length ? values[index] : m;
+    }
+    return function (s) {
+        return s.replace(regEx, resolve);
+    };
+}
+exports.createMapper = createMapper;
+//# sourceMappingURL=repMap.js.map

package/dist/util/resolveFile.d.ts

@@ -0,0 +1,13 @@
+export interface ResolveFileResult {
+    filename: string;
+    relativeTo: string | undefined;
+    found: boolean;
+}
+/**
+ * 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
+ */
+export declare function resolveFile(filename: string, relativeTo: string): ResolveFileResult;
+//# sourceMappingURL=resolveFile.d.ts.map

package/dist/util/resolveFile.js

@@ -0,0 +1,127 @@
+"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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,23 @@
+"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/simpleCache.d.ts

@@ -0,0 +1,46 @@
+export declare class SimpleWeakCache<K extends object, T> {
+    readonly size: number;
+    private L0;
+    private L1;
+    private L2;
+    private sizeL0;
+    constructor(size: number);
+    has(key: K): boolean;
+    get(key: K): T | undefined;
+    set(key: K, value: T): void;
+    private _set;
+    private caches;
+    private rotate;
+}
+export declare class AutoWeakCache<K extends object, T> extends SimpleWeakCache<K, T> {
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T, size: number);
+    get(key: K): T;
+}
+/**
+ * This will cache between `size` and 3 x `size` items.
+ * It has three stashes, L0, L1, and L2. Each can contain `size` items.
+ * When L0 is full, its items are given to L1 and L1's are given to L2, and L2 is empties.
+ *
+ * The stashes are searched in order, L0...L2. If an item is found in L1, or L2, it is
+ * promoted to L0.
+ */
+export declare class SimpleCache<K, T> {
+    readonly size: number;
+    private L0;
+    private L1;
+    private L2;
+    constructor(size: number);
+    has(key: K): boolean;
+    get(key: K): T | undefined;
+    set(key: K, value: T): void;
+    private _set;
+    private caches;
+    private rotate;
+}
+export declare class AutoCache<K, T> extends SimpleCache<K, T> {
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T, size: number);
+    get(key: K): T;
+}
+//# sourceMappingURL=simpleCache.d.ts.map

package/dist/util/simpleCache.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoCache = exports.SimpleCache = exports.AutoWeakCache = exports.SimpleWeakCache = void 0;
+class SimpleWeakCache {
+    constructor(size) {
+        this.size = size;
+        this.L0 = new WeakMap();
+        this.L1 = new WeakMap();
+        this.L2 = new WeakMap();
+        this.sizeL0 = 0;
+    }
+    has(key) {
+        for (const c of this.caches()) {
+            if (c.has(key))
+                return true;
+        }
+        return false;
+    }
+    get(key) {
+        for (const c of this.caches()) {
+            const entry = c.get(key);
+            if (entry) {
+                if (c !== this.L0) {
+                    this._set(key, entry);
+                }
+                return entry.v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        this._set(key, { v: value });
+    }
+    _set(key, entry) {
+        if (this.L0.has(key)) {
+            this.L0.set(key, entry);
+            return this;
+        }
+        if (this.sizeL0 >= this.size) {
+            this.rotate();
+        }
+        this.sizeL0 += 1;
+        this.L0.set(key, entry);
+    }
+    caches() {
+        return [this.L0, this.L1, this.L2];
+    }
+    rotate() {
+        this.L2 = this.L1;
+        this.L1 = this.L0;
+        this.L0 = new WeakMap();
+        this.sizeL0 = 0;
+    }
+}
+exports.SimpleWeakCache = SimpleWeakCache;
+class AutoWeakCache extends SimpleWeakCache {
+    constructor(factory, size) {
+        super(size);
+        this.factory = factory;
+    }
+    get(key) {
+        const v = super.get(key);
+        if (v !== undefined)
+            return v;
+        const val = this.factory(key);
+        this.set(key, val);
+        return val;
+    }
+}
+exports.AutoWeakCache = AutoWeakCache;
+/**
+ * This will cache between `size` and 3 x `size` items.
+ * It has three stashes, L0, L1, and L2. Each can contain `size` items.
+ * When L0 is full, its items are given to L1 and L1's are given to L2, and L2 is empties.
+ *
+ * The stashes are searched in order, L0...L2. If an item is found in L1, or L2, it is
+ * promoted to L0.
+ */
+class SimpleCache {
+    constructor(size) {
+        this.size = size;
+        this.L0 = new Map();
+        this.L1 = new Map();
+        this.L2 = new Map();
+    }
+    has(key) {
+        for (const c of this.caches()) {
+            if (c.has(key))
+                return true;
+        }
+        return false;
+    }
+    get(key) {
+        for (const c of this.caches()) {
+            const entry = c.get(key);
+            if (entry) {
+                if (c !== this.L0) {
+                    this._set(key, entry);
+                }
+                return entry.v;
+            }
+        }
+        return undefined;
+    }
+    set(key, value) {
+        this._set(key, { v: value });
+    }
+    _set(key, entry) {
+        if (this.L0.has(key)) {
+            this.L0.set(key, entry);
+            return this;
+        }
+        if (this.L0.size >= this.size) {
+            this.rotate();
+        }
+        this.L0.set(key, entry);
+    }
+    caches() {
+        return [this.L0, this.L1, this.L2];
+    }
+    rotate() {
+        this.L2 = this.L1;
+        this.L1 = this.L0;
+        this.L0 = new Map();
+    }
+}
+exports.SimpleCache = SimpleCache;
+class AutoCache extends SimpleCache {
+    constructor(factory, size) {
+        super(size);
+        this.factory = factory;
+    }
+    get(key) {
+        const v = super.get(key);
+        if (v !== undefined)
+            return v;
+        const val = this.factory(key);
+        this.set(key, val);
+        return val;
+    }
+}
+exports.AutoCache = AutoCache;
+//# sourceMappingURL=simpleCache.js.map

package/dist/util/text.d.ts

@@ -0,0 +1,9 @@
+export declare function isUpperCase(word: string): boolean;
+export declare function isLowerCase(word: string): boolean;
+export declare function isFirstCharacterUpper(word: string): boolean;
+export declare function isFirstCharacterLower(word: string): boolean;
+export declare function ucFirst(word: string): string;
+export declare function lcFirst(word: string): string;
+export declare function matchCase(example: string, word: string): string;
+export declare function removeAccents(text: string): string;
+//# sourceMappingURL=text.d.ts.map

package/dist/util/text.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeAccents = exports.matchCase = exports.lcFirst = exports.ucFirst = exports.isFirstCharacterLower = exports.isFirstCharacterUpper = exports.isLowerCase = exports.isUpperCase = void 0;
+const regExFirstUpper = /^\p{Lu}\p{M}?\p{Ll}+$/u;
+const regExAllUpper = /^(?:\p{Lu}\p{M}?)+$/u;
+const regExAllLower = /^(?:\p{Ll}\p{M}?)+$/u;
+const regExAccents = /\p{M}/gu;
+function isUpperCase(word) {
+    return !!word.match(regExAllUpper);
+}
+exports.isUpperCase = isUpperCase;
+function isLowerCase(word) {
+    return !!word.match(regExAllLower);
+}
+exports.isLowerCase = isLowerCase;
+function isFirstCharacterUpper(word) {
+    return isUpperCase(word.slice(0, 1));
+}
+exports.isFirstCharacterUpper = isFirstCharacterUpper;
+function isFirstCharacterLower(word) {
+    return isLowerCase(word.slice(0, 1));
+}
+exports.isFirstCharacterLower = isFirstCharacterLower;
+function ucFirst(word) {
+    return word.slice(0, 1).toUpperCase() + word.slice(1);
+}
+exports.ucFirst = ucFirst;
+function lcFirst(word) {
+    return word.slice(0, 1).toLowerCase() + word.slice(1);
+}
+exports.lcFirst = lcFirst;
+function matchCase(example, word) {
+    if (example.match(regExFirstUpper)) {
+        return word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase();
+    }
+    if (example.match(regExAllLower)) {
+        return word.toLowerCase();
+    }
+    if (example.match(regExAllUpper)) {
+        return word.toUpperCase();
+    }
+    if (isFirstCharacterUpper(example)) {
+        return ucFirst(word);
+    }
+    if (isFirstCharacterLower(example)) {
+        return lcFirst(word);
+    }
+    return word;
+}
+exports.matchCase = matchCase;
+function removeAccents(text) {
+    return text.normalize('NFD').replace(regExAccents, '');
+}
+exports.removeAccents = removeAccents;
+//# sourceMappingURL=text.js.map

package/dist/util/textRegex.d.ts

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

package/dist/util/textRegex.js

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

package/dist/util/timer.d.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,58 @@
+"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