bumped deps

Author: justinwilaby

Diff for: lib/SpellCheckerBase.d.ts

@@ -1,108 +0,0 @@
-import { SuggestedItem } from "./SuggestedItem";
-export interface WasmSymSpell extends WebAssembly.Exports {
-    memory: WebAssembly.Memory;
-    symspell: (dictionaryEditDistance: number, countThreshold: number) => void;
-    lookup: (ptr: number, length: number, verbosity: Verbosity, maxEditDistance: number, includeUnknowns: boolean, includeSelf: boolean) => void;
-    lookup_compound: (ptr: number, length: number, maxEditDistance: number) => void;
-    write_to_dictionary: (prt: number, length: number, isBigram: boolean) => void;
-}
-export declare enum Verbosity {
-    Top = 0,
-    Closest = 1,
-    All = 2
-}
-export interface SymSpellOptions {
-    /**
-     * The maximum Levenshtein distance to consider
-     * when matching the input against the dictionary.
-     * default=2 (0: no correction, word segmentation only)
-     */
-    dictionaryEditDistance: number;
-    /**
-     * The minimum frequency count for dictionary words
-     * to be considered correct spellings.
-     */
-    countThreshold: number;
-}
-export interface CheckSpellingOptions {
-    verbosity: Verbosity;
-    maxEditDistance: number;
-    includeUnknown: boolean;
-    includeSelf: boolean;
-}
-export declare type ResultsHandler = (suggestedItems: SuggestedItem[]) => void;
-export declare const defaultOptions: SymSpellOptions;
-export declare const defaultCheckSpellingOptions: CheckSpellingOptions;
-/**
- * This class provides the wrapper for the spellcheck-wasm.wasm functionality.
- */
-export declare abstract class SpellcheckerBase {
-    protected wasmSymSpell: WasmSymSpell;
-    protected writeBuffer: Uint8Array;
-    /**
-     * The handler set by the consumer to receive
-     * suggested items from the wasm.
-     */
-    resultHandler: ResultsHandler;
-    protected constructor(resultHandler?: ResultsHandler);
-    protected abstract encodeString(str: string): Uint8Array;
-    /**
-     * Writes a chunk of bytes to the dictionary. This operation is
-     * useful when implementing a custom dictionary where additional
-     * entries are required beyond the supplied corpus.
-     *
-     * Caution should be used since writing multiple megabytes at once
-     * often results in a memory out of bounds error. Streaming at 32-64kb
-     * chunks is recommended.
-     *
-     * @param chunk Uint8Array The chunk containing the bytes to write
-     * @param isBigram boolean Indicates whether this chunk should be written to the bigram dictionary instead.
-     */
-    writeToDictionary(chunk: Uint8Array, isBigram?: boolean): void;
-    /**
-     * Prepares the spellcheck wasm for use.
-     *
-     * @param wasmLocation
-     * @param dictionaryLocation
-     * @param bigramLocation
-     * @param options
-     */
-    abstract prepareSpellchecker(wasmLocation: string, dictionaryLocation: string, bigramLocation: string, options: SymSpellOptions): Promise<void>;
-    abstract prepareSpellchecker(wasFetchResponse: Response, dictionaryFetchResponse: Response, bigramFetchResponse: Response, options: SymSpellOptions): Promise<void>;
-    /**
-     * Performs a single spelling check based on the supplied word and options.
-     * The suggestions list will be provided to the resultHandler().
-     *
-     * @param word string The word to perform spell checking on.
-     * @param options CheckSpellingOptions The options to use for this spell check lookup
-     */
-    checkSpelling(word: Uint8Array | string, options?: CheckSpellingOptions): void;
-    /**
-     * Performs a spelling check based on the supplied sentence and options.
-     * The suggestions list will be provided to the resultHandler().
-     *
-     * @param sentence string The sentence to perform spell checking on.
-     * @param options CheckSpellingOptions The options to use for this spell check lookup
-     */
-    checkSpellingCompound(sentence: Uint8Array | string, options?: Pick<CheckSpellingOptions, 'maxEditDistance'>): void;
-    /**
-     * @internal
-     *
-     * Traps responses form the wasm and converts them into
-     * their respective SuggestedItem instances.
-     *
-     * @param ptr number The pointer in memory where this result set is located
-     * @param length number The number of total bytes in the set
-     */
-    protected resultTrap: (ptr: number, length: number) => void;
-    /**
-     * Allocations within the WASM process
-     * detach reference to the memory buffer.
-     * We check for this and create a new Uint8Array
-     * with the new memory buffer reference if needed.
-     *
-     * @param chunk
-     * @param memory
-     */
-    protected writeToBuffer(chunk: Uint8Array, memory: WebAssembly.Memory): void;
-}

Diff for: lib/SpellCheckerBase.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SuggestedItem_1 = require("./SuggestedItem");
-var Verbosity;
-(function (Verbosity) {
-    // Top suggestion with the highest term frequency of the suggestions of smallest edit distance found.
-    Verbosity[Verbosity["Top"] = 0] = "Top";
-    // All suggestions of smallest edit distance found, suggestions ordered by term frequency.
-    Verbosity[Verbosity["Closest"] = 1] = "Closest";
-    //All suggestions within maxEditDistance, suggestions ordered by edit distance
-    // , then by term frequency (slower, no early termination).</summary>
-    Verbosity[Verbosity["All"] = 2] = "All";
-})(Verbosity = exports.Verbosity || (exports.Verbosity = {}));
-exports.defaultOptions = {
-    dictionaryEditDistance: 2,
-    countThreshold: 1
-};
-exports.defaultCheckSpellingOptions = {
-    includeUnknown: false,
-    includeSelf: false,
-    maxEditDistance: 2,
-    verbosity: Verbosity.Closest
-};
-/**
- * This class provides the wrapper for the spellcheck-wasm.wasm functionality.
- */
-class SpellcheckerBase {
-    constructor(resultHandler) {
-        /**
-         * @internal
-         *
-         * Traps responses form the wasm and converts them into
-         * their respective SuggestedItem instances.
-         *
-         * @param ptr number The pointer in memory where this result set is located
-         * @param length number The number of total bytes in the set
-         */
-        this.resultTrap = (ptr, length) => {
-            const { memory } = this.wasmSymSpell;
-            this.resultHandler(SuggestedItem_1.deserializeSuggestedItems(memory.buffer, ptr, length));
-        };
-        this.resultHandler = resultHandler;
-    }
-    /**
-     * Writes a chunk of bytes to the dictionary. This operation is
-     * useful when implementing a custom dictionary where additional
-     * entries are required beyond the supplied corpus.
-     *
-     * Caution should be used since writing multiple megabytes at once
-     * often results in a memory out of bounds error. Streaming at 32-64kb
-     * chunks is recommended.
-     *
-     * @param chunk Uint8Array The chunk containing the bytes to write
-     * @param isBigram boolean Indicates whether this chunk should be written to the bigram dictionary instead.
-     */
-    writeToDictionary(chunk, isBigram = false) {
-        this.writeToBuffer(chunk, this.wasmSymSpell.memory);
-        this.wasmSymSpell.write_to_dictionary(0, chunk.byteLength, isBigram);
-    }
-    /**
-     * Performs a single spelling check based on the supplied word and options.
-     * The suggestions list will be provided to the resultHandler().
-     *
-     * @param word string The word to perform spell checking on.
-     * @param options CheckSpellingOptions The options to use for this spell check lookup
-     */
-    checkSpelling(word, options = exports.defaultCheckSpellingOptions) {
-        const { lookup, memory } = this.wasmSymSpell;
-        let encodedString;
-        if (word instanceof Uint8Array) {
-            encodedString = word;
-        }
-        else {
-            encodedString = this.encodeString(word);
-        }
-        this.writeToBuffer(encodedString, memory);
-        lookup(0, encodedString.byteLength, options.verbosity, options.maxEditDistance, options.includeUnknown, options.includeSelf);
-    }
-    /**
-     * Performs a spelling check based on the supplied sentence and options.
-     * The suggestions list will be provided to the resultHandler().
-     *
-     * @param sentence string The sentence to perform spell checking on.
-     * @param options CheckSpellingOptions The options to use for this spell check lookup
-     */
-    checkSpellingCompound(sentence, options = exports.defaultCheckSpellingOptions) {
-        const { lookup_compound, memory } = this.wasmSymSpell;
-        let encodedString;
-        if (sentence instanceof Uint8Array) {
-            encodedString = sentence;
-        }
-        else {
-            encodedString = this.encodeString(sentence);
-        }
-        this.writeToBuffer(encodedString, memory);
-        lookup_compound(0, encodedString.byteLength, options.maxEditDistance);
-    }
-    /**
-     * Allocations within the WASM process
-     * detach reference to the memory buffer.
-     * We check for this and create a new Uint8Array
-     * with the new memory buffer reference if needed.
-     *
-     * @param chunk
-     * @param memory
-     */
-    writeToBuffer(chunk, memory) {
-        if (!this.writeBuffer || this.writeBuffer.buffer !== memory.buffer || this.writeBuffer.byteLength < chunk.byteLength) {
-            if (memory.buffer.byteLength < chunk.byteLength) {
-                const delta = Math.ceil((chunk.byteLength - memory.buffer.byteLength) / 65536); // 64 * 1024;
-                memory.grow(delta);
-            }
-            this.writeBuffer = new Uint8Array(memory.buffer, 0, chunk.byteLength);
-        }
-        this.writeBuffer.set(chunk, 0);
-    }
-}
-exports.SpellcheckerBase = SpellcheckerBase;

Diff for: lib/SuggestedItem.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class SuggestedItem {
-    constructor(data, ptr) {
-        this.cache = {};
-        this.data = data;
-        this.ptr = ptr;
-    }
-    get count() {
-        return this.cache.count || (this.cache.count = readU32(this.data, this.ptr));
-    }
-    get distance() {
-        return this.cache.distance || (this.cache.distance = readU32(this.data, this.ptr + 4));
-    }
-    get term() {
-        if (this.cache.term) {
-            return this.cache.term;
-        }
-        const start = this.ptr + 12;
-        const end = start + readU32(this.data, this.ptr + 8);
-        return (this.cache.term = SuggestedItem.decodeString(this.data.slice(start, end)));
-    }
-    toJSON() {
-        const { count, distance, term } = this;
-        return { count, distance, term };
-    }
-}
-exports.SuggestedItem = SuggestedItem;
-function readU32(buffer, ptr) {
-    return (buffer[ptr + 3] << 24) | (buffer[ptr + 2] << 16) | (buffer[ptr + 1] << 8) | buffer[ptr];
-}
-exports.readU32 = readU32;
-/**
- * Suggested items are encoded by the wasm to be as compact as possible and
- * reside in the wasm ArrayBuffer. This function slices that ArrayBuffer into
- * the data representing each SuggestedItem and supplies it as the data source
- * for all properties within the respective SuggestedItem.
- *
- * This is not JSON encoded data since JSON tokens often exceed the data they
- * encapsulate making them far less efficient.
- *
- *
- * @param buffer ArrayBufferLike The ArrayBuffer from the wasm memory export.
- * @param ptr number The beginning byte for the SuggestedItems
- * @param length number The total number of byes comprising all suggested items in memory.
- */
-function deserializeSuggestedItems(buffer, ptr, length) {
-    const rawSlice = new Uint8Array(buffer.slice(ptr, ptr + length));
-    ptr = 0; // pointer resets to zero when we slice
-    // Find each position of the encoded suggest item
-    // within the buffer
-    const numItems = readU32(rawSlice, 0); // bytes 0-3 represent the u32 of total items encoded in LE
-    ptr += 4;
-    const suggestedItems = [];
-    for (let i = 0; i < numItems; i++) {
-        const itemLen = readU32(rawSlice, ptr); //bytes ptr + 3 represent the number of bytes in each item encoded in LE
-        ptr += 4;
-        // All suggested items share the same slice but the pointer
-        // is updated to indicate where the property values start.
-        suggestedItems[i] = new SuggestedItem(rawSlice, ptr);
-        ptr += itemLen;
-    }
-    return suggestedItems;
-}
-exports.deserializeSuggestedItems = deserializeSuggestedItems;

Diff for: lib/frequency_bigramdictionary_en_243_342.txt.gz

@@ -1 +0,0 @@
-export * from "./spellchecker-wasm.wasm_bg.js";