Pasted

import Random from "./Random";
 
const bow = Symbol("Beginning of word");
const eow = Symbol("Ending of word");
 
export { bow, eow };
 
type StringOrSymbol = symbol | string;
type RawDataForMapping = Array<string>;
 
interface TempMapping {
    // @ts-ignore Waiting for https://github.com/Microsoft/TypeScript/pull/26797
    [key: StringOrSymbol]: {
        // @ts-ignore Waiting for https://github.com/Microsoft/TypeScript/pull/26797
        [key: StringOrSymbol]: number;
    };
}
 
export interface Mapping {
    // @ts-ignore Waiting for https://github.com/Microsoft/TypeScript/pull/26797
    [key: StringOrSymbol]: Array<[number, StringOrSymbol]>;
}
 
interface MarkovOptions {
    minLen: number;
    maxLen: number;
}
 
export const generateMapping = (raw: RawDataForMapping): Mapping => {
    const mapping: TempMapping = {
        [bow]: {
            [eow]: 0,
        },
    };
 
    for (const word of raw) {
        const lowWord = word.toLowerCase();
 
        for (let i = 0; i < lowWord.length; ++i) {
            const char = lowWord[i];
 
            if (i === 0) {
                if (!(char in mapping[bow])) {
                    mapping[bow][char] = 0;
                }
 
                mapping[bow][char] += 1;
            }
 
            if (!(char in mapping)) {
                mapping[char] = {
                    [eow]: 0,
                };
            }
 
            let nextChar: StringOrSymbol = eow;
 
            if (i < lowWord.length - 1) {
                nextChar = lowWord[i + 1];
            }
 
            if (!(nextChar in mapping[char])) {
                mapping[char][nextChar] = 0;
            }
 
            mapping[char][nextChar] += 1;
        }
    }
 
    const keys = (Object.keys(mapping) as Array<StringOrSymbol>).concat([bow]);
 
    for (const key of keys) {
        const entries: Array<[StringOrSymbol, number]> = Object.entries(mapping[key]);
 
        if (eow in mapping[key]) {
            entries.push([eow, mapping[key][eow]]);
        }
 
        mapping[key] = entries.map(entry => entry.reverse());
    }
 
    return mapping;
};
 
export const generateChain = (
    mapping: Mapping,
    random: Random,
    { minLen, maxLen }: MarkovOptions,
) => {
    let word = "";
    let curLetter: StringOrSymbol = bow;
 
    for (let i = 0; i < maxLen; ++i) {
        curLetter = random.weighted(mapping[curLetter]);
 
        if (curLetter === eow) {
            if (i >= minLen) {
                break;
            } else {
                curLetter = random.weighted(mapping[bow]);
            }
        }
 
        word += curLetter as string;
    }
 
    return word;
};