lib.ts

// Zalgo characters, see https://eeemo.net/
interface ZalgoCharset
{
    type: "zalgo";
    zalgoLevel?: number; // How many additional zalgo characters to append to each character
}

// Characters that are not rendered on most text editors/browsers:
// U+FE00 - U+FE0F Variation Selector
interface InvisibleCharset
{
    type: "invisible";
}

// "I" characters that look the same:
// U+0049 Latin Capital letter I
// U+0399 Greek Capital Letter Iota
// U+0406 Cyrillic Capital Letter Byelorussian-Ukrainian I
interface IIIICharset
{
    type: "iiii";
}

// Characters that are made out of lines (or something like that)
interface LinesCharset
{
    type: "lines";
}

// User-defined characters
interface CustomCharset
{
    type: "custom";

    // Custom characters to use in variable names.
    // Characters can actually be more more than one character long;
    // in that case, the entire string will be used as part of the variable name.
    // Empty strings are skipped.
    characters: string[];
}

export type Charset = ZalgoCharset | InvisibleCharset | IIIICharset | LinesCharset | CustomCharset;

export type CharsetType = Charset["type"];

export type CodeGenerationTarget =
    | "es6+"    // Modern browsers, https://caniuse.com/es6
    | "nodejs"  // Node.js - this usually also works in browsers using the V8 javascript engine (mostly chromium based browsers)
    | "es5-"    // Old browsers, ES5 or earlier
    ;

// If the obfuscated code is deobfuscated, then don't run the original code at all
interface DeobfuscationProtectionModeSkip
{
    type: "skip";
}

// If the code is deobfuscated, then throw an error
interface DeobfuscationProtectionModeThrowError
{
    type: "error";
}

// If the code is deobfuscated, then run an infinite loop (which usually freezes the page)
interface DeobfuscationProtectionModeInfiniteLoop
{
    type: "loop";
}

// If the code is deobfuscated, then run a user-provided code
interface DeobfuscationProtectionModeRunCustomCode
{
    type: "custom";
    codeToRun: string; // The code to run when deobfuscated
}

export type DeobfuscationProtection =
    | DeobfuscationProtectionModeSkip
    | DeobfuscationProtectionModeThrowError
    | DeobfuscationProtectionModeInfiniteLoop
    | DeobfuscationProtectionModeRunCustomCode
    ;

export type DeobfuscationProtectionType = DeobfuscationProtection["type"];

export interface ObfuscationOptions
{
    charset?: Charset; // Type of the character set to use, see the comments for each character set for details
    variableNameLength?: number; // How long should variable names be in the generated code
    target?: CodeGenerationTarget; // Which version of JavaScript to target
    deobfuscationProtection?: DeobfuscationProtection; // Describes what should happen if the code is deobfuscated
    rngSeed?: number; // Number to use when seeding the random number generator (same seed == same code output). Must be in range [0, 2^32-1]
}

export const enum ObfuscateErrorType
{
    CannotGetVariableName,
    CannotGetVariableNameCustom,
    CharsetIsIncompatibleES5,
    HasInvalidCustomCharacters
}

const errorMessages: { [key in ObfuscateErrorType]: string } = {
    [ObfuscateErrorType.CannotGetVariableName]: "Cannot get a variable name, try increasing the variable name length",
    [ObfuscateErrorType.CannotGetVariableNameCustom]: "Cannot get a variable name, try adding more custom characters or increase the variable name length",
    [ObfuscateErrorType.CharsetIsIncompatibleES5]: "The selected charset is not supported for es5 target",
    [ObfuscateErrorType.HasInvalidCustomCharacters]: "Some of the custom characters cannot be used in variable names"
};

export class ObfuscateError
{
    public readonly type: ObfuscateErrorType;
    public readonly message: string;
    public readonly invalidCharacters: Set<string> | null; // Not null if type is `HasInvalidCustomCharacters`

    constructor(type: ObfuscateErrorType, invalidCharacters?: Set<string>)
    {
        this.type = type;
        this.message = errorMessages[type];
        this.invalidCharacters = invalidCharacters ?? null;
    }
}

interface ObfuscationOptionsInternal
{
    charset: Charset;
    variableNameLength: number;
    target: CodeGenerationTarget;
    deobfuscationProtection: DeobfuscationProtection | null;
}

// Simple random number generator with seed
function Mulberry32(seed: number)
{
    return () =>
    {
        let t = seed += 0x6D2B79F5;
        t = Math.imul(t ^ t >>> 15, t | 1);
        t ^= t + Math.imul(t ^ t >>> 7, t | 61);
        return ((t ^ t >>> 14) >>> 0) / 4294967296;
    };
}

let Random = Math.random;

function Shuffle<T>(array: Array<T>)
{
    let current = array.length;
    let temp;
    let rand;

    while (current !== 0)
    {
        rand = Math.floor(Random() * current);
        --current;

        temp = array[current];
        array[current] = array[rand];
        array[rand] = temp;
    }
}

function Urand(min: number, max?: number)
{
    if (max === undefined)
    {
        return Math.floor(Random() * min);
    }

    return Math.floor(Random() * max - min) + min;
}

function RandomElementsOfStringArray(array: string[], count: number)
{
    let ret = "";
    for (let i = 0; i < count; ++i)
    {
        ret += array[Urand(array.length)];
    }

    return ret;
}

function RandomElementOf<T>(array: T[])
{
    return array[Urand(array.length)];
}

function IsValidName(name: string)
{
    try
    {
        eval("var " + name);
        return true;
    }
    catch (e)
    {
        return false;
    }
}

const zalgoCharsExtended = [
    "\u08f1", "\u0363", "\u0364", "\u0365", "\u0366", "\u0367", "\u0368", "\u0369",
    "\u036a", "\u036b", "\u036c", "\u036d", "\u036e", "\u036f", "\u0483", "\u0484",
    "\u0485", "\u0486", "\u0593", "\u0594", "\u0595", "\u0597", "\u0598", "\u059c",
    "\u059e", "\u059f", "\u05a0", "\u05a1", "\u05a8", "\u05a9", "\u05ab", "\u05ac",
    "\u05af", "\u05b5", "\u05c4", "\u0610", "\u0611", "\u0612", "\u0613", "\u0614",
    "\u0615", "\u0616", "\u0617", "\u0618", "\u0619", "\u061a", "\u0656", "\u0657",
    "\u0658", "\u065a", "\u065b", "\u065d", "\u065e", "\u065f", "\u0674", "\u06d6",
    "\u06d7", "\u06d8", "\u06d9", "\u06da", "\u06db", "\u06dc", "\u06df", "\u06e0",
    "\u06e1", "\u06e2", "\u06e3", "\u06e4", "\u06e7", "\u06e8", "\u06ea", "\u06eb",
    "\u06ec", "\u06ed", "\u08e4", "\u08e5", "\u08e6", "\u08e7", "\u08e8",
    "\u08e9", "\u08f0", "\u08f2", "\u08f3", "\u08f4", "\u08f5", "\u08f6", "\u08f7",
    "\u08f8", "\u08f9", "\u08fa", "\u08fb", "\u08fc", "\u08fd", "\u08fe", "\u0e31",
    "\u0e34", "\u0e35", "\u0e36", "\u0e37", "\u0e38", "\u0e39", "\u0e3a", "\u0e47",
    "\u0e48", "\u0e49", "\u0e4a", "\u0e4b", "\u0e4c", "\u0e4d", "\u0e4e", "\u0ec9",
    "\u0f19", "\u0f35", "\u0f37", "\u0f72", "\u0f7a", "\u0f7b", "\u0f7c", "\u0f7d",
    "\u0f80", "\u0f84", "\u1dc0", "\u1dc1", "\u1dc2", "\u1dc3", "\u1dc4", "\u1dc5",
    "\u1dc6", "\u1dc7", "\u1dc8", "\u1dc9", "\u1dca", "\u1dfe", "\u1dff", "\ufb1e",
    "\ufc5e", "\ufc5f", "\ufc60", "\ufc61", "\ufc62", "\ufc63"
];

// Stolen from http://eeemo.net/
const zalgo_up = [
    '\u030d', '\u030e', '\u0304', '\u0305',
    '\u033f', '\u0311', '\u0306', '\u0310',
    '\u0352', '\u0357', '\u0351', '\u0307',
    '\u0308', '\u030a', '\u0342', '\u0343',
    '\u0344', '\u034a', '\u034b', '\u034c',
    '\u0303', '\u0302', '\u030c', '\u0350',
    '\u0300', '\u0301', '\u030b', '\u030f',
    '\u0312', '\u0313', '\u0314', '\u033d',
    '\u0309', '\u0363', '\u0364', '\u0365',
    '\u0366', '\u0367', '\u0368', '\u0369',
    '\u036a', '\u036b', '\u036c', '\u036d',
    '\u036e', '\u036f', '\u033e', '\u035b',
    '\u0346', '\u031a'
];

const zalgo_down = [
    '\u0316', '\u0317', '\u0318', '\u0319',
    '\u031c', '\u031d', '\u031e', '\u031f',
    '\u0320', '\u0324', '\u0325', '\u0326',
    '\u0329', '\u032a', '\u032b', '\u032c',
    '\u032d', '\u032e', '\u032f', '\u0330',
    '\u0331', '\u0332', '\u0333', '\u0339',
    '\u033a', '\u033b', '\u033c', '\u0345',
    '\u0347', '\u0348', '\u0349', '\u034d',
    '\u034e', '\u0353', '\u0354', '\u0355',
    '\u0356', '\u0359', '\u035a', '\u0323'
];

const zalgo_mid = [
    '\u0315', '\u031b', '\u0340', '\u0341',
    '\u0358', '\u0321', '\u0322', '\u0327',
    '\u0328', '\u0334', '\u0335', '\u0336',
    '\u034f', '\u035c', '\u035d', '\u035e',
    '\u035f', '\u0360', '\u0362', '\u0338',
    '\u0337', '\u0361'
];

const standaloneChars = [
    "\u13B0", "\u13B1", "\u2C0D", "\u2CB2",
    "\u2CBA", "\uA722", "\uA724", "\uA78B",

    "\u02B9", "\u02BA", "\u02BB", "\u02BC",
    "\u02BD", "\u02BE", "\u02BF", "\u02C6",
    "\u02C7", "\u02C8", "\u02C9", "\u02CA",
    "\u02CB", "\u02CC", "\u02CE", "\u02CF",
    "\u02D0", "\u02D1", "\u02EC", "\u0374",
    "\u037A", "\u0559", "\u0640", "\u07F4",
    "\u07F5", "\u07FA", "\u0971", "\u1843",
    "\u1C78", "\u1C79", "\u1C7A", "\u1C7B",
    "\u1C7C", "\u1D54", "\u1D55", "\u2D6F",
    "\u3035", "\u3033", "\u309D",
    "\u30FC", "\u30FD", "\u30FE", "\uA4F8",
    "\uA4F9", "\uA4FA", "\uA4FB", "\uA4FC",
    "\uA4FD", "\uA67F", "\uA788", "\uFF70",
    "\uFF9E", "\uFF9F", "\uA9E6",
    "\u05D9", "\u05D5", "\u0621", "\u0629",
    "\u0647", "\u06C0", "\u06C1", "\u06C2",
    "\u06C3", "\u06D5", "\u0715", "\u0716",
    "\u0718", "\u0719", "\u071A", "\u071D",
    "\u0722", "\u072A", "\u072F", "\u074D",
    "\u075A", "\u0765", "\u0766", "\u0780",
    "\u0789", "\u0799", "\u079A", "\u07D1",
    "\u07EA", "\u0B83", "\u0B9F", "\u0CF2",
    "\u0E14", "\u0E15", "\u0E16", "\u0E23",
    "\u0E27", "\u0E32", "\u0E33", "\u0E40",
    "\u0E45", "\u0EB0", "\u0EB2",
    "\u0EC0", "\u0F44", "\u0F4B", "\u0F50",
    "\u0F54", "\u0F55", "\u0F56", "\u0F66",
    "\u113C", "\u113E", "\u1173", "\u119E",
    "\u11A2", "\u141D", "\u141F", "\u1420",
    "\u1425", "\u1426", "\u1427", "\u1428",
    "\u1429", "\u1449", "\u144A", "\u14BB",
    "\u14BC", "\u14BD", "\u14BE", "\u14D0",
    "\u1508", "\u1540", "\u153E",
];

const startingChars = [
    "\u02b9", "\u02ba", "\u02bb", "\u02bc", "\u02bd", "\u02be", "\u02bf", "\u02c6",
    "\u02c7", "\u02c8", "\u02cc", "\u02d1", "\u0374", "\u037a", "\u0559", "\u1843",
    "\u1c78", "\u1c79", "\u1c7a", "\u1c7c", "\u1d54", "\u1d55", "\u1da5",
    "\u309d", "\u30fd", "\ua4f8", "\ua4f9", "\ua4fa", "\ua4fb", "\ua4fc", "\ua4fd",
    "\ua67f", "\ua717", "\ua718", "\ua719", "\ua71a", "\ua788", "\uff9e", "\uff9f",
    "\ua9e6", "\u05d9", "\u0621", "\u0627", "\u0674", "\u06c0", "\u06c1", "\u06c2",
    "\u06c3", "\u06d5", "\u0715", "\u0716", "\u0719", "\u071d", "\u072a", "\u072f",
    "\u0780", "\u0787", "\u0789", "\u0799", "\u079a", "\u07a2", "\u07a3", "\u07d1",
    "\u07e8", "\u0eb2", "\u03b3", "\u0f44", "\u0f4b", "\u0f56", "\u0f8b", "\u141d",
    "\u141e", "\u141f", "\u1420", "\u1425", "\u1426", "\u1427", "\u1449", "\u14a1",
    "\u14a2", "\u14bb", "\u14bc", "\u14bd", "\u14d0", "\u14d2", "\u14ea", "\u1505",
    "\u1507", "\u1508", "\u1509", "\u150a", "\u153e", "\u1550", "\u155d", "\u156a",
    "\u1595", "\u159f", "\u15a6", "\u15ae", "\u1690", "\u1691", "\u1692", "\u1693",
    "\u1694", "\u16b2", "\u16cd", "\u16e7", "\u1822", "\u1823", "\u1824", "\u1825",
    "\u1826", "\u1827", "\u1829", "\u182b", "\u1830", "\u1831", "\u1832", "\u1833",
    "\u1834", "\u1835", "\u1836", "\u1837", "\u1838", "\u1839", "\u183a", "\u183b",
    "\u184d", "\u1855", "\u185f", "\u186a", "\u188f", "\u189c", "\u18a4", "\u18a5",
    "\u18a6", "\u18d9", "\u18da", "\u18de", "\u18df", "\u2d30", "\u2d3e", "\u2d42",
    "\u2d46", "\u2d48", "\u2d53", "\u2d57", "\u318d", "\u31b4", "\u31b5", "\u31b6"
];

const baseChars = [
    "\u02b9", "\u02ba", "\u02bb", "\u02bc", "\u02bd", "\u02be", "\u02bf", "\u02c6",
    "\u02c7", "\u02c8", "\u02cc", "\u02d1", "\u0374", "\u037a", "\u0559", "\u1d54",
    "\u1d55", "\u1da5", "\ua4f8", "\ua4f9", "\ua4fa", "\ua4fb", "\ua4fc", "\ua4fd",
    "\ua67f", "\ua717", "\ua718", "\ua719", "\ua71a", "\ua788", "\u05d9", "\u0621",
    "\u0627", "\u0674", "\u06c0", "\u06c1", "\u06c2", "\u06c3", "\u06d5", "\u03b3"
];

const linesLetters = [
    "\u13B1", "\u13DD",
    "\u13DE", "\u13DF",
    "\u2C84", "\u2CA4",
    "\u2CB6", "\u2CBA",
    "\u2CD0", "\u2CDE",
    "\uA78B", "\u{10411}",
    "\u{10415}", "\u{1041B}",
    "\u{10423}", "\u{1D5A2}",
    "\u{1D5A8}", "\u{1D5A9}",
    "\u{1D5AB}", "\u{1D5D6}",
    "\u{1D5DC}", "\u{1D5DD}",
    "\u{1D5DF}", "\u{1D758}",
    "\u{1D75E}", "\u{1D763}",
    "\u2C85", "\u2C93",
    "\u2CA5", "\u2CB7",
    "\u2CBB", "\u2CDF",
    "\uA78C", "\u{10439}",
    "\u{1043D}", "\u{10443}",
    "\u{1044B}", "\u{1D5C5}",
    "\u{1D5F9}", "\uAB81",
    "\uABAE", "\uABAF",
    "\u02B9", "\u02BB",
    "\u02BC", "\u02BD",
    "\u02C8", "\u02C9",
    "\u02CA", "\u02CB",
    "\u02CC", "\u02CD",
    "\u02CE", "\u02CF",
    "\u0374", "\u0559",
    "\u07F4", "\u07F5",
    "\u1C7B", "\u1C7C",
    "\uA4F9", "\uA60C",
    "\uFF70", "\u01C0",
    "\u01C1", "\u0B9F",
    "\u1100", "\u1102",
    "\u115F", "\u1160",
    "\u1173", "\u1175",
    "\u119E", "\u11A1",
    "\u11A8", "\u11AB",
    "\u11FA", "\u1427",
    "\u1428", "\u1429",
    "\u1433", "\u1438",
    "\u1440", "\u1441",
    "\u1444", "\u1445",
    "\u1449", "\u144A",
    "\u14A3", "\u14A5",
    "\u14A7", "\u14AA",
    "\u14AC", "\u14AF",
    "\u14B2", "\u14B7",
    "\u1540", "\u167F",
    "\u16C1", "\u16CC",
    "\u16E7", "\u18B4",
    "\u18B5", "\u18B6",
    "\u18DE", "\u18DF",
    "\u1963", "\u2D4E",
    "\u2D4F", "\u30CB",
    "\u30FF", "\u3127",
    "\u3131", "\u3134",
    "\u3137", "\u3161",
    "\u3163", "\u318D",
    "\u318E",

    //"\uFF9E", "\uFF9F",

];

const linesLetters_compatibility = [
    "\u13b1", "\u13dd", "\u13de", "\u13df",
    "\u2c84", "\u2ca4", "\u2cb6", "\u2cba",
    "\u2cd0", "\u2cde", "\ua78b", "\u2c85",
    "\u2c93", "\u2ca5", "\u2cb7", "\u2cbb",
    "\u2cdf", "\ua78c", "\u02bb", "\u02bc",
    "\u02bd", "\u0559", "\u07f4", "\u07f5",
    "\u1c7b", "\u1c7c", "\ua60c", "\uff70",
    "\u01c0", "\u01c1", "\u0b9f", "\u1100",
    "\u1102", "\u115f", "\u1160", "\u1173",
    "\u1175", "\u119e", "\u11a1", "\u11a8",
    "\u11ab", "\u1427", "\u1428", "\u1429",
    "\u1433", "\u1438", "\u1440", "\u1441",
    "\u1444", "\u1445", "\u1449", "\u144a",
    "\u14a3", "\u14a5", "\u14a7", "\u14aa",
    "\u14ac", "\u14af", "\u14b2", "\u14b7",
    "\u1540", "\u16c1", "\u16cc", "\u16e7",
    "\u1963", "\u2d4e", "\u2d4f", "\u30cb",
    "\u30ff", "\u3127", "\u3131", "\u3134",
    "\u3137", "\u3161", "\u3163", "\u318d",
    "\u318e"
];

const iLetters = ["\u0049", "\u0399", "\u0406"];

interface CustomCharacterData
{
    startingChars: string[];
    nonStartingChars: string[];
}

function Unreachable(_: never): never
{
    throw Error("Unreachable");
}

export function CheckCustomCharacters(characters: string[])
{
    // Unique characters
    const startingChars = new Set<string>();
    const nonStartingChars = new Set<string>();
    const invalidChars = new Set<string>();

    // Same characters as above, but characters can appear multiple times
    const allNonStartingChars: string[] = [];
    const allStartingChars: string[] = [];

    // These can cause `"var a" + char` to be valid code, so these are skipped early
    const badCharacters = ["\n", "\r", "\t", " ", ";"];

    for (const char of characters)
    {
        if (char.length === 0)
        {
            // Skip empty
            continue;
        }

        if (badCharacters.includes(char))
        {
            // Skip bad character
            invalidChars.add(char);
            continue;
        }

        if (char.length !== 1)
        {
            // Longer "character", must not contain any of the bad characters
            let valid = true;
            for (const ch of char)
            {
                if (badCharacters.includes(ch))
                {
                    valid = false;
                    break;
                }
            }

            if (!valid)
            {
                invalidChars.add(char);
                continue;
            }
        }

        if (invalidChars.has(char))
        {
            // Already checked, invalid
            continue;
        }

        if (nonStartingChars.has(char))
        {
            // Already checked, valid
            // Add again to increase chance
            allNonStartingChars.push(char);
            continue;
        }

        if (startingChars.has(char))
        {
            // Same as before, but for starting characters
            allStartingChars.push(char);
            continue;
        }

        try
        {
            // Check if the current character is valid as a starting character in a variable name
            eval("var " + char);

            // If no exception is thrown, then it's valid
            startingChars.add(char);
            allStartingChars.push(char);
        }
        catch { }

        try
        {
            // Check again, but as a non-starting character
            eval("var a" + char);
            nonStartingChars.add(char);
            allNonStartingChars.push(char);
        }
        catch
        {
            // The current character cannot be used
            invalidChars.add(char);
        }
    }

    return {
        startingChars: allStartingChars,
        nonStartingChars: allNonStartingChars,
        invalidChars,
    };
}

let debugVarIndex = 0;
let debuggingVarNames = false;

function GetRandomVariableName(length: number, allowLonger: boolean, options: ObfuscationOptionsInternal, customCharacterData: CustomCharacterData)
{
    if (debuggingVarNames)
    {
        return "a_" + (debugVarIndex++);
    }

    const { charset } = options;

    let name = "";
    switch (charset.type)
    {
        case "zalgo":
            {
                name = RandomElementOf(startingChars);
                const zalgoLevel = charset.zalgoLevel ?? 3;
                while (name.length < length)
                {
                    if (zalgoLevel === 0)
                    {
                        name += RandomElementOf(standaloneChars);
                    }
                    else
                    {
                        if (Random() < 0.9)
                        {
                            // Add a random number of zalgo characters with a starting character
                            name += RandomElementOf(baseChars);

                            const min = zalgoLevel;
                            const max = zalgoLevel * 1.5;
                            const diff = max - min;

                            name += RandomElementsOfStringArray(zalgo_up, Math.floor(Random() * diff + min));
                            name += RandomElementsOfStringArray(zalgo_mid, Math.floor(Random() * diff + min));
                            name += RandomElementsOfStringArray(zalgo_down, Math.floor(Random() * diff + min));
                            continue;
                        }
                        else
                        {
                            // Add a random extended zalgo character with a starting character
                            // The only character that actually works and is not a letter is _
                            name += "_";
                            const count = Urand(zalgoLevel, zalgoLevel * 1.5);
                            const ch = RandomElementOf(zalgoCharsExtended);

                            for (let j = 0; j < count; ++j)
                            {
                                name += ch;
                            }

                            continue;
                        }
                    }
                }

                break;
            }
        case "lines":
            {
                name = RandomElementsOfStringArray(options.target === "es5-" ? linesLetters_compatibility : linesLetters, length);
                break;
            }
        case "invisible":
            {
                name = "\u02cb";
                for (let i = 0; i < length; ++i)
                {
                    name += String.fromCharCode(0xfe00 + (Random() * 16) | 0);
                }

                break;
            }
        case "iiii":
            {
                name = RandomElementsOfStringArray(iLetters, length);
                break;
            }
        case "custom":
            {
                name =
                    RandomElementsOfStringArray(customCharacterData.startingChars, 1) +
                    RandomElementsOfStringArray(customCharacterData.nonStartingChars, length - 1);

                break;
            }
        default:
            Unreachable(charset);
    }

    if (allowLonger)
    {
        return name;
    }

    // Trim name to the given length

    const chars = [...name].slice(0, length);
    return chars.join("");
}

function GetNewVariableName(usedVariableNames: Set<string>, options: ObfuscationOptionsInternal, customCharacterData: CustomCharacterData)
{
    const { variableNameLength, charset } = options;
    const allowLongerName = charset.type === "zalgo";

    let len: number;
    if (allowLongerName)
    {
        const min = variableNameLength;
        const max = variableNameLength * 1.5;
        len = Math.floor(Random() * (max - min) + min);
    }
    else
    {
        len = variableNameLength;
    }

    const maxAttempts = 100;
    for (let i = 0; i < maxAttempts; ++i)
    {
        const name = GetRandomVariableName(len, allowLongerName, options, customCharacterData);
        if (!IsValidName(name))
        {
            // Should not happen, was already checked before
            continue;
        }

        if (!usedVariableNames.has(name))
        {
            // Found a new variable name which has not been used yet
            usedVariableNames.add(name);
            return name;
        }
    }

    // Could not get new variable name

    if (charset.type === "custom")
    {
        throw new ObfuscateError(ObfuscateErrorType.CannotGetVariableNameCustom);
    }
    else
    {
        throw new ObfuscateError(ObfuscateErrorType.CannotGetVariableName);
    }
}

function GetCharCodes(str: string)
{
    // Note: this will split characters with char code >0xffff into two characters
    // But those will be re-combined after string concatenation, so it will work fine
    // By not using code points, we only need to go to 32768 for the highest number bit, instead of 524288, which saves some space

    // return str.split("").map(ch => ch.charCodeAt(0));
    const codes = new Array<number>(str.length);
    for (let i = 0; i < str.length; ++i)
    {
        codes[i] = str.charCodeAt(i);
    }

    return codes;
}

function GetIntFromBits(number: number, i0: string, i1: string, i2: string, i4: string, i8: string, i16: string, i32: string, i64: string,
    i128: string, i256: string, i512: string, i1024: string, i2048: string, i4096: string, i8192: string, i16384: string, i32768: string)
{
    // Construct a number from bits, using the given variable names
    // e.g. the number 20 can be constructed from 4 + 16

    if (number === 0)
    {
        return i0;
    }

    const ret: string[] = [];

    const numberNames = [i1, i2, i4, i8, i16, i32, i64, i128, i256, i512, i1024, i2048, i4096, i8192, i16384, i32768];
    for (const num of numberNames)
    {
        if (number & 1)
        {
            ret.push(num);
        }

        number >>= 1;
    }

    Shuffle(ret);

    let retStr = ret[0]; // Should always have at least one element

    for (let i = 1; i < ret.length; ++i)
    {
        // Use + or | at random; since the numbers are powers of 2, both have the same effect
        retStr += Random() < 0.5 ? "+" : "|";
        retStr += ret[i];
    }

    return retStr;
}

function ValidateRngSeed(seed: number)
{
    if (Number.isNaN(seed) || !Number.isFinite(seed))
    {
        return 0;
    }
    else if (seed < 0)
    {
        return 0;
    }
    else if (seed > 0xffffffff)
    {
        return 0xffffffff;
    }

    return Math.floor(seed);
}

// Returns the obfuscated version of the input code
// Throws `ObfuscateError` if the code could not be obfuscated for some reason
// See comments for `ObfuscationOptions` for more information about the options (everything is optional)
export function Obfuscate(inputCode: string, options?: ObfuscationOptions): string
{
    if (inputCode === "")
    {
        return "";
    }

    const optionsValidated: ObfuscationOptionsInternal = {
        charset: options?.charset ?? { type: "zalgo" },
        variableNameLength: Math.max(options?.variableNameLength ?? 2, 2),
        target: options?.target ?? "es6+",
        deobfuscationProtection: options?.deobfuscationProtection ?? null
    };

    const rngSeed = options?.rngSeed ?? null;
    Random = (rngSeed === null) ? Math.random : Mulberry32(ValidateRngSeed(rngSeed));

    const { charset, variableNameLength, target, deobfuscationProtection } = optionsValidated;

    if (target === "es5-")
    {
        if (charset.type === "zalgo" || charset.type === "invisible")
        {
            throw new ObfuscateError(ObfuscateErrorType.CharsetIsIncompatibleES5);
        }
    }

    // Check custom characters, or just use an empty array if the charset is not custom
    const customCharacterData = CheckCustomCharacters(charset.type === "custom" ? charset.characters : []);
    if (customCharacterData.invalidChars.size !== 0)
    {
        throw new ObfuscateError(ObfuscateErrorType.HasInvalidCustomCharacters, customCharacterData.invalidChars);
    }

    const usedVariableNames = new Set<string>();
    function GetVariableName()
    {
        return GetNewVariableName(usedVariableNames, optionsValidated, customCharacterData);
    }

    const resultSegments: string[] = [];
    function AddToResult(str: string)
    {
        resultSegments.push(str);
    }

    AddToResult("(" + (target === "es5-" ? "function()" : "()=>") + "{var ");

    const v_number_0 = GetVariableName();
    const v_number_1 = GetVariableName();
    const v_number_2 = GetVariableName();
    const v_number_4 = GetVariableName();
    const v_number_8 = GetVariableName();
    const v_number_16 = GetVariableName();
    const v_number_32 = GetVariableName();
    const v_number_64 = GetVariableName();
    const v_number_128 = GetVariableName();
    const v_number_256 = GetVariableName();
    const v_number_512 = GetVariableName();
    const v_number_1024 = GetVariableName();
    const v_number_2048 = GetVariableName();
    const v_number_4096 = GetVariableName();
    const v_number_8192 = GetVariableName();
    const v_number_16384 = GetVariableName();
    const v_number_32768 = GetVariableName();

    // Generate variables for each letter in the input code
    const letters = new Map<number, { variableName: string, assignmentExpr: string }>();

    function GetNumber(num: number)
    {
        return GetIntFromBits(num,
            v_number_0, v_number_1, v_number_2, v_number_4, v_number_8, v_number_16, v_number_32,
            v_number_64, v_number_128, v_number_256, v_number_512, v_number_1024, v_number_2048,
            v_number_4096, v_number_8192, v_number_16384, v_number_32768)
    }

    const inputCharCodes = GetCharCodes(inputCode);

    // Collect unique characters from the input text
    for (const ch of inputCharCodes)
    {
        if (letters.has(ch))
        {
            continue;
        }

        const variableName = GetVariableName();
        letters.set(ch, { variableName, assignmentExpr: variableName + "=" + GetNumber(ch) });
    }

    const allowLongerName = charset.type === "zalgo";

    function GetRandomStr(allowLonger: boolean)
    {
        return GetRandomVariableName(variableNameLength, allowLonger, optionsValidated, customCharacterData);
    }

    AddToResult(v_number_0 + "='" + GetRandomStr(allowLongerName) + "'&'" + GetRandomStr(allowLongerName) + "',");
    AddToResult(v_number_1 + "=-~'" + GetRandomStr(allowLongerName) + "',");
    AddToResult(v_number_2 + "=" + v_number_1 + "-~'" + GetRandomStr(false) + "',");
    AddToResult(v_number_4 + "=" + v_number_2 + "+" + v_number_2 + ",");
    AddToResult(v_number_8 + "=" + v_number_4 + "*" + v_number_2 + ",");
    AddToResult(v_number_16 + "=" + v_number_2 + "*" + v_number_4 + "*" + v_number_2 + ",");
    AddToResult(v_number_32 + "=" + v_number_8 + "*" + v_number_4 + ",");
    AddToResult(v_number_64 + "=" + v_number_4 + "*" + v_number_16 + ",");
    AddToResult(v_number_128 + "=" + v_number_8 + "*" + v_number_2 + "*" + v_number_8 + ",");
    AddToResult(v_number_256 + "=" + v_number_64 + "*" + v_number_4 + ",");
    AddToResult(v_number_512 + "=" + v_number_8 + "*" + v_number_64 + ",");
    AddToResult(v_number_1024 + "=" + v_number_4 + "*" + v_number_256 + ",");
    AddToResult(v_number_2048 + "=" + v_number_64 + "*" + v_number_32 + ",");
    AddToResult(v_number_4096 + "=" + v_number_256 + "*" + v_number_16 + ",");
    AddToResult(v_number_8192 + "=" + v_number_8 + "*" + v_number_1024 + ",");
    AddToResult(v_number_16384 + "=" + v_number_32 + "*" + v_number_512 + ",");
    AddToResult(v_number_32768 + "=" + v_number_4 + "*" + v_number_8192 + ",");

    // "acCdefghilmnoprsStuv. " <- we need these characters

    // "false" = !1+[]
    const v_string_false = GetVariableName();
    AddToResult(v_string_false + "=!" + v_number_1 + "+[],");

    // f = "false"[0]
    const v_char_f = GetVariableName();
    AddToResult(v_char_f + "=" + v_string_false + "[" + v_number_0 + "],");

    // "undefined" = "f"[1]+[]
    const v_string_undefined = GetVariableName();
    AddToResult(v_string_undefined + "=" + v_char_f + "[" + v_number_1 + "]+[],");

    // a = "false"[1]
    const v_char_a = GetVariableName();
    AddToResult(v_char_a + "=" + v_string_false + "[" + v_number_1 + "],");

    // l = "false"[2]
    const v_char_l = GetVariableName();
    AddToResult(v_char_l + "=" + v_string_false + "[" + v_number_2 + "],");

    // s = "false"[3]
    const v_char_s = GetVariableName();
    AddToResult(v_char_s + "=" + v_string_false + "[" + v_number_2 + "+" + v_number_1 + "],");

    // e = "false"[4]
    const v_char_e = GetVariableName();
    AddToResult(v_char_e + "=" + v_string_false + "[" + v_number_4 + "],");

    // i = "undefined"[5]
    const v_char_i = GetVariableName();
    AddToResult(v_char_i + "=" + v_string_undefined + "[" + v_number_4 + "+" + v_number_1 + "],");

    // "[object Object]"
    const v_string_object_object = GetVariableName();
    AddToResult(v_string_object_object + "=[]+{},");

    // c = "[object Object]"[5]
    const v_char_c = GetVariableName();
    AddToResult(v_char_c + "=" + v_string_object_object + "[" + v_number_4 + "+" + v_number_1 + "],");

    // b = "[object Object]"[2]
    const v_char_b = GetVariableName();
    AddToResult(v_char_b + "=" + v_string_object_object + "[" + v_number_2 + "],");

    // u = "undefined"[0]
    const v_char_u = GetVariableName();
    AddToResult(v_char_u + "=" + v_string_undefined + "[" + v_number_0 + "],");

    // n = "undefined"[1]
    const v_char_n = GetVariableName();
    AddToResult(v_char_n + "=" + v_string_undefined + "[" + v_number_1 + "],");

    // t = (!0+[])[0]
    const v_char_t = GetVariableName();
    AddToResult(v_char_t + "=(!" + v_number_0 + "+[])[" + v_number_0 + "],");

    // o = "[object Object]"[1]
    const v_char_o = GetVariableName();
    AddToResult(v_char_o + "=" + v_string_object_object + "[" + v_number_1 + "],");

    // space = "[object Object]"[7]
    const v_char_space = GetVariableName();
    AddToResult(v_char_space + "=" + v_string_object_object + "[" + v_number_8 + "-" + v_number_1 + "],");

    // d = "undefined"[2]
    const v_char_d = GetVariableName();
    AddToResult(v_char_d + "=" + v_string_undefined + "[" + v_number_2 + "],");

    // r = (!0+[])[1]
    const v_char_r = GetVariableName();
    AddToResult(v_char_r + "=(!" + v_number_0 + "+[])[" + v_number_1 + "],");

    // "constructor"
    const v_string_constructor = GetVariableName();
    AddToResult(
        v_string_constructor + "=" +
        [v_char_c, v_char_o, v_char_n, v_char_s, v_char_t, v_char_r, v_char_u, v_char_c, v_char_t, v_char_o, v_char_r,].join("+")
        + ","
    );

    // []["filter"]
    const v_function_filter = GetVariableName();
    AddToResult(v_function_filter + "=[][" + [v_char_f, v_char_i, v_char_l, v_char_t, v_char_e, v_char_r].join("+") + "],");

    // []["filter"]["constructor"]
    const v_function_function = GetVariableName();
    AddToResult(v_function_function + "=" + v_function_filter + "[" + v_string_constructor + "],");

    const v_char_g = GetVariableName();
    const v_char_S = GetVariableName();

    if (target === "nodejs")
    {
        // `btoa` is not always available on node.js, so we need to use a different approach
        // Here, we convert native functions to strings, which always works in node.js,
        // but is not consistent across browsers, because it's not part of the ECMAScript standard

        // ''["constructor"]+[]
        const v_string_StringConstructor = GetVariableName();
        AddToResult(v_string_StringConstructor + "=''[" + v_string_constructor + "]+[],");

        // S = (''["constructor"]+[])[1+8]
        AddToResult(v_char_S + "=" + v_string_StringConstructor + "[" + v_number_1 + "+" + v_number_8 + "],");

        // g = (''["constructor"]+[])[16-2]
        AddToResult(v_char_g + "=" + v_string_StringConstructor + "[" + v_number_16 + "-" + v_number_2 + "],");
    }
    else
    {
        // []["filter"]["constructor"]("return btoa")()
        const v_function_btoa = GetVariableName();
        AddToResult(
            v_function_btoa + "=" + v_function_function + "(" +
            [v_char_r, v_char_e, v_char_t, v_char_u, v_char_r, v_char_n, v_char_space, v_char_b, v_char_t, v_char_o, v_char_a].join("+")
            + ")(),"
        );

        // S = btoa("a ")[1]
        AddToResult(v_char_S + "=" + v_function_btoa + "(" + v_char_a + "+" + v_char_space + ")[" + v_number_1 + "],");

        // g = btoa("b")[1]
        AddToResult(v_char_g + "=" + v_function_btoa + "(" + v_char_b + ")[" + v_number_1 + "],");
    }

    // "toString"
    const v_string_toString = GetVariableName();
    AddToResult(v_string_toString + "=" + [v_char_t, v_char_o, v_char_S, v_char_t, v_char_r, v_char_i, v_char_n, v_char_g].join("+") + ",");

    // p = (16+8+1)["toString"](32)
    const v_char_p = GetVariableName();
    AddToResult(v_char_p + "=(" + v_number_1 + "+" + v_number_8 + "+" + v_number_16 + ")[" + v_string_toString + "](" + v_number_32 + "),");

    // []["constructor"]["constructor"]("return escape")()
    const v_function_escape = GetVariableName();
    AddToResult(
        v_function_escape + "=[][" + v_string_constructor + "][" + v_string_constructor + "](" +
        [v_char_r, v_char_e, v_char_t, v_char_u, v_char_r, v_char_n, v_char_space, v_char_e, v_char_s, v_char_c, v_char_a, v_char_p, v_char_e].join("+")
        + ")(),"
    );

    // C = escape(''["big"]())[2]
    const v_char_C = GetVariableName();
    AddToResult(v_char_C + "=" + v_function_escape + "(''[" + [v_char_b, v_char_i, v_char_g].join("+") + "]())[" + v_number_2 + "],");

    // m = (16+4+2)["toString"](32)
    const v_char_m = GetVariableName();
    AddToResult(v_char_m + "=(" + v_number_16 + "+" + v_number_4 + "+" + v_number_2 + ")[" + v_string_toString + "](" + v_number_32 + "),");

    // h = (16+1)["toString"](32)
    const v_char_h = GetVariableName();
    AddToResult(v_char_h + "=(" + v_number_16 + "+" + v_number_1 + ")[" + v_string_toString + "](" + v_number_32 + "),");

    // h = (32-1)["toString"](32)
    const v_char_v = GetVariableName();
    AddToResult(v_char_v + "=(" + v_number_32 + "-" + v_number_1 + ")[" + v_string_toString + "](" + v_number_32 + "),");

    // ''["constructor"]["fromCharCode"]
    const v_function_stringFromCharCode = GetVariableName();
    AddToResult(
        v_function_stringFromCharCode + "=''[" + v_string_constructor + "][" +
        [v_char_f, v_char_r, v_char_o, v_char_m, v_char_C, v_char_h, v_char_a, v_char_r, v_char_C, v_char_o, v_char_d, v_char_e].join("+")
        + "],"
    );

    // []["filter"]["constructor"]("return eval")()
    const v_function_eval = GetVariableName();
    AddToResult(
        v_function_eval + "=" + v_function_function + "(" +
        [v_char_r, v_char_e, v_char_t, v_char_u, v_char_r, v_char_n, v_char_space, v_char_e, v_char_v, v_char_a, v_char_l].join("+")
        + ")(),"
    );

    let v_bool_deobfuscationOk = "";
    if (deobfuscationProtection)
    {
        const dummyString = GetRandomStr(allowLongerName);
        const v_string_dummyString = GetVariableName();
        AddToResult(v_string_dummyString + "='" + dummyString + "',");

        const v_function_deobfuscationProtection = GetVariableName();
        const functionStart = target === "es5-" ? "function()" : "()=>";
        AddToResult(v_function_deobfuscationProtection + "=" + functionStart + "{'" + dummyString + "'},");

        // How this works:
        // In javascript, you can convert functions to a string, and if you convert a user-defined function to string,
        // you'll get back the exact string representation of the function
        // Deobfuscators usually format the code to make it more readable, so we create a dummy function which will be formatted for sure
        // So we store the original string representation, and compare it with the new one
        // If the code was formatted, then those two won't match, and we can do stuff with that

        v_bool_deobfuscationOk = GetVariableName();
        AddToResult(
            v_bool_deobfuscationOk + "=(" + v_function_deobfuscationProtection + "+[])["
            + [v_char_s, v_char_u, v_char_b, v_char_s, v_char_t, v_char_r].join("+")
            + "](" + GetNumber(functionStart.length + 2) + "," + GetNumber(dummyString.length) + ")==" + v_string_dummyString + ","
        );

        if (deobfuscationProtection.type !== "skip")
        {
            const v_string_otherFunctionName = GetVariableName();
            const v_string_param1_deobfuscationProtection = GetVariableName();

            AddToResult(v_string_otherFunctionName + "=" + v_function_function + "('" + v_string_param1_deobfuscationProtection + "',");

            function GetCharCodesOf(str: string)
            {
                const charCodes = GetCharCodes(str);
                return v_function_stringFromCharCode + "(" + charCodes.map(charCode => GetNumber(charCode))
                    .join(",") + ")";
            }

            switch (deobfuscationProtection.type)
            {
                case "error":
                    {
                        AddToResult(GetCharCodesOf("!function \u0192(){" + v_string_param1_deobfuscationProtection + "=='" + dummyString + "'||\u0192()}()"));
                        break;
                    }
                case "loop":
                    {
                        AddToResult(GetCharCodesOf("if(" + v_string_param1_deobfuscationProtection + "!='" + dummyString + "')for(;;){}"));
                        break;
                    }
                case "custom":
                    {
                        AddToResult(GetCharCodesOf(
                            v_string_param1_deobfuscationProtection + "=='" + dummyString
                            + "'||!function(){" + deobfuscationProtection.codeToRun + "}()"
                        ));
                        break;
                    }
                default:
                    Unreachable(deobfuscationProtection);
            }

            AddToResult(
                ")((" + v_function_deobfuscationProtection + "+[])["
                + [v_char_s, v_char_u, v_char_b, v_char_s, v_char_t, v_char_r].join("+")
                + "](" + GetNumber(functionStart.length + 2) + "," + GetNumber(dummyString.length) + ")),"
            );
        }
    }

    const finalLetters: string[] = [];
    for (const [_, letterData] of letters)
    {
        finalLetters.push(letterData.assignmentExpr);
    }

    Shuffle(finalLetters);

    AddToResult(finalLetters.join(",") + ";");

    if (deobfuscationProtection)
    {
        AddToResult(v_bool_deobfuscationOk + "&&");
    }

    AddToResult(v_function_eval + "(");

    // Assemble the characters from the input code, using String.fromCharCode
    // The maximum number of function arguments is limited (e.g. 65535 on chrome), so for long texts, we need to split up the process
    // `batchCount` indicates how many arguments we use for a function call
    // 4096 should be fine on all browsers
    // Also add random count at a time
    const batchCount = 4096;
    const batchData: string[] = [];
    let textIndex = 0;
    while (textIndex < inputCharCodes.length)
    {
        const finalTextAssembled = [];
        const batchEndIndex = Math.min(textIndex + Math.floor(batchCount * (Random() * 0.5 + 0.5)), inputCharCodes.length);

        while (textIndex < batchEndIndex)
        {
            const letterData = letters.get(inputCharCodes[textIndex])!;
            finalTextAssembled.push(letterData.variableName);
            ++textIndex;
        }

        const currentBatchText = v_function_stringFromCharCode + "(" + finalTextAssembled.join(",") + ")";
        batchData.push(currentBatchText);
    }

    AddToResult(batchData.join("+"));
    AddToResult(")");
    AddToResult("})()");

    return resultSegments.join("");
}