@shaxpir/duiduidui-models 1.0.1 → 1.2.0

package/dist/util/Base62.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Base62 = void 0;
-class Base62 {
-    static encode(value, padToLength = 1) {
-        if (value < 0) {
-            throw new Error("number out of range: " + value);
-        }
-        let result = "";
-        while (value > 0) {
-            let index = value % 62;
-            let digit = Base62.CHARS.charAt(index);
-            result = digit + result;
-            value = Math.floor(value / 62);
-        }
-        while (result.length < padToLength) {
-            result = "0" + result;
-        }
-        return result;
-    }
-    static decode(value) {
-        let result = 0;
-        for (let i = 0, len = value.length; i < len; i++) {
-            let c = value.charAt(i);
-            result *= 62;
-            result += Base62.CHARS.indexOf(c);
-        }
-        return result;
-    }
-    static fromHexHash(hex, length) {
-        // NOTE: the crazy one-liner below is equivalent to this commented code...
-        //   const b64 = Buffer.from(hex, 'hex').toString('base64');
-        // ...but it doesn't require Buffer class, which is only available in Node.js, not in browsers.
-        // This one-liner came from stackoverflow: https://stackoverflow.com/questions/23190056/hex-to-base64-converter-for-javascript
-        const b64 = btoa(hex.match(/\w{2}/g).map((a) => { return String.fromCharCode(parseInt(a, 16)); }).join(""));
-        let alphanum = b64.replace(/[^a-zA-Z0-9]/g, "");
-        if (alphanum.length < length) {
-            alphanum = alphanum.padEnd(length, "0");
-        }
-        else if (alphanum.length > length) {
-            alphanum = alphanum.substring(0, length);
-        }
-        return alphanum;
-    }
-}
-exports.Base62 = Base62;
-Base62.CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

package/dist/util/BinarySearch.d.ts

@@ -1,7 +0,0 @@
-import { CompactDateTime } from "../models/content/Time";
-import { SpeechMarkItem } from "../models/content/Speech";
-export declare class BinarySearch {
-    static ofDateTimes(value: CompactDateTime, values: CompactDateTime[]): number;
-    static ofStrings(value: string, values: string[]): number;
-    static ofSpeechMarks(seekPoint: number, speechMarks: SpeechMarkItem[]): number;
-}

package/dist/util/BinarySearch.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinarySearch = void 0;
-class BinarySearch {
-    static ofDateTimes(value, values) {
-        return BinarySearch.ofStrings(value, values);
-    }
-    static ofStrings(value, values) {
-        let low = 0;
-        let high = values.length - 1;
-        while (low <= high) {
-            let mid = Math.floor((low + high) / 2);
-            let midValue = values[mid];
-            let comparison = midValue.localeCompare(value);
-            if (comparison < 0) {
-                low = mid + 1;
-            }
-            else if (comparison > 0) {
-                high = mid - 1;
-            }
-            else {
-                return mid;
-            }
-        }
-        return -(low + 1);
-    }
-    static ofSpeechMarks(seekPoint, speechMarks) {
-        let low = 0;
-        let high = speechMarks.length - 1;
-        while (low <= high) {
-            let mid = Math.floor((low + high) / 2);
-            let speechMark = speechMarks[mid];
-            if (speechMark.time < seekPoint) {
-                low = mid + 1;
-            }
-            else if (speechMark.time > seekPoint) {
-                high = mid - 1;
-            }
-            else {
-                return mid;
-            }
-        }
-        return low - 1;
-    }
-}
-exports.BinarySearch = BinarySearch;

package/dist/util/CachingHasher.d.ts

@@ -1,8 +0,0 @@
-import { ContentId } from '../models/content/Content';
-export declare class CachingHasher {
-    private static readonly MAX_SIZE;
-    private static md5HashLookup;
-    private static contentIdLookup;
-    static makeMd5Hash(text: string): string;
-    static makeMd5ContentId(text: string): ContentId;
-}

package/dist/util/CachingHasher.js

@@ -1,41 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CachingHasher = void 0;
-const md5_1 = __importDefault(require("md5"));
-const Base62_1 = require("./Base62");
-class CachingHasher {
-    static makeMd5Hash(text) {
-        if (CachingHasher.md5HashLookup.size > CachingHasher.MAX_SIZE) {
-            CachingHasher.md5HashLookup.clear();
-        }
-        if (CachingHasher.md5HashLookup.has(text)) {
-            return CachingHasher.md5HashLookup.get(text);
-        }
-        else {
-            const rawHash = (0, md5_1.default)(text);
-            this.md5HashLookup.set(text, rawHash);
-            return rawHash;
-        }
-    }
-    static makeMd5ContentId(text) {
-        if (CachingHasher.contentIdLookup.size > CachingHasher.MAX_SIZE) {
-            CachingHasher.contentIdLookup.clear();
-        }
-        if (CachingHasher.contentIdLookup.has(text)) {
-            return CachingHasher.contentIdLookup.get(text);
-        }
-        else {
-            const rawHash = (0, md5_1.default)(text);
-            const asBase62 = Base62_1.Base62.fromHexHash(rawHash, 16);
-            this.contentIdLookup.set(text, asBase62);
-            return asBase62;
-        }
-    }
-}
-exports.CachingHasher = CachingHasher;
-CachingHasher.MAX_SIZE = 1000;
-CachingHasher.md5HashLookup = new Map();
-CachingHasher.contentIdLookup = new Map();

package/dist/util/Color.d.ts

@@ -1,32 +0,0 @@
-export declare class RGB {
-    r: number;
-    g: number;
-    b: number;
-    constructor(r: number, g: number, b: number);
-    toHEX(): string;
-    toHSV(): HSV;
-    toHSLUV(): HSLUV;
-    static parse(color: string): RGB;
-}
-export declare class HSLUV {
-    h: number;
-    s: number;
-    l: number;
-    constructor(h: number, s: number, l: number);
-    toRGB(): RGB;
-}
-export declare class HSV {
-    h: number;
-    s: number;
-    v: number;
-    constructor(h: number, s: number, v: number);
-    toRGB(): RGB;
-}
-export declare class Color {
-    private static readonly EPSILON_SATURATION;
-    static normalize(color: string): string;
-    static makeShadeOf(color: string, hslOverride: {
-        [key: string]: number;
-    }): string;
-    static interpolate(loColor: string, hiColor: string, steps: number, percent: number): string;
-}

package/dist/util/Color.js

@@ -1,204 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Color = exports.HSV = exports.HSLUV = exports.RGB = void 0;
-const hsluv_1 = require("hsluv");
-const NumberFormat_1 = require("./NumberFormat");
-class RGB {
-    constructor(r, g, b) {
-        this.r = r;
-        this.g = g;
-        this.b = b;
-    }
-    toHEX() {
-        return "#" +
-            NumberFormat_1.NumberFormat.asHex(this.r, 2) +
-            NumberFormat_1.NumberFormat.asHex(this.g, 2) +
-            NumberFormat_1.NumberFormat.asHex(this.b, 2);
-    }
-    toHSV() {
-        let r = this.r;
-        let g = this.g;
-        let b = this.b;
-        let max = Math.max(r, g, b);
-        let min = Math.min(r, g, b);
-        let d = max - min;
-        let h;
-        switch (max) {
-            case min:
-                h = 0;
-                break;
-            case r:
-                h = (g - b) + d * (g < b ? 6 : 0);
-                h /= 6 * d;
-                break;
-            case g:
-                h = (b - r) + d * 2;
-                h /= 6 * d;
-                break;
-            case b:
-                h = (r - g) + d * 4;
-                h /= 6 * d;
-                break;
-        }
-        let s = max === 0 ? 0 : d / max;
-        let v = max / 255;
-        return new HSV(h, s, v);
-    }
-    toHSLUV() {
-        const converter = new hsluv_1.Hsluv();
-        converter.rgb_r = this.r / 255;
-        converter.rgb_g = this.g / 255;
-        converter.rgb_b = this.b / 255;
-        converter.rgbToHsluv();
-        const h = converter.hsluv_h;
-        const s = converter.hsluv_s;
-        const l = converter.hsluv_l;
-        return new HSLUV(h, s, l);
-    }
-    static parse(color) {
-        // match RGB values formatted as "rgb(12,34,56)" (with optional whitespace)
-        let match = /^\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*$/i.exec(color);
-        if (match !== null) {
-            return new RGB(parseInt(match[1]), parseInt(match[2]), parseInt(match[3]));
-        }
-        // match RGB values formatted as "#AABBCC" (with optional #hash prefix)
-        match = /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(color);
-        if (match !== null) {
-            return new RGB(parseInt(match[1], 16), parseInt(match[2], 16), parseInt(match[3], 16));
-        }
-        // match RGB values formatted as "#ABC" (with optional #hash prefix)
-        match = /^#?([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(color);
-        if (match !== null) {
-            const red = match[1] + match[1];
-            const grn = match[2] + match[2];
-            const blu = match[3] + match[3];
-            return new RGB(parseInt(red, 16), parseInt(grn, 16), parseInt(blu, 16));
-        }
-        throw Error("can\x27t parse color: " + color);
-    }
-}
-exports.RGB = RGB;
-// We get better interpolations by using a perceptually uniform color space...
-// https://programmingdesignsystems.com/color/perceptually-uniform-color-spaces/
-class HSLUV {
-    constructor(h, s, l) {
-        this.h = h;
-        this.s = s;
-        this.l = l;
-    }
-    toRGB() {
-        let h = this.h;
-        let s = this.s;
-        let l = this.l;
-        let converter = new hsluv_1.Hsluv();
-        converter.hsluv_h = h;
-        converter.hsluv_s = s;
-        converter.hsluv_l = l;
-        converter.hsluvToRgb();
-        let r = Math.round(converter.rgb_r * 255);
-        let g = Math.round(converter.rgb_g * 255);
-        let b = Math.round(converter.rgb_b * 255);
-        return new RGB(r, g, b);
-    }
-}
-exports.HSLUV = HSLUV;
-class HSV {
-    constructor(h, s, v) {
-        this.h = h;
-        this.s = s;
-        this.v = v;
-    }
-    toRGB() {
-        let h = this.h;
-        let s = this.s;
-        let v = this.v;
-        let i = Math.floor(h * 6);
-        let f = h * 6 - i;
-        let p = v * (1 - s);
-        let q = v * (1 - f * s);
-        let t = v * (1 - (1 - f) * s);
-        let r, g, b;
-        switch (i % 6) {
-            case 0:
-                r = v, g = t, b = p;
-                break;
-            case 1:
-                r = q, g = v, b = p;
-                break;
-            case 2:
-                r = p, g = v, b = t;
-                break;
-            case 3:
-                r = p, g = q, b = v;
-                break;
-            case 4:
-                r = t, g = p, b = v;
-                break;
-            case 5:
-                r = v, g = p, b = q;
-                break;
-        }
-        return new RGB(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255));
-    }
-}
-exports.HSV = HSV;
-class Color {
-    static normalize(color) {
-        let rgb = RGB.parse(color);
-        return rgb.toHEX();
-    }
-    static makeShadeOf(color, hslOverride) {
-        let rgb = RGB.parse(color);
-        let hsluv = rgb.toHSLUV();
-        if (hslOverride.hasOwnProperty("h")) {
-            hsluv.h = hslOverride.h;
-        }
-        if (hslOverride.hasOwnProperty("s")) {
-            hsluv.s = hslOverride.s;
-        }
-        if (hslOverride.hasOwnProperty("l")) {
-            hsluv.l = hslOverride.l;
-        }
-        rgb = hsluv.toRGB();
-        return rgb.toHEX();
-    }
-    static interpolate(loColor, hiColor, steps, percent) {
-        // NOTE: Unlike HSV (where all 3 values are floats between 0 and 1), the HSLUV color space
-        // has a hue value between 0 and 360, and saturation and lightness values between 0 and 100.
-        let loRGB = RGB.parse(loColor);
-        let hiRGB = RGB.parse(hiColor);
-        // There's no point interpolating if the number of steps is only 2.
-        if (steps === 2) {
-            return percent > 0.5 ? hiRGB.toHEX() : loRGB.toHEX();
-        }
-        let loHSLUV = loRGB.toHSLUV();
-        let hiHSLUV = hiRGB.toHSLUV();
-        // If one of the colors is completely desaturated, it should share the same hue as the other color
-        if (loHSLUV.s < Color.EPSILON_SATURATION)
-            loHSLUV.h = hiHSLUV.h;
-        if (hiHSLUV.s < Color.EPSILON_SATURATION)
-            hiHSLUV.h = loHSLUV.h;
-        let clockwiseDiff = (loHSLUV.h >= hiHSLUV.h) ? 1 + hiHSLUV.h - loHSLUV.h : hiHSLUV.h - loHSLUV.h;
-        let counterClockwiseDiff = (loHSLUV.h >= hiHSLUV.h) ? loHSLUV.h - hiHSLUV.h : 1 + loHSLUV.h - hiHSLUV.h;
-        // Quantize the percentage to a certain number of discreet color steps.
-        // We've already handled 2-step quantization above, and values less than 2
-        // are ignored because they don't make sense.
-        if (steps >= 3) {
-            percent = Math.round(percent * (steps - 1)) / (steps - 1);
-        }
-        // Interpolate the values
-        let h = (clockwiseDiff <= counterClockwiseDiff)
-            ? loHSLUV.h + (clockwiseDiff * percent)
-            : loHSLUV.h - (counterClockwiseDiff * percent);
-        if (h < 0)
-            h = 360 + h;
-        if (h > 360)
-            h = h - 360;
-        let s = (1 - percent) * loHSLUV.s + percent * hiHSLUV.s;
-        let l = (1 - percent) * loHSLUV.l + percent * hiHSLUV.l;
-        let rgb = new HSLUV(h, s, l).toRGB();
-        return rgb.toHEX();
-    }
-}
-exports.Color = Color;
-Color.EPSILON_SATURATION = 1.0;

package/dist/util/Dispatch.d.ts

@@ -1,15 +0,0 @@
-export type DispatchTopic = string;
-export type DispatchCallback = (topic: string, details?: any) => void;
-export interface DispatchMessage {
-    topic: DispatchTopic;
-    details?: any;
-}
-export declare class Dispatch {
-    private static debug;
-    private static readonly callbacksByTopic;
-    static setDebug(value: boolean): void;
-    static subscribe(topic: string, callback: DispatchCallback): void;
-    static unsubscribe(topic: DispatchTopic, callback: DispatchCallback): void;
-    static publish(topic: DispatchTopic, details?: any): Promise<void>;
-    static sequence(messages: DispatchMessage[]): Promise<void>;
-}

package/dist/util/Dispatch.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dispatch = void 0;
-class Dispatch {
-    static setDebug(value) {
-        Dispatch.debug = value;
-    }
-    static subscribe(topic, callback) {
-        let topicCallbacks = [];
-        if (Dispatch.callbacksByTopic.has(topic)) {
-            topicCallbacks = Dispatch.callbacksByTopic.get(topic);
-        }
-        else {
-            Dispatch.callbacksByTopic.set(topic, topicCallbacks);
-        }
-        topicCallbacks.push(callback);
-    }
-    static unsubscribe(topic, callback) {
-        if (Dispatch.callbacksByTopic.has(topic)) {
-            let topicCallbacks = [];
-            let newTopicCallbacks = [];
-            for (let i = 0, len = topicCallbacks.length; i < len; i++) {
-                let cb = topicCallbacks[i];
-                if (cb.toString() != callback.toString()) {
-                    newTopicCallbacks.push(callback);
-                }
-            }
-            if (newTopicCallbacks.length == 0) {
-                Dispatch.callbacksByTopic.delete(topic);
-            }
-            else {
-                Dispatch.callbacksByTopic.set(topic, newTopicCallbacks);
-            }
-        }
-    }
-    // Calls all the callbacks to this particular topic.  Returns a Promise which resolves when ALL
-    // of the topic callbacks have also resolved, or in the same event loop if they are synchronous.
-    static async publish(topic, details) {
-        if (Dispatch.callbacksByTopic.has(topic)) {
-            let topicCallbackResults = [];
-            let errors = [];
-            let subjectSubscribers = Dispatch.callbacksByTopic.get(topic);
-            if (Dispatch.debug) {
-                console.log(`Dispatching '${topic}' to ${subjectSubscribers.length} subscribers, with details: ${JSON.stringify(details)}`);
-            }
-            for (let i = 0, len = subjectSubscribers.length; i < len; i++) {
-                let callback = subjectSubscribers[i];
-                // catch errors here so we don't interrupt any of the other callbacks
-                let result;
-                try {
-                    result = callback(topic, details);
-                    topicCallbackResults.push(result);
-                }
-                catch (e) {
-                    errors.push(e);
-                }
-            }
-            await Promise.all(topicCallbackResults);
-            if (errors.length > 0) {
-                return Promise.reject(errors);
-            }
-            return Promise.resolve();
-        }
-        else if (Dispatch.debug) {
-            console.log(`Dispatch has no subscribers to topic '${topic}'`);
-        }
-    }
-    // Fire off a sequence of messages.  Waits for the preceding message callbacks to finish / resolve
-    // before publishing the next (if the first message throws an exception, this short-circuits).
-    static async sequence(messages) {
-        for (let i = 0, len = messages.length; i < len; i++) {
-            let message = messages[i];
-            await Dispatch.publish(message.topic, message.details);
-        }
-    }
-}
-exports.Dispatch = Dispatch;
-Dispatch.debug = false;
-Dispatch.callbacksByTopic = new Map();

package/dist/util/EditDistance.d.ts

@@ -1,13 +0,0 @@
-export declare class EditDistance {
-    private static readonly CHARACTERS;
-    private static readonly FORBIDDEN_START_AND_END_CHARS;
-    static readonly ALWAYS_TRUE: (word: string) => boolean;
-    static of(s1: string, s2: string): number;
-    static permute(word: string, distance: number, predicate?: (word: string) => boolean): string[];
-    private static preFilterCandidate;
-    private static generateDeleteCandidates;
-    private static generateTransposeCandidates;
-    private static generateReplaceCandidates;
-    private static generateInsertCandidates;
-    private static collectCandidateIfPassPredicate;
-}

package/dist/util/EditDistance.js

@@ -1,184 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EditDistance = void 0;
-const Struct_1 = require("../util/Struct");
-class EditDistance {
-    // This function copied from here:
-    // https://github.com/gustaveWPM/Typescript-Damerau-Levenshtein/blob/main/damerauLevenshtein.ts
-    // The algorithm is designed here:
-    // https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance
-    static of(s1, s2) {
-        if (s1 === s2)
-            return 0;
-        const [s1len, s2len] = [s1.length, s2.length];
-        const matrix = Array.from({ length: s1len + 1 }, () => new Array(s2len + 1).fill(0));
-        for (let y = 1; y <= s1len; y++)
-            matrix[y][0] = y;
-        for (let x = 1; x <= s2len; x++)
-            matrix[0][x] = x;
-        for (let y = 1; y <= s1len; y++) {
-            for (let x = 1; x <= s2len; x++) {
-                if (s1[y - 1] === s2[x - 1]) {
-                    matrix[y][x] = matrix[y - 1][x - 1];
-                }
-                else {
-                    matrix[y][x] =
-                        1 +
-                            Math.min(matrix[y - 1][x], matrix[y][x - 1], matrix[y - 1][x - 1]);
-                    if (y > 1 &&
-                        x > 1 &&
-                        s1[y - 1] === s2[x - 2] &&
-                        s1[y - 2] === s2[x - 1]) {
-                        matrix[y][x] = Math.min(matrix[y][x], matrix[y - 2][x - 2] + 1);
-                    }
-                }
-            }
-        }
-        return matrix[s1len][s2len];
-    }
-    static permute(word, distance, predicate) {
-        let roots = [word];
-        let predicateIsFunction = typeof (predicate) === "function";
-        let useDeferredPredicate = distance > 1 && predicateIsFunction;
-        let failed = {};
-        let candidates = {};
-        while (distance > 0) {
-            let p = distance > 1 || !predicateIsFunction
-                ? EditDistance.ALWAYS_TRUE
-                : predicate;
-            let lastGenCandidates = Struct_1.Struct.clone(candidates);
-            for (let i = 0, len = roots.length; i < len; i++) {
-                word = roots[i];
-                let wordLength = word.length;
-                EditDistance.generateDeleteCandidates(failed, candidates, p, word, wordLength);
-                EditDistance.generateTransposeCandidates(failed, candidates, p, word, wordLength);
-                EditDistance.generateReplaceCandidates(failed, candidates, p, word, wordLength);
-                EditDistance.generateInsertCandidates(failed, candidates, p, word, wordLength);
-            }
-            distance--;
-            if (distance === 0) {
-                if (useDeferredPredicate) {
-                    let confirmedCandidates = {};
-                    for (let candidate in candidates) {
-                        EditDistance.collectCandidateIfPassPredicate(failed, confirmedCandidates, candidate, predicate);
-                    }
-                    candidates = confirmedCandidates;
-                }
-            }
-            else {
-                roots = [];
-                for (let candidate in candidates) {
-                    if (!lastGenCandidates.hasOwnProperty(candidate)) {
-                        roots.push(candidate);
-                    }
-                }
-            }
-        }
-        return Object.keys(candidates);
-    }
-    static preFilterCandidate(failed, candidates, candidate, predicate) {
-        const firstChar = candidate.charAt(0);
-        const lastChar = candidate.charAt(candidate.length - 1);
-        if (!EditDistance.FORBIDDEN_START_AND_END_CHARS.includes(firstChar) && !EditDistance.FORBIDDEN_START_AND_END_CHARS.includes(lastChar)) {
-            EditDistance.collectCandidateIfPassPredicate(failed, candidates, candidate, predicate);
-        }
-    }
-    static generateDeleteCandidates(failed, candidates, predicate, word, len) {
-        if (len < 2) {
-            return;
-        }
-        let last = len - 1;
-        for (let i = 0; i < len; i++) {
-            let candidate;
-            if (i === 0) {
-                candidate = word.substring(1);
-            }
-            else if (i === last) {
-                candidate = word.substring(0, last);
-            }
-            else {
-                candidate = word.substring(0, i) + word.substring(i + 1, len);
-            }
-            EditDistance.preFilterCandidate(failed, candidates, candidate, predicate);
-        }
-    }
-    static generateTransposeCandidates(failed, candidates, predicate, word, len) {
-        if (len < 2) {
-            return;
-        }
-        else {
-            let last = len - 1;
-            for (let i = 0; i < last; i++) {
-                let textBefore = i === 0 ? "" : word.substring(0, i);
-                let a = word.charAt(i);
-                let b = word.charAt(i + 1);
-                let textAfter = i === last - 1 ? "" : word.substring(i + 2);
-                const candidate = textBefore + b + a + textAfter;
-                EditDistance.preFilterCandidate(failed, candidates, candidate, predicate);
-            }
-        }
-    }
-    static generateReplaceCandidates(failed, candidates, predicate, word, len) {
-        if (len < 2) {
-            return;
-        }
-        let last = len - 1;
-        for (let i = 0; i < len; i++) {
-            let charToReplace = word.charAt(i);
-            for (let j = 0, jLen = EditDistance.CHARACTERS.length; j < jLen; j++) {
-                let c = EditDistance.CHARACTERS[j];
-                if (c !== charToReplace) {
-                    let candidate;
-                    if (i === 0) {
-                        candidate = c + word.substring(1);
-                    }
-                    else if (i === last) {
-                        candidate = word.substring(0, last) + c;
-                    }
-                    else {
-                        candidate = word.substring(0, i) + c + word.substring(i + 1, len);
-                    }
-                    EditDistance.preFilterCandidate(failed, candidates, candidate, predicate);
-                }
-            }
-        }
-    }
-    static generateInsertCandidates(failed, candidates, predicate, word, len) {
-        for (let j = 0, jLen = EditDistance.CHARACTERS.length; j < jLen; j++) {
-            let c = EditDistance.CHARACTERS[j];
-            EditDistance.preFilterCandidate(failed, candidates, c + word, predicate);
-            for (let i = 1; i < len; i++) {
-                EditDistance.preFilterCandidate(failed, candidates, word.substring(0, i) + c + word.substring(i, len), predicate);
-            }
-            EditDistance.preFilterCandidate(failed, candidates, word + c, predicate);
-        }
-    }
-    static collectCandidateIfPassPredicate(failed, candidates, candidate, predicate) {
-        // If this candidate has failed, don't bother checking it again.
-        if (failed.hasOwnProperty(candidate)) {
-            return;
-        }
-        // If we've already collected this candidate, don't collect it again.
-        if (candidates.hasOwnProperty(candidate)) {
-            return;
-        }
-        if (!predicate(candidate)) {
-            failed[candidate] = candidate;
-            return;
-        }
-        candidates[candidate] = candidate;
-    }
-}
-exports.EditDistance = EditDistance;
-// This list of characters is used to generate candidates for the edit distance algorithm.
-// These characters exclude numerals, punctuation, and most non-English characters. However,
-// this list does include the characters çéñöü becuase they are common in English borrow-words
-// like "façade", "café", "jalapeño", and "über". This list also includes the hyphen and
-// apostrophe, which are common in English words. This list excludes characters that might
-// be common in proper names from non-English cultures, like "á", "í", "ó", "ú", "ý", "ÿ",
-// "â", "ê", "î", "ô", "û", so we will sometimes be unable to include those words in
-// spelling suggestions.
-EditDistance.CHARACTERS = "abcdefghijklmnopqrstuvwxyzçéñöü'-";
-// We don't allow words to start or end with a hyphen or apostrophe.
-EditDistance.FORBIDDEN_START_AND_END_CHARS = "-'";
-EditDistance.ALWAYS_TRUE = function () { return true; };