{"version":3,"sources":["jsdelivr-header.js","/npm/figlet@1.5.0/lib/figlet.js"],"names":[],"mappings":"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","file":"/npm/figlet@1.5.0/lib/figlet.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/figlet@1.5.0/lib/figlet.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*\n    FIGlet.js (a FIGDriver for FIGlet fonts)\n    By Patrick Gillespie (patorjk@gmail.com)\n    Originally Written For: http://patorjk.com/software/taag/\n    License: MIT (with this header staying intact)\n\n    This JavaScript code aims to fully implement the FIGlet spec.\n    Full FIGlet spec: http://patorjk.com/software/taag/docs/figfont.txt\n\n    FIGlet fonts are actually kind of complex, which is why you will see\n    a lot of code about parsing and interpreting rules. The actual generation\n    code is pretty simple and is done near the bottom of the code.\n*/\n\n\"use strict\";\n\nvar figlet = figlet || (function() {\n\n    // ---------------------------------------------------------------------\n    // Private static variables\n\n    var FULL_WIDTH = 0,\n        FITTING = 1,\n        SMUSHING = 2,\n        CONTROLLED_SMUSHING = 3;\n\n    // ---------------------------------------------------------------------\n    // Variable that will hold information about the fonts\n\n    var figFonts = {}; // What stores all of the FIGlet font data\n    var figDefaults = {\n        font: 'Standard',\n        fontPath: './fonts'\n    };\n\n    // ---------------------------------------------------------------------\n    // Private static methods\n\n    /*\n        This method takes in the oldLayout and newLayout data from the FIGfont header file and returns\n        the layout information.\n    */\n    function getSmushingRules(oldLayout, newLayout) {\n        var rules = {};\n        var val, index, len, code;\n        var codes = [[16384,\"vLayout\",SMUSHING], [8192,\"vLayout\",FITTING], [4096, \"vRule5\", true], [2048, \"vRule4\", true],\n                     [1024, \"vRule3\", true], [512, \"vRule2\", true], [256, \"vRule1\", true], [128, \"hLayout\", SMUSHING],\n                     [64, \"hLayout\", FITTING], [32, \"hRule6\", true], [16, \"hRule5\", true], [8, \"hRule4\", true], [4, \"hRule3\", true],\n                     [2, \"hRule2\", true], [1, \"hRule1\", true]];\n\n        val = (newLayout !== null) ? newLayout : oldLayout;\n        index = 0;\n        len = codes.length;\n        while ( index < len ) {\n            code = codes[index];\n            if (val >= code[0]) {\n                val = val - code[0];\n                rules[code[1]] = (typeof rules[code[1]] === \"undefined\") ? code[2] : rules[code[1]];\n            } else if (code[1] !== \"vLayout\" && code[1] !== \"hLayout\") {\n                rules[code[1]] = false;\n            }\n            index++;\n        }\n\n        if (typeof rules[\"hLayout\"] === \"undefined\") {\n            if (oldLayout === 0) {\n                rules[\"hLayout\"] = FITTING;\n            } else if (oldLayout === -1) {\n                rules[\"hLayout\"] = FULL_WIDTH;\n            } else {\n                if (rules[\"hRule1\"] || rules[\"hRule2\"] || rules[\"hRule3\"] || rules[\"hRule4\"] ||rules[\"hRule5\"] || rules[\"hRule6\"] ) {\n                    rules[\"hLayout\"] = CONTROLLED_SMUSHING;\n                } else {\n                    rules[\"hLayout\"] = SMUSHING;\n                }\n            }\n        } else if (rules[\"hLayout\"] === SMUSHING) {\n            if (rules[\"hRule1\"] || rules[\"hRule2\"] || rules[\"hRule3\"] || rules[\"hRule4\"] ||rules[\"hRule5\"] || rules[\"hRule6\"] ) {\n                rules[\"hLayout\"] = CONTROLLED_SMUSHING;\n            }\n        }\n\n        if (typeof rules[\"vLayout\"] === \"undefined\") {\n            if (rules[\"vRule1\"] || rules[\"vRule2\"] || rules[\"vRule3\"] || rules[\"vRule4\"] ||rules[\"vRule5\"]  ) {\n                rules[\"vLayout\"] = CONTROLLED_SMUSHING;\n            } else {\n                rules[\"vLayout\"] = FULL_WIDTH;\n            }\n        } else if (rules[\"vLayout\"] === SMUSHING) {\n            if (rules[\"vRule1\"] || rules[\"vRule2\"] || rules[\"vRule3\"] || rules[\"vRule4\"] ||rules[\"vRule5\"]  ) {\n                rules[\"vLayout\"] = CONTROLLED_SMUSHING;\n            }\n        }\n\n        return rules;\n    }\n\n    /* The [vh]Rule[1-6]_Smush functions return the smushed character OR false if the two characters can't be smushed */\n\n    /*\n        Rule 1: EQUAL CHARACTER SMUSHING (code value 1)\n\n            Two sub-characters are smushed into a single sub-character\n            if they are the same.  This rule does not smush\n            hardblanks.  (See rule 6 on hardblanks below)\n    */\n    function hRule1_Smush(ch1, ch2, hardBlank) {\n        if (ch1 === ch2 && ch1 !== hardBlank) {return ch1;}\n        return false;\n    }\n\n    /*\n        Rule 2: UNDERSCORE SMUSHING (code value 2)\n\n            An underscore (\"_\") will be replaced by any of: \"|\", \"/\",\n            \"\\\", \"[\", \"]\", \"{\", \"}\", \"(\", \")\", \"<\" or \">\".\n    */\n    function hRule2_Smush(ch1, ch2) {\n        var rule2Str = \"|/\\\\[]{}()<>\";\n        if (ch1 === \"_\") {\n            if (rule2Str.indexOf(ch2) !== -1) {return ch2;}\n        } else if (ch2 === \"_\") {\n            if (rule2Str.indexOf(ch1) !== -1) {return ch1;}\n        }\n        return false;\n    }\n\n    /*\n        Rule 3: HIERARCHY SMUSHING (code value 4)\n\n            A hierarchy of six classes is used: \"|\", \"/\\\", \"[]\", \"{}\",\n            \"()\", and \"<>\".  When two smushing sub-characters are\n            from different classes, the one from the latter class\n            will be used.\n    */\n    function hRule3_Smush(ch1, ch2) {\n        var rule3Classes = \"| /\\\\ [] {} () <>\";\n        var r3_pos1 = rule3Classes.indexOf(ch1);\n        var r3_pos2 = rule3Classes.indexOf(ch2);\n        if (r3_pos1 !== -1 && r3_pos2 !== -1) {\n            if (r3_pos1 !== r3_pos2 && Math.abs(r3_pos1-r3_pos2) !== 1) {\n                return rule3Classes.substr(Math.max(r3_pos1,r3_pos2), 1);\n            }\n        }\n        return false;\n    }\n\n    /*\n        Rule 4: OPPOSITE PAIR SMUSHING (code value 8)\n\n            Smushes opposing brackets (\"[]\" or \"][\"), braces (\"{}\" or\n            \"}{\") and parentheses (\"()\" or \")(\") together, replacing\n            any such pair with a vertical bar (\"|\").\n    */\n    function hRule4_Smush(ch1, ch2) {\n        var rule4Str = \"[] {} ()\";\n        var r4_pos1 = rule4Str.indexOf(ch1);\n        var r4_pos2 = rule4Str.indexOf(ch2);\n        if (r4_pos1 !== -1 && r4_pos2 !== -1) {\n            if (Math.abs(r4_pos1-r4_pos2) <= 1) {\n                return \"|\";\n            }\n        }\n        return false;\n    }\n\n    /*\n        Rule 5: BIG X SMUSHING (code value 16)\n\n            Smushes \"/\\\" into \"|\", \"\\/\" into \"Y\", and \"><\" into \"X\".\n            Note that \"<>\" is not smushed in any way by this rule.\n            The name \"BIG X\" is historical; originally all three pairs\n            were smushed into \"X\".\n    */\n    function hRule5_Smush(ch1, ch2) {\n        var rule5Str = \"/\\\\ \\\\/ ><\";\n        var rule5Hash = {\"0\": \"|\", \"3\": \"Y\", \"6\": \"X\"};\n        var r5_pos1 = rule5Str.indexOf(ch1);\n        var r5_pos2 = rule5Str.indexOf(ch2);\n        if (r5_pos1 !== -1 && r5_pos2 !== -1) {\n            if ((r5_pos2-r5_pos1) === 1) {\n                return rule5Hash[r5_pos1];\n            }\n        }\n        return false;\n    }\n\n    /*\n        Rule 6: HARDBLANK SMUSHING (code value 32)\n\n            Smushes two hardblanks together, replacing them with a\n            single hardblank.  (See \"Hardblanks\" below.)\n    */\n    function hRule6_Smush(ch1, ch2, hardBlank) {\n        if (ch1 === hardBlank && ch2 === hardBlank) {\n            return hardBlank;\n        }\n        return false;\n    }\n\n    /*\n        Rule 1: EQUAL CHARACTER SMUSHING (code value 256)\n\n            Same as horizontal smushing rule 1.\n    */\n    function vRule1_Smush(ch1, ch2) {\n        if (ch1 === ch2) {return ch1;}\n        return false;\n    }\n\n    /*\n        Rule 2: UNDERSCORE SMUSHING (code value 512)\n\n            Same as horizontal smushing rule 2.\n    */\n    function vRule2_Smush(ch1, ch2) {\n        var rule2Str = \"|/\\\\[]{}()<>\";\n        if (ch1 === \"_\") {\n            if (rule2Str.indexOf(ch2) !== -1) {return ch2;}\n        } else if (ch2 === \"_\") {\n            if (rule2Str.indexOf(ch1) !== -1) {return ch1;}\n        }\n        return false;\n    }\n\n    /*\n        Rule 3: HIERARCHY SMUSHING (code value 1024)\n\n            Same as horizontal smushing rule 3.\n    */\n    function vRule3_Smush(ch1, ch2) {\n        var rule3Classes = \"| /\\\\ [] {} () <>\";\n        var r3_pos1 = rule3Classes.indexOf(ch1);\n        var r3_pos2 = rule3Classes.indexOf(ch2);\n        if (r3_pos1 !== -1 && r3_pos2 !== -1) {\n            if (r3_pos1 !== r3_pos2 && Math.abs(r3_pos1-r3_pos2) !== 1) {\n                return rule3Classes.substr(Math.max(r3_pos1,r3_pos2), 1);\n            }\n        }\n        return false;\n    }\n\n    /*\n        Rule 4: HORIZONTAL LINE SMUSHING (code value 2048)\n\n            Smushes stacked pairs of \"-\" and \"_\", replacing them with\n            a single \"=\" sub-character.  It does not matter which is\n            found above the other.  Note that vertical smushing rule 1\n            will smush IDENTICAL pairs of horizontal lines, while this\n            rule smushes horizontal lines consisting of DIFFERENT\n            sub-characters.\n    */\n    function vRule4_Smush(ch1, ch2) {\n        if ( (ch1 === \"-\" && ch2 === \"_\") || (ch1 === \"_\" && ch2 === \"-\") ) {\n            return \"=\";\n        }\n        return false;\n    }\n\n    /*\n        Rule 5: VERTICAL LINE SUPERSMUSHING (code value 4096)\n\n            This one rule is different from all others, in that it\n            \"supersmushes\" vertical lines consisting of several\n            vertical bars (\"|\").  This creates the illusion that\n            FIGcharacters have slid vertically against each other.\n            Supersmushing continues until any sub-characters other\n            than \"|\" would have to be smushed.  Supersmushing can\n            produce impressive results, but it is seldom possible,\n            since other sub-characters would usually have to be\n            considered for smushing as soon as any such stacked\n            vertical lines are encountered.\n    */\n    function vRule5_Smush(ch1, ch2) {\n        if ( ch1 === \"|\" && ch2 === \"|\" ) {\n            return \"|\";\n        }\n        return false;\n    }\n\n    /*\n        Universal smushing simply overrides the sub-character from the\n        earlier FIGcharacter with the sub-character from the later\n        FIGcharacter.  This produces an \"overlapping\" effect with some\n        FIGfonts, wherin the latter FIGcharacter may appear to be \"in\n        front\".\n    */\n    function uni_Smush(ch1, ch2, hardBlank) {\n        if (ch2 === \" \" || ch2 === \"\") {\n            return ch1;\n        } else if (ch2 === hardBlank && ch1 !== \" \") {\n            return ch1;\n        } else {\n            return ch2;\n        }\n    }\n\n    // --------------------------------------------------------------------------\n    // main vertical smush routines (excluding rules)\n\n    /*\n        txt1 - A line of text\n        txt2 - A line of text\n        opts - FIGlet options array\n\n        About: Takes in two lines of text and returns one of the following:\n        \"valid\" - These lines can be smushed together given the current smushing rules\n        \"end\" - The lines can be smushed, but we're at a stopping point\n        \"invalid\" - The two lines cannot be smushed together\n    */\n    function canVerticalSmush(txt1, txt2, opts) {\n        if (opts.fittingRules.vLayout === FULL_WIDTH) {return \"invalid\";}\n        var ii, len = Math.min(txt1.length, txt2.length);\n        var ch1, ch2, endSmush = false, validSmush;\n        if (len===0) {return \"invalid\";}\n\n        for (ii = 0; ii < len; ii++) {\n            ch1 = txt1.substr(ii,1);\n            ch2 = txt2.substr(ii,1);\n            if (ch1 !== \" \" && ch2 !== \" \") {\n                if (opts.fittingRules.vLayout === FITTING) {\n                    return \"invalid\";\n                } else if (opts.fittingRules.vLayout === SMUSHING) {\n                    return \"end\";\n                } else {\n                    if (vRule5_Smush(ch1,ch2)) {endSmush = endSmush || false; continue;} // rule 5 allow for \"super\" smushing, but only if we're not already ending this smush\n                    validSmush = false;\n                    validSmush = (opts.fittingRules.vRule1) ? vRule1_Smush(ch1,ch2) : validSmush;\n                    validSmush = (!validSmush && opts.fittingRules.vRule2) ? vRule2_Smush(ch1,ch2) : validSmush;\n                    validSmush = (!validSmush && opts.fittingRules.vRule3) ? vRule3_Smush(ch1,ch2) : validSmush;\n                    validSmush = (!validSmush && opts.fittingRules.vRule4) ? vRule4_Smush(ch1,ch2) : validSmush;\n                    endSmush = true;\n                    if (!validSmush) {return \"invalid\";}\n                }\n            }\n        }\n        if (endSmush) {\n            return \"end\";\n        } else {\n            return \"valid\";\n        }\n    }\n\n    function getVerticalSmushDist(lines1, lines2, opts) {\n        var maxDist = lines1.length;\n        var len1 = lines1.length;\n        var len2 = lines2.length;\n        var subLines1, subLines2, slen;\n        var curDist = 1;\n        var ii, ret, result;\n        while (curDist <= maxDist) {\n\n            subLines1 = lines1.slice(Math.max(0,len1-curDist), len1);\n            subLines2 = lines2.slice(0, Math.min(maxDist, curDist));\n\n            slen = subLines2.length;//TODO:check this\n            result = \"\";\n            for (ii = 0; ii < slen; ii++) {\n                ret = canVerticalSmush(subLines1[ii], subLines2[ii], opts);\n                if (ret === \"end\") {\n                    result = ret;\n                } else if (ret === \"invalid\") {\n                    result = ret;\n                    break;\n                } else {\n                    if (result === \"\") {\n                        result = \"valid\";\n                    }\n                }\n            }\n\n            if (result === \"invalid\") {curDist--;break;}\n            if (result === \"end\") {break;}\n            if (result === \"valid\") {curDist++;}\n        }\n\n        return Math.min(maxDist,curDist);\n    }\n\n    function verticallySmushLines(line1, line2, opts) {\n        var ii, len = Math.min(line1.length, line2.length);\n        var ch1, ch2, result = \"\", validSmush;\n\n        for (ii = 0; ii < len; ii++) {\n            ch1 = line1.substr(ii,1);\n            ch2 = line2.substr(ii,1);\n            if (ch1 !== \" \" && ch2 !== \" \") {\n                if (opts.fittingRules.vLayout === FITTING) {\n                    result += uni_Smush(ch1,ch2);\n                } else if (opts.fittingRules.vLayout === SMUSHING) {\n                    result += uni_Smush(ch1,ch2);\n                } else {\n                    validSmush = (opts.fittingRules.vRule5) ? vRule5_Smush(ch1,ch2) : validSmush;\n                    validSmush = (!validSmush && opts.fittingRules.vRule1) ? vRule1_Smush(ch1,ch2) : validSmush;\n                    validSmush = (!validSmush && opts.fittingRules.vRule2) ? vRule2_Smush(ch1,ch2) : validSmush;\n                    validSmush = (!validSmush && opts.fittingRules.vRule3) ? vRule3_Smush(ch1,ch2) : validSmush;\n                    validSmush = (!validSmush && opts.fittingRules.vRule4) ? vRule4_Smush(ch1,ch2) : validSmush;\n                    result += validSmush;\n                }\n            } else {\n                result += uni_Smush(ch1,ch2);\n            }\n        }\n        return result;\n    }\n\n    function verticalSmush(lines1, lines2, overlap, opts) {\n        var len1 = lines1.length;\n        var len2 = lines2.length;\n        var piece1 = lines1.slice(0, Math.max(0,len1-overlap));\n        var piece2_1 = lines1.slice(Math.max(0,len1-overlap), len1);\n        var piece2_2 = lines2.slice(0, Math.min(overlap, len2));\n        var ii, len, line, piece2 = [], piece3, result = [];\n\n        len = piece2_1.length;\n        for (ii = 0; ii < len; ii++) {\n            if (ii >= len2) {\n                line = piece2_1[ii];\n            } else {\n                line = verticallySmushLines(piece2_1[ii], piece2_2[ii], opts);\n            }\n            piece2.push(line);\n        }\n\n        piece3 = lines2.slice(Math.min(overlap,len2), len2);\n\n        return result.concat(piece1,piece2,piece3);\n    }\n\n    function padLines(lines, numSpaces) {\n        var ii, len = lines.length, padding = \"\";\n        for (ii = 0; ii < numSpaces; ii++) {\n            padding += \" \";\n        }\n        for (ii = 0; ii < len; ii++) {\n            lines[ii] += padding;\n        }\n    }\n\n    function smushVerticalFigLines(output, lines, opts) {\n        var len1 = output[0].length;\n        var len2 = lines[0].length;\n        var overlap;\n        if (len1 > len2) {\n            padLines(lines, len1-len2);\n        } else if (len2 > len1) {\n            padLines(output, len2-len1);\n        }\n        overlap = getVerticalSmushDist(output, lines, opts);\n        return verticalSmush(output, lines, overlap,opts);\n    }\n\n    // -------------------------------------------------------------------------\n    // Main horizontal smush routines (excluding rules)\n\n    function getHorizontalSmushLength(txt1, txt2, opts) {\n        if (opts.fittingRules.hLayout === FULL_WIDTH) {return 0;}\n        var ii, len1 = txt1.length, len2 = txt2.length;\n        var maxDist = len1;\n        var curDist = 1;\n        var breakAfter = false;\n        var validSmush = false;\n        var seg1, seg2, ch1, ch2;\n        if (len1 === 0) {return 0;}\n\n        distCal: while (curDist <= maxDist) {\n            seg1 = txt1.substr(len1-curDist,curDist);\n            seg2 = txt2.substr(0,Math.min(curDist,len2));\n            for (ii = 0; ii < Math.min(curDist,len2); ii++) {\n                ch1 = seg1.substr(ii,1);\n                ch2 = seg2.substr(ii,1);\n                if (ch1 !== \" \" && ch2 !== \" \" ) {\n                    if (opts.fittingRules.hLayout === FITTING) {\n                        curDist = curDist - 1;\n                        break distCal;\n                    } else if (opts.fittingRules.hLayout === SMUSHING) {\n                        if (ch1 === opts.hardBlank || ch2 === opts.hardBlank) {\n                            curDist = curDist - 1; // universal smushing does not smush hardblanks\n                        }\n                        break distCal;\n                    } else {\n                        breakAfter = true; // we know we need to break, but we need to check if our smushing rules will allow us to smush the overlapped characters\n                        validSmush = false; // the below checks will let us know if we can smush these characters\n\n                        validSmush = (opts.fittingRules.hRule1) ? hRule1_Smush(ch1,ch2,opts.hardBlank) : validSmush;\n                        validSmush = (!validSmush && opts.fittingRules.hRule2) ? hRule2_Smush(ch1,ch2,opts.hardBlank) : validSmush;\n                        validSmush = (!validSmush && opts.fittingRules.hRule3) ? hRule3_Smush(ch1,ch2,opts.hardBlank) : validSmush;\n                        validSmush = (!validSmush && opts.fittingRules.hRule4) ? hRule4_Smush(ch1,ch2,opts.hardBlank) : validSmush;\n                        validSmush = (!validSmush && opts.fittingRules.hRule5) ? hRule5_Smush(ch1,ch2,opts.hardBlank) : validSmush;\n                        validSmush = (!validSmush && opts.fittingRules.hRule6) ? hRule6_Smush(ch1,ch2,opts.hardBlank) : validSmush;\n\n                        if (!validSmush) {\n                            curDist = curDist - 1;\n                            break distCal;\n                        }\n                    }\n                }\n            }\n            if (breakAfter) {break;}\n            curDist++;\n        }\n        return Math.min(maxDist,curDist);\n    }\n\n    function horizontalSmush(textBlock1, textBlock2, overlap, opts) {\n        var ii, jj, ch, outputFig = [],\n            overlapStart,piece1,piece2,piece3,len1,len2,txt1,txt2;\n\n        for (ii = 0; ii < opts.height; ii++) {\n            txt1 = textBlock1[ii];\n            txt2 = textBlock2[ii];\n            len1 = txt1.length;\n            len2 = txt2.length;\n            overlapStart = len1-overlap;\n            piece1 = txt1.substr(0,Math.max(0,overlapStart));\n            piece2 = \"\";\n\n            // determine overlap piece\n            var seg1 = txt1.substr(Math.max(0,len1-overlap),overlap);\n            var seg2 = txt2.substr(0,Math.min(overlap,len2));\n\n            for (jj = 0; jj < overlap; jj++) {\n                var ch1 = (jj < len1) ? seg1.substr(jj,1) : \" \";\n                var ch2 = (jj < len2) ? seg2.substr(jj,1) : \" \";\n\n                if (ch1 !== \" \" && ch2 !== \" \") {\n                    if (opts.fittingRules.hLayout === FITTING) {\n                        piece2 += uni_Smush(ch1, ch2, opts.hardBlank);\n                    } else if (opts.fittingRules.hLayout === SMUSHING) {\n                        piece2 += uni_Smush(ch1, ch2, opts.hardBlank);\n                    } else {\n                        // Controlled Smushing\n                        var nextCh = \"\";\n                        nextCh = (!nextCh && opts.fittingRules.hRule1) ? hRule1_Smush(ch1,ch2,opts.hardBlank) : nextCh;\n                        nextCh = (!nextCh && opts.fittingRules.hRule2) ? hRule2_Smush(ch1,ch2,opts.hardBlank) : nextCh;\n                        nextCh = (!nextCh && opts.fittingRules.hRule3) ? hRule3_Smush(ch1,ch2,opts.hardBlank) : nextCh;\n                        nextCh = (!nextCh && opts.fittingRules.hRule4) ? hRule4_Smush(ch1,ch2,opts.hardBlank) : nextCh;\n                        nextCh = (!nextCh && opts.fittingRules.hRule5) ? hRule5_Smush(ch1,ch2,opts.hardBlank) : nextCh;\n                        nextCh = (!nextCh && opts.fittingRules.hRule6) ? hRule6_Smush(ch1,ch2,opts.hardBlank) : nextCh;\n                        nextCh = nextCh || uni_Smush(ch1, ch2, opts.hardBlank);\n                        piece2 += nextCh;\n                    }\n                } else {\n                    piece2 += uni_Smush(ch1, ch2, opts.hardBlank);\n                }\n            }\n\n            if (overlap >= len2) {\n                piece3 = \"\";\n            } else {\n                piece3 = txt2.substr(overlap,Math.max(0,len2-overlap));\n            }\n            outputFig[ii] = piece1 + piece2 + piece3;\n        }\n        return outputFig;\n    }\n\n    /*\n        Creates new empty ASCII placeholder of give len\n        - len - number\n    */\n    function newFigChar(len) {\n        var outputFigText = [], row;\n        for (row = 0; row < len; row++) {\n            outputFigText[row] = \"\";\n        }\n        return outputFigText;\n    }\n\n    /*\n       join words or single characaters into single Fig line\n       - array - array of ASCII words or single characters: {fig: array, overlap: number}\n       - len - height of the Characters (number of rows)\n       - opt - options object\n    */\n    function joinFigArray(array, len, opts) {\n        return array.reduce(function(acc, data) {\n            return horizontalSmush(acc, data.fig, data.overlap, opts);\n        }, newFigChar(len));\n    }\n\n    /*\n       break long word return leftover characters and line before the break\n       - figChars - list of single ASCII characters in form {fig, overlap}\n       - len - number of rows\n       - opt - options object\n    */\n    function breakWord(figChars, len, opts) {\n        var result = {};\n        for (var i = figChars.length; --i;) {\n            var w = joinFigArray(figChars.slice(0, i), len, opts);\n            if (figLinesWidth(w) <= opts.width) {\n                result.outputFigText = w;\n                if (i < figChars.length) {\n                    result.chars = figChars.slice(i);\n                } else {\n                    result.chars = [];\n                }\n                break;\n            }\n        }\n        return result;\n    }\n\n    function generateFigTextLines(txt, figChars, opts) {\n        var charIndex, figChar, spaceIndex, overlap = 0, row, outputFigText, len, height=opts.height, outputFigLines = [], maxWidth, prevWidth, nextFigChars, figWords = [], char, isSpace, textFigWord, textFigLine, tmpBreak;\n\n        outputFigText = newFigChar(height);\n        if (opts.width > 0 && opts.whitespaceBreak) {\n            // list of characters is used to break in the middle of the word when word is logner\n            // chars is array of characters with {fig, overlap} and overlap is for whole word\n            nextFigChars = {\n                chars: [],\n                overlap: overlap\n            };\n        }\n        if (opts.printDirection === 1) {\n            txt = txt.split('').reverse().join('');\n        }\n        len = txt.length;\n        for (charIndex = 0; charIndex < len; charIndex++) {\n            char = txt.substr(charIndex, 1);\n            isSpace = char.match(/\\s/);\n            figChar = figChars[char.charCodeAt(0)];\n            textFigLine = null;\n            if (figChar) {\n                if (opts.fittingRules.hLayout !== FULL_WIDTH) {\n                    overlap = 10000;// a value too high to be the overlap\n                    for (row = 0; row < opts.height; row++) {\n                        overlap = Math.min(overlap, getHorizontalSmushLength(outputFigText[row], figChar[row], opts));\n                    }\n                    overlap = (overlap === 10000) ? 0 : overlap;\n                }\n                if (opts.width > 0) {\n                    if (opts.whitespaceBreak) {\n                        // next character in last word (figChars have same data as words)\n                        textFigWord = joinFigArray(nextFigChars.chars.concat([{\n                            fig: figChar, overlap: overlap\n                        }]), height, opts);\n                        textFigLine = joinFigArray(figWords.concat([{\n                            fig: textFigWord, overlap: nextFigChars.overlap\n                        }]), height, opts);\n                        maxWidth = figLinesWidth(textFigLine);\n                    } else {\n                        textFigLine = horizontalSmush(outputFigText, figChar, overlap, opts);\n                        maxWidth = figLinesWidth(textFigLine);\n                    }\n                    if (maxWidth >= opts.width && charIndex > 0) {\n                        if (opts.whitespaceBreak) {\n                            outputFigText = joinFigArray(figWords.slice(0, -1), height, opts);\n                            if (figWords.length > 1) {\n                                outputFigLines.push(outputFigText);\n                                outputFigText = newFigChar(height);\n                            }\n                            figWords = [];\n                        } else {\n                            outputFigLines.push(outputFigText);\n                            outputFigText = newFigChar(height);\n                        }\n                    }\n                }\n                if (opts.width > 0 && opts.whitespaceBreak) {\n                    if (!isSpace || charIndex === len - 1) {\n                        nextFigChars.chars.push({fig: figChar, overlap: overlap});\n                    }\n                    if (isSpace || charIndex === len - 1) {\n                        // break long words\n                        tmpBreak = null;\n                        while (true) {\n                            textFigLine = joinFigArray(nextFigChars.chars, height, opts);\n                            maxWidth = figLinesWidth(textFigLine);\n                            if (maxWidth >= opts.width) {\n                                tmpBreak = breakWord(nextFigChars.chars, height, opts);\n                                nextFigChars = { chars: tmpBreak.chars };\n                                outputFigLines.push(tmpBreak.outputFigText);\n                            } else {\n                                break;\n                            }\n                        }\n                        // any leftovers\n                        if (maxWidth > 0) {\n                            if (tmpBreak) {\n                                figWords.push({fig: textFigLine, overlap: 1});\n                            } else {\n                                figWords.push({\n                                    fig: textFigLine,\n                                    overlap: nextFigChars.overlap\n                                });\n                            }\n                        }\n                        // save space character and current overlap for smush in joinFigWords\n                        if (isSpace) {\n                            figWords.push({fig: figChar, overlap: overlap});\n                            outputFigText = newFigChar(height);\n                        }\n                        if (charIndex === len - 1) {\n                            // last line\n                            outputFigText = joinFigArray(figWords, height, opts);\n                        }\n                        nextFigChars = {\n                            chars: [],\n                            overlap: overlap\n                        };\n                        continue;\n                    }\n                }\n                outputFigText = horizontalSmush(outputFigText, figChar, overlap, opts);\n            }\n        }\n        // special case when last line would be empty\n        // this may happen if text fit exactly opt.width\n        if (figLinesWidth(outputFigText) > 0) {\n            outputFigLines.push(outputFigText);\n        }\n        // remove hardblanks\n        if (opts.showHardBlanks !== true) {\n            outputFigLines.forEach(function(outputFigText) {\n                len = outputFigText.length;\n                for (row = 0; row < len; row++) {\n                    outputFigText[row] = outputFigText[row].replace(new RegExp(\"\\\\\"+opts.hardBlank,\"g\"),\" \");\n                }\n            });\n        }\n        return outputFigLines;\n    }\n\n    // -------------------------------------------------------------------------\n    // Parsing and Generation methods\n\n    var getHorizontalFittingRules = function(layout, options) {\n        var props = [\"hLayout\", \"hRule1\",\"hRule2\",\"hRule3\",\"hRule4\",\"hRule5\",\"hRule6\"],\n            params = {}, prop, ii;\n        if (layout === \"default\") {\n            for (ii = 0; ii < props.length; ii++) {\n                params[props[ii]] = options.fittingRules[props[ii]];\n            }\n        } else if (layout === \"full\") {\n            params = {\"hLayout\": FULL_WIDTH,\"hRule1\":false,\"hRule2\":false,\"hRule3\":false,\"hRule4\":false,\"hRule5\":false,\"hRule6\":false};\n        } else if (layout === \"fitted\") {\n            params = {\"hLayout\": FITTING,\"hRule1\":false,\"hRule2\":false,\"hRule3\":false,\"hRule4\":false,\"hRule5\":false,\"hRule6\":false};\n        } else if (layout === \"controlled smushing\") {\n            params = {\"hLayout\": CONTROLLED_SMUSHING,\"hRule1\":true,\"hRule2\":true,\"hRule3\":true,\"hRule4\":true,\"hRule5\":true,\"hRule6\":true};\n        } else if (layout === \"universal smushing\") {\n            params = {\"hLayout\": SMUSHING,\"hRule1\":false,\"hRule2\":false,\"hRule3\":false,\"hRule4\":false,\"hRule5\":false,\"hRule6\":false};\n        } else {\n            return;\n        }\n        return params;\n    };\n\n    var getVerticalFittingRules = function(layout, options) {\n        var props = [\"vLayout\", \"vRule1\",\"vRule2\",\"vRule3\",\"vRule4\",\"vRule5\"],\n            params = {}, prop, ii;\n        if (layout === \"default\") {\n            for (ii = 0; ii < props.length; ii++) {\n                params[props[ii]] = options.fittingRules[props[ii]];\n            }\n        } else if (layout === \"full\") {\n            params = {\"vLayout\": FULL_WIDTH,\"vRule1\":false,\"vRule2\":false,\"vRule3\":false,\"vRule4\":false,\"vRule5\":false};\n        } else if (layout === \"fitted\") {\n            params = {\"vLayout\": FITTING,\"vRule1\":false,\"vRule2\":false,\"vRule3\":false,\"vRule4\":false,\"vRule5\":false};\n        } else if (layout === \"controlled smushing\") {\n            params = {\"vLayout\": CONTROLLED_SMUSHING,\"vRule1\":true,\"vRule2\":true,\"vRule3\":true,\"vRule4\":true,\"vRule5\":true};\n        } else if (layout === \"universal smushing\") {\n            params = {\"vLayout\": SMUSHING,\"vRule1\":false,\"vRule2\":false,\"vRule3\":false,\"vRule4\":false,\"vRule5\":false};\n        } else {\n            return;\n        }\n        return params;\n    };\n    /*\n        Return max line of the ASCII Art\n        - text is array of lines for text\n        - char is next character\n     */\n    var figLinesWidth = function(textLines) {\n        return Math.max.apply(Math, textLines.map(function(line, i) {\n            return line.length;\n        }));\n    };\n\n    /*\n        Generates the ASCII Art\n        - fontName: Font to use\n        - option: Options to override the defaults\n        - txt: The text to make into ASCII Art\n    */\n    var generateText = function(fontName, options, txt) {\n        txt = txt.replace(/\\r\\n/g,\"\\n\").replace(/\\r/g,\"\\n\");\n        var lines = txt.split(\"\\n\");\n        var figLines = [];\n        var ii, len, output;\n        len = lines.length;\n        for (ii = 0; ii < len; ii++) {\n            figLines = figLines.concat( generateFigTextLines(lines[ii], figFonts[fontName], options) );\n        }\n        len = figLines.length;\n        output = figLines[0];\n        for (ii = 1; ii < len; ii++) {\n            output = smushVerticalFigLines(output, figLines[ii], options);\n        }\n\n        return output ? output.join(\"\\n\") : '';\n    };\n\n    // -------------------------------------------------------------------------\n    // Public methods\n\n    /*\n        A short-cut for the figlet.text method\n\n        Parameters:\n        - txt (string): The text to make into ASCII Art\n        - options (object/string - optional): Options that will override the current font's default options.\n          If a string is provided instead of an object, it is assumed to be the font name.\n\n            * font\n            * horizontalLayout\n            * verticalLayout\n            * showHardBlanks - Wont remove hardblank characters\n\n        - next (function): A callback function, it will contained the outputted ASCII Art.\n    */\n    var me = function(txt, options, next) {\n        me.text(txt, options, next);\n    };\n    me.text = function(txt, options, next) {\n        var fontName = '';\n\n        // Validate inputs\n        txt = txt + '';\n\n        if (typeof arguments[1] === 'function') {\n            next = options;\n            options = {};\n            options.font = figDefaults.font; // default font\n        }\n\n        if (typeof options === 'string') {\n            fontName = options;\n            options = {};\n        } else {\n            options = options || {};\n            fontName = options.font || figDefaults.font;\n        }\n\n        /*\n            Load the font. If it loads, it's data will be contained in the figFonts object.\n            The callback will recieve a fontsOpts object, which contains the default\n            options of the font (its fitting rules, etc etc).\n        */\n        me.loadFont(fontName, function(err, fontOpts) {\n            if (err) {\n                return next(err);\n            }\n\n            next(null, generateText(fontName, _reworkFontOpts(fontOpts, options), txt));\n        });\n    };\n\n    /*\n        Synchronous version of figlet.text.\n        Accepts the same parameters.\n     */\n    me.textSync = function(txt, options) {\n        var fontName = '';\n\n        // Validate inputs\n        txt = txt + '';\n\n        if (typeof options === 'string') {\n            fontName = options;\n            options = {};\n        } else {\n            options = options || {};\n            fontName = options.font || figDefaults.font;\n        }\n\n        var fontOpts = _reworkFontOpts(me.loadFontSync(fontName), options);\n        return generateText(fontName, fontOpts, txt);\n    };\n\n    /*\n      takes assigned options and merges them with the default options from the choosen font\n     */\n    function _reworkFontOpts(fontOpts, options) {\n        var myOpts = JSON.parse(JSON.stringify(fontOpts)), // make a copy because we may edit this (see below)\n            params,\n            prop;\n\n        /*\n         If the user is chosing to use a specific type of layout (e.g., 'full', 'fitted', etc etc)\n         Then we need to override the default font options.\n         */\n        if (typeof options.horizontalLayout !== 'undefined') {\n            params = getHorizontalFittingRules(options.horizontalLayout, fontOpts);\n            for (prop in params) {\n                myOpts.fittingRules[prop] = params[prop];\n            }\n        }\n        if (typeof options.verticalLayout !== 'undefined') {\n            params = getVerticalFittingRules(options.verticalLayout, fontOpts);\n            for (prop in params) {\n                myOpts.fittingRules[prop] = params[prop];\n            }\n        }\n        myOpts.printDirection = (typeof options.printDirection !== 'undefined') ? options.printDirection : fontOpts.printDirection;\n        myOpts.showHardBlanks = options.showHardBlanks || false;\n        myOpts.width = options.width || -1;\n        myOpts.whitespaceBreak = options.whitespaceBreak || false;\n\n        return myOpts;\n    }\n\n    /*\n        Returns metadata about a specfic FIGlet font.\n\n        Returns:\n            next(err, options, headerComment)\n            - err: The error if an error occurred, otherwise null/falsey.\n            - options (object): The options defined for the font.\n            - headerComment (string): The font's header comment.\n    */\n    me.metadata = function(fontName, next) {\n        fontName = fontName + '';\n\n        /*\n            Load the font. If it loads, it's data will be contained in the figFonts object.\n            The callback will recieve a fontsOpts object, which contains the default\n            options of the font (its fitting rules, etc etc).\n        */\n        me.loadFont(fontName, function(err, fontOpts) {\n            if (err) {\n                next(err);\n                return;\n            }\n\n            next(null, fontOpts, figFonts[fontName].comment);\n        });\n    };\n\n    /*\n        Allows you to override defaults. See the definition of the figDefaults object up above\n        to see what properties can be overridden.\n        Returns the options for the font.\n    */\n    me.defaults = function(opts) {\n        if (typeof opts === 'object' && opts !== null) {\n            for (var prop in opts) {\n                if (opts.hasOwnProperty(prop)) {\n                    figDefaults[prop] = opts[prop];\n                }\n            }\n        }\n        return JSON.parse(JSON.stringify(figDefaults));\n    };\n\n    /*\n        Parses data from a FIGlet font file and places it into the figFonts object.\n    */\n    me.parseFont = function(fontName, data) {\n        data = data.replace(/\\r\\n/g,\"\\n\").replace(/\\r/g,\"\\n\");\n        figFonts[fontName] = {};\n\n        var lines = data.split(\"\\n\");\n        var headerData = lines.splice(0,1)[0].split(\" \");\n        var figFont = figFonts[fontName];\n        var opts = {};\n\n        opts.hardBlank = headerData[0].substr(5,1);\n        opts.height = parseInt(headerData[1], 10);\n        opts.baseline = parseInt(headerData[2], 10);\n        opts.maxLength = parseInt(headerData[3], 10);\n        opts.oldLayout = parseInt(headerData[4], 10);\n        opts.numCommentLines = parseInt(headerData[5], 10);\n        opts.printDirection = (headerData.length >= 6) ? parseInt(headerData[6], 10) : 0;\n        opts.fullLayout = (headerData.length >= 7) ? parseInt(headerData[7], 10) : null;\n        opts.codeTagCount = (headerData.length >= 8) ? parseInt(headerData[8], 10) : null;\n        opts.fittingRules = getSmushingRules(opts.oldLayout, opts.fullLayout);\n\n        figFont.options = opts;\n\n        // error check\n        if (opts.hardBlank.length !== 1 ||\n            isNaN(opts.height) ||\n            isNaN(opts.baseline) ||\n            isNaN(opts.maxLength) ||\n            isNaN(opts.oldLayout) ||\n            isNaN(opts.numCommentLines) )\n        {\n            throw new Error('FIGlet header contains invalid values.');\n        }\n\n        /*\n            All FIGlet fonts must contain chars 32-126, 196, 214, 220, 228, 246, 252, 223\n        */\n\n        var charNums = [], ii;\n        for (ii = 32; ii <= 126; ii++) {\n            charNums.push(ii);\n        }\n        charNums = charNums.concat(196, 214, 220, 228, 246, 252, 223);\n\n        // error check - validate that there are enough lines in the file\n        if (lines.length < (opts.numCommentLines + (opts.height * charNums.length)) ) {\n            throw new Error('FIGlet file is missing data.');\n        }\n\n        /*\n            Parse out the context of the file and put it into our figFont object\n        */\n\n        var cNum, endCharRegEx, parseError = false;\n\n        figFont.comment = lines.splice(0,opts.numCommentLines).join(\"\\n\");\n        figFont.numChars = 0;\n\n        while (lines.length > 0 && figFont.numChars < charNums.length) {\n            cNum = charNums[figFont.numChars];\n            figFont[cNum] = lines.splice(0,opts.height);\n            // remove end sub-chars\n            for (ii = 0; ii < opts.height; ii++) {\n                if (typeof figFont[cNum][ii] === \"undefined\") {\n                    figFont[cNum][ii] = \"\";\n                } else {\n                    endCharRegEx = new RegExp(\"\\\\\"+figFont[cNum][ii].substr(figFont[cNum][ii].length-1,1)+\"+$\");\n                    figFont[cNum][ii] = figFont[cNum][ii].replace(endCharRegEx,\"\");\n                }\n            }\n            figFont.numChars++;\n        }\n\n        /*\n            Now we check to see if any additional characters are present\n        */\n\n        while (lines.length > 0) {\n            cNum = lines.splice(0,1)[0].split(\" \")[0];\n            if ( /^0[xX][0-9a-fA-F]+$/.test(cNum) ) {\n                cNum = parseInt(cNum, 16);\n            } else if ( /^0[0-7]+$/.test(cNum) ) {\n                cNum = parseInt(cNum, 8);\n            } else if ( /^[0-9]+$/.test(cNum) ) {\n                cNum = parseInt(cNum, 10);\n            } else if ( /^-0[xX][0-9a-fA-F]+$/.test(cNum) ) {\n                cNum = parseInt(cNum, 16);\n            } else {\n                if (cNum === \"\") {break;}\n                // something's wrong\n                console.log(\"Invalid data:\"+cNum);\n                parseError = true;\n                break;\n            }\n\n            figFont[cNum] = lines.splice(0,opts.height);\n            // remove end sub-chars\n            for (ii = 0; ii < opts.height; ii++) {\n                if (typeof figFont[cNum][ii] === \"undefined\") {\n                    figFont[cNum][ii] = \"\";\n                } else {\n                    endCharRegEx = new RegExp(\"\\\\\"+figFont[cNum][ii].substr(figFont[cNum][ii].length-1,1)+\"+$\");\n                    figFont[cNum][ii] = figFont[cNum][ii].replace(endCharRegEx,\"\");\n                }\n            }\n            figFont.numChars++;\n        }\n\n        // error check\n        if (parseError === true) {\n            throw new Error('Error parsing data.');\n        }\n\n        return opts;\n    };\n\n    /*\n        Loads a font.\n    */\n    me.loadFont = function(fontName, next) {\n        if (figFonts[fontName]) {\n            next(null, figFonts[fontName].options);\n            return;\n        }\n\n        if (typeof fetch !== 'function') {\n          console.error('figlet.js requires the fetch API or a fetch polyfill such as https://cdnjs.com/libraries/fetch');\n          throw new Error('fetch is required for figlet.js to work.')\n        }\n\n        fetch(figDefaults.fontPath + '/' + fontName + '.flf')\n            .then(function(response) {\n                if(response.ok) {\n                    return response.text();\n                }\n\n                console.log('Unexpected response', response);\n                throw new Error('Network response was not ok.');\n            })\n            .then(function(text) {\n                next(null, me.parseFont(fontName, text));\n            })\n            .catch(next);\n    };\n\n    /*\n        loads a font synchronously, not implemented for the browser\n     */\n    me.loadFontSync = function(name) {\n        if (figFonts[name]) {\n          return figFonts[name].options;\n        }\n        throw new Error('synchronous font loading is not implemented for the browser');\n    };\n\n    /*\n        preloads a list of fonts prior to using textSync\n        - fonts: an array of font names (i.e. [\"Standard\",\"Soft\"])\n        - next: callback function\n     */\n    me.preloadFonts = function(fonts, next) {\n        var fontData = [];\n\n        fonts.reduce(function(promise, name){\n            return promise.then(function() {\n                return fetch(figDefaults.fontPath + '/' + name + '.flf').then((response) => {\n                    return response.text();\n                }).then(function(data) {\n                    fontData.push(data);\n                });\n            });\n        }, Promise.resolve()).then(function(res){\n            for(var i in fonts){\n                me.parseFont(fonts[i], fontData[i]);\n            }\n\n            if(next)next();\n        });\n    };\n\n    me.figFonts = figFonts;\n\n    return me;\n})();\n\n// for node.js\nif (typeof module !== 'undefined') {\n    if (typeof module.exports !== 'undefined') {\n        module.exports = figlet;\n    }\n}\n"]}