<repo_name>panoply/prettydiff<file_sep>/tests/browser-demo.js
import "../js/browser.js";
(function () {
    let button = document.getElementsByTagName("button")[0],
        execute = function () {
            let prettydiff = window.prettydiff,
                options = prettydiff.options,
                output = "";
            options.api = "dom";
            options.language = "auto";
            options.lexer = "script";
            options.mode = "beautify";
            options.source = document.getElementById("input").value;
            output = prettydiff(options);
            document.getElementById("output").value = output;
        };
    button.onclick = execute;
}());<file_sep>/index.d.ts
declare var ace: any;
declare var options: any;
declare var prettydiff: pd;
declare module NodeJS {
    interface Global {
        sparser: any;
        prettydiff: any
    }
}
type api = "any" | "dom" | "node";
type codes = [string, number, number, number, number];
type languageAuto = [string, string, string];
type lexer = "any" | "markup" | "script" | "style";
type mode = "beautify" | "diff" | "minify" | "parse";
type qualifier = "begins" | "contains" | "ends" | "file begins" | "file contains" | "file ends" | "file is" | "file not" | "file not contains" | "filesystem contains" | "filesystem not contains" | "is" | "not" | "not contains";
interface commandList {
    [key: string]: {
        description: string;
        example: {
            code: string;
            defined: string;
        }[];
    }
}
interface compareStore extends Array<[number, number]>{
    [index:number]: [number, number];
}
interface data {
    begin: number[];
    ender: number[];
    lexer: string[];
    lines: number[];
    stack: string[];
    token: string[];
    types: string[];
}
interface diffJSON extends Array<["+"|"-"|"=", string]|["r", string, string]> {
    [index:number]: ["+"|"-"|"=", string]|["r", string, string];
}
interface diffmeta {
    differences: number;
    lines: number;
}
interface diffStatus {
    diff: boolean;
    source: boolean;
}
interface difftable {
    [key: string]: [number, number];
}
interface diffview {
    (): [string, number, number]
}
interface dom {
    [key: string]: any;
}
interface domMethods {
    app: {
        [key: string]: any;
    };
    event: {
        [key: string]: any;
    };
}
interface externalIndex {
    [key: string]: number;
}
interface finalFile {
    css: {
        color: {
            canvas: string;
            shadow: string;
            white: string;
        };
        global: string;
        reports: string;
    };
    html: {
        body: string;
        color: string;
        head: string;
        htmlEnd: string;
        intro: string;
        scriptEnd: string;
        scriptStart: string;
    };
    order: string[];
    script: {
        beautify: string;
        diff: string;
        minimal: string;
    };
}
interface language {
    auto(sample:string, defaultLang:string): languageAuto;
    nameproper(input:string): string;
    setlexer(input:string):string;
}
interface library {
    (): string;
}
interface meta {
    error: string;
    lang: [string, string, string];
    time: string;
    insize: number;
    outsize: number;
    difftotal: number;
    difflines: number;
}
interface modifyOps {
    end: string;
    injectFlag: string;
    start: string;
}
interface nodeCopyParams {
    callback:Function;
    destination:string;
    exclusions:string[];
    target:string;
}
interface nodeError extends Error {
    code: string;
}
interface nodeFileProps {
    atime: number;
    mode: number;
    mtime: number;
}
interface nodeLists {
    emptyline: boolean;
    heading: string;
    obj: any;
    property: "eachkey" | string;
    total: boolean;
}
interface opcodes extends Array<codes> {
    [index: number]: codes;
}
interface option {
    api: api;
    default: boolean | number | string;
    definition: string;
    label: string;
    lexer: lexer;
    mode: "any" | mode;
    type: "boolean" | "number" | "string";
    values?: {
        [key: string]: string;
    }
}
interface optionDef {
    [key:string]: option;
}
interface optionFunctions {
    definitions?: {};
}
interface perform {
    codeLength: number;
    diff: string;
    end: [number, number];
    index: number;
    source: string;
    start: [number, number];
    store: number[];
    test: boolean;
}
interface pd {
    (meta?): string;
    api: any;
    beautify: any;
    end: number;
    iterator: number;
    meta: meta;
    minify: any;
    options: any,
    saveAs?: Function;
    scopes: scriptScopes;
    sparser: any;
    start: number;
    version: version;
}
interface readDirectory {
    callback: Function;
    exclusions: string[];
    path: string;
    recursive: boolean;
    symbolic: boolean;
}
interface record {
    begin: number;
    ender: number;
    lexer: string;
    lines: number;
    stack: string;
    token: string;
    types: string;
}
interface scriptScopes extends Array<[string, number]>{
    [index:number]: [string, number];
}
interface simulationItem {
    artifact?: string;
    command: string;
    file?: string;
    qualifier: qualifier;
    test: string;
}
interface version {
    date: string;
    number: string;
    parse: string;
}
interface Window {
    sparser: any;
}<file_sep>/minify/script.ts
/*global prettydiff*/
(function minify_script_init():void {
    "use strict";
    const script = function minify_script(options:any):string {
        (function minify_script_options() {
            if (options.language === "json") {
                options.wrap = 0;
            } else if (options.language === "titanium") {
                options.correct = false;
            }
        }());
        const data:data = options.parsed,
            lf:"\r\n"|"\n"      = (options.crlf === true)
                ? "\r\n"
                : "\n",
            lexer:string = "script",
            invisibles:string[] = ["x;", "x}", "x{", "x(", "x)"],
            end:number  = (prettydiff.end < 1 || prettydiff.end > data.token.length)
                ? data.token.length
                : prettydiff.end + 1,
            build:string[]    = [],
            lastsemi = function minify_script_lastsemi() {
                let aa:number = a,
                    bb:number = 0;
                do {
                    if (data.types[aa] === "end") {
                        bb = bb + 1;
                    } else if (data.types[aa] === "start") {
                        bb = bb - 1;
                    }
                    if (bb < 0) {
                        if (data.token[aa - 1] === "for") {
                            build.push(";");
                            count = count + 1;
                        }
                        return;
                    }
                    aa = aa - 1;
                } while (aa > -1);
            };
        let a:number        = prettydiff.start,
            count:number    = 0,
            external:string = "";
        if (options.top_comments === true && options.minify_keep_comments === false && data.types[a] === "comment" && prettydiff.start === 0) {
            if (a > 0) {
                build.push(lf);
            }
            do {
                build.push(data.token[a]);
                build.push(lf);
                a = a + 1;
            } while (a < end && data.types[a] === "comment");
        }
        do {
            if (data.lexer[a] === lexer || prettydiff.minify[data.lexer[a]] === undefined) {
                if (data.types[a] === "comment" && options.minify_keep_comments === true) {
                    if (data.types[a - 1] !== "comment" && a > 0) {
                        build.push(lf);
                        build.push(lf);
                    }
                    build.push(data.token[a]);
                    if (data.types[a + 1] !== "comment") {
                        build.push(lf);
                    }
                    build.push(lf);
                } else if (data.types[a] !== "comment") {
                    if (data.types[a - 1] === "operator" && data.types[a] === "operator" && data.token[a] !== "!") {
                        build.push(" ");
                        count = count + 1;
                    }
                    if ((data.types[a] === "word" || data.types[a] === "references") && (
                        data.types[a + 1] === "word" ||
                        data.types[a + 1] === "reference" ||
                        data.types[a + 1] === "literal" ||
                        data.types[a + 1] === "number" ||
                        data.token[a + 1] === "x{"
                    )) {
                        if (
                            data.types[a - 1] === "literal" &&
                            data.token[a - 1].charAt(0) !== "\"" &&
                            data.token[a - 1].charAt(0) !== "'"
                        ) {
                            build.push(" ");
                            count = count + 1;
                        }
                        build.push(data.token[a]);
                        build.push(" ");
                        count = count + data.token[a].length + 1;
                    } else if (data.token[a] === "x;" && data.token[a + 1] !== "}") {
                        build.push(";");
                        count = count + 1;
                    } else if (data.token[a] === ";" && data.token[a + 1] === "}") {
                        lastsemi();
                    } else if (invisibles.indexOf(data.token[a]) < 0) {
                        build.push(data.token[a]);
                        count = count + data.token[a].length;
                    }
                }
                if (a < end - 1 && count + data.token[a + 1].length > options.wrap && options.wrap > 0 && options.minify_wrap === true) {
                    if (build[build.length - 1] === " ") {
                        build.pop();
                    }
                    if (data.token[a + 1] === ";") {
                        build.pop();
                        build.push(lf);
                        build.push(data.token[a]);
                    } else {
                        build.push(lf);
                    }
                    count = 0;
                }
            } else {
                let skip:number = a,
                    quit:boolean = false;
                do {
                    if (data.lexer[a + 1] === lexer && data.begin[a + 1] < skip) {
                        break;
                    }
                    if (data.token[skip - 1] === "return" && data.types[a] === "end" && data.begin[a] === skip) {
                        break;
                    }
                    a = a + 1;
                } while (a < end);
                prettydiff.start = skip;
                prettydiff.end = a;
                if (a > end - 1) {
                    a = skip;
                    quit = true;
                    prettydiff.end = end - 2;
                }
                external = prettydiff.minify[data.lexer[a]](options).replace(/\s+$/, "");
                if (options.wrap > 0 && options.minify_wrap === true && data.token[skip - 1] !== "return") {
                    build.push(lf);
                }
                build.push(external);
                if (quit === true) {
                    break;
                }
                if (options.wrap > 0 && options.minify_wrap === true) {
                    build.push(lf);
                    count = 0;
                }
            }
            a = a + 1;
        } while (a < end);
        prettydiff.iterator = end - 1;
        if (options.new_line === true && a === data.token.length && build[build.length - 1].indexOf(lf) < 0) {
            build.push(lf);
        }
        return build.join("");
    };
    global.prettydiff.minify.script = script;
}());<file_sep>/options.md
# Pretty Diff Options

## attribute_sort
property | value
-----------|---
api        | any
default    | false
definition | Alphanumerically sort markup attributes. Attribute sorting is ignored on tags that contain attributes template attributes.
label      | Sort Attributes
lexer      | markup
mode       | any
type       | boolean

## attribute_sort_list
property | value
-----------|---
api        | any
default    | 
definition | A comma separated list of attribute names. Attributes will be sorted according to this list and then alphanumerically. This option requires 'attribute_sort' have a value of true.
label      | Sort Attribute List
lexer      | markup
mode       | any
type       | string

## brace_line
property | value
-----------|---
api        | any
default    | false
definition | If true an empty line will be inserted after opening curly braces and before closing curly braces.
label      | Brace Lines
lexer      | script
mode       | beautify
type       | boolean

## brace_padding
property | value
-----------|---
api        | any
default    | false
definition | Inserts a space after the start of a container and before the end of the container if the contents of that container are not indented; such as: conditions, function arguments, and escaped sequences of template strings.
label      | Brace Padding
lexer      | script
mode       | beautify
type       | boolean

## brace_style
property | value
-----------|---
api        | any
default    | none
definition | Emulates JSBeautify's brace_style option using existing Pretty Diff options.
label      | Brace Style
lexer      | script
mode       | beautify
type       | string
values | collapse, collapse-preserve-inline, expand, none

### Value Definitions
* **collapse** - Sets options.format_object to 'indent' and options.neverflatten to true.
* **collapse-preserve-inline** - Sets options.bracepadding to true and options.format_object to 'inline'.
* **expand** - Sets options.braces to true, options.format_object to 'indent', and options.neverflatten to true.
* **none** - Ignores this option

## braces
property | value
-----------|---
api        | any
default    | false
definition | Determines if opening curly braces will exist on the same line as their condition or be forced onto a new line. (Allman style indentation).
label      | Style of Indent
lexer      | script
mode       | beautify
type       | boolean

## case_space
property | value
-----------|---
api        | any
default    | false
definition | If the colon separating a case's expression (of a switch/case block) from its statement should be followed by a space instead of indentation, thereby keeping the case on a single line of code.
label      | Space Following Case
lexer      | script
mode       | beautify
type       | boolean

## color
property | value
-----------|---
api        | any
default    | white
definition | The color scheme of the reports.
label      | Color
lexer      | any
mode       | any
type       | string
values | canvas, shadow, white

### Value Definitions
* **canvas** - A light brown color scheme
* **shadow** - A black and ashen color scheme
* **white** - A white and pale grey color scheme

## comment_line
property | value
-----------|---
api        | any
default    | false
definition | If a blank new line should be forced above comments.
label      | Force an Empty Line Above Comments
lexer      | markup
mode       | beautify
type       | boolean

## comments
property | value
-----------|---
api        | any
default    | false
definition | This will determine whether comments should always start at position 0 of each line or if comments should be indented according to the code.
label      | Indent Comments
lexer      | any
mode       | beautify
type       | boolean

## complete_document
property | value
-----------|---
api        | any
default    | false
definition | Allows a preference for generating a complete HTML document instead of only generating content.
label      | Generate A Complete HTML File
lexer      | markup
mode       | any
type       | boolean

## compressed_css
property | value
-----------|---
api        | any
default    | false
definition | If CSS should be beautified in a style where the properties and values are minifed for faster reading of selectors.
label      | Compressed CSS
lexer      | style
mode       | beautify
type       | boolean

## conditional
property | value
-----------|---
api        | any
default    | false
definition | If true then conditional comments used by Internet Explorer are preserved at minification of markup.
label      | IE Comments (HTML Only)
lexer      | markup
mode       | minify
type       | boolean

## config
property | value
-----------|---
api        | node
default    | 
definition | By default Pretty Diff will look into the directory structure contain the value of option 'source' for a file named `.prettydiffrc` for saved option settings. This option allows a user to specify any file at any location in the local file system for configuration settings. A value of 'none' tells the application to bypass reading any configuration file.
label      | Custom Config File Location
lexer      | any
mode       | any
type       | string

## content
property | value
-----------|---
api        | any
default    | false
definition | This will normalize all string content to 'text' so as to eliminate some differences from the output.
label      | Ignore Content
lexer      | any
mode       | diff
type       | boolean

## correct
property | value
-----------|---
api        | any
default    | false
definition | Automatically correct some sloppiness in code.
label      | Fix Sloppy Code
lexer      | any
mode       | any
type       | boolean

## crlf
property | value
-----------|---
api        | any
default    | false
definition | If line termination should be Windows (CRLF) format.  Unix (LF) format is the default.
label      | Line Termination
lexer      | any
mode       | any
type       | boolean

## css_insert_lines
property | value
-----------|---
api        | any
default    | false
definition | Inserts new line characters between every CSS code block.
label      | Insert Empty Lines
lexer      | style
mode       | beautify
type       | boolean

## diff
property | value
-----------|---
api        | any
default    | 
definition | The code sample to be compared to 'source' option.  This is required if mode is 'diff'.
label      | Code to Compare
lexer      | any
mode       | diff
type       | string

## diff_comments
property | value
-----------|---
api        | any
default    | false
definition | If true then comments will be preserved so that both code and comments are compared by the diff engine.
label      | Code Comments
lexer      | any
mode       | diff
type       | boolean

## diff_context
property | value
-----------|---
api        | any
default    | -1
definition | This shortens the diff output by allowing a specified number of equivalent lines between each line of difference.  This option is only used with diff_format:html.
label      | Context Size
lexer      | any
mode       | diff
type       | number

## diff_format
property | value
-----------|---
api        | any
default    | text
definition | The format of the output.  The command line output format is text, similar to Unix 'diff'.
label      | Diff Format
lexer      | any
mode       | diff
type       | string
values | html, json, text

### Value Definitions
* **html** - An HTML format for embedding in web pages, or as a complete web page if document_complete is true.
* **json** - A JSON format.
* **text** - Formatted similar to the Unix 'diff' command line utility.

## diff_label
property | value
-----------|---
api        | any
default    | New Sample
definition | This allows for a descriptive label for the diff file code of the diff HTML output.
label      | Label for Diff Sample
lexer      | any
mode       | diff
type       | string

## diff_rendered_html
property | value
-----------|---
api        | any
default    | false
definition | Compares complete HTML documents and injects custom CSS so that the differences display not in the code, but in the rendered page in a browser.  This option is currently confined only to markup languages, read_method file, and mode diff.  Option diff_format is ignored.
label      | Compare Rendered HTML
lexer      | markup
mode       | diff
type       | boolean

## diff_space_ignore
property | value
-----------|---
api        | any
default    | false
definition | If white space only differences should be ignored by the diff tool.
label      | Remove White Space
lexer      | any
mode       | diff
type       | boolean

## diff_view
property | value
-----------|---
api        | any
default    | sidebyside
definition | This determines whether the diff HTML output should display as a side-by-side comparison or if the differences should display in a single table column.
label      | Diff View Type
lexer      | any
mode       | diff
type       | string
values | inline, sidebyside

### Value Definitions
* **inline** - A single column where insertions and deletions are vertically adjacent.
* **sidebyside** - Two column comparison of changes.

## else_line
property | value
-----------|---
api        | any
default    | false
definition | If else_line is true then the keyword 'else' is forced onto a new line.
label      | Else On New Line
lexer      | script
mode       | beautify
type       | boolean

## end_comma
property | value
-----------|---
api        | any
default    | never
definition | If there should be a trailing comma in arrays and objects. Value "multiline" only applies to modes beautify and diff.
label      | Trailing Comma
lexer      | script
mode       | beautify
type       | string
values | always, never, none

### Value Definitions
* **always** - Always ensure there is a tailing comma
* **never** - Remove trailing commas
* **none** - Ignore this option

## end_quietly
property | value
-----------|---
api        | node
default    | default
definition | A node only option to determine if terminal summary data should be logged to the console.
label      | Log Summary to Console
lexer      | any
mode       | any
type       | string
values | default, log, quiet

### Value Definitions
* **default** - Default minimal summary
* **log** - Verbose logging
* **quiet** - No extraneous logging

## force_attribute
property | value
-----------|---
api        | any
default    | false
definition | If all markup attributes should be indented each onto their own line.
label      | Force Indentation of All Attributes
lexer      | markup
mode       | beautify
type       | boolean

## force_indent
property | value
-----------|---
api        | any
default    | false
definition | Will force indentation upon all content and tags without regard for the creation of new text nodes.
label      | Force Indentation of All Content
lexer      | markup
mode       | beautify
type       | boolean

## format_array
property | value
-----------|---
api        | any
default    | default
definition | Determines if all array indexes should be indented, never indented, or left to the default.
label      | Formatting Arrays
lexer      | script
mode       | beautify
type       | string
values | default, indent, inline

### Value Definitions
* **default** - Default formatting
* **indent** - Always indent each index of an array
* **inline** - Ensure all array indexes appear on a single line

## format_object
property | value
-----------|---
api        | any
default    | default
definition | Determines if all object keys should be indented, never indented, or left to the default.
label      | Formatting Objects
lexer      | script
mode       | beautify
type       | string
values | default, indent, inline

### Value Definitions
* **default** - Default formatting
* **indent** - Always indent each key/value pair
* **inline** - Ensure all key/value pairs appear on the same single line

## function_name
property | value
-----------|---
api        | any
default    | false
definition | If a space should follow a JavaScript function name.
label      | Space After Function Name
lexer      | script
mode       | beautify
type       | boolean

## help
property | value
-----------|---
api        | node
default    | 80
definition | A node only option to print documentation to the console. The value determines where to wrap text.
label      | Help Wrapping Limit
lexer      | any
mode       | any
type       | number

## indent_char
property | value
-----------|---
api        | any
default    |  
definition | The string characters to comprise a single indentation. Any string combination is accepted.
label      | Indentation Characters
lexer      | any
mode       | beautify
type       | string

## indent_level
property | value
-----------|---
api        | any
default    | 0
definition | How much indentation padding should be applied to beautification? This option is internally used for code that requires switching between libraries.
label      | Indentation Padding
lexer      | any
mode       | beautify
type       | number

## indent_size
property | value
-----------|---
api        | any
default    | 4
definition | The number of 'indent_char' values to comprise a single indentation.
label      | Indent Size
lexer      | any
mode       | beautify
type       | number

## jsscope
property | value
-----------|---
api        | any
default    | none
definition | An educational tool to generate HTML output of JavaScript code to identify scope regions and declared references by color.  This option is ignored unless the code language is JavaScript or TypeScript.
label      | JavaScript Scope Identification
lexer      | script
mode       | beautify
type       | string
values | html, none, report

### Value Definitions
* **html** - generates HTML output with escaped angle braces and ampersands for embedding as code, which is handy in code producing tools
* **none** - prevents use of this option
* **report** - generates HTML output that renders in web browsers

## language
property | value
-----------|---
api        | any
default    | auto
definition | The lowercase single word common name of the source code's programming language. The value 'auto' imposes language and lexer auto-detection, which ignores deliberately specified lexer values. The value 'text' is converted to 'auto' if options 'mode' is not 'diff'. Value 'text' allows literal comparisons.
label      | Language
lexer      | any
mode       | any
type       | string

## language_default
property | value
-----------|---
api        | any
default    | text
definition | The fallback option if option 'lang' is set to 'auto' and a language cannot be detected.
label      | Language Auto-Detection Default
lexer      | any
mode       | any
type       | string

## language_name
property | value
-----------|---
api        | any
default    | JavaScript
definition | The formatted proper name of the code sample's language for use in reports read by people.
label      | Formatted Name of the Code's Language
lexer      | any
mode       | any
type       | string

## lexer
property | value
-----------|---
api        | any
default    | auto
definition | This option determines which sets of rules to use in the language parser. If option 'language' has a value of 'auto', which is the default value, this option is ignored. The value 'text' is converted to 'auto' if options 'mode' is not 'diff'. Value 'text' allows literal comparisons.
label      | Parsing Lexer
lexer      | any
mode       | any
type       | string
values | auto, markup, script, style

### Value Definitions
* **auto** - The value 'auto' imposes language and lexer auto-detection, which ignores deliberately specified language values.
* **markup** - parses languages like XML and HTML
* **script** - parses languages with a C style syntax, such as JavaScript
* **style** - parses CSS like languages

## list_options
property | value
-----------|---
api        | node
default    | false
definition | A Node.js only option that writes current option settings to the console.
label      | Options List
lexer      | any
mode       | any
type       | boolean

## method_chain
property | value
-----------|---
api        | any
default    | 3
definition | When to break consecutively chained methods and properties onto separate lines. A negative value disables this option. A value of 0 ensures method chains are never broken.
label      | Method Chains
lexer      | script
mode       | beautify
type       | number

## minify_keep_comments
property | value
-----------|---
api        | any
default    | false
definition | Prevents minification from stripping out comments.
label      | Keep Comments
lexer      | any
mode       | minify
type       | boolean

## minify_wrap
property | value
-----------|---
api        | any
default    | false
definition | Whether minified script should wrap after a specified character width.  This option requires a value from option 'wrap'.
label      | Minification Wrapping
lexer      | script
mode       | minify
type       | boolean

## mode
property | value
-----------|---
api        | any
default    | diff
definition | The operation to be performed.
label      | Mode
lexer      | any
mode       | any
type       | string
values | beautify, diff, minify, parse

### Value Definitions
* **beautify** - beautifies code and returns a string
* **diff** - returns either command line list of differences or an HTML report
* **minify** - minifies code and returns a string
* **parse** - using option 'parseFormat' returns an object with shallow arrays, a multidimensional array, or an HTML report

## never_flatten
property | value
-----------|---
api        | any
default    | false
definition | If destructured lists in script should never be flattend.
label      | Never Flatten Destructured Lists
lexer      | script
mode       | beautify
type       | boolean

## new_line
property | value
-----------|---
api        | any
default    | false
definition | Insert an empty line at the end of output.
label      | New Line at End of Code
lexer      | any
mode       | any
type       | boolean

## no_case_indent
property | value
-----------|---
api        | any
default    | false
definition | If a case statement should receive the same indentation as the containing switch block.
label      | Case Indentation
lexer      | script
mode       | beautify
type       | boolean

## no_lead_zero
property | value
-----------|---
api        | any
default    | false
definition | Whether leading 0s in CSS values immediately preceding a decimal should be removed or prevented.
label      | Leading 0s
lexer      | style
mode       | any
type       | boolean

## no_semicolon
property | value
-----------|---
api        | any
default    | false
definition | Removes semicolons that would be inserted by ASI. This option is in conflict with option 'correct' and takes precedence over conflicting features. Use of this option is a possible security/stability risk.
label      | No Semicolons
lexer      | script
mode       | beautify
type       | boolean

## node_error
property | value
-----------|---
api        | node
default    | false
definition | A Node.js only option if parse errors should be written to the console.
label      | Write Parse Errors in Node
lexer      | any
mode       | any
type       | boolean

## object_sort
property | value
-----------|---
api        | any
default    | false
definition | Sorts markup attributes and properties by key name in script and style.
label      | Object/Attribute Sort
lexer      | any
mode       | beautify
type       | boolean

## output
property | value
-----------|---
api        | node
default    | 
definition | A file path for which to write output. If this option is not specified output will be printed to the shell.
label      | Output Location
lexer      | any
mode       | any
type       | string

## parse_format
property | value
-----------|---
api        | any
default    | parallel
definition | Determines the output format for 'parse' mode.
label      | Parse Format
lexer      | any
mode       | parse
type       | string
values | htmltable, parallel, sequential, table

### Value Definitions
* **htmltable** - generates the 'table' type output for the DOM but escapes the HTML tags for rendering as HTML code in a HTML tool
* **parallel** - returns an object containing series of parallel arrays
* **sequential** - returns an array where each index is a child object containing the parsed token and all descriptive data
* **table** - generates a colorful grid of output for either the dom or command line interface

## parse_space
property | value
-----------|---
api        | any
default    | false
definition | Whether whitespace tokens should be included in markup parse output.
label      | Retain White Space Tokens in Parse Output
lexer      | markup
mode       | parse
type       | boolean

## preserve
property | value
-----------|---
api        | any
default    | 0
definition | The maximum number of consecutive empty lines to retain.
label      | Preserve Consecutive New Lines
lexer      | any
mode       | beautify
type       | number

## preserve_comment
property | value
-----------|---
api        | any
default    | false
definition | Prevent comment reformatting due to option wrap.
label      | Eliminate Word Wrap Upon Comments
lexer      | any
mode       | beautify
type       | boolean

## preserve_text
property | value
-----------|---
api        | any
default    | false
definition | If text in the provided markup code should be preserved exactly as provided. This option eliminates beautification and wrapping of text content.
label      | Preserve Markup Text White Space
lexer      | markup
mode       | any
type       | boolean

## quote
property | value
-----------|---
api        | any
default    | false
definition | If true and mode is 'diff' then all single quote characters will be replaced by double quote characters in both the source and diff file input so as to eliminate some differences from the diff report HTML output.
label      | Normalize Quotes
lexer      | any
mode       | diff
type       | boolean

## quote_convert
property | value
-----------|---
api        | any
default    | none
definition | If the quotes of script strings or markup attributes should be converted to single quotes or double quotes.
label      | Indent Size
lexer      | any
mode       | any
type       | string
values | double, none, single

### Value Definitions
* **double** - Converts single quotes to double quotes
* **none** - Ignores this option
* **single** - Converts double quotes to single quotes

## read_method
property | value
-----------|---
api        | node
default    | auto
definition | The option determines how Node.js should receive input.  All output will be printed to the shell unless the option 'output' is specified, which will write output to a file.
label      | Read Method
lexer      | any
mode       | any
type       | string
values | auto, directory, file, screen, subdirectory

### Value Definitions
* **auto** - changes to value subdirectory, file, or screen depending on source resolution
* **directory** - process all files in the specified directory only
* **file** - reads a file and outputs to a file.  file requires option 'output'
* **screen** - reads from screen and outputs to screen
* **subdirectory** - process all files in a directory and its subdirectories

## selector_list
property | value
-----------|---
api        | any
default    | false
definition | If comma separated CSS selectors should present on a single line of code.
label      | Indent Size
lexer      | style
mode       | beautify
type       | boolean

## semicolon
property | value
-----------|---
api        | any
default    | false
definition | If true and mode is 'diff' and lang is 'javascript' all semicolon characters that immediately precede any white space containing a new line character will be removed so as to eliminate some differences from the code comparison.
label      | Indent Size
lexer      | script
mode       | diff
type       | boolean

## source
property | value
-----------|---
api        | any
default    | 
definition | The source code or location for interpretation. This option is required for all modes.
label      | Source Sample
lexer      | any
mode       | any
type       | string

## source_label
property | value
-----------|---
api        | any
default    | Source Sample
definition | This allows for a descriptive label of the source file code for the diff HTML output.
label      | Label for Source Sample
lexer      | any
mode       | diff
type       | string

## space
property | value
-----------|---
api        | any
default    | true
definition | Inserts a space following the function keyword for anonymous functions.
label      | Function Space
lexer      | script
mode       | beautify
type       | boolean

## space_close
property | value
-----------|---
api        | any
default    | false
definition | Markup self-closing tags end will end with ' />' instead of '/>'.
label      | Close Markup Self-Closing Tags with a Space
lexer      | markup
mode       | beautify
type       | boolean

## styleguide
property | value
-----------|---
api        | any
default    | none
definition | Provides a collection of option presets to easily conform to popular JavaScript style guides.
label      | Script Styleguide
lexer      | script
mode       | beautify
type       | string
values | airbnb, crockford, google, jquery, jslint, mediawiki, mrdoob, none, semistandard, standard, yandex

### Value Definitions
* **airbnb** - https://github.com/airbnb/javascript
* **crockford** - http://jslint.com/
* **google** - https://google.github.io/styleguide/jsguide.html
* **jquery** - https://contribute.jquery.org/style-guide/js/
* **jslint** - http://jslint.com/
* **mediawiki** - https://www.mediawiki.org/wiki/Manual:Coding_conventions/JavaScript
* **mrdoob** - https://github.com/mrdoob/three.js/wiki/Mr.doob's-Code-Style%E2%84%A2
* **none** - Ignores this option
* **semistandard** - https://github.com/Flet/semistandard
* **standard** - https://standardjs.com/
* **yandex** - https://github.com/ymaps/codestyle/blob/master/javascript.md

## summary_only
property | value
-----------|---
api        | node
default    | false
definition | Node only option to output only number of differences.
label      | Output Diff Only Without A Summary
lexer      | any
mode       | diff
type       | boolean

## tag_merge
property | value
-----------|---
api        | any
default    | false
definition | Allows immediately adjacement start and end markup tags of the same name to be combined into a single self-closing tag.
label      | Merge Adjacent Start and End tags
lexer      | markup
mode       | any
type       | boolean

## tag_sort
property | value
-----------|---
api        | any
default    | false
definition | Sort child items of each respective markup parent element.
label      | Sort Markup Child Items
lexer      | markup
mode       | any
type       | boolean

## ternary_line
property | value
-----------|---
api        | any
default    | false
definition | If ternary operators in JavaScript ? and : should remain on the same line.
label      | Keep Ternary Statements On One Line
lexer      | script
mode       | beautify
type       | boolean

## top_comments
property | value
-----------|---
api        | any
default    | false
definition | If mode is 'minify' this determines whether comments above the first line of code should be kept.
label      | Retain Comment At Code Start
lexer      | any
mode       | minify
type       | boolean

## unformatted
property | value
-----------|---
api        | any
default    | false
definition | If markup tags should have their insides preserved. This option is only available to markup and does not support child tokens that require a different lexer.
label      | Markup Tag Preservation
lexer      | markup
mode       | any
type       | boolean

## variable_list
property | value
-----------|---
api        | any
default    | none
definition | If consecutive JavaScript variables should be merged into a comma separated list or if variables in a list should be separated.
label      | Variable Declaration Lists
lexer      | script
mode       | any
type       | string
values | each, list, none

### Value Definitions
* **each** - Ensurce each reference is a single declaration statement.
* **list** - Ensure consecutive declarations are a comma separated list.
* **none** - Ignores this option.

## version
property | value
-----------|---
api        | node
default    | false
definition | A Node.js only option to write the version information to the console.
label      | Version
lexer      | any
mode       | any
type       | boolean

## vertical
property | value
-----------|---
api        | any
default    | false
definition | If lists of assignments and properties should be vertically aligned. This option is not used with the markup lexer.
label      | Vertical Alignment
lexer      | any
mode       | beautify
type       | boolean

## wrap
property | value
-----------|---
api        | any
default    | 0
definition | Character width limit before applying word wrap. A 0 value disables this option. A negative value concatenates script strings.
label      | Wrap
lexer      | any
mode       | any
type       | number<file_sep>/api/prettydiff-webtool.ts
/*global ace*/
/*jshint laxbreak: true*/
/*jslint for: true*/
/*****************************************************************************
 This is written by <NAME> on 3 Mar 2009.

 Please see the license.txt file associated with the Pretty Diff
 application for license information.
 ****************************************************************************/
if ((/^http:\/\/((\w|-)+\.)*prettydiff\.com/).test(location.href) === true || location.href.indexOf("www.prettydiff.com") > -1) {
    let loc:string = location.href.replace("http", "https").replace("https://www.", "https://");
    location.replace(loc);
}
(function dom_init():void {
    "use strict";
    const id = function dom_id(x:string):any {
            if (document.getElementById === undefined) {
                return;
            }
            return document.getElementById(x);
        },
        page = (function dom__dataPage():HTMLDivElement {
            const divs:HTMLCollectionOf<HTMLDivElement> = document.getElementsByTagName("div");
            if (divs.length === 0) {
                return null;
            }
            return divs[0];
        }()),
        textarea = {
            codeIn: id("input"),
            codeOut: id("output"),
        },
        aceStore:any = {
            codeIn: {},
            codeOut: {},
            height: 0
        },
        method:domMethods = {
            app: {},
            event: {}
        },
        data:any = {
            commentString: [],
            langvalue: ["javascript", "javascript", "JavaScript"],
            mode: "diff",
            settings: {
                report: {
                    code: {},
                    feed: {},
                    stat: {}
                }
            },
            tabtrue: false,
            zIndex: 0
        },
        report = {
            code: {
                body: null,
                box: id("codereport")
            },
            feed: {
                body: null,
                box: id("feedreport")
            },
            stat: {
                body: null,
                box: id("statreport")
            }
        },
        test = {
            // delect if Ace Code Editor is supported
            ace           : (location.href.toLowerCase().indexOf("ace=false") < 0 && typeof ace === "object"),
            // get the lowercase useragent string
            agent         : (typeof navigator === "object")
                ? navigator
                    .userAgent
                    .toLowerCase()
                : "",
            // test for standard web audio support
            audio         : ((typeof AudioContext === "function" || typeof AudioContext === "object") && AudioContext !== null)
                ? new AudioContext()
                : null,
            // delays the toggling of test.load to false for asynchronous code sources
            delayExecution: false,
            // am I served from the Pretty Diff domain
            domain        : (location.href.indexOf("prettydiff.com") < 15 && location.href.indexOf("prettydiff.com") > -1),
            // If the output is too large the report must open and minimize in a single step
            filled        : {
                code: false,
                feed: false,
                stat: false
            },
            // test for support of the file api
            fs            : (typeof FileReader === "function"),
            // stores keypress state to avoid execution of event.execute from certain key
            // combinations
            keypress      : false,
            keysequence   : [],
            // supplement to ensure keypress is returned to false only after other keys
            // other than ctrl are released
            keystore      : [],
            // some operations should not occur as the page is initially loading
            load          : true,
            // whether to save things locally
            store         : (id("localStorage-no") !== null && id("localStorage-no").checked === true)
                ? false
                : true,
            // supplies alternate keyboard navigation to editable text areas
            tabesc        : []
        },
        load                = function dom_load():void {
            const pages:string            = (page === null || page === undefined || page.getAttribute("id") === null)
                    ? ""
                    : page.getAttribute("id"),
                security = function dom_load_security():void {
                    const scripts:HTMLCollectionOf<HTMLScriptElement> = document.getElementsByTagName("script"),
                        exclusions:string[] = [
                            "js/webtool.js",
                            "browser-demo.js",
                            "node_modules/ace-builds"
                        ],
                        len:number = scripts.length,
                        exlen:number = exclusions.length;
                    let a:number = 0,
                        b:number = 0,
                        src:string = "";
                    // this prevents errors, but it also means you are executing too early.
                    if (len > 0) {
                        do {
                            src = scripts[a].getAttribute("src");
                            if (src === null) {
                                break;
                            }
                            if (src.indexOf("?") > 0) {
                                src = src.slice(0, src.indexOf("?"));
                            }
                            b = 0;
                            do {
                                if (src.indexOf(exclusions[b]) > -1) {
                                    break;
                                }
                                b = b + 1;
                            } while (b < exlen);
                            if (b === exlen) {
                                break;
                            }
                            a = a + 1;
                        } while (a < len);
                        if (a < len) {
                            let warning:HTMLDivElement = document.createElement("div");
                                warning.setAttribute("id", "security-warning");
                                warning.innerHTML = `<h1>Warning</h1><h2>This page contains unauthorized script and may be a security risk.</h2><code>${(src === null) ? scripts[a].innerHTML : src}</code>`;
                                document.getElementsByTagName("body")[0].insertBefore(warning, document.getElementsByTagName("body")[0].firstChild);
                        }
                    }
                };
            if (pages === "webtool") {
                let a:number = 0,
                    x:HTMLInputElement,
                    inputs:HTMLCollectionOf<HTMLInputElement>,
                    selects:HTMLCollectionOf<HTMLSelectElement>,
                    buttons:HTMLCollectionOf<HTMLButtonElement>,
                    inputsLen:number       = 0,
                    idval:string              = "",
                    name:string            = "",
                    type:string            = "",
                    parent:HTMLElement;
                const aceApply = function dom_load_aceApply(nodeName:string, maxWidth:boolean):any {
                        const div:HTMLDivElement        = document.createElement("div"),
                            node:HTMLDivElement       = textarea[nodeName],
                            parent:HTMLElement     = <HTMLElement>node.parentNode.parentNode,
                            labels:HTMLCollectionOf<HTMLLabelElement> = parent.getElementsByTagName("label"),
                            label:HTMLLabelElement = labels[labels.length - 1],
                            attributes:NamedNodeMap = node.attributes,
                            p:HTMLParagraphElement = document.createElement("p"),
                            dollar:string     = "$",
                            len:number        = attributes.length;
                        let a:number          = 0,
                            edit:any       = {};
                        do {
                            if (attributes[a].name !== "rows" && attributes[a].name !== "cols" && attributes[a].name !== "wrap") {
                                div.setAttribute(attributes[a].name, attributes[a].value);
                            }
                            a = a + 1;
                        } while (a < len);
                        label.parentNode.removeChild(label);
                        p.appendChild(label);
                        p.setAttribute("class", "inputLabel");
                        parent.appendChild(p);
                        parent.appendChild(div);
                        parent.removeChild(node.parentNode);
                        if (maxWidth === true) {
                            div.style.width = "100%";
                        }
                        div.style.fontSize              = "1.4em";
                        edit                            = ace.edit(div);
                        textarea[nodeName]          = div.getElementsByTagName("textarea")[0];
                        edit[`${dollar}blockScrolling`] = Infinity;
                        if (nodeName === "codeIn") {
                            const slider:HTMLElement = document.createElement("span"),
                                span:HTMLElement = document.createElement("span"),
                                p:HTMLElement = document.createElement("p"),
                                description:string = "Slide this control left and right to adjust the 'options.wrap' value for word wrapping the code.";
                            p.innerHTML = description;
                            p.setAttribute("id", "ace-slider-description");
                            p.style.display = "none";
                            span.innerHTML = `<button title="${description}" aria-describedby="ace-slider-description">\u25bc</button>`;
                            slider.appendChild(span);
                            slider.appendChild(p);
                            slider.setAttribute("id", "slider");
                            span.onmousedown = method.event.aceSlider;
                            parent.insertBefore(slider, div);
                        }
                        return edit;
                    },
                    aces = function dom_load_aces(event:Event):void {
                        const el:HTMLInputElement = <HTMLInputElement>event.srcElement || <HTMLInputElement>event.target,
                            elId:string   = el.getAttribute("id"),
                            acedisable      = function dom_load_aces_acedisable():void {
                                let addy:string   = "",
                                    loc:number    = location
                                        .href
                                        .indexOf("ace=false"),
                                    place:string[]  = [],
                                    symbol:string = "?";
                                method.app.options(event);
                                if (elId === "ace-yes" && loc > 0) {
                                    place = location
                                        .href
                                        .split("ace=false");
                                    if (place[1].indexOf("&") < 0 && place[1].indexOf("%26") < 0) {
                                        place[0] = place[0].slice(0, place[0].length - 1);
                                    }
                                    location.replace(place.join(""));
                                } else if (elId === "ace-no" && loc < 0) {
                                    addy = location.href;
                                    addy = addy.slice(0, addy.indexOf("#") + 1);
                                    if (location.href.indexOf("?") < location.href.length - 1 && location.href.indexOf("?") > 0) {
                                        symbol = "&";
                                    }
                                    location.replace(`${addy + symbol}ace=false`);
                                }
                            };
                        if (el.checked === true) {
                            acedisable();
                        }
                    },
                    areaShiftUp = function dom_load_areaShiftUp(event:KeyboardEvent):void {
                        if (event.keyCode === 16 && test.tabesc.length > 0) {
                            test.tabesc = [];
                        }
                        if (event.keyCode === 17 || event.keyCode === 224) {
                            data.tabtrue = true;
                        }
                    },
                    areaTabOut = function dom_load_areaTabOut(event:KeyboardEvent):void {
                        const node:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target;
                        let len:number   = test.tabesc.length,
                            esc:boolean   = false,
                            key:number   = 0;
                        key  = event.keyCode;
                        if (key === 17 || key === 224) {
                            if (data.tabtrue === false && (test.tabesc[0] === 17 || test.tabesc[0] === 224 || len > 1)) {
                                return;
                            }
                            data.tabtrue = false;
                        }
                        if (node.nodeName.toLowerCase() === "textarea") {
                            if (test.ace === true) {
                                if (node === textarea.codeOut) {
                                    esc = true;
                                }
                            }
                            if (node === textarea.codeIn) {
                                esc = true;
                            }
                        }
                        if (esc === true) {
                            esc             = false;
                            data.tabtrue = false;
                            if ((len === 1 && test.tabesc[0] !== 16 && key !== test.tabesc[0]) || (len === 2 && key !== test.tabesc[1])) {
                                test.tabesc = [];
                                return;
                            }
                            if (len === 0 && (key === 16 || key === 17 || key === 224)) {
                                test
                                    .tabesc
                                    .push(key);
                                return;
                            }
                            if (len === 1 && (key === 17 || key === 224)) {
                                if (test.tabesc[0] === 17 || test.tabesc[0] === 224) {
                                    esc = true;
                                } else {
                                    test
                                        .tabesc
                                        .push(key);
                                    return;
                                }
                            } else if (len === 2 && (key === 17 || key === 224)) {
                                esc = true;
                            } else if (len > 0) {
                                test.tabesc = [];
                            }
                            if (esc === true) {
                                if (len === 2) {
                                    //back tab
                                    if (node === textarea.codeIn) {
                                        id("inputfile").focus();
                                    } else if (node === textarea.codeOut) {
                                        textarea
                                            .codeIn
                                            .focus();
                                    }
                                } else {
                                    //forward tab
                                    if (node === textarea.codeOut) {
                                        id("button-primary")
                                            .getElementsByTagName("button")[0]
                                            .focus();
                                    } else if (node === textarea.codeIn) {
                                        textarea
                                            .codeOut
                                            .focus();
                                    }
                                }
                                if (test.tabesc[0] === 16) {
                                    test.tabesc = [16];
                                } else {
                                    test.tabesc = [];
                                }
                            }
                        }
                        method
                            .event
                            .sequence(event);
                    },
                    backspace       = function dom_load_backspace(event:KeyboardEvent):boolean {
                        const bb:Element = <Element>event.srcElement || <Element>event.target;
                        if (event.keyCode === 8) {
                            if (bb.nodeName === "textarea" || (bb.nodeName === "input" && (bb.getAttribute("type") === "text" || bb.getAttribute("type") === "password"))) {
                                return true;
                            }
                            return false;
                        }
                        if (event.type === "keydown") {
                            method.event.sequence(event);
                        }
                        return true;
                    },
                    clearComment = function dom_load_clearComment():void {
                        const comment = id("commentString");
                        localStorage.setItem("commentString", "[]");
                        data.commentString      = [];
                        if (comment !== null) {
                            comment.innerHTML = "/*prettydiff.com \u002a/";
                        }
                    },
                    feeds = function dom_load_feeds(el:HTMLInputElement):void {
                        const feedradio       = function dom_load_feeds_feedradio(event:Event):boolean {
                            let parent:HTMLElement,
                                aa:number,
                                radios:HTMLCollectionOf<HTMLInputElement>;
                            const elly:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
                                item:HTMLElement   = <HTMLElement>elly.parentNode,
                                radio:HTMLInputElement  = item.getElementsByTagName("input")[0];
                            parent = <HTMLElement>item.parentNode;
                            radios = parent.getElementsByTagName("input");
                            aa     = radios.length - 1;
                            do {
                                parent = <HTMLElement>radios[aa].parentNode;
                                parent.removeAttribute("class");
                                radios[aa].checked = false;
                                aa = aa - 1;
                            } while (aa > -1);
                            radio.checked = true;
                            radio.focus();
                            item.setAttribute("class", "active-focus");
                            method.app.options(event);
                            event.preventDefault();
                            return false;
                        };
                        el.onfocus = feedradio;
                        el.onblur  = function dom_load_feeds_feedblur():void {
                            const item = <HTMLElement>el.parentNode;
                            item.setAttribute("class", "active");
                        },
                        el.onclick = feedradio;
                        parent = <HTMLElement>x.parentNode;
                        parent = parent.getElementsByTagName("label")[0];
                        parent.onclick = feedradio;
                    },
                    feedsubmit = function dom_load_feedsubmit():void {
                        let a:number = 0;
                        const datapack:any  = {},
                            namecheck:any = (localStorage.getItem("settings") !== undefined && localStorage.getItem("settings") !== null)
                                ? JSON.parse(localStorage.getItem("settings"))
                                : {},
                            radios:HTMLCollectionOf<HTMLInputElement> = id("feedradio1")
                                .parentNode
                                .parentNode
                                .getElementsByTagName("input"),
                            text      = (id("feedtextarea") === null)
                                ? ""
                                :id("feedtextarea")
                                    .value,
                            email:string     = (id("feedemail") === null)
                                ? ""
                                : id("feedemail")
                                    .value,
                            xhr:XMLHttpRequest = new XMLHttpRequest(),
                            sendit    = function dom_load_feedsubmit_sendit():void {
                                const node:HTMLElement = id("feedintro");
                                xhr.withCredentials = true;
                                xhr.open("POST", "https://prettydiff.com:8000/feedback/", true);
                                xhr.setRequestHeader("Content-type", "application/json; charset=utf-8");
                                xhr.send(JSON.stringify(datapack));
                                report
                                    .feed
                                    .box
                                    .getElementsByTagName("button")[1]
                                    .click();
                                if (node !== null) {
                                    node.innerHTML = "Please feel free to submit feedback about Pretty Diff at any time by answering t" +
                                            "he following questions.";
                                }
                            };
                        if (id("feedradio1") === null || namecheck.knownname !== data.settings.knownname) {
                            return;
                        }
                        a = radios.length - 1;
                        if (a > 0) {
                            do {
                                if (radios[a].checked === true) {
                                    break;
                                }
                                a = a - 1;
                            } while (a > -1);
                        }
                        if (a < 0) {
                            return;
                        }
                        datapack.comment  = text;
                        datapack.email    = email;
                        datapack.name     = data.settings.knownname;
                        datapack.rating   = a + 1;
                        datapack.settings = data.settings;
                        datapack.type     = "feedback";
                        sendit();
                    },
                    file = function dom_load_file(event:Event):void {
                        const input:HTMLInputElement = <HTMLInputElement>event.srcElement || <HTMLInputElement>event.target;
                        let a:number         = 0,
                            id:string        = "",
                            files:FileList,
                            textareaEl:HTMLTextAreaElement,
                            parent:HTMLElement,
                            reader:FileReader,
                            fileStore:string[] = [],
                            fileCount:number = 0;
                        id    = input.getAttribute("id");
                        files = input.files;
                        if (test.fs === true && files[0] !== null && typeof files[0] === "object") {
                            if (input.nodeName === "input") {
                                parent = <HTMLElement>input.parentNode.parentNode;
                                textareaEl = parent.getElementsByTagName("textarea")[0];
                            }
                            const fileLoad  = function dom_event_file_onload(event:Event):void {
                                    const tscheat:string = "result";
                                    fileStore.push(event.target[tscheat]);
                                    if (a === fileCount) {
                                        if (test.ace === true) {
                                            if (id === "outputfile") {
                                                aceStore
                                                    .codeOut
                                                    .setValue(fileStore.join("\n\n"));
                                                aceStore
                                                    .codeOut
                                                    .clearSelection();
                                            } else {
                                                aceStore
                                                    .codeIn
                                                    .setValue(fileStore.join("\n\n"));
                                                aceStore
                                                    .codeIn
                                                    .clearSelection();
                                            }
                                        } else {
                                            textarea.codeIn.value = fileStore.join("\n\n");
                                        }
                                        if (options.mode !== "diff") {
                                            method
                                                .event
                                                .execute();
                                        }
                                    }
                                };
                            fileCount = files.length;
                            do {
                                reader  = new FileReader();
                                reader.onload  = fileLoad;
                                reader.onerror = function dom_event_file_onerror(event:any):void {
                                    if (textareaEl !== undefined) {
                                        textareaEl.value = `Error reading file:\n\nThis is the browser's description: ${event.error.name}`;
                                    }
                                    fileCount   = -1;
                                };
                                if (files[a] !== undefined) {
                                    reader.readAsText(files[a], "UTF-8");
                                }
                                a = a + 1;
                            } while (a < fileCount);
                            if (options.mode !== "diff") {
                                method
                                    .event
                                    .execute();
                            }
                        }
                    },
                    fixHeight = function dom_load_fixHeight():void {
                        const input:HTMLElement = id("input"),
                            output:HTMLElement = id("output"),
                            headlineNode:HTMLElement = id("headline"),
                            height:number   = window.innerHeight || document.getElementsByTagName("body")[0].clientHeight;
                        let math:number     = 0,
                            headline:number = 0;
                        if (headlineNode !== null && headlineNode.style.display === "block") {
                            headline = 3.8;
                        }
                        if (test.ace === true) {
                            math = (height / 14) - (15.81 + headline);
                            aceStore.height = math;
                            if (input !== null) {
                                input.style.height = `${math}em`;
                                aceStore
                                    .codeIn
                                    .setStyle(`height:${math}em`);
                                aceStore
                                    .codeIn
                                    .resize();
                            }
                            if (output !== null) {
                                output.style.height = `${math}em`;
                                aceStore
                                    .codeOut
                                    .setStyle(`height:${math}em`);
                                aceStore
                                    .codeOut
                                    .resize();
                            }
                        } else {
                            math = (height / 14.4) - (15.425 + headline);
                            if (input !== null) {
                                input.style.height = `${math}em`;
                            }
                            if (output !== null) {
                                output.style.height = `${math}em`;
                            }
                        }
                    },
                    indentchar   = function dom_load_indentchar():void {
                        const insize:HTMLInputElement = id("option-indent_size"),
                            inchar:HTMLInputElement = id("option-indent_char"),
                            tabSizeNumber:number = (insize === null || isNaN(Number(insize.value)) === true)
                                ? 4
                                : Number(insize.value),
                            tabSize:number = (tabSizeNumber < 1)
                                ? 4
                                : tabSizeNumber;
                        if (test.ace === true) {
                            if (inchar !== null && inchar.value === " ") {
                                aceStore
                                    .codeIn
                                    .getSession()
                                    .setUseSoftTabs(true);
                                aceStore
                                    .codeOut
                                    .getSession()
                                    .setUseSoftTabs(true);
                                aceStore
                                    .codeIn
                                    .getSession()
                                    .setTabSize(tabSize);
                                aceStore
                                    .codeOut
                                    .getSession()
                                    .setTabSize(tabSize);
                            } else {
                                aceStore
                                    .codeIn
                                    .getSession()
                                    .setUseSoftTabs(false);
                                aceStore
                                    .codeOut
                                    .getSession()
                                    .setUseSoftTabs(false);
                            }
                        }
                    },
                    insize   = function dom_load_insize():void {
                        const insize:HTMLInputElement = id("option-indent_size"),
                            tabSizeNumber:number = (insize === null || isNaN(Number(insize.value)) === true)
                                ? 4
                                : Number(insize.value),
                            tabSize:number = (tabSizeNumber < 1)
                                ? 4
                                : tabSizeNumber;
                        if (test.ace === true) {
                            aceStore
                                .codeIn
                                .getSession()
                                .setTabSize(tabSize);
                            aceStore
                                .codeOut
                                .getSession()
                                .setTabSize(tabSize);
                        }
                    },
                    modes = function dom_load_modes(event:Event):void {
                        const elly:HTMLElement = <HTMLElement>event.target || <HTMLElement>event.srcElement,
                            mode = elly.getAttribute("id").replace("mode", "");
                        method.event.modeToggle(mode);
                        method.app.options(event);
                    },
                    numeric = function dom_load_numeric(event:Event):void {
                        const el:HTMLInputElement = <HTMLInputElement>event.srcElement || <HTMLInputElement>event.target;
                        let val = el.value,
                            negative:boolean = (/^(\s*-)/).test(val),
                            split:string[] = val.replace(/\s|-/g, "").split(".");
                        if (split.length > 1) {
                            val = `${split[0].replace(/\D/g, "")}.${split[1].replace(/\D/, "")}`;
                        } else {
                            val = split[0].replace(/\D/g, "");
                        }
                        if (negative === true) {
                            val = `-${val}`;
                        }
                        el.value = val;
                        if (el === id("option-indent_char")) {
                            indentchar();
                        } else if (el === id("option-indent_size")) {
                            insize();
                        }
                        if (test.load === false) {
                            method.app.options(event);
                        }
                    },
                    prepBox = function dom_load_prepBox(boxName:string):void {
                        if (report[boxName].box === null || (test.domain === false && boxName === "feed")) {
                            return;
                        }
                        const jsscope = id("option-jsscope"),
                            buttonGroup:HTMLElement = report[boxName]
                                .box
                                .getElementsByTagName("p")[0],
                            title:HTMLButtonElement = report[boxName]
                                .box
                                .getElementsByTagName("h3")[0]
                                .getElementsByTagName("button")[0],
                            filedrop = function dom_load_prepBox_filedrop(event:Event):void {
                                event.stopPropagation();
                                event.preventDefault();
                                file(event);
                            },
                            filenull = function dom_load_prepBox_filenull(event:Event):void {
                                event.stopPropagation();
                                event.preventDefault();
                            };
                        if (test.fs === true) {
                            report[boxName].box.ondragover  = filenull;
                            report[boxName].box.ondragleave = filenull;
                            report[boxName].box.ondrop      = filedrop;
                        }
                        report[boxName].body.onmousedown = function dom_load_prepBox_top():void {
                            method.app.zTop(report[boxName].body.parentNode);
                        };
                        parent = <HTMLElement>title.parentNode;
                        title.onmousedown                         = method.event.grab;
                        title.ontouchstart                        = method.event.grab;
                        title.onfocus                             = method.event.minimize;
                        title.onblur                              = function dom_load_prepBox_blur():void {
                            title.onclick = null;
                        };
                        if (data.settings.report[boxName] === undefined) {
                            data.settings.report[boxName] = {};
                        }
                        if (boxName === "code" && jsscope !== null && jsscope[jsscope.selectedIndex].value === "report" && buttonGroup.innerHTML.indexOf("save") < 0) {
                            if (test.agent.indexOf("firefox") > 0 || test.agent.indexOf("presto") > 0) {
                                let saveNode:HTMLElement = document.createElement("a");
                                saveNode.setAttribute("href", "#");
                                saveNode.onclick   = method.event.save;
                                saveNode.innerHTML = "<button class='save' title='Convert report to text that can be saved.' tabindex=" +
                                                    "'-1'>S</button>";
                                buttonGroup.insertBefore(saveNode, buttonGroup.firstChild);
                            } else {
                                let saveNode:HTMLElement = document.createElement("button");
                                saveNode.setAttribute("class", "save");
                                saveNode.setAttribute("title", "Convert report to text that can be saved.");
                                saveNode.innerHTML = "S";
                                buttonGroup.insertBefore(saveNode, buttonGroup.firstChild);
                            }
                        }
                        if (data.settings.report[boxName].min === false) {
                            buttonGroup.style.display = "block";
                            title.style.cursor    = "move";
                            if (buttonGroup.innerHTML.indexOf("save") > 0) {
                                buttonGroup.getElementsByTagName("button")[1].innerHTML = "\u035f";
                                if (test.agent.indexOf("macintosh") > 0) {
                                    parent.style.width = `${(data.settings.report[boxName].width / 10) - 8.15}em`;
                                } else {
                                    parent.style.width = `${(data.settings.report[boxName].width / 10) - 9.75}em`;
                                }
                            } else {
                                buttonGroup.getElementsByTagName("button")[0].innerHTML = "\u035f";
                                if (test.agent.indexOf("macintosh") > 0) {
                                    parent.style.width = `${(data.settings.report[boxName].width / 10) - 5.15}em`;
                                } else {
                                    parent.style.width = `${(data.settings.report[boxName].width / 10) - 6.75}em`;
                                }
                            }
                            if (data.settings.report[boxName].top < 15) {
                                data.settings.report[boxName].top = 15;
                            }
                            report[boxName].box.style.right    = "auto";
                            report[boxName].box.style.left     = `${data.settings.report[boxName].left / 10}em`;
                            report[boxName].box.style.top      = `${data.settings.report[boxName].top / 10}em`;
                            report[boxName].body.style.width   = `${data.settings.report[boxName].width / 10}em`;
                            report[boxName].body.style.height  = `${data.settings.report[boxName].height / 10}em`;
                            report[boxName].body.style.display = "block";
                        }
                        if (boxName === "feed") {
                            id("feedsubmit").onclick = feedsubmit;
                        }
                    },
                    select = function dom_load_select(event:Event):void {
                        const elly:HTMLSelectElement = <HTMLSelectElement>event.target || <HTMLSelectElement>event.srcElement;
                        selectDescription(elly);
                        method.app.options(event);
                        if (elly.getAttribute("id") === "option-color") {
                            method.event.colorScheme(event);
                        }
                    },
                    selectDescription = function dom_load_selectDescription(el:HTMLSelectElement):void {
                        const opts:HTMLCollectionOf<HTMLOptionElement> = el.getElementsByTagName("option"),
                            desc:string = opts[el.selectedIndex].getAttribute("data-description"),
                            opt:HTMLOptionElement = <HTMLOptionElement>el[el.selectedIndex],
                            value:string = opt.value,
                            parent:HTMLElement = <HTMLElement>el.parentNode,
                            span:HTMLSpanElement = parent.getElementsByTagName("span")[0];
                        span.innerHTML = ` <strong>${value}</strong> \u2014 ${desc}`;
                    },
                    textareablur    = function dom_load_textareablur(event:Event):void {
                        const el:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
                            tabkey = id("textareaTabKey");
                        if (tabkey === null) {
                            return;
                        }
                        tabkey.style.display = "none";
                        if (test.ace === true) {
                            const item = <HTMLElement>el.parentNode;
                            item.setAttribute("class", item.getAttribute("class").replace(" filefocus", ""));
                        }
                    },
                    textareafocus   = function dom_load_textareafocus(event:Event):void {
                        const el:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
                            tabkey:HTMLElement = id("textareaTabKey"),
                            aria:HTMLElement   = id("arialive");
                        if (tabkey === null) {
                            return;
                        }
                        tabkey.style.zIndex = String(data.zIndex + 10);
                        if (aria !== null) {
                            aria.innerHTML = tabkey.innerHTML;
                        }
                        if (options.mode === "diff") {
                            tabkey.style.right = "51%";
                            tabkey.style.left  = "auto";
                        } else {
                            tabkey.style.left  = "51%";
                            tabkey.style.right = "auto";
                        }
                        tabkey.style.display = "block";
                        if (test.ace === true) {
                            let item = <HTMLElement>el.parentNode;
                            item.setAttribute("class", `${item.getAttribute("class")} filefocus`);
                        }
                    };

                // prep default announcement text
                {
                    const headline  = id("headline"),
                        headtext    = (headline === null)
                            ? null
                            : headline.getElementsByTagName("p")[0],
                        x           = Math.random(),
                        circulation = [
                            "Available in your editor with <a href=\"https://unibeautify.com/\">Unibeautify</a>",
                            "Updated to <a href=\"https://www.npmjs.com/package/prettydiff\">NPM</a>.",
                            "Check out the <a href=\"https://sparser.io/demo/\">parsing utility</a> that makes this possible.",
                            "Supporting <a href=\"documentation.xhtml#languages\">45 languages</a> as of version 101.0.11"
                        ];
                    if (headline !== null) {
                        headtext.innerHTML = circulation[Math.floor(x * circulation.length)];
                        if (location.href.indexOf("ignore") > 0) {
                            headline.innerHTML = "<h2>BETA TEST SITE.</h2> <p>Official Pretty Diff is at <a href=\"https://prettydiff.com/\">https://prettydiff.com/</a></p> <span class=\"clear\"></span>";
                        }
                    }
                }

                // changing the default value of diff_format and complete_document for the browser tool
                {
                    let el:HTMLElement = document.getElementById("option-diff_format"),
                        ops:HTMLCollectionOf<HTMLOptionElement> = el.getElementsByTagName("option"),
                        sel:HTMLSelectElement,
                        a:number = 0;
                    options.diff_format = "html";
                    sel = <HTMLSelectElement>el;
                    if (ops[0].innerHTML !== "html") {
                        do {
                            a = a + 1;
                        } while (a < ops.length && ops[a].innerHTML !== "html");
                    }
                    if (a < ops.length) {
                        sel.selectedIndex = a;
                    }
                }

                // build the Ace editors
                if (test.ace === true) {
                    const insize:HTMLInputElement = id("option-indent_size"),
                        tabSizeNumber:number = (insize === null || isNaN(Number(insize.value)) === true)
                            ? 4
                            : Number(insize.value),
                        tabSize:number = (tabSizeNumber < 1)
                            ? 4
                            : tabSizeNumber;
                    if (textarea.codeIn !== null) {
                        aceStore.codeIn = aceApply("codeIn", true);
                    }
                    if (textarea.codeOut !== null) {
                        aceStore.codeOut = aceApply("codeOut", true);
                    }
                    aceStore
                        .codeIn
                        .getSession()
                        .setTabSize(tabSize);
                    aceStore
                        .codeOut
                        .getSession()
                        .setTabSize(tabSize);
                }
                x = id("ace-no");
                if (test.ace === false && x !== null && x.checked === false) {
                    x.checked = true;
                }

                // preps stored settings
                // should come after events are assigned
                if (localStorage.getItem("settings") !== undefined && localStorage.getItem("settings") !== null) {
                    if (localStorage.getItem("settings").indexOf(":undefined") > 0 && test.store === true) {
                        localStorage.setItem("settings", localStorage.getItem("settings").replace(/:undefined/g, ":false"));
                    }
                    data.settings = JSON.parse(localStorage.getItem("settings"));
                    const keys:string[] = Object.keys(data.settings),
                        keylen:number = keys.length;
                    let a:number = 0,
                        el:HTMLElement,
                        sel:HTMLSelectElement,
                        name:string,
                        opt:HTMLOptionElement,
                        numb:number;
                    do {
                        if (keys[a] !== "report" && keys[a] !== "knownname" && keys[a] !== "feedback") {
                            el = id(keys[a]) || id(data.settings[keys[a]]);
                            if (el !== null) {
                                name = el.nodeName.toLowerCase();
                                if (name === "select") {
                                    sel = <HTMLSelectElement>el;
                                    sel.selectedIndex = data.settings[keys[a]];
                                    opt = <HTMLOptionElement>sel[sel.selectedIndex];
                                    options[keys[a].replace("option-", "")] = opt.value;
                                    if (keys[a] === "option-color") {
                                        method.event.colorScheme(null);
                                    }
                                } else {
                                    if (keys[a] === "mode") {
                                        id(data.settings[keys[a]]).checked = true;
                                        options.mode = data.settings[keys[a]].replace("mode", "");
                                        method.event.modeToggle(options.mode);
                                    } else if (typeof data.settings[keys[a]] === "string" && data.settings[keys[a]].indexOf("option-true-") === 0) {
                                        id(data.settings[keys[a]]).checked = true;
                                        options[keys[a].replace("option-", "")] = true;
                                    } else if (typeof data.settings[keys[a]] === "string" && data.settings[keys[a]].indexOf("option-false-") === 0) {
                                        id(data.settings[keys[a]]).checked = true;
                                    } else if (keys[a].indexOf("option-") === 0) {
                                        if (id(keys[a]).getAttribute("data-type") === "number") {
                                            numb = Number(data.settings[keys[a]]);
                                            if (isNaN(numb) === false) {
                                                id(keys[a]).value = data.settings[keys[a]];
                                                options[keys[a].replace("option-", "")] = numb;
                                                if (test.ace === true && keys[a] === "option-wrap") {
                                                    if (numb < 1) {
                                                        numb = 80;
                                                    }
                                                    aceStore.codeIn.setPrintMarginColumn(numb);
                                                    aceStore.codeOut.setPrintMarginColumn(numb);
                                                }
                                            }
                                        } else {
                                            id(keys[a]).value = data.settings[keys[a]];
                                            options[keys[a].replace("option-", "")] = data.settings[keys[a]];
                                        }
                                        if (keys[a] === "option-indent_size") {
                                            insize();
                                        } else if (keys[a] === "option-indent_char") {
                                            indentchar();
                                        }
                                    } else if (id(data.settings[keys[a]]) !== null) {
                                        id(data.settings[keys[a]]).checked = true;
                                    }
                                }
                            }
                        }
                        a = a + 1;
                    } while (a < keylen)
                    if (data.settings.report === undefined) {
                        data.settings.report = {
                            code: {},
                            feed: {},
                            stat: {}
                        };
                    }
                    if (data.settings.knownname === undefined && test.store === true) {
                        data.settings.knownname = `${Math
                            .random()
                            .toString()
                            .slice(2) + Math
                            .random()
                            .toString()
                            .slice(2)}`;
                        localStorage.setItem("settings", JSON.stringify(data.settings));
                    }
                } else {
                    data.settings.knownname = `${Math
                        .random()
                        .toString()
                        .slice(2) + Math
                        .random()
                        .toString()
                        .slice(2)}`;
                }
                if (options.diff === undefined) {
                    options.diff = "";
                }
                if (localStorage.getItem("source") !== undefined && localStorage.getItem("source") !== null) {
                    options.source = localStorage.getItem("source");
                    if (test.ace === true) {
                        aceStore.codeIn.setValue(options.source);
                    } else {
                        textarea.codeIn.value = options.source;
                    }
                }
                if (localStorage.getItem("diff") !== undefined && localStorage.getItem("diff") !== null) {
                    options.diff = localStorage.getItem("diff");
                    if (options.mode === "diff") {
                        if (test.ace === true) {
                            aceStore.codeOut.setValue(options.diff);
                        } else {
                            textarea.codeOut.value = options.diff;
                        }
                    }
                }

                //  feedback dialogue config data (current disabled)
                if (data.settings.feedback === undefined) {
                    data.settings.feedback         = {};
                    data.settings.feedback.newb    = false;
                    data.settings.feedback.veteran = false;
                }
                x = id("feedsubmit");
                if (x !== null) {
                    x.onclick = feedsubmit;
                }

                // assigns event handlers to input elements
                inputs    = document.getElementsByTagName("input");
                inputsLen = inputs.length;
                a = 0;
                do {
                    x = inputs[a];
                    type = x.getAttribute("type");
                    idval   = x.getAttribute("id");
                    if (type === "radio") {
                        name = x.getAttribute("name");
                        if (id === data.settings[name]) {
                            x.checked = true;
                        }
                        if (idval.indexOf("feedradio") === 0) {
                            feeds(x);
                        } else if (name === "mode") {
                            x.onclick = modes;
                        } else if (name === "ace-radio") {
                            x.onclick = aces;
                        } else {
                            x.onclick = method.app.options;
                        }
                    } else if (type === "text") {
                        if (x.getAttribute("data-type") === "number") {
                            x.onkeyup = numeric;
                        } else {
                            x.onkeyup = method.app.options;
                        }
                        if (data.settings[idval] !== undefined) {
                            x.value = data.settings[idval];
                        }
                        if (idval === "option-language" && options.mode !== "diff" && x.value === "text") {
                            x.value = "auto";
                        }
                    } else if (type === "file") {
                        x.onchange = file;
                        x.onfocus  = function dom_load_filefocus():void {
                            x.setAttribute("class", "filefocus");
                        };
                        x.onblur   = function dom_load_fileblur():void {
                            x.removeAttribute("class");
                        };
                    }
                    a = a + 1;
                } while (a < inputsLen);

                // assigns event handlers to select elements
                selects    = document.getElementsByTagName("select");
                inputsLen = selects.length;
                a = 0;
                if (inputsLen > 0) { 
                    do {
                        idval = selects[a].getAttribute("id");
                        if (idval === "option-color") {
                            if (data.settings["option-color"] !== undefined) {
                                selects[a].selectedIndex = Number(data.settings["option-color"]);
                                selectDescription(selects[a]);
                            }
                        } else {
                            if (typeof data.settings[idval] === "number") {
                                selects[a].selectedIndex = data.settings[idval];
                                selectDescription(selects[a]);
                            }
                        }
                        selects[a].onchange = select;
                        a = a + 1;
                    } while (a < inputsLen);
                }

                // assigns event handlers to buttons
                buttons    = document.getElementsByTagName("button");
                inputsLen = buttons.length;
                a = 0;
                do {
                    name  = buttons[a].getAttribute("class");
                    idval = buttons[a].getAttribute("id");
                    if (name === null) {
                        if (buttons[a].value === "Execute") {
                            buttons[a].onclick = method.event.execute;
                        } else if (idval === "resetOptions") {
                            buttons[a].onclick = method.event.reset;
                        }
                    } else if (name === "minimize") {
                        buttons[a].onclick = method.event.minimize;
                    } else if (name === "maximize") {
                        buttons[a].onclick = method.event.maximize;
                        parent = <HTMLElement>buttons[a].parentNode.parentNode;
                        if (data.settings[parent.getAttribute("id")] !== undefined && data.settings[parent.getAttribute("id")].max === true) {
                            buttons[a].click();
                        }
                    } else if (name === "resize") {
                        buttons[a].onmousedown = method.event.resize;
                    } else if (name === "save") {
                        buttons[a].onclick = method.event.save;
                    }
                    a = a + 1;
                } while (a < inputsLen);

                // preps the file inputs
                if (test.fs === false) {
                    x = id("inputfile");
                    if (x !== null) {
                        x.disabled = true;
                    }
                    x = id("outputfile");
                    if (x !== null) {
                        x.disabled = true;
                    }
                }

                // prep the floating GUI windows
                // should come after store settings are processed
                report.feed.body = (report.feed.box === null)
                    ? null
                    : report
                        .feed
                        .box
                        .getElementsByTagName("div")[0];
                report.code.body = (report.code.box === null)
                    ? null
                    : report
                        .code
                        .box
                        .getElementsByTagName("div")[0];
                report.stat.body = (report.stat.box === null)
                    ? null
                    : report
                        .stat
                        .box
                        .getElementsByTagName("div")[0];
                prepBox("feed");
                prepBox("code");
                prepBox("stat");

                // sets default configurations from URI query string
                // should come after all configurations are processed, so as to override
                if (typeof location === "object" && typeof location.href === "string" && location.href.indexOf("?") > -1) {
                    let b:number        = 0,
                        c:number        = 0,
                        paramLen:number = 0,
                        param:string[]    = [],
                        colors:HTMLCollectionOf<HTMLOptionElement>,
                        lang:HTMLInputElement = id("option-language"),
                        source:string   = "",
                        diff:string     = "";
                    const color:HTMLSelectElement    = id("option-color"),
                        params   = location
                            .href
                            .split("?")[1]
                            .split("&");
                    if (color !== null) {
                        colors = color.getElementsByTagName("option");
                    }
                    paramLen = params.length;
                    b = 0;
                    do {
                        param = params[b].split("=");
                        if (param.length > 1) {
                            param[1] = param[1].toLowerCase();
                        } else {
                            param.push("");
                        }
                        if (param[0] === "m" || param[0] === "mode") {
                            param[0] = "mode";
                            if (param[1] === "analysis" && id("modeanalysis") !== null) {
                                method
                                    .event
                                    .modeToggle("analysis");
                                id("modeanalysis").checked = true;
                            } else if (param[1] === "beautify" && id("modebeautify") !== null) {
                                method
                                    .event
                                    .modeToggle("beautify");
                                id("modebeautify").checked = true;
                            } else if (param[1] === "diff" && id("modediff") !== null) {
                                method
                                    .event
                                    .modeToggle("diff");
                                id("modediff").checked = true;
                            } else if (param[1] === "minify" && id("modeminify") !== null) {
                                method
                                    .event
                                    .modeToggle("minify");
                                id("modeminify").checked = true;
                            } else if (param[1] === "parse" && id("modeparse") !== null) {
                                method
                                    .event
                                    .modeToggle("parse");
                                id("modeparse").checked = true;
                            } else {
                                params.splice(b, 1);
                                b = b - 1;
                                paramLen = paramLen - 1;
                            }
                        } else if (param[0] === "s" || param[0] === "source") {
                            param[0] = "source";
                            source = param[1];
                        } else if ((param[0] === "d" || param[0] === "diff") && textarea.codeOut !== null) {
                            param[0] = "diff";
                            diff = param[1];
                            if (test.ace === true && diff !== undefined) {
                                aceStore
                                    .codeOut
                                    .setValue(diff);
                                aceStore
                                    .codeOut
                                    .clearSelection();
                            } else {
                                textarea.codeOut.value = diff;
                            }
                        } else if ((param[0] === "l" || param[0] === "lang" || param[0] === "language") && lang !== null) {
                            param[0] = "lang";
                            if (param[1] === "text" || param[1] === "plain" || param[1] === "plaintext") {
                                param[1] = "text";
                                method
                                    .event
                                    .modeToggle("diff");
                            } else if (param[1] === "js" || param[1] === "") {
                                param[1] = "javascript";
                            } else if (param[1] === "markup") {
                                param[1] = "xml";
                            } else if (param[1] === "jstl") {
                                param[1] = "jsp";
                            } else if (param[1] === "erb" || param[1] === "ejs") {
                                param[1] = "html_ruby";
                            } else if (param[1] === "tss" || param[1] === "titanium") {
                                param[1] = "tss";
                            }
                            lang.value = param[1];
                            if (test.ace === true && c > -1) {
                                if (param[1] === "vapor") {
                                    aceStore
                                        .codeIn
                                        .getSession()
                                        .setMode("ace/mode/html");
                                    aceStore
                                        .codeOut
                                        .getSession()
                                        .setMode("ace/mode/html");
                                } else {
                                    aceStore
                                        .codeIn
                                        .getSession()
                                        .setMode(`ace/mode/${param[1]}`);
                                    aceStore
                                        .codeOut
                                        .getSession()
                                        .setMode(`ace/mode/${param[1]}`);
                                }
                            }
                            method.app.langkey({
                                sample: aceStore.codeIn.getValue(),
                                name: param[1]
                            });
                        } else if (param[0] === "c" || param[0] === "color") {
                            param[0] = "color";
                            c = colors.length - 1;
                            do {
                                if (colors[c].innerHTML.toLowerCase() === param[1]) {
                                    color.selectedIndex = c;
                                    method
                                        .event
                                        .colorScheme(null);
                                    break;
                                }
                                c = c - 1;
                            } while (c > -1);
                            if (c < 0) {
                                params.splice(b, 1);
                                b = b - 1;
                                paramLen = paramLen - 1;
                            }
                        } else if (param[0] === "jsscope") {
                            param[1] = "report";
                            method
                                .app
                                .hideOutput(id("option-jsscope"));
                        } else if (param[0] === "jscorrect" || param[0] === "correct" || param[0] === "fix") {
                            param[0] = "correct";
                            param[1] = "true";
                            x = id("option-true-correct");
                            if (x !== null) {
                                x.checked = true;
                            }
                        } else if (param[0] === "html" || param[0] === "vapor") {
                            param[1] = "true";
                            if (lang !== null) {
                                lang.value = "html";
                            }
                            if (test.ace === true) {
                                aceStore
                                    .codeIn
                                    .getSession()
                                    .setMode("ace/mode/html");
                                aceStore
                                    .codeOut
                                    .getSession()
                                    .setMode("ace/mode/html");
                            }
                        } else if (param[0] === "localstorage") {
                            if (param[1] === "false" || param[1] === "" || param[1] === undefined) {
                                test.store = false;
                                if (id("localStorage-no") !== null) {
                                    id("localStorage-no").checked = true;
                                }
                            } else {
                                test.store = true;
                                if (id("localStorage-yes") !== null) {
                                    id("localStorage-yes").checked = true;
                                }
                            }
                        } else if (options[param[0]] !== undefined) {
                            options[param[0]] = param[1];
                            if (id(`option-true-${param[0]}`) !== null) {
                                id(`option-true-${param[0]}`).checked = true;
                            }
                        }
                        b = b + 1;
                    } while (b < paramLen);
                    if (source !== "" && source !== undefined && source !== null) {
                        if (textarea.codeIn !== null) {
                            if (test.ace === true) {
                                aceStore
                                    .codeIn
                                    .setValue(source);
                                aceStore
                                    .codeIn
                                    .clearSelection();
                            } else {
                                textarea.codeIn.value = source;
                            }
                            method
                                .event
                                .execute();
                        }
                    }
                }

                // sets audio configuration
                if (test.audio !== null) {
                    const audioString:string[] = [
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "rm<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>qqqqqqqqqqqqqqqqqqqqqqqqq",
                        "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
                        "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
                        "qqqqqqqqqqqqqqqq<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "c<KEY>s/uxmAQoE<KEY>AoYWxwaGEpqqqqqqqqqqqqqqqqqqqqqqqq",
                        "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqgCAAtSPpWqmHQBU",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "7uAUByID<KEY>",
                        "hhbHBoYSmqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
                        "qqqqqqqqqqqqqqqqqqqqqqqqqqqq<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
                        "qqqqqqqqqqqqqqqqqqqqqqqqqqqq<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        <KEY>CYwAgA",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "e52FZ/ruvwtgoJm8v9v65yoD6anJTEFNRTMuOTkgKGFscGhhKaqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
                        "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
                        "qqqqqqqqqqqqqqqqqiq<KEY>",
                        "GL<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "fr/4YAg7e+Rf/dVWZt3aBl//<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "b<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "////<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>/////<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>RAW4D7mJQ",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>
                        "<KEY>////<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>////<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>RG<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "DBpAiMAMBMSAsBQFxekwIANDBxAtM+P1OwxPMIgoMMAnMCRPFANGACKwSCocCEETCosD/QozCMRTAQC0",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        <KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>Msk<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "TMC0AsMAiEYJ4Ug0OdkIEwUABzAfAmQiMA4CYgARi5gDAYmAUBoYVadgtzocL5gwIZguFDJUQmLo7Dgy",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>glm<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "dDiucKFB<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "tyI8ryMCAEDBI<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>AY<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "///<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "K<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "////<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "///+<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "wLEYHMUgYwEBEFomLAILBowIBUrzGghRFTLexer/+<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "igBI2O<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>/////<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        <KEY>",
                        "I4DzxDPoBK<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>BA<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "4ZfzDn97+4YjEcHhlUa2PAr9f/cr34/cu583a/+75/97ju/aqYHAEssMBMAgHAHEoDgQB2AAADAPBABI",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        <KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>",
                        "<KEY>NzYaizgv406AYS4MAPM7NFDUja6zKBGdRN+aBymxq9LrJtK1qavVCozjOtabE5",
                        "6wrRGLJCsIU5TEFNRTMuOTkgKGFscGhhKao="
                    ];
                    data.audio = {};
                    data.audio.binary = window.atob(audioString.join(""));
                    data.audio.play   = function dom_load_audio():void {
                        const source:AudioBufferSourceNode  = test
                                .audio
                                .createBufferSource(),
                            focused:HTMLElement = <HTMLElement>document.activeElement,
                            buff:ArrayBuffer   = new ArrayBuffer(data.audio.binary.length),
                            bytes:Uint8Array   = new Uint8Array(buff),
                            bytelen:number = buff.byteLength;
                        let z:number       = 0;
                        do {
                            bytes[z] = data
                                .audio
                                .binary
                                .charCodeAt(z);
                            z = z + 1;
                        } while (z < bytelen);
                        test
                            .audio
                            .decodeAudioData(buff, function dom_load_audio_decode(buffer:AudioBuffer):void {
                                source.buffer = buffer;
                                source.loop   = false;
                                source.connect(test.audio.destination);
                                source.start(0, 0, 1.8);
                                // eslint-disable-next-line
                                console.log("You found a secret!");
                                focused.focus();
                            });
                    };
                }

                // sets some default event configurations
                if (textarea.codeIn !== null) {
                    textarea.codeIn.onfocus   = textareafocus;
                    textarea.codeIn.onblur    = textareablur;
                    if (test.ace === true) {
                        textarea.codeIn.onkeydown = function dom_load_bindInDownAce(event:KeyboardEvent):void {
                            areaTabOut(event);
                            method
                                .event
                                .keydown(event);
                        };
                    } else {
                        textarea.codeIn.onkeydown = function dom_load_bindInDown(event:KeyboardEvent):void {
                            method
                                .event
                                .fixtabs(event, textarea.codeIn);
                            areaTabOut(event);
                            method
                                .event
                                .keydown(event);
                        };
                    }
                }
                if (textarea.codeOut !== null) {
                    textarea.codeOut.onfocus   = textareafocus;
                    textarea.codeOut.onblur    = textareablur;
                    if (test.ace === true) {
                        textarea.codeOut.onkeydown = areaTabOut;
                    }
                }
                window.onresize     = fixHeight;
                window.onkeyup      = areaShiftUp;
                document.onkeypress = backspace;
                document.onkeydown  = backspace;

                // sets vertical responsive design layout
                // must occur after all other visual and interactive changes
                fixHeight();
                method.app.hideOutput();

                // connecting to web sockets if running as localhost
                if (location.href.indexOf("//localhost:") > 0) {
                    let ws = new WebSocket(`ws://localhost:${(function dom_load_webSocketsPort():number {
                        const uri = location.href;
                        let str:string = uri.slice(location.href.indexOf("host:") + 5),
                            ind:number = str.indexOf("/");
                        if (ind > 0) {
                            str = str.slice(0, ind);
                        }
                        ind = str.indexOf("?");
                        if (ind > 0) {
                            str = str.slice(0, ind);
                        }
                        ind = str.indexOf("#");
                        if (ind > 0) {
                            str = str.slice(0, ind);
                        }
                        ind = Number(str);
                        if (isNaN(ind) === true) {
                            return 8080;
                        }
                        return ind;
                    }()) + 1}`);
                    ws.addEventListener("message", function dom_load_webSockets(event):void {
                        if (event.data === "reload") {
                            location.reload();
                        }
                    });
                    document.getElementsByTagName("body")[0].style.display = "none";
                    window.onload = function dom_load_webSocketLoaded():void {
                        security();
                        document.getElementsByTagName("body")[0].style.display = "block";
                        id("button-primary").getElementsByTagName("button")[0].click();
                    };
                }

                // sets up the option comment string
                x = id("commentString");
                if (x !== null) {
                    if (localStorage.getItem("commentString") !== undefined && localStorage.getItem("commentString") !== null && localStorage.getItem("commentString") !== "") {
                        data.commentString = JSON.parse(localStorage.getItem("commentString"));
                    }
                    if (x.value.length === 0) {
                        x.innerHTML = "/*prettydiff.com \u002a/";
                    } else {
                        x.innerHTML = `/*prettydiff.com ${data
                            .commentString
                            .join(", ")
                            .replace(/api\./g, "")} \u002a/`;
                    }
                    x = id("commentClear");
                    if (x !== null) {
                        x.onclick = clearComment;
                    }
                }

                // set the ace wrap slider load conditions
                if (test.ace === true) {
                    const slide:HTMLElement = id("slider"),
                        input:HTMLElement = id("input"),
                        gutter:HTMLElement = <HTMLElement>input.getElementsByClassName("ace_gutter")[0],
                        wrap:number = (options.wrap > 1)
                            ? options.wrap
                            : 80;
                    setTimeout(function dom_load_aceGutter() {
                        slide.style.marginLeft = gutter.style.width;
                    }, 500);
                    slide.getElementsByTagName("span")[0].style.left = `${wrap * 1.0035}em`;
                    if (options.mode !== "beautify") {
                        slide.style.display = "none";
                    }
                }
            }
            if (pages === "documentation") {
                let a:number = 0,
                    b:number           = 0,
                    colorParam:string  = (typeof location === "object" && typeof location.href === "string" && location.href.indexOf("?") > -1)
                        ? location
                            .href
                            .toLowerCase()
                            .split("?")[1]
                        : "";
                const docbuttons:HTMLCollectionOf<HTMLButtonElement>  = document.getElementsByTagName("button"),
                    docbuttonClick = function dom_load_documentation_showhide(event:Event):void {
                        const x:HTMLElement = <HTMLElement>event.target || <HTMLElement>event.srcElement,
                            span:HTMLSpanElement = x.getElementsByTagName("span")[0],
                            parent:HTMLElement = <HTMLElement>x
                                .parentNode
                                .parentNode,
                            target:HTMLDivElement = parent.getElementsByTagName("div")[0];
                        if (target === undefined) {
                            return;
                        }
                        if (span.innerHTML === "Show") {
                            target.setAttribute("class", "content-show");
                            span.innerHTML = "Hide";
                        } else {
                            target.setAttribute("class", "content-hide");
                            span.innerHTML = "Show";
                        }
                    },
                    colorScheme:HTMLSelectElement = id("option-color"),
                    hashgo      = function dom_load_documentation_hashgo():void {
                        let hash:string     = "",
                            test:boolean     = false,
                            hashnode:HTMLElement,
                            parent:HTMLElement;
                        const body:HTMLBodyElement = document.getElementsByTagName("body")[0];
                        if (location.href.indexOf("#") > 0) {
                            hash     = location
                                .href
                                .split("#")[1];
                            hashnode = document.getElementById(hash);
                            if (hashnode !== null) {
                                parent = <HTMLElement>hashnode.parentNode;
                                test   = (parent.nodeName.toLowerCase() === "h2" || parent.getAttribute("class") === "content-hide");
                                if (test === true) {
                                    parent = <HTMLElement>parent.parentNode;
                                    parent.getElementsByTagName("button")[0].click();
                                } else {
                                    do {
                                        parent = <HTMLElement>parent.parentNode;
                                        test   = (parent.nodeName.toLowerCase() === "h2" || parent.getAttribute("class") === "content-hide");
                                    } while (test === false && parent.nodeName.toLowerCase() !== "body");
                                    if (test === true) {
                                        parent = <HTMLElement>parent.parentNode;
                                        parent.getElementsByTagName("button")[0].click();
                                    }
                                }
                                document.documentElement.scrollTop = hashnode.offsetTop;
                                body.scrollTop                     = hashnode.offsetTop;
                            }
                        }
                    },
                    colorChange = function dom_load_documentation_colorChange():void {
                        const options:HTMLCollectionOf<HTMLOptionElement> = colorScheme.getElementsByTagName("option"),
                            olen:number = options.length;
                        if (test.store === true && localStorage !== null && localStorage.getItem("settings") !== undefined && localStorage.getItem("settings") !== null && localStorage.getItem("settings").indexOf(":undefined") > 0) {
                            localStorage.setItem("settings", localStorage.getItem("settings").replace(/:undefined/g, ":false"));
                        }
                        data.settings = (localStorage.getItem("settings") !== undefined && localStorage.getItem("settings") !== null)
                            ? JSON.parse(localStorage.getItem("settings"))
                            : {};
                        if (colorParam.indexOf("c=") === 0 || colorParam.indexOf("&c=") > -1) {
                            if (colorParam.indexOf("&c=") > -1) {
                                colorParam.substr(colorParam.indexOf("&c=") + 1);
                            }
                            colorParam = colorParam.split("&")[0];
                            colorParam = colorParam.substr(colorParam.indexOf("=") + 1);
                            b = 0;
                            do {
                                if (options[b].value.toLowerCase() === colorParam) {
                                    colorScheme.selectedIndex = b;
                                    break;
                                }
                                b = b + 1;
                            } while (b < olen);
                        }
                        if (((olen > 0 && b !== olen) || olen === 0) && data.settings["option-color"] !== undefined) {
                            colorScheme.selectedIndex = data.settings["option-color"];
                        }
                        method
                            .event
                            .colorScheme(null);
                        colorScheme.onchange = method.event.colorScheme;
                    };
                b = docbuttons.length;
                a = 0;
                do {
                    if (docbuttons[a].parentNode.nodeName.toLowerCase() === "h2") {
                        docbuttons[a].onclick = docbuttonClick;
                    }
                    a = a + 1;
                } while (a < b);
                if (colorScheme !== null) {
                    colorChange();
                }
                window.onhashchange = hashgo;
                hashgo();
                window.onload = security;
            }
            if (pages === "page") {
                let b:number          = 0,
                    colorOptions:HTMLCollectionOf<HTMLOptionElement>,
                    olen:number       = 0,
                    colorParam:string = (typeof location === "object" && typeof location.href === "string" && location.href.indexOf("?") > -1)
                        ? location
                            .href
                            .toLowerCase()
                            .split("?")[1]
                        : "";
                const node    = id("option-color");
                colorOptions = node.getElementsByTagName("option");
                olen    = colorOptions.length;
                if (node !== null) {
                    if (test.store === true && localStorage !== null && localStorage.getItem("settings") !== undefined && localStorage.getItem("settings") !== null && localStorage.getItem("settings").indexOf(":undefined") > 0) {
                        localStorage.setItem("settings", localStorage.getItem("settings").replace(/:undefined/g, ":false"));
                    }
                    data.settings = (localStorage.getItem("settings") !== undefined && localStorage.getItem("settings") !== null)
                        ? JSON.parse(localStorage.getItem("settings"))
                        : {};
                    if (colorParam.indexOf("c=") === 0 || colorParam.indexOf("&c=") > -1) {
                        if (colorParam.indexOf("&c=") > -1) {
                            colorParam.substr(colorParam.indexOf("&c=") + 1);
                        }
                        colorParam = colorParam.split("&")[0];
                        colorParam = colorParam.substr(colorParam.indexOf("=") + 1);
                        b = 0;
                        do {
                            if (colorOptions[b].value.toLowerCase() === colorParam) {
                                node.selectedIndex = b;
                                break;
                            }
                            b = b + 1;
                        } while (b < olen);
                    }
                    if (((olen > 0 && b !== olen) || olen === 0) && data.settings["option-color"] !== undefined) {
                        node.selectedIndex = data.settings["option-color"];
                    }
                    method
                        .event
                        .colorScheme(null);
                    node.onchange = method.event.colorScheme;
                }
                {
                    let inca:number  = 0,
                        incb:number  = 0,
                        ol:HTMLCollectionOf<HTMLOListElement>,
                        li:HTMLCollectionOf<HTMLLIElement>,
                        lilen:number = 0;
                    const div:HTMLCollectionOf<HTMLDivElement> = document.getElementsByTagName("div"),
                        len:number   = div.length;
                    inca = 0;
                    do {
                        if (div[inca].getAttribute("class") === "beautify") {
                            ol = div[inca].getElementsByTagName("ol");
                            if (ol[0].getAttribute("class") === "count") {
                                li    = ol[0].getElementsByTagName("li");
                                lilen = li.length;
                                incb  = 0;
                                do {
                                    if (li[incb].getAttribute("class") === "fold") {
                                        li[incb].onclick = method.event.beaufold;
                                    }
                                    incb = incb + 1;
                                } while (incb < lilen);
                            }
                        }
                        inca = inca + 1;
                    } while (inca < len);
                }
                window.onload = security;
            }
            test.load = false;
        };
    let meta:any,
        options:any,
        prettydiff:any;
    
    // builds the Pretty Diff options comment as options are updated
    method.app.commentString = function dom_app_commentString():void {
        const comment:HTMLElement = id("commentString");
        if (comment !== null) {
            if (data.commentString.length === 0) {
                comment.innerHTML = "/*prettydiff.com \u002a/";
            } else if (data.commentString.length === 1) {
                comment.innerHTML = `/*prettydiff.com ${data
                    .commentString[0]
                    .replace(/&/g, "&amp;")
                    .replace(/</g, "&lt;")
                    .replace(/>/g, "&gt;")
                    .replace(/api\./g, "")} \u002a/`;
            } else {
                data.commentString.sort();
                comment.innerHTML = `/*prettydiff.com ${data
                    .commentString
                    .join(", ")
                    .replace(/&/g, "&amp;")
                    .replace(/</g, "&lt;")
                    .replace(/>/g, "&gt;")
                    .replace(/api\./g, "")} \u002a/`;
            }
        }
        method.app.hideOutput();
        if (test.store === true) {
            localStorage.setItem("commentString", JSON.stringify(data.commentString));
        }
    };
    // stretches input to 100% width if output is a html report
    method.app.hideOutput = function dom_app_hideOutput():void {
        let hide:boolean;
        if (options.complete_document === true) {
            hide = false;
        } else if (options.parse_format === "renderhtml" && options.mode === "parse") {
            hide = true;
        } else if (options.jsscope === "report" && options.mode === "beautify") {
            hide = true;
        } else {
            hide = false;
        }
        if (hide === true) {
            if (test.ace === true) {
                id("output").parentNode.style.display = "none";
                id("input").parentNode.style.width = "100%";
            } else {
                id("output").parentNode.parentNode.style.display = "none";
                id("input").parentNode.parentNode.style.width = "100%";
            }
        } else {
            if (test.ace === true) {
                id("output").parentNode.style.display = "block";
                id("input").parentNode.style.width = "49%";
            } else {
                id("output").parentNode.parentNode.style.display = "block";
                id("input").parentNode.parentNode.style.width = "49%";
            }
        }
    };
    // determine the specific language if auto or unknown
    method.app.langkey  = function dom_app_langkey(obj:any):[string, string, string] {
        let defaultval:string  = "",
            defaultt:string    = "",
            value:languageAuto;
        const language:language    = prettydiff.api.language,
            langdefault:HTMLInputElement = id("option-language_default");
        if (typeof language !== "object") {
            return ["", "", ""];
        }
        defaultval = (langdefault === null)
            ? "javascript"
            : (langdefault.value === "text" && options.mode !== "diff")
                ? "javascript"
                : langdefault.value;
        defaultt = language.setlexer(defaultval);
        if (defaultval === "auto") {
            obj.name = "auto";
        }
        if (obj.name === "auto" && obj.sample !== "") {
            data.langvalue = language.auto(obj.sample, defaultt);
        } else if (obj.name === "csv") {
            data.langvalue = ["plain_text", "csv", "CSV"];
        } else if (obj.name === "text") {
            data.langvalue = ["plain_text", "text", "Plain Text"];
        } else if (obj.name !== "") {
            data.langvalue = [obj.name, language.setlexer(obj.name), language.nameproper(obj.name)];
        } else if (obj.sample !== "" || test.ace === false) {
            data.langvalue = language.auto(obj.sample, defaultt);
        } else {
            data.langvalue = [defaultt, language.setlexer(defaultt), language.nameproper(defaultt)];
        }
        value = data.langvalue;
        if (test.ace === true) {
            if (value[0] === "script" || value[0] === "tss") {
                value = ["javascript", value[1], value[2]];
            } else if (value[0] === "dustjs") {
                value = ["html", value[1], value[2]];
            } else if (value[0] === "markup") {
                value = ["xml", value[1], value[2]];
            } else if (value[1] === "style") {
                value = ["css", value[1], value[2]];
            }
            if (textarea.codeIn !== null) {
                if (value[0] === "vapor") {
                    aceStore
                        .codeIn
                        .getSession()
                        .setMode("ace/mode/html");
                } else {
                    aceStore
                        .codeIn
                        .getSession()
                        .setMode(`ace/mode/${value[0]}`);
                }
            }
            if (textarea.codeOut !== null) {
                if (value[0] === "vapor") {
                    aceStore
                        .codeOut
                        .getSession()
                        .setMode("ace/mode/html");
                } else {
                    aceStore
                        .codeOut
                        .getSession()
                        .setMode(`ace/mode/${value[0]}`);
                }
            }
        }
        if (obj.name === "text") {
            return ["text", "text", "Plain Text"];
        }
        if (obj.name !== "") {
            return value;
        }
        if (value.length < 1 && obj.name === "") {
            if (textarea.codeIn !== null) {
                value = language.auto(textarea.codeIn.value, defaultt);
            }
            if (value.length < 1) {
                return ["javascript", "script", "JavaScript"];
            }
            data.langvalue = value;
        }
        return value;
    };
    //store tool changes into localStorage to maintain state
    method.app.options  = function dom_app_options(event:Event):void {
        let x:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
            input:HTMLInputElement,
            select:HTMLSelectElement,
            item:HTMLElement,
            node:string   = "",
            value:string = "",
            xname:string  = "",
            type:string   = "",
            idval:string     = "",
            classy:string = "",
            h3:HTMLElement,
            body:HTMLElement,
            opt:HTMLOptionElement;
        xname = x.nodeName.toLowerCase();
        if (xname === "div") {
            if (x.getAttribute("class") === "box") {
                item = x;
            } else {
                if (x.getElementsByTagName("input")[0] === undefined) {
                    return;
                }
                item = x.getElementsByTagName("input")[0];
            }
        } else if (xname === "input" || xname === "textarea") {
            input = <HTMLInputElement>x;
            item = input;
        } else if (xname === "select") {
            select = <HTMLSelectElement>x;
            item = select;
        } else if (xname === "button") {
            item = <HTMLElement>x.parentNode;
            item = (item.nodeName.toLowerCase() === "a")
                ? <HTMLElement>item.parentNode.parentNode
                : <HTMLElement>item.parentNode
        } else {
            input = <HTMLInputElement>x.getElementsByTagName("input")[0];
            item = input;
        }
        if (test.load === false && item !== id("option-language")) {
            item.focus();
        }
        node   = item
            .nodeName
            .toLowerCase();
        xname  = item.getAttribute("name");
        type   = item.getAttribute("type");
        idval  = item.getAttribute("id");
        classy = item.getAttribute("class");
        if (test.load === true) {
            return;
        }
        if (node === "input") {
            if (type === "radio") {
                data.settings[xname] = idval;
            } else if (type === "text") {
                data.settings[idval] = input.value;
            }
        } else if (node === "select") {
            data.settings[idval] = select.selectedIndex;
        } else if (node === "div" && classy === "box") {
            h3   = item.getElementsByTagName("h3")[0];
            body = item.getElementsByTagName("div")[0];
            idval = idval.replace("report", "");
            if (data.settings.report[idval] === undefined) {
                data.settings.report[idval] = {};
            }
            if (body.style.display === "none" && h3.clientWidth < 175) {
                data.settings.report[idval].min = true;
                data.settings.report[idval].max = false;
            } else if (data.settings.report[idval].max === false || data.settings.report[idval].max === undefined) {
                data.settings.report[idval].min  = false;
                data.settings.report[idval].left = item.offsetLeft;
                data.settings.report[idval].top  = item.offsetTop;
                if (test.agent.indexOf("macintosh") > 0) {
                    data.settings.report[idval].width  = (body.clientWidth - 20);
                    data.settings.report[idval].height = (body.clientHeight - 53);
                } else {
                    data.settings.report[idval].width  = (body.clientWidth - 4);
                    data.settings.report[idval].height = (body.clientHeight - 36);
                }
            }
        } else if (node === "button" && idval !== null) {
            data.settings[idval] = item
                .innerHTML
                .replace(/\s+/g, " ");
        }
        if (test.store === true) {
            localStorage.setItem("settings", JSON.stringify(data.settings));
        }
        if (classy === "box" || page.getAttribute("id") !== "webtool") {
            return;
        }
        if (item.nodeName.toLowerCase() === "select") {
            opt  = <HTMLOptionElement>select[select.selectedIndex];
            value = opt.value;
        } else {
            value = input.value;
        }
        if (idval.indexOf("option-") === 0) {
            classy = idval.replace("option-", "");
            if (classy.indexOf("true-") === 0) {
                classy = classy.replace("true-", "");
                options[classy] = true;
            } else if (classy.indexOf("false-") === 0) {
                classy = classy.replace("false-", "");
                options[classy] = false;
            } else if (item.getAttribute("data-type") === "number") {
                if (isNaN(Number(value)) === false) {
                    options[classy] = Number(value);
                }
            } else {
                options[classy] = value;
            }
        } else if (idval === "inputlabel") {
            classy = "sourcelabel";
            options.source_label = value;
        } else if (idval === "outputlabel") {
            classy = "difflabel";
            options.diff_label = value;
        }
        if (classy !== null && options[classy] !== undefined && classy !== "source" && classy !== "diff") {
            let a:number = 0;
            const cslen:number = data.commentString.length;
            if (cslen > 0) {
                do {
                    if (data.commentString[a].slice(0, data.commentString[a].indexOf(":")) === classy) {
                        data.commentString.splice(a, 1);
                        break;
                    }
                    a = a + 1;
                } while (a < cslen);
            }
            if (typeof options[classy] === "number" || typeof options[classy] === "boolean") {
                data.commentString.push(`${classy}: ${options[classy]}`);
            } else {
                data.commentString.push(`${classy}: "${options[classy]}"`);
            }
            method.app.commentString();
        }
        if (test.ace === true && x.getAttribute("id") === "option-wrap" && isNaN(Number(input.value)) === false) {
            let numb:number = Number(input.value);
            if (numb < 1) {
                numb = 80;
            }
            aceStore.codeIn.setPrintMarginColumn(numb);
            aceStore.codeOut.setPrintMarginColumn(numb);
        }
    };

    //ace wrap slider
    method.event.aceSlider = function dom_app_aceSlider(event:Event):boolean {
        let subOffset:number = 0,
            cursorStatus:string = "ew",
            node:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
            slide:HTMLElement = <HTMLElement>node.parentNode,
            parent:HTMLElement = <HTMLElement>slide.parentNode,
            value:number = 0;
        const touch:boolean       = (event !== null && event.type === "touchstart"),
            width:number = parent.clientWidth,
            scale:number = 8.35,
            max:number = Math.round(((parent.offsetLeft + width) / scale) - scale),
            wrap = id("option-wrap");
        if (node.nodeName === "button") {
            node = slide;
            slide = parent;
            parent = <HTMLElement>parent.parentNode;
        }
        if (touch === true) {
            document.ontouchmove  = function dom_event_colSliderGrab_Touchboxmove(f:TouchEvent):void {
                f.preventDefault();
                subOffset = Math.round((f.touches[0].clientX / scale) - scale);
                if (subOffset > max) {
                    node.style.left = `${max}em`;
                    cursorStatus    = "e";
                    value = max;
                } else if (subOffset < 0) {
                    node.style.left = "0";
                    cursorStatus    = "w";
                    value = 0;
                } else if (subOffset < max && subOffset > 0) {
                    node.style.left = `${subOffset * 1.0035}em`;
                    cursorStatus    = "ew";
                    value = subOffset;
                }
                aceStore.codeIn.setPrintMarginColumn(value);
                aceStore.codeOut.setPrintMarginColumn(value);
                document.ontouchend = function dom_event_colSliderGrab_Touchboxmove_drop(f:TouchEvent):void {
                    f.preventDefault();
                    node.style.cursor = `${cursorStatus}-resize`;
                    node.getElementsByTagName("button")[0].style.cursor = `${cursorStatus}-resize`;
                    document.onmousemove = null;
                    document.onmouseup   = null;
                    wrap.value = value;
                    data.settings["option-wrap"] = value;
                    if (test.store === true) {
                        localStorage.setItem("settings", JSON.stringify(data.settings));
                    }
                    method.event.execute();
                };
            };
            document.ontouchstart = null;
        } else {
            document.onmousemove = function dom_event_colSliderGrab_Mouseboxmove(f:MouseEvent):void {
                f.preventDefault();
                subOffset = Math.round((f.clientX / scale) - scale);
                if (subOffset > max) {
                    node.style.left = `${max}em`;
                    cursorStatus    = "e";
                    value = max;
                } else if (subOffset < 0) {
                    node.style.left = "0";
                    cursorStatus    = "w";
                    value = 0;
                } else if (subOffset < max && subOffset > 0) {
                    node.style.left = `${subOffset * 1.0035}em`;
                    cursorStatus    = "ew";
                    value = subOffset;
                }
                aceStore.codeIn.setPrintMarginColumn(value);
                aceStore.codeOut.setPrintMarginColumn(value);
                document.onmouseup = function dom_event_colSliderGrab_Mouseboxmove_drop(f:MouseEvent):void {
                    f.preventDefault();
                    node.style.cursor = `${cursorStatus}-resize`;
                    node.getElementsByTagName("button")[0].style.cursor = `${cursorStatus}-resize`;
                    document.onmousemove = null;
                    document.onmouseup   = null;
                    wrap.value = value;
                    data.settings["option-wrap"] = value;
                    if (test.store === true) {
                        localStorage.setItem("settings", JSON.stringify(data.settings));
                    }
                    method.event.execute();
                };
            };
            document.onmousedown = null;
        }
        return false;
    };
    //allows visual folding of function in the JSPretty jsscope HTML output
    method.event.beaufold = function dom_event_beaufold(event:Event):void {
        let a:number     = 0,
            b:string     = "";
        const el:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
            title:string[] = el
                .getAttribute("title")
                .split("line "),
            parent:[HTMLElement, HTMLElement] = [<HTMLElement>el.parentNode, <HTMLElement>el.parentNode.nextSibling],
            min:number   = Number(title[1].substr(0, title[1].indexOf(" "))),
            max:number   = Number(title[2]),
            list:[HTMLCollectionOf<HTMLLIElement>, HTMLCollectionOf<HTMLLIElement>]  = [
                parent[0].getElementsByTagName("li"),
                parent[1].getElementsByTagName("li")
            ];
        a = min;
        if (el.innerHTML.charAt(0) === "-") {
            do {
                list[0][a].style.display = "none";
                list[1][a].style.display = "none";
                a = a + 1;
            } while (a < max);
            el.innerHTML = `+${el
                .innerHTML
                .substr(1)}`;
        } else {
            do {
                list[0][a].style.display = "block";
                list[1][a].style.display = "block";
                if (list[0][a].getAttribute("class") === "fold" && list[0][a].innerHTML.charAt(0) === "+") {
                    b = list[0][a].getAttribute("title");
                    b = b.substring(b.indexOf("to line ") + 1);
                    a = Number(b) - 1;
                }
                a = a + 1;
            } while (a < max);
            el.innerHTML = `-${el
                .innerHTML
                .substr(1)}`;
        }
    };
    //change the color scheme of the web UI
    method.event.colorScheme = function dom_event_colorScheme(event:Event):void {
        const item:HTMLSelectElement = id("option-color"),
            option:HTMLCollectionOf<HTMLOptionElement>    = item.getElementsByTagName("option"),
            optionLen:number = option.length,
            index:number     = (function dom_event_colorScheme_indexLen():number {
                if (item.selectedIndex < 0 || item.selectedIndex > optionLen) {
                    item.selectedIndex = optionLen - 1;
                    return optionLen - 1;
                }
                return item.selectedIndex;
            }()),
            color:string     = option[index]
                .innerHTML
                .toLowerCase()
                .replace(/\s+/g, ""),
            logo      = id("pdlogo"),
            output    = id("output");
        let theme:string     = "",
            logoColor:string = "";
        document
            .getElementsByTagName("body")[0]
            .setAttribute("class", color);
        if (test.ace === true && page.getAttribute("id") === "webtool") {
            if (color === "white") {
                theme = "ace/theme/textmate";
            }
            if (color === "shadow") {
                theme = "ace/theme/idle_fingers";
            }
            if (color === "canvas") {
                theme = "ace/theme/textmate";
            }
            aceStore
                .codeIn
                .setTheme(theme);
            aceStore
                .codeOut
                .setTheme(theme);
        }
        if (output !== null) {
            if (options.mode === "diff") {
                if (options.color === "white") {
                    output.style.background = "#fff";
                } else if (options.color === "shadow") {
                    output.style.background = "transparent";
                } else if (options.color === "canvas") {
                    output.style.background = "#f2f2f2";
                }
            } else {
                if (options.color === "white") {
                    output.style.background = "#f2f2f2";
                } else if (options.color === "shadow") {
                    output.style.background = "#111";
                } else if (options.color === "canvas") {
                    output.style.background = "#ccccc8";
                }
            }
        }
        if (logo !== null) {
            if (color === "canvas") {
                logoColor = "664";
            } else if (color === "shadow") {
                logoColor = "999";
            } else {
                logoColor = "666";
            }
            logo.style.borderColor = `#${logoColor}`;
            logo
                .getElementsByTagName("g")[0]
                .setAttribute("fill", `#${logoColor}`);
        }
        if (test.load === false && event !== null) {
            method
                .app
                .options(event);
        }
    };
    // allows grabbing and resizing columns (from the third column) in the diff
    // side-by-side report
    method.event.colSliderGrab = function dom_event_colSliderGrab(event:Event):boolean {
        let subOffset:number   = 0,
            withinRange:boolean = false,
            offset:number      = 0,
            cursorStatus:string      = "ew",
            diffLeft:HTMLElement,
            node:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target;
        const touch:boolean       = (event !== null && event.type === "touchstart"),
            diffRight:HTMLElement   = (function dom_event_colSliderGrab_nodeFix():HTMLElement {
                if (node.nodeName === "li") {
                    node = <HTMLElement>node.parentNode;
                }
                return <HTMLElement>node.parentNode;
            }()),
            diff:HTMLElement        = <HTMLElement>diffRight.parentNode,
            lists:HTMLCollectionOf<HTMLOListElement>       = diff.getElementsByTagName("ol"),
            par1:HTMLElement   = <HTMLElement>lists[2].parentNode,
            par2:HTMLElement   = <HTMLElement>lists[2].parentNode.parentNode,
            counter:number     = lists[0].clientWidth,
            data:number        = lists[1].clientWidth,
            width:number       = par1.clientWidth,
            total:number       = par2.clientWidth,
            min:number         = ((total - counter - data - 2) - width),
            max:number         = (total - width - counter),
            minAdjust:number   = min + 15,
            maxAdjust:number   = max - 20;
        diffLeft = <HTMLElement>diffRight.previousSibling;
        offset = par1.offsetLeft - par2.offsetLeft;
        event.preventDefault();
        if (report.code.box !== null) {
            offset = offset + report.code.box.offsetLeft;
            offset = offset - report.code.body.scrollLeft;
        } else {
            subOffset = (par1.scrollLeft > document.body.scrollLeft)
                ? par1.scrollLeft
                : document.body.scrollLeft;
            offset    = offset - subOffset;
        }
        offset             = offset + node.clientWidth;
        node.style.cursor  = "ew-resize";
        diff.style.width   = `${total / 10}em`;
        diff.style.display = "inline-block";
        if (diffLeft.nodeType !== 1) {
            do {
                diffLeft = <HTMLElement>diffLeft.previousSibling;
            } while (diffLeft.nodeType !== 1);
        }
        diffLeft.style.display   = "block";
        diffRight.style.width    = `${diffRight.clientWidth / 10}em`;
        diffRight.style.position = "absolute";
        if (touch === true) {
            document.ontouchmove  = function dom_event_colSliderGrab_Touchboxmove(f:TouchEvent):void {
                f.preventDefault();
                subOffset = offset - f.touches[0].clientX;
                if (subOffset > minAdjust && subOffset < maxAdjust) {
                    withinRange = true;
                }
                if (withinRange === true && subOffset > maxAdjust) {
                    diffRight.style.width = `${(total - counter - 2) / 10}em`;
                    cursorStatus          = "e";
                } else if (withinRange === true && subOffset < minAdjust) {
                    diffRight.style.width = `${(total - counter - data - 2) / 10}em`;
                    cursorStatus          = "w";
                } else if (subOffset < max && subOffset > min) {
                    diffRight.style.width = `${(width + subOffset) / 10}em`;
                    cursorStatus          = "ew";
                }
                document.ontouchend = function dom_event_colSliderGrab_Touchboxmove_drop(f:TouchEvent):void {
                    f.preventDefault();
                    node.style.cursor = `${cursorStatus}-resize`;
                    document.ontouchmove = null;
                    document.ontouchend  = null;
                };
            };
            document.ontouchstart = null;
        } else {
            document.onmousemove = function dom_event_colSliderGrab_Mouseboxmove(f:MouseEvent):void {
                f.preventDefault();
                subOffset = offset - f.clientX;
                if (subOffset > minAdjust && subOffset < maxAdjust) {
                    withinRange = true;
                }
                if (withinRange === true && subOffset > maxAdjust) {
                    diffRight.style.width = `${(total - counter - 2) / 10}em`;
                    cursorStatus          = "e";
                } else if (withinRange === true && subOffset < minAdjust) {
                    diffRight.style.width = `${(total - counter - data - 2) / 10}em`;
                    cursorStatus          = "w";
                } else if (subOffset < max && subOffset > min) {
                    diffRight.style.width = `${(width + subOffset) / 10}em`;
                    cursorStatus          = "ew";
                }
                document.onmouseup = function dom_event_colSliderGrab_Mouseboxmove_drop(f:MouseEvent):void {
                    f.preventDefault();
                    node.style.cursor = `${cursorStatus}-resize`;
                    document.onmousemove = null;
                    document.onmouseup   = null;
                };
            };
            document.onmousedown = null;
        }
        return false;
    };
    //allows visual folding of consecutive equal lines in a diff report
    method.event.difffold = function dom_event_difffold(event:Event):void {
        let a:number         = 0,
            b:number         = 0,
            max:number,
            lists:HTMLCollectionOf<HTMLLIElement>[] = [];
        const node:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
            title:string[]     = node
                .getAttribute("title")
                .split("line "),
            min:number       = Number(title[1].substr(0, title[1].indexOf(" "))),
            inner:string     = node.innerHTML,
            parent:HTMLElement    = <HTMLElement>node.parentNode.parentNode,
            par1:HTMLElement = <HTMLElement>parent.parentNode,
            listnodes:HTMLCollectionOf<HTMLOListElement> = (parent.getAttribute("class") === "diff")
                ? parent.getElementsByTagName("ol")
                : par1.getElementsByTagName("ol"),
            listLen:number   = listnodes.length;
        do {
            lists.push(listnodes[a].getElementsByTagName("li"));
            a = a + 1;
        } while (a < listLen);
        max = (max >= lists[0].length)
            ? lists[0].length
            : Number(title[2]);
        if (inner.charAt(0) === "-") {
            node.innerHTML = `+${inner.substr(1)}`;
            a = min;
            if (min < max) {
                do {
                    b = 0;
                    do {
                        lists[b][a].style.display = "none";
                        b = b + 1;
                    } while (b < listLen);
                    a = a + 1;
                } while (a < max);
            }
        } else {
            node.innerHTML = `-${inner.substr(1)}`;
            a = min;
            if (min < max) {
                do {
                    b = 0;
                    do {
                        lists[b][a].style.display = "block";
                        b = b + 1;
                    } while (b < listLen);
                    a = a + 1;
                } while (a < max);
            }
        }
    };
    // execute bundles arguments in preparation for executing prettydiff references
    method.event.execute = function dom_event_execute(event:KeyboardEvent):boolean {
        let lang:[string, string, string],
            errortext:string   = "",
            requests:boolean    = false,
            requestd:boolean    = false,
            completed:boolean   = false,
            completes:boolean   = false,
            autolang:boolean    = false,
            autolexer:boolean = false,
            node:HTMLSelectElement        = id("option-jsscope");
        const startTime:number = Date.now(),
            lex:HTMLSelectElement = id("option-lexer"),
            lexval:HTMLOptionElement = (lex === null)
                ? null
                : <HTMLOptionElement>lex[lex.selectedIndex],
            langvalue:string = (id("option-language") === null || id("option-language").value === "" || lexval === null || lexval.value === "" || lexval.value === "auto")
                ? "auto"
                : id("option-language").value,
            ann:HTMLParagraphElement = id("announcement"),
            domain:RegExp       = (/^((https?:\/\/)|(file:\/\/\/))/),
            lf:HTMLInputElement = id("option-crlf"),
            opt:HTMLOptionElement = <HTMLOptionElement>node[node.selectedIndex],
            textout:boolean     = (options.jsscope !== "report" && (node === null || opt.value !== "report")),
            app = function dom_event_execute_app() {
                let output:string = "";
                const sanitize = function dom_event_execute_app_sanitize(input:string):string {
                        return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
                    },
                    renderOutput  = function dom_event_execute_app_renderOutput():void {
                        let diffList:HTMLCollectionOf<HTMLOListElement>,
                            button:HTMLButtonElement,
                            buttons:HTMLCollectionOf<HTMLButtonElement>,
                            pdlang:string     = "",
                            parent:HTMLElement,
                            chromeSave:boolean = false;
                        const commanumb  = function dom_event_execute_app_renderOutput_commanumb(numb):string {
                                let str:string = "",
                                    len:number = 0,
                                    arr:string[] = [];
                                if (typeof numb !== "number" || isNaN(numb) === true) {
                                    return numb;
                                }
                                str = String(numb);
                                if (str.length < 4) {
                                    return str;
                                }
                                arr = str.split("");
                                len = str.length - 4
                                do {
                                    arr[len] = `${arr[len]},`;
                                    len = len - 3;
                                } while (len > -1);
                                return arr.join("");
                            },
                            langtext = function dom_event_execute_app_renderOutput_langtext():string {
                                if (autolang === true) {
                                    return `Code type is set to <em>auto</em>. Presumed language is <strong>${data.langvalue[2]}</strong>.`;
                                }
                                if (autolexer === true) {
                                    return `Language is set to <strong>${data.langvalue[2]}</strong>. Presumed lexer is <strong>${data.langvalue[1]}</strong>.`;
                                }
                                if (options.language === "text") {
                                    return `Language set to <strong>Plain Text</strong>.`;
                                }
                                return `Language set to <strong>${data.langvalue[2]}</strong>.`;
                            };
                        meta.time = (function dom_event_execute_app_renderOutput_proctime() {
                            const plural       = function dom_event_execute_app_renderOutput_proctime_plural(x:number, y:string):string {
                                    let a = x + y;
                                    if (x !== 1) {
                                        a = `${a}s`;
                                    }
                                    if (y !== " second") {
                                        a = `${a} `;
                                    }
                                    return a;
                                },
                                minute       = function dom_event_execute_app_renderOutput_proctime_minute():void {
                                    minutes      = elapsed / 60;
                                    minuteString = plural(minutes, " minute");
                                    minutes      = elapsed - (minutes * 60);
                                    secondString = (minutes === 1)
                                        ? "1 second"
                                        : `${minutes.toFixed(3)} seconds`;
                                };
                            let elapsed:number      = (Date.now() - startTime) / 1000,
                                minuteString:string = "",
                                hourString:string   = "",
                                minutes:number      = 0,
                                hours:number        = 0,
                                secondString:string = String(elapsed);
                            if (elapsed >= 60 && elapsed < 3600) {
                                minute();
                            } else if (elapsed >= 3600) {
                                hours      = elapsed / 3600;
                                hourString = hours.toString();
                                elapsed    = elapsed - (hours * 3600);
                                hourString = plural(hours, " hour");
                                minute();
                            } else {
                                secondString = plural(Number(secondString), " second");
                            }
                            return hourString + minuteString + secondString;
                        }());
                        meta.outsize = output.length;
                        data.zIndex = data.zIndex + 1;
                        if (autolexer === true) {
                            options.lexer = "auto";
                        }
                        button           = report
                            .code
                            .box
                            .getElementsByTagName("p")[0]
                            .getElementsByTagName("button")[0];
                        if (button.getAttribute("class") === "save" && button.innerHTML === "H") {
                            chromeSave       = true;
                            button.innerHTML = "S";
                        }
                        if (output.length > 125000) {
                            test.filled.code = true;
                        } else {
                            test.filled.code = false;
                        }
                        if ((options.mode === "parse" && options.parse_format === "table" && options.complete_document === false) || (options.language === "csv" && options.mode !== "diff")) {
                            if (report.code.box !== null) {
                                if (options.language === "csv") {
                                    let a:number       = 0,
                                        b:number       = output.length,
                                        c:number       = 0,
                                        d:number       = 0,
                                        cells:number   = 0,
                                        heading:boolean = false,
                                        tr:HTMLElement,
                                        table:HTMLElement,
                                        td:HTMLElement,
                                        body:HTMLElement,
                                        div:HTMLElement;
                                    do {
                                        if (output[a].length > cells) {
                                            cells = output[a].length;
                                        }
                                        a = a + 1;
                                    } while (a < b);
                                    if (b > 5) {
                                        c = output[0].length;
                                        a = 0;
                                        do {
                                            if (isNaN(Number(output[0][a])) === false || (output[0][a].length < 4 && output[0][a].length < output[1][a].length && output[0][a].length < output[2][a].length)) {
                                                break;
                                            }
                                            a = a + 1;
                                        } while (a < c);
                                        if (a === c) {
                                            a = 0;
                                            do {
                                                if (output[1][a] !== undefined && (isNaN(Number(output[1][a].charAt(0))) === false || output[1][a].length < 4)) {
                                                    break;
                                                }
                                                a = a + 1;
                                            } while (a < c);
                                            if (a < c) {
                                                do {
                                                    if (output[2][d] !== undefined && (isNaN(Number(output[2][d].charAt(0))) === false || output[2][d].length < 4)) {
                                                        if (d === a) {
                                                            heading = true;
                                                        }
                                                        break;
                                                    }
                                                    d = d + 1;
                                                } while (d < c);
                                            }
                                        }
                                    }
                                    div   = document.createElement("div");
                                    table = document.createElement("table");
                                    div.setAttribute("class", "doc");
                                    table.setAttribute("class", "analysis");
                                    table.setAttribute("summary", "CSV data");
                                    a = 0;
                                    if (heading === true) {
                                        a            = 1;
                                        body         = document.createElement("thead");
                                        tr           = document.createElement("tr");
                                        td           = document.createElement("th");
                                        td.innerHTML = "Index";
                                        tr.appendChild(td);
                                        c = 0;
                                        do {
                                            td = document.createElement("th");
                                            if (output[0][c] !== undefined) {
                                                td.innerHTML = output[0][c];
                                            }
                                            tr.appendChild(td);
                                            c = c + 1;
                                        } while (c < cells);
                                        body.appendChild(tr);
                                        table.appendChild(body);
                                    }
                                    body = document.createElement("tbody");
                                    do {
                                        tr = document.createElement("tr");
                                        td = document.createElement("td");
                                        if (a === 0) {
                                            td.innerHTML = "Index";
                                        } else {
                                            td.innerHTML = String(a);
                                        }
                                        tr.appendChild(td);
                                        c = 0;
                                        do {
                                            td = document.createElement("td");
                                            if (output[a][c] !== undefined) {
                                                td.innerHTML = output[a][c];
                                            }
                                            tr.appendChild(td);
                                            c = c + 1;
                                        } while (c < cells);
                                        body.appendChild(tr);
                                        a = a + 1;
                                    } while (a < b);
                                    table.appendChild(body);
                                    div.appendChild(table);
                                    report
                                        .code
                                        .body
                                        .appendChild(div);
                                } else if (options.mode === "parse") {
                                    if (report.code.box !== null) {
                                        const table:string[] = [];
                                        table.push("<div class='report'><h4>Parsed Output</h4>");
                                        table.push(output);
                                        table.push("</div>");
                                        output = `<p>${langtext()}</p>${table.join("")}`;
                                        report.code.body.innerHTML = output;
                                        if (report.code.body.style.display === "none") {
                                            report.code.box.getElementsByTagName("h3")[0].getElementsByTagName("button")[0].focus();
                                        }
                                        report.code.box.style.top   = `${data.settings.report.code.top / 10}em`;
                                        report.code.box.style.right = "auto";
                                    }
                                }
                            } else if (options.language !== "csv") {
                                if (test.ace === true) {
                                    aceStore
                                        .codeOut
                                        .setValue(output);
                                    aceStore
                                        .codeOut
                                        .clearSelection();
                                } else {
                                    textarea.codeOut.value = output;
                                }
                            }
                        } else if (options.mode === "beautify") {
                            if (options.jsscope === "report" && options.complete_document === false && report.code.box !== null && (data.langvalue[0] === "javascript" || data.langvalue[0] === "jsx") && output.indexOf("Error:") !== 0) {
                                report.code.body.innerHTML = output;
                                if (report.code.body.style.display === "none") {
                                    report.code.box.getElementsByTagName("h3")[0].getElementsByTagName("button")[0].focus();
                                }
                                report.code.box.style.top   = `${data.settings.report.code.top / 10}em`;
                                report.code.box.style.right = "auto";
                                diffList                                 = report
                                    .code
                                    .body
                                    .getElementsByTagName("ol");
                                if (diffList.length > 0) {
                                    const list:HTMLCollectionOf<HTMLLIElement> = diffList[0].getElementsByTagName("li");
                                    let a:number    = 0,
                                        b:number    = list.length;
                                    do {
                                        if (list[a].getAttribute("class") === "fold") {
                                            list[a].onclick = method.event.beaufold;
                                        }
                                        a = a + 1;
                                    } while (a < b);
                                }
                                return;
                            }
                            if (test.ace === true) {
                                aceStore
                                    .codeOut
                                    .setValue(output);
                                aceStore
                                    .codeOut
                                    .clearSelection();
                            } else {
                                textarea.codeOut.value = output;
                            }
                        } else if (options.mode === "diff" && report.code.box !== null) {
                            buttons          = report
                                .code
                                .box
                                .getElementsByTagName("p")[0]
                                .getElementsByTagName("button");
                            if (options.diff_format === "json" && options.diff_rendered_html === false) {
                                const json:diffJSON = JSON.parse(output).diff,
                                    len:number = json.length,
                                    tab:string = (function dom_event_execute_app_renderOutput_diffTab():string {
                                        const tabout:string[] = [];
                                        let aa:number = options.indent_size;
                                        do {
                                            tabout.push(options.indent_char);
                                            aa = aa - 1;
                                        } while (aa > 0);
                                        return tabout.join("");
                                    }()),
                                    json_output:string[] = [`{"diff": [`];
                                    let a:number = 0;
                                do {
                                    if (json[a][0] === "r") {
                                        json_output.push(`${tab}["${json[a][0]}", "${json[a][1].replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}", "${json[a][2].replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"],`);
                                    } else {
                                        json_output.push(`${tab}["${json[a][0]}", "${json[a][1].replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"],`);
                                    }
                                    a = a + 1;
                                } while (a < len);
                                json_output[json_output.length - 1] = json_output[json_output.length - 1].replace(/\],$/, "]");
                                json_output.push("]}");
                                output = `<textarea>${json_output.join("\n")}</textarea>`;
                            }
                            if (options.complete_document === true || options.diff_rendered_html === true) {
                                output = `<textarea>${sanitize(output)}</textarea>`;
                            }
                            report.code.body.innerHTML = `<p>${langtext()}</p><p><strong>Execution time:</strong> <em>${meta.time}</em></p>${output}`;
                            if ((autolang === true || autolexer === true) && report.code.body.firstChild !== null) {
                                if (report.code.body.firstChild.nodeType > 1) {
                                    report
                                        .code
                                        .body
                                        .removeChild(report.code.body.firstChild);
                                }
                            }
                            let textarea:HTMLTextAreaElement = report.code.body.getElementsByTagName("textarea")[0];
                            if (textarea === undefined) {
                                diffList = report
                                    .code
                                    .body
                                    .getElementsByTagName("ol");
                                if (diffList.length > 0) {
                                    const cells:HTMLCollectionOf<HTMLLIElement> = diffList[0].getElementsByTagName("li"),
                                        len:number   = cells.length;
                                    let a:number     = 0;
                                    do {
                                        if (cells[a].getAttribute("class") === "fold") {
                                            cells[a].onclick = method.event.difffold;
                                        }
                                        a = a + 1;
                                    } while (a < len);
                                }
                                if (options.diff_view === "sidebyside" && diffList.length > 3) {
                                    diffList[2].onmousedown  = method.event.colSliderGrab;
                                    diffList[2].ontouchstart = method.event.colSliderGrab;
                                }
                            } else {
                                textarea.style.height = `${(report.code.body.clientHeight - 140) / 12}em`;
                            }
                        } else if (options.mode === "minify" || options.mode === "parse") {
                            if (test.ace === true) {
                                aceStore
                                    .codeOut
                                    .setValue(output);
                                aceStore
                                    .codeOut
                                    .clearSelection();
                            } else {
                                textarea.codeOut.value = output;
                            }
                        }
                        if (ann !== null) {
                            if (errortext.indexOf("end tag") > 0 || errortext.indexOf("Duplicate id") > 0) {
                                ann.setAttribute("class", "error");
                                ann.innerHTML = sanitize(errortext);
                            } else if (id("jserror") !== null) {
                                ann.removeAttribute("class");
                                ann.innerHTML = `<strong>${id("jserror")
                                    .getElementsByTagName("strong")[0]
                                    .innerHTML}</strong> <span>See 'Code Report' for details</span>`;
                            } else {
                                ann.innerHTML = langtext();
                                if (options.mode === "parse" && options.parse_format !== "htmltable") {
                                    pdlang = "tokens";
                                } else {
                                    pdlang = "characters";
                                }
                                if (prettydiff.sparser.parseerror !== "" && ann !== null) {
                                    ann.innerHTML = `${ann.innerHTML}<span><strong>Parse Error:</strong> ${sanitize(prettydiff.sparser.parseerror)}</span>`;
                                } else if (meta.error === "" || meta.error === undefined) {
                                    ann.innerHTML = `${ann.innerHTML}<span><em>Execution time:</em> <strong>${sanitize(meta.time)}</strong>. <em>Output size:</em> <strong>${commanumb(meta.outsize)} ${pdlang}</strong></span>`;
                                } else {
                                    ann.innerHTML = `${ann.innerHTML}<span><strong>${sanitize(meta.error)}</strong></span>`;
                                }
                            }
                        }
                        buttons = report
                            .code
                            .box
                            .getElementsByTagName("p")[0]
                            .getElementsByTagName("button");
                        if (chromeSave === true) {
                            buttons[0].click();
                        }
                        parent = <HTMLElement>buttons[1].parentNode;
                        if (parent.style.display === "none" && (options.mode === "diff" || (options.mode === "beautify" && options.jsscope === "report" && lang[1] === "javascript"))) {
                            buttons[1].click();
                        }
                    };
                data.langvalue = lang;

                if (options.mode === "diff") {
                    if (prettydiff.beautify[options.lexer] === undefined && options.lexer !== "auto" && options.lexer !== "text") {
                        if (ann !== null) {
                            ann.innerHTML = `Library <em>prettydiff.beautify.${options.lexer}</em> is <strong>undefined</strong>.`;
                        }
                        options.language = "text";
                    }
                    let diffmeta = {
                        differences: 0,
                        lines: 0
                    };
                    meta.insize = options.source.length + options.diff.length;
                    output = prettydiff(diffmeta);
                    meta.difftotal = diffmeta.differences;
                    meta.difflines = diffmeta.lines;
                } else {
                    meta.insize = options.source.length;
                    output = prettydiff();
                    if (output.indexOf("Error: ") === 0) {
                        ann.innerHTML = output.replace("Error: ", "");
                        output = options.source;
                    }
                }
                renderOutput();
            };

        meta.error   = "";
        options.api  = "dom";
        options.crlf = (lf !== null && lf.checked === true);
        if (typeof event === "object" && event !== null && event.type === "keyup") {
            // jsscope does not get the convenience of keypress execution, because its
            // overhead is costly do not execute keypress from alt, home, end, or arrow keys
            if ((textout === false && options.mode === "beautify") || event.altKey === true || event.keyCode === 16 || event.keyCode === 18 || event.keyCode === 35 || event.keyCode === 36 || event.keyCode === 37 || event.keyCode === 38 || event.keyCode === 39 || event.keyCode === 40) {
                return false;
            }
            if (test.keypress === true) {
                if (test.keystore.length > 0) {
                    test
                        .keystore
                        .pop();
                    if (event.keyCode === 17 || event.ctrlKey === true || event.keyCode === 224) {
                        test.keypress = false;
                        test.keystore = [];
                    } else {
                        if (test.keystore.length === 0) {
                            test.keypress = false;
                        }
                        return false;
                    }
                }
            }
            if ((event.keyCode === 17 || event.ctrlKey === true || event.keyCode === 224) && test.keypress === true && test.keystore.length === 0) {
                test.keypress = false;
                return false;
            }
        }
        if (test.ace === true) {
            options.source = aceStore.codeIn.getValue();
        } else {
            options.source = textarea.codeIn.value;
        }
        if (options.source === undefined || options.source === "") {
            if (ann !== null) {
                ann.innerHTML = "No source sample to process.";
            }
            return false;
        }
        if (test.store === true) {
            if (options.source.length > 4800000) {
                // eslint-disable-next-line
                console.warn("Source sample too large to save in browser localStorage.");
            } else {
                localStorage.setItem("source", options.source);
            }
        }

        //gather updated dom nodes
        {
            const li:HTMLCollectionOf<HTMLLIElement> = id("addOptions").getElementsByTagName("li"),
                reg:RegExp = (/option-((true-)|(false-))?/);
            let a:number = li.length,
                select:HTMLSelectElement,
                input:HTMLInputElement,
                opt:HTMLOptionElement;
            do {
                a = a - 1;
                if (li[a].getElementsByTagName("div")[0].style.display === "none") {
                    select = li[a].getElementsByTagName("select")[0];
                    if (select === undefined) {
                        input = li[a].getElementsByTagName("input")[0];
                        if (input.getAttribute("type") === "radio") {
                            if (input.value === "false" && input.checked === true) {
                                options[input.getAttribute("id").replace(reg, "")] = false;
                            } else if (input.value === "false" && input.checked === false) {
                                options[input.getAttribute("id").replace(reg, "")] = true;
                            } else if (input.value === "true" && input.checked === true) {
                                options[input.getAttribute("id").replace(reg, "")] = true;
                            } else if (input.value === "true" && input.checked === false) {
                                options[input.getAttribute("id").replace(reg, "")] = false;
                            }
                        } else {
                            if (input.getAttribute("data-type") === "number") {
                                options[input.getAttribute("id").replace(reg, "")] = Number(input.value);
                            } else {
                                options[input.getAttribute("id").replace(reg, "")] = input.value;
                            }
                        }
                    } else {
                        opt = <HTMLOptionElement>select[select.selectedIndex];
                        options[select.getAttribute("id").replace(reg, "")] = opt.value;
                    }
                }
            } while (a > 0);
        }
        if (options.language === "") {
            options.language = "auto";
        }
        if (options.language === "auto") {
            autolang = true;
        }
        if (options.lexer === "auto") {
            autolexer = true;
        }
        if (test.ace === true) {
            options.source = aceStore.codeIn.getValue();
        } else {
            options.source = textarea.codeIn.value;
        }
        if (domain.test(options.source) === true) {
            const filetest:boolean       = (options.source.indexOf("file:///") === 0),
                protocolRemove:string = (filetest === true)
                    ? options
                        .source
                        .split(":///")[1]
                    : options
                        .source
                        .split("://")[1],
                slashIndex:number     = (protocolRemove !== undefined)
                    ? protocolRemove.indexOf("/")
                    : 0,
                xhr:XMLHttpRequest            = new XMLHttpRequest();
            if ((slashIndex > 0 || options.source.indexOf("http") === 0) && typeof protocolRemove === "string" && protocolRemove.length > 0) {
                requests = true;
                xhr.onreadystatechange = function dom_event_execute_xhrSource_statechange() {
                    if (xhr.readyState === 4) {
                        if (xhr.status === 200 || xhr.status === 0) {
                            options.source = xhr
                                .responseText
                                .replace(/\r\n/g, "\n");
                            if (options.mode !== "diff" || requestd === false || (requestd === true && completed === true)) {
                                if (test.ace === true) {
                                    lang = method
                                        .app
                                        .langkey({
                                            sample: aceStore.codeIn.getValue(),
                                            name: "auto"
                                        });
                                } else {
                                    lang = method
                                        .app
                                        .langkey({
                                            sample: options.source,
                                            name: "auto"
                                        });
                                }
                                app();
                                return;
                            }
                            completes = true;
                        } else {
                            options.source = "Error: transmission failure receiving source code from address.";
                        }
                    }
                };
                if (filetest === true) {
                    xhr.open("GET", options.source.replace(/(\s*)$/, "").replace(/%26/g, "&").replace(/%3F/, "?"), true);
                } else {
                    xhr.open("GET", `proxy.php?x=${options.source.replace(/(\s*)$/, "").replace(/%26/g, "&").replace(/%3F/, "?")}`, true);
                }
                xhr.send();
            }
        }
        if (options.mode === "diff") {
            if (id("inputlabel") !== null) {
                options.source_label = id("inputlabel").value;
            }
            if (id("outputlabel") !== null) {
                options.diff_label = id("outputlabel").value;
            }
            if (test.ace === true) {
                options.diff = aceStore.codeOut.getValue();
            } else {
                options.diff = textarea.codeOut.value;
            }
            if (options.diff === undefined || options.diff === "") {
                return false;
            }
            if (test.store === true) {
                localStorage.setItem("diff", options.diff);
            }
            if (options.language === "text" || options.lexer === "text") {
                options.language = "text";
                options.lexer = "text";
                options.language_name = "Plain Text";
                autolang = false;
                autolexer = false;
            }
            if (test.ace === true) {
                options.diff = aceStore.codeOut.getValue();
            } else {
                options.diff = textarea.codeOut.value;
            }
            if (domain.test(options.diff) === true) {
                const filetest:boolean       = (options.diff.indexOf("file:///") === 0),
                    protocolRemove:string = (filetest === true)
                        ? options
                            .diff
                            .split(":///")[1]
                        : options
                            .diff
                            .split("://")[1],
                    slashIndex:number     = (protocolRemove !== undefined)
                        ? protocolRemove.indexOf("/")
                        : 0,
                    xhr:XMLHttpRequest            = new XMLHttpRequest();
                if ((slashIndex > 0 || options.diff.indexOf("http") === 0) && typeof protocolRemove === "string" && protocolRemove.length > 0) {
                    requestd = true;
                    xhr.onreadystatechange = function dom_event_execute_xhrSource_statechange() {
                        if (xhr.readyState === 4) {
                            if (xhr.status === 200 || xhr.status === 0) {
                                options.diff = xhr
                                    .responseText
                                    .replace(/\r\n/g, "\n");
                                if (requests === false || (requests === true && completes === true)) {
                                    app();
                                    return;
                                }
                                completed = true;
                            } else {
                                options.diff = "Error: transmission failure receiving diff code from address.";
                            }
                        }
                    };
                    if (filetest === true) {
                        xhr.open("GET", options.diff.replace(/(\s*)$/, "").replace(/%26/g, "&").replace(/%3F/, "?"), true);
                    } else {
                        xhr.open("GET", `proxy.php?x=${options.diff.replace(/(\s*)$/, "").replace(/%26/g, "&").replace(/%3F/, "?")}`, true);
                    }
                    xhr.send();
                }
            }
        } else {
            if (ann !== null) {
                if (options.language === "text") {
                    ann.innerHTML = "The value of <em>options.language</em> is <strong>text</strong> but <em>options.mode</em> is not <strong>diff</strong>.";
                } else if (options.lexer === "text") {
                    ann.innerHTML = "The value of <em>options.lexer</em> is <strong>text</strong> but <em>options.mode</em> is not <strong>diff</strong>.";
                }
            }
        }
        if (requests === false && requestd === false) {
            if (langvalue === "auto") {
                if (test.ace === true) {
                    lang = method
                        .app
                        .langkey({
                            sample: aceStore.codeIn.getValue(),
                            name: "auto"
                        });
                } else {
                    lang = method
                        .app
                        .langkey({
                            sample: id("input").value,
                            name: "auto"
                        });
                }
            } else {
                lang = method.app.langkey({
                    sample: "",
                    name: langvalue
                });
            }
            app();
        }
    };
    // this function allows typing of tab characters into textareas without the
    // textarea loosing focus
    method.event.fixtabs = function dom_event_fixtabs(event:KeyboardEvent, node:HTMLInputElement):boolean {
        let start:string = "",
            end:string   = "",
            val:string   = "",
            sel:number   = 0;
        if (typeof event !== "object" || event === null || event.type !== "keydown" || event.keyCode !== 9 || typeof node.selectionStart !== "number" || typeof node.selectionEnd !== "number") {
            return true;
        }
        val              = node.value;
        sel              = node.selectionStart;
        start            = val.substring(0, sel);
        end              = val.substring(sel, val.length);
        node.value          = `${start}\t${end}`;
        node.selectionStart = sel + 1;
        node.selectionEnd   = sel + 1;
        event.preventDefault();
        return false;
    };
    //basic drag and drop for the report windows references events: minimize
    method.event.grab = function dom_event_grab(event:Event):boolean {
        const x:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
            box:HTMLElement        = (x.nodeName.toLowerCase() === "h3")
                ? <HTMLElement>x.parentNode
                : <HTMLElement>x.parentNode.parentNode,
            parent:HTMLElement     = box.getElementsByTagName("p")[0],
            save:boolean       = (parent.innerHTML.indexOf("save") > -1),
            minifyTest:boolean = (parent.style.display === "none"),
            buttons:HTMLCollectionOf<HTMLButtonElement>    = box
                .getElementsByTagName("p")[0]
                .getElementsByTagName("button"),
            minButton:HTMLButtonElement  = (save === true)
                ? buttons[1]
                : buttons[0],
            resize:HTMLButtonElement     = (save === true)
                ? buttons[3]
                : buttons[2],
            touch:boolean      = (event !== null && event.type === "touchstart"),
            mouseEvent = <MouseEvent>event,
            touchEvent = <TouchEvent>event,
            mouseX = (touch === true)
                ? 0
                : mouseEvent.clientX,
            mouseY = (touch === true)
                ? 0
                : mouseEvent.clientY,
            touchX = (touch === true)
                ? touchEvent.touches[0].clientX
                : 0,
            touchY = (touch === true)
                ? touchEvent.touches[0].clientY
                : 0,
            filled:boolean     = ((box === report.stat.box && test.filled.stat === true) || (box === report.feed.box && test.filled.feed === true) || (box === report.code.box && test.filled.code === true)),    
            drop       = function dom_event_grab_drop(e:Event):boolean {
                const headingWidth = box.getElementsByTagName("h3")[0].clientWidth,
                    idval   = box.getAttribute("id").replace("report", "");
                boxLeft = box.offsetLeft;
                boxTop  = box.offsetTop;
                if (touch === true) {
                    document.ontouchmove = null;
                    document.ontouchend  = null;
                } else {
                    document.onmousemove = null;
                    document.onmouseup   = null;
                }
                if (boxTop < 10) {
                    box.style.top = "1em";
                } else if (boxTop > (max - 40)) {
                    box.style.top = `${(max / 10) - 4}em`;
                } else {
                    box.style.top = `${boxTop / 10}em`;
                }
                if (boxLeft < ((headingWidth * -1) + 40)) {
                    box.style.left = `${((headingWidth * -1) + 40) / 10}em`;
                }
                data.settings.report[idval].top    = boxTop;
                data.settings.report[idval].left   = boxLeft;
                body.style.opacity = "1";
                box.style.height   = "auto";
                heading.style.top  = "100%";
                resize.style.top   = "100%";
                method
                    .app
                    .options(e);
                e.preventDefault();
                return false;
            },
            boxmoveTouch    = function dom_event_grab_touch(f:TouchEvent):boolean {
                f.preventDefault();
                box.style.right = "auto";
                box.style.left      = `${(boxLeft + (f.touches[0].clientX - touchX)) / 10}em`;
                box.style.top       = `${(boxTop + (f.touches[0].clientY - touchY)) / 10}em`;
                document.ontouchend = drop;
                return false;
            },
            boxmoveClick = function dom_event_grab_click(f:MouseEvent):boolean {
                f.preventDefault();
                box.style.right = "auto";
                box.style.left     = `${(boxLeft + (f.clientX - mouseX)) / 10}em`;
                box.style.top      = `${(boxTop + (f.clientY - mouseY)) / 10}em`;
                document.onmouseup = drop;
                return false;
            };
        let boxLeft:number    = box.offsetLeft,
            boxTop:number     = box.offsetTop,
            body:HTMLElement       = box.getElementsByTagName("div")[0],
            heading:HTMLElement    = (box.firstChild.nodeType > 1)
                ? <HTMLElement>box.firstChild.nextSibling
                : <HTMLElement>box.firstChild,
            max:number        = document.getElementsByTagName("body")[0].clientHeight;
        if (minifyTest === true) {
            if (filled === true) {
                box.style.right = "auto";
            } else {
                box.style.left = "auto";
            }
            minButton.click();
            return false;
        }
        method
            .app
            .zTop(box);
        event.preventDefault();
        if (body.nodeType !== 1) {
            do {
                body = <HTMLElement>body.previousSibling;
            } while (body.nodeType !== 1);
        }
        if (heading.nodeType !== 1) {
            do {
                heading = <HTMLElement>heading.nextSibling;
            } while (heading.nodeType !== 1);
        }
        heading = <HTMLElement>heading.lastChild;
        if (heading.nodeType !== 1) {
            do {
                heading = <HTMLElement>heading.previousSibling;
            } while (heading.nodeType !== 1);
        }
        body.style.opacity = ".5";
        heading.style.top  = `${box.clientHeight / 20}0em`;
        box.style.height   = ".1em";
        resize.style.top   = `${(Number(body.style.height.replace("em", "")) + 5.45) / 1.44}em`;
        if (touch === true) {
            document.ontouchmove  = boxmoveTouch;
            document.ontouchstart = null;
        } else {
            document.onmousemove = boxmoveClick;
            document.onmousedown = null;
        }
        method
            .app
            .options(event);
        return false;
    };
    //tests if a key press is a short command
    method.event.keydown = function dom_event_keydown(event:KeyboardEvent):void {
        if (test.keypress === true && (test.keystore.length === 0 || event.keyCode !== test.keystore[test.keystore.length - 1]) && event.keyCode !== 17 && event.keyCode !== 224) {
            test
                .keystore
                .push(event.keyCode);
        }
        if (event.keyCode === 17 || event.ctrlKey === true || event.keyCode === 224) {
            test.keypress = true;
        }
    };
    //maximize report window to available browser window
    method.event.maximize = function dom_event_maximize(event:Event):void {
        let node:HTMLElement = <HTMLElement>event.srcElement || <HTMLElement>event.target,
            parent:HTMLElement,
            save:boolean    = false,
            box:HTMLElement,
            idval:string      = "",
            heading:HTMLElement,
            body:HTMLElement,
            top:number,
            left:number,
            buttons:HTMLCollectionOf<HTMLButtonElement>,
            resize:HTMLButtonElement,
            textarea:HTMLCollectionOf<HTMLTextAreaElement>;
        if (node.nodeType !== 1) {
            return;
        }
        parent = <HTMLElement>document.body.parentNode;
        left = (parent.scrollLeft > document.body.scrollLeft)
            ? parent.scrollLeft
            : document.body.scrollLeft;
        top = (parent.scrollTop > document.body.scrollTop)
            ? parent.scrollTop
            : document.body.scrollTop;
        parent = <HTMLElement>node.parentNode;
        buttons = parent.getElementsByTagName("button");
        resize  = buttons[buttons.length - 1];
        save    = (parent.innerHTML.indexOf("save") > -1);
        box     = <HTMLElement>parent.parentNode;
        idval   = box.getAttribute("id").replace("report", "");
        heading = box.getElementsByTagName("h3")[0];
        body    = box.getElementsByTagName("div")[0];
        method
            .app
            .zTop(box);

        //maximize
        if (node.innerHTML === "\u2191") {
            node.innerHTML = "\u2193";
            node.setAttribute("title", "Return this dialogue to its prior size and location.");
            data.settings.report[idval].max = true;
            data.settings.report[idval].min = false;
            if (test.store === true) {
                localStorage.setItem("settings", JSON.stringify(data.settings));
            }
            data.settings.report[idval].top    = box.offsetTop;
            data.settings.report[idval].left   = box.offsetLeft;
            data.settings.report[idval].height = body.clientHeight - 36;
            data.settings.report[idval].width  = body.clientWidth - 3;
            data.settings.report[idval].zindex = box.style.zIndex;
            box.style.top               = `${top / 10}em`;
            box.style.left              = `${left / 10}em`;
            if (typeof window.innerHeight === "number") {
                body.style.height = `${(window.innerHeight / 10) - 5.5}em`;
                if (save === true) {
                    heading.style.width = `${(window.innerWidth / 10) - 13.76}em`;
                } else {
                    heading.style.width = `${(window.innerWidth / 10) - 10.76}em`;
                }
                body.style.width = `${(window.innerWidth / 10) - 4.1}em`;
            }
            resize.style.display = "none";

            //return to normal size
        } else {
            data.settings.report[idval].max = false;
            node.innerHTML              = "\u2191";
            node.setAttribute("title", "Maximize this dialogue to the browser window.");
            box.style.top  = `${data.settings.report[idval].top / 10}em`;
            box.style.left = `${data.settings.report[idval].left / 10}em`;
            if (save === true) {
                heading.style.width = `${(data.settings.report[idval].width / 10) - 9.76}em`;
            } else {
                heading.style.width = `${(data.settings.report[idval].width / 10) - 6.76}em`;
            }
            body.style.width     = `${data.settings.report[idval].width / 10}em`;
            body.style.height    = `${data.settings.report[idval].height / 10}em`;
            box.style.zIndex     = data.settings.report[idval].zindex;
            resize.style.display = "block";
            method
                .app
                .options(event);
        }
        textarea = body.getElementsByTagName("textarea");
        if (textarea.length === 1) {
            textarea[0].style.height = `${(body.clientHeight - 140) / 12}em`;
        }
    };
    //minimize report windows to the default size and location
    method.event.minimize = function dom_event_minimize(e:Event):boolean {
        const node:HTMLElement = <HTMLElement>e.srcElement || <HTMLElement>e.target,
            growth    = function dom_event_minimize_growth():boolean {
                let width:number        = 17,
                    height:number       = 3,
                    leftTarget:number   = 0,
                    topTarget:number    = 0,
                    widthTarget:number  = 0,
                    heightTarget:number = 0,
                    incW:number         = 0,
                    incH:number         = 0,
                    incL:number         = 0,
                    incT:number         = 0,
                    saveSpace:number    = (save === true)
                        ? 9.45
                        : 6.45,
                    grow         = function dom_event_minimize_growth_grow():boolean {
                        width                    = width + incW;
                        height                   = height + incH;
                        left                = left + incL;
                        top                 = top + incT;
                        body.style.width    = `${width}em`;
                        body.style.height   = `${height}em`;
                        heading.style.width = `${width - saveSpace}em`;
                        box.style.left      = `${left}em`;
                        box.style.top       = `${top}em`;
                        if (width + incW < widthTarget || height + incH < heightTarget) {
                            setTimeout(dom_event_minimize_growth_grow, 1);
                        } else {
                            box.style.left      = `${leftTarget}em`;
                            box.style.top       = `${topTarget}em`;
                            body.style.width    = `${widthTarget}em`;
                            body.style.height   = `${heightTarget}em`;
                            heading.style.width = `${widthTarget - saveSpace}em`;
                            method
                                .app
                                .options(e);
                            if (textarea.length === 1) {
                                textarea[0].style.display = "block";
                                textarea[0].style.height = `${(body.clientHeight - 140) / 12}em`;
                            }
                            return false;
                        }
                        return true;
                    };
                method
                    .app
                    .zTop(box);
                buttonMin.innerHTML   = "\u035f";
                parent.style.display  = "block";
                box.style.borderWidth = ".1em";
                box.style.right       = "auto";
                body.style.display    = "block";
                heading.getElementsByTagName("button")[0].style.cursor = "move";
                heading.style.borderLeftStyle                          = "none";
                heading.style.borderTopStyle                           = "none";
                heading.style.margin                                   = "-0.1em 1.7em -3.2em -0.1em";
                if (test.agent.indexOf("macintosh") > 0) {
                    saveSpace = (save === true)
                        ? 8
                        : 5;
                }
                if (typeof data.settings.report[idval].left === "number") {
                    leftTarget   = (data.settings.report[idval].left / 10);
                    topTarget    = (data.settings.report[idval].top / 10);
                    widthTarget  = (data.settings.report[idval].width / 10);
                    heightTarget = (data.settings.report[idval].height / 10);
                } else {
                    top                    = top + 4;
                    data.settings.report[idval].left   = 200;
                    data.settings.report[idval].top    = (top * 10);
                    data.settings.report[idval].width  = 550;
                    data.settings.report[idval].height = 450;
                    leftTarget                  = 10;
                    topTarget                   = 2;
                    widthTarget                 = 55;
                    heightTarget                = 45;
                }
                widthTarget  = widthTarget - 0.3;
                heightTarget = heightTarget - 3.55;
                if (step === 1) {
                    box.style.left    = `${leftTarget}em`;
                    box.style.top     = `${topTarget}em`;
                    body.style.width  = `${widthTarget}em`;
                    body.style.height = `${heightTarget}em`;
                    heading.style.width    = `${widthTarget - saveSpace}em`;
                    body.style.right = "auto";
                    body.style.display = "block";
                    box.getElementsByTagName("p")[0].style.display = "block";
                    method
                        .app
                        .options(e);
                    if (textarea.length === 1) {
                        textarea[0].style.display = "block";
                        textarea[0].style.height = `${(body.clientHeight - 140) / 12}em`;
                    }
                    return false;
                }
                incW                    = (widthTarget > width)
                    ? ((widthTarget - width) / step)
                    : ((width - widthTarget) / step);
                incH                    = (heightTarget > height)
                    ? ((heightTarget - height) / step)
                    : ((height - heightTarget) / step);
                incL                    = (leftTarget - left) / step;
                incT                    = (topTarget - top) / step;
                box.style.right    = "auto";
                body.style.display = "block";
                grow();
                return false;
            },
            shrinkage = function dom_event_minimize_shrinkage():boolean {
                let width        = body.clientWidth / 10,
                    height       = body.clientHeight / 10,
                    incL         = (((window.innerWidth / 10) - final - 17) - left) / step,
                    incT         = 0,
                    incW         = (width === 17)
                        ? 0
                        : (width > 17)
                            ? ((width - 17) / step)
                            : ((17 - width) / step),
                    incH         = height / step,
                    shrink       = function dom_event_minimize_shrinkage_shrink():boolean {
                        left                = left + incL;
                        top                 = top + incT;
                        width                    = width - incW;
                        height                   = height - incH;
                        body.style.width    = `${width}em`;
                        heading.style.width = `${width}em`;
                        body.style.height   = `${height}em`;
                        box.style.left      = `${left}em`;
                        box.style.top       = `${top}em`;
                        if (width - incW > 16.8) {
                            setTimeout(dom_event_minimize_shrinkage_shrink, 1);
                        } else {
                            box.style.left      = "auto";
                            box.style.top       = "auto";
                            box.style.right     = `${final}em`;
                            data.settings.report[idval].max = false;
                            body.style.display  = "none";
                            heading.getElementsByTagName("button")[0].style.cursor = "pointer";
                            heading.style.margin                                   = "-0.1em 0em -3.2em -0.1em";
                            box.style.zIndex                                            = "2";
                            method
                                .app
                                .options(e);
                            return false;
                        }
                        return true;
                    };
                parentNode = <HTMLElement>box.parentNode;
                incT = (((parentNode.offsetTop / 10) - top) / step);
                buttonMin.innerHTML = "\u2191";
                if (textarea.length === 1) {
                    textarea[0].style.display = "none";
                }
                //if a maximized window is minimized
                if (buttonMax.innerHTML === "\u2191") {
                    if (test.agent.indexOf("macintosh") > 0) {
                        data.settings.report[idval].top    = box.offsetTop;
                        data.settings.report[idval].left   = box.offsetLeft;
                        data.settings.report[idval].height = body.clientHeight - 17;
                        data.settings.report[idval].width  = body.clientWidth - 17;
                    } else {
                        data.settings.report[idval].top    = box.offsetTop;
                        data.settings.report[idval].left   = box.offsetLeft;
                        data.settings.report[idval].height = body.clientHeight;
                        data.settings.report[idval].width  = body.clientWidth;
                    }
                    if (data.zIndex > 2) {
                        data.zIndex      = data.zIndex - 3;
                        parent.style.zIndex = data.zIndex;
                    }
                } else {
                    buttonMax.innerHTML         = "\u2191";
                    data.settings.report[idval].top    = data.settings.report[idval].top + 1;
                    data.settings.report[idval].left   = data.settings.report[idval].left - 7;
                    data.settings.report[idval].height = data.settings.report[idval].height + 35.5;
                    data.settings.report[idval].width  = data.settings.report[idval].width + 3;
                }
                parent.style.display = "none";
                shrink();
                return false;
            };
        let parent:HTMLElement = <HTMLElement>node.parentNode,
            parentNode:HTMLElement,
            box:HTMLElement,
            final:number    = 0,
            idval:string        = "",
            body:HTMLElement,
            heading:HTMLElement,
            buttons:HTMLCollectionOf<HTMLButtonElement>,
            save:boolean      = false,
            buttonMin:HTMLButtonElement,
            buttonMax:HTMLButtonElement,
            left:number      = 0,
            top:number       = 0,
            buttonRes:HTMLButtonElement,
            textarea:HTMLCollectionOf<HTMLTextAreaElement>,
            step:number      = (parent.style.display === "none" && (options.mode === "diff" || (options.mode === "beautify" && options.jsscope === "report" && options.lang === "javascript")))
                ? 1
                : 50;
        if (node.parentNode.nodeName.toLowerCase() === "h3") {
            heading = <HTMLElement>node.parentNode;
            box     = <HTMLElement>heading.parentNode;
            parent  = box.getElementsByTagName("p")[0];
        } else {
            parent  = (node.parentNode.nodeName.toLowerCase() === "a")
                ? <HTMLElement>node.parentNode.parentNode
                : <HTMLElement>node.parentNode;
            box     = <HTMLElement>parent.parentNode;
            heading = box.getElementsByTagName("h3")[0];
        }
        idval                   = box.getAttribute("id").replace("report", "");
        body                    = box.getElementsByTagName("div")[0];
        textarea                = body.getElementsByTagName("textarea");
        buttons                 = parent.getElementsByTagName("button");
        save                    = (parent.innerHTML.indexOf("save") > -1);
        buttonMin               = (save === true)
            ? buttons[1]
            : buttons[0];
        buttonMax               = (save === true)
            ? buttons[2]
            : buttons[1];
        left                    = (box.offsetLeft / 10 > 1)
            ? box.offsetLeft / 10
            : 1;
        top                     = (box.offsetTop / 10 > 1)
            ? box.offsetTop / 10
            : 1;
        buttonRes               = (save === true)
            ? buttons[3]
            : buttons[2];
        buttonRes.style.display = "block";
        if (box === report.feed.box) {
            if (test.filled.feed === true) {
                step = 1;
            }
            final = 38.8;
        }
        if (box === report.code.box) {
            if (test.filled.code === true) {
                step = 1;
            }
            final = 19.8;
        }
        if (box === report.stat.box) {
            if (test.filled.stat === true) {
                step = 1;
            }
            final = 0.8;
        }
        if (typeof e.preventDefault === "function") {
            e.preventDefault();
        }
        if (buttonMin.innerHTML === "\u035f") {
            shrinkage();
        } else {
            growth();
        }
        return false;
    };
    //toggles between modes
    method.event.modeToggle = function dom_event_modeToggle(mode:string):void {
        const commentString = function dom_event_modeToggle_commentString():void {
                const value:string = `mode: "${options.mode}"`;
                let a:number = data.commentString.length;
                if (a > 0) {
                    do {
                        a = a - 1;
                        if (data.commentString[a].indexOf("mode:") === 0) {
                            data.commentString[a] = value;
                            break;
                        }
                        if (data.commentString[a] < "mode:") {
                            data.commentString.splice(a, 0, value);
                            break;
                        }
                    } while (a > 0);
                } else {
                    data.commentString.push(value);
                }
                method.app.commentString();
            },
            cycleOptions = function dom_event_modeToggle_cycleOptions():void {
                const li:HTMLLIElement[] = id("addOptions").getElementsByTagName("li"),
                    lilen:number = li.length,
                    disable = function dom_event_modeToggle_cycleOptions_disable(parent:HTMLElement, enable:boolean):void {
                        const inputs:HTMLCollectionOf<HTMLInputElement> = parent.getElementsByTagName("input"),
                            sels:HTMLCollectionOf<HTMLSelectElement> = parent.getElementsByTagName("select");
                        if (sels.length > 0) {
                            if (enable === true) {
                                sels[0].disabled = false;
                            } else {
                                sels[0].disabled = true;
                            }
                        } else {
                            if (enable === true) {
                                inputs[0].disabled = false;
                            } else {
                                inputs[0].disabled = true;
                            }
                            if (inputs.length > 1) {
                                if (enable === true) {
                                    inputs[1].disabled = false;
                                } else {
                                    inputs[1].disabled = true;
                                }
                            }
                        }
                    };
                let a:number = 0,
                    div:HTMLDivElement,
                    modeat:string;
                do {
                    if (li[a].getAttribute("data-mode") !== "any") {
                        div = li[a].getElementsByTagName("div")[0];
                        modeat = li[a].getAttribute("data-mode");
                        if (modeat !== mode && mode !== "diff") {
                            div.innerHTML = `This option is not available in mode '${mode}'.`;
                            div.style.display = "block";
                            disable(li[a], false);
                        } else if (mode === "diff" && modeat !== "diff" && modeat !== "beautify") {
                            div.innerHTML = `This option is not available in mode '${mode}'.`;
                            div.style.display = "block";
                            disable(li[a], false);
                        } else {
                            div.style.display = "none";
                            disable(li[a], true);
                        }
                    }
                    a = a + 1;
                } while (a < lilen);
            },
            makeChanges = function dom_event_modeToggle_makeChanges():void {
                const text:string = mode.charAt(0).toUpperCase() + mode.slice(1),
                    ci:HTMLElement = id("codeInput"),
                    cilabel:HTMLCollectionOf<HTMLLabelElement> = ci.getElementsByTagName("label"),
                    input:HTMLTextAreaElement = id("input"),
                    output:HTMLTextAreaElement = id("output"),
                    outLabel:HTMLElement = <HTMLElement>ci.getElementsByClassName("inputLabel")[1],
                    sourceLabel:HTMLElement = id("inputlabel").parentNode,
                    outputLabel:HTMLElement = id("outputlabel").parentNode,
                    outputFile:HTMLElement = id("outputfile").parentNode;
                if (mode === "diff") {
                    ci.getElementsByTagName("h2")[0].innerHTML = "Compare Code";
                    cilabel[0].innerHTML = "Base File";
                    cilabel[2].innerHTML = "Compare code sample";
                    cilabel[5].innerHTML = " Compare new code"
                    outLabel.style.marginTop = "0";
                    sourceLabel.style.display = "block";
                    outputLabel.style.display = "block";
                    outputFile.style.display = "block";
                    id("slider").style.display = "none";
                    if (options.color === "white") {
                        output.style.background = "#fff";
                    } else if (options.color === "shadow") {
                        output.style.background = "transparent";
                    } else if (options.color === "canvas") {
                        output.style.background = "#f2f2f2";
                    }
                    input.onkeyup = null;
                    if (test.ace === true) {
                        aceStore.codeIn.onkeyup = null;
                        aceStore
                            .codeOut
                            .setReadOnly(false);
                        if (options.diff !== undefined && options.diff !== null) {
                            aceStore.codeOut.setValue(options.diff);
                        }
                        parent = <HTMLElement>output.parentNode;
                        parent.setAttribute("class", "output");
                    } else {
                        output.readOnly = false;
                        if (options.diff !== undefined) {
                            output.value = options.diff;
                        }
                        parent = <HTMLElement>output.parentNode.parentNode;
                        parent.setAttribute("class", "output");
                    }
                } else {
                    ci.getElementsByTagName("h2")[0].innerHTML = text;
                    cilabel[0].innerHTML = `${text} file`;
                    cilabel[2].innerHTML = `${text} code sample`;
                    cilabel[5].innerHTML = `${text} output`;
                    parent = <HTMLElement>document.getElementById("inputfile").parentNode;
                    outLabel.style.marginTop = `${(parent.clientHeight + 11.5) / 10}em`;
                    sourceLabel.style.display = "none";
                    outputLabel.style.display = "none";
                    outputFile.style.display = "none";
                    input.onkeyup = method.event.execute;
                    if (options.mode === "beautify") {
                        id("slider").style.display = "block";
                    } else {
                        id("slider").style.display = "none";
                    }
                    if (options.color === "white") {
                        output.style.background = "#f2f2f2";
                    } else if (options.color === "shadow") {
                        output.style.background = "#111";
                    } else if (options.color === "canvas") {
                        output.style.background = "#ccccc8";
                    }
                    if (test.ace === true) {
                        aceStore.codeOut.setValue("");
                        aceStore
                            .codeOut
                            .setReadOnly(true);
                        parent = <HTMLElement>output.parentNode;
                        parent.setAttribute("class", "readonly");
                    } else {
                        output.readOnly = true;
                        output.value = "";
                        parent = <HTMLElement>output.parentNode.parentNode;
                        parent.setAttribute("class", "readonly");
                    }
                }
            };
        let parent:HTMLElement;
        options.mode = mode;
        makeChanges();
        cycleOptions();
        commentString();
    };
    //reset tool to default configuration
    method.event.reset = function dom_event_reset():void {
        const comment:HTMLElement = id("commentString");
        let nametry:string  = "",
            name:string     = "";
        localStorage.setItem("source", "");
        localStorage.setItem("diff", "");
        localStorage.setItem("commentString", "[]");
        if (data.settings === undefined || data.settings.knownname === undefined) {
            if (data.settings === undefined) {
                data.settings = {
                    feedback: {
                        newb   : false,
                        veteran: false
                    }
                };
            }
            if (localStorage.getItem("settings") !== undefined && localStorage.getItem("settings") !== null) {
                nametry = JSON.stringify(localStorage.getItem("settings"));
            }
            if (localStorage.getItem("settings") === undefined || localStorage.getItem("settings") === null || nametry === "" || nametry.indexOf("knownname") < 0) {
                name = `"${Math
                    .random()
                    .toString()
                    .slice(2) + Math
                    .random()
                    .toString()
                    .slice(2)}"`;
            }
            data.settings.knownname = name;
        }
        if (data.settings.feedback === undefined) {
            data.settings.feedback = {
                newb   : false,
                veteran: false
            };
        }
        localStorage.setItem("settings", `{"feedback":{"newb":${data.settings.feedback.newb},"veteran":${data.settings.feedback.veteran}},"report":{"code":{},"feed":{},"stat":{}},"knownname":${data.settings.knownname}}`);
        data.commentString = [];
        if (comment !== null) {
            comment.innerHTML = "/*prettydiff.com \u002a/";
        }
        id("modediff").checked = true;
        location.reload();
    };
    //resize report window to custom width and height on drag
    method.event.resize = function dom_event_resize(e:MouseEvent):void {
        let bodyWidth:number  = 0,
            bodyHeight:number = 0;
        const node:HTMLElement = <HTMLElement>e.srcElement || <HTMLElement>e.target,
            parent:HTMLElement     = <HTMLElement>node.parentNode,
            save:boolean       = (parent.innerHTML.indexOf("save") > -1),
            box:HTMLElement        = <HTMLElement>parent.parentNode,
            body:HTMLDivElement       = box.getElementsByTagName("div")[0],
            offX:number = e.clientX,
            offY:number = e.clientY,
            heading:HTMLHeadingElement    = box.getElementsByTagName("h3")[0],
            mac:boolean        = (test.agent.indexOf("macintosh") > 0),
            offsetw:number    = (mac === true)
                ? 20
                : 4,
            offseth:number    = (mac === true)
                ? 54
                : 36,
            drop       = function dom_event_resize_drop():void {
                document.onmousemove = null;
                bodyWidth            = body.clientWidth;
                bodyHeight           = body.clientHeight;
                method
                    .app
                    .options(e);
                document.onmouseup = null;
            },
            boxsize    = function dom_event_resize_boxsize(f:MouseEvent):void {
                body.style.width = `${(bodyWidth + ((f.clientX - offsetw) - offX)) / 10}em`;
                if (save === true) {
                    heading.style.width = `${((bodyWidth + (f.clientX - offX)) / 10) - 10.15}em`;
                } else {
                    heading.style.width = `${((bodyWidth + (f.clientX - offX)) / 10) - 7.15}em`;
                }
                body.style.height  = `${(bodyHeight + ((f.clientY - offseth) - offY)) / 10}em`;
                document.onmouseup = drop;
            };
        bodyWidth  = body.clientWidth,
        bodyHeight = body.clientHeight
        method
            .app
            .zTop(box);
        document.onmousemove = boxsize;
        document.onmousedown = null;
    };
    //tell the browser to "save as"
    method.event.save = function dom_event_save():void {
        let blob = new Blob([report.code.body.innerHTML], {type: "application/xhtml+xml;charset=utf-8"});
        prettydiff.saveAs(blob, "prettydiff.xhtml", {autoBom: true});
    };
    //analyzes combinations of consecutive key presses
    method.event.sequence = function dom_event_sequence(event:KeyboardEvent):void {
        let seq   = test.keysequence;
        const len   = seq.length,
            key   = event.keyCode;
        if (len === 0 || len === 1) {
            if (key === 38) {
                seq.push(true);
            } else {
                test.keysequence = [];
                seq = test.keysequence;
            }
        } else if (len === 2 || len === 3) {
            if (key === 40) {
                seq.push(true);
            } else {
                test.keysequence = [];
                seq = test.keysequence;
            }
        } else if (len === 4 || len === 6) {
            if (key === 37) {
                seq.push(true);
            } else {
                test.keysequence = [];
                seq = test.keysequence;
            }
        } else if (len === 5 || len === 7) {
            if (key === 39) {
                seq.push(true);
            } else {
                test.keysequence = [];
                seq = test.keysequence;
            }
        } else if (len === 8) {
            if (key === 66) {
                seq.push(true);
            } else {
                test.keysequence = [];
                seq = test.keysequence;
            }
        } else if (len === 9) {
            if (key === 65) {
                if (data.audio !== undefined) {
                    data
                        .audio
                        .play();
                }
                const body:HTMLBodyElement = document.getElementsByTagName("body")[0],
                    scroll:number = (document.documentElement.scrollTop > body.scrollTop)
                        ? document.documentElement.scrollTop
                        : body.scrollTop,
                    color:HTMLSelectElement  = id("option-color"),
                    max:number    = color
                        .getElementsByTagName("option")
                        .length - 1,
                    change = function dom_event_sequence_colorChange_change():void {
                        color.selectedIndex = ind;
                        method
                            .event
                            .colorScheme(event);
                    };
                let ind:number    = color.selectedIndex;
                ind = ind - 1;
                if (ind < 0) {
                    ind = max;
                }
                change();
                ind = ind + 1;
                if (ind > max) {
                    ind = 0;
                }
                setTimeout(change, 1500);
                document.documentElement.scrollTop = scroll;
                body.scrollTop = scroll;
            }
            test.keysequence = [];
        }
    };
    //intelligently raise the z-index of the report windows
    method.app.zTop     = function dom_app_top(x:HTMLElement):void {
        const indexListed = data.zIndex,
            indexes     = [
                (report.feed.box === null)
                    ? 0
                    : Number(report.feed.box.style.zIndex),
                (report.code.box === null)
                    ? 0
                    : Number(report.code.box.style.zIndex),
                (report.stat.box === null)
                    ? 0
                    : Number(report.stat.box.style.zIndex)
            ];
        let indexMax    = Math.max(indexListed, indexes[0], indexes[1], indexes[2]) + 1;
        if (indexMax < 11) {
            indexMax = 11;
        }
        data.zIndex = indexMax;
        if (x.nodeType === 1) {
            x.style.zIndex = String(indexMax);
        }
    };
    // prettydiff dom insertion start
    // prettydiff dom insertion end
    meta = prettydiff.meta;
    options = prettydiff.options;
    options.api = "dom";
    load();
}());
<file_sep>/api/mode.ts
/*global prettydiff*/
function mode(diffmeta?:diffmeta):string {
    "use strict";
    const pdcomment = function mode_pdcomment():void {
            const ops:any = prettydiff.sparser.options;
            let sindex:number = options.source.search(/((\/(\*|\/))|<!--*)\s*prettydiff\.com/),
                dindex:number = options.diff.search(/((\/(\*|\/))|<!--*)\s*prettydiff\.com/),
                a:number = 0,
                b:number = 0,
                keys:string[],
                def:any,
                len:number;
            // parses the prettydiff settings comment
            //
            // - Source Priorities:
            // * the prettydiff comment is only accepted if it occurs before non-comments (near the top)
            // * options.source is the priority material for reading the comment
            // * the prettydiff comment will be processed from options.diff only if it present there, missing from options.source, and options.mode is diff
            //
            // - Examples:
            //    /*prettydiff.com width:80 preserve:4*/
            //    /* prettydiff.com width:80 preserve:4 */
            //    /*prettydiff.com width=80 preserve=4 */
            //    // prettydiff.com width=80 preserve:4
            //    <!-- prettydiff.com width:80 preserve=4 -->
            //    <!--prettydiff.com width:40 preserve:2-->
            //
            // - Parsing Considerations:
            // * there may be any amount of space at the start or end of the comment
            // * "prettydiff.com" must exist at the start of the comment
            // * comment must exist prior to non-comment tokens (near top of code)
            // * parameters are name value pairs separated by white space
            // * the delimiter separating name and value is either ":" or "=" characters
        
            if ((sindex > -1 && (sindex === 0 || "\"':".indexOf(options.source.charAt(sindex - 1)) < 0)) || (options.mode === "diff" && dindex > -1 && (dindex === 0 || "\"':".indexOf(options.diff.charAt(dindex - 1)) < 0))) {
                let pdcom:number = sindex,
                    a:number = (pdcom > -1)
                        ? pdcom
                        : dindex,
                    b:number = 0,
                    quote:string = "",
                    item:string = "",
                    lang:string = "",
                    lex:string = "",
                    valkey:string[] = [],
                    op:string[] = [];
                const ops:string[] = [],
                    source:string = (pdcom > -1)
                        ? options.source
                        : options.diff,
                    len:number = source.length,
                    comment:string = (source.charAt(a) === "<")
                        ? "<!--"
                        : (source.charAt(a + 1) === "/")
                            ? "//"
                            : "/\u002a",
                    esc = function mode_pdcomment_esc():boolean {
                        if (source.charAt(a - 1) !== "\\") {
                            return false;
                        }
                        let x:number = a;
                        do {
                            x = x - 1;
                        } while (x > 0 && source.charAt(x) === "\\");
                        if ((a - x) % 2 === 0) {
                            return true;
                        }
                        return false;
                    };
                do {
                    if (source.slice(a - 3, a) === "com") {
                        break;
                    }
                    a = a + 1;
                } while (a < len);
                do {
                    if (esc() === false) {
                        if (quote === "") {
                            if (source.charAt(a) === "\"") {
                                quote = "\"";
                                if (ops.length > 0 && (ops[ops.length - 1].charAt(ops[ops.length - 1].length - 1) === ":" || ops[ops.length - 1].charAt(ops[ops.length - 1].length - 1) === "=")) {
                                    b = a;
                                }
                            } else if (source.charAt(a) === "'") {
                                quote = "'";
                                if (ops.length > 0 && (ops[ops.length - 1].charAt(ops[ops.length - 1].length - 1) === ":" || ops[ops.length - 1].charAt(ops[ops.length - 1].length - 1) === "=")) {
                                    b = a;
                                }
                            } else if (source.charAt(a) === "`") {
                                quote = "`";
                                if (ops.length > 0 && (ops[ops.length - 1].charAt(ops[ops.length - 1].length - 1) === ":" || ops[ops.length - 1].charAt(ops[ops.length - 1].length - 1) === "=")) {
                                    b = a;
                                }
                            } else if ((/\s/).test(source.charAt(a)) === false && b === 0) {
                                b = a;
                            } else if (source.charAt(a) === "," || ((/\s/).test(source.charAt(a)) === true && b > 0)) {
                                item = source.slice(b, a);
                                if (ops.length > 0) {
                                    if (ops.length > 0 && (item === ":" || item === "=") && ops[ops.length - 1].indexOf("=") < 0 && ops[ops.length - 1].indexOf(":") < 0) {
                                        // for cases where white space is between option name and assignment operator
                                        ops[ops.length - 1] = ops[ops.length - 1] + item;
                                        b = a;
                                    } else if (ops.length > 0 && (ops[ops.length - 1].charAt(ops[ops.length - 1].length - 1) === ":" || ops[ops.length - 1].charAt(ops[ops.length - 1].length - 1) === "=")) {
                                        // for cases where white space is between assignment operator and value
                                        ops[ops.length - 1] = ops[ops.length - 1] + item;
                                        b = 0;
                                    } else {
                                        ops.push(item);
                                        b = 0;
                                    }
                                } else {
                                    ops.push(item);
                                    b = 0;
                                }
                            }
                            if (comment === "<!--" && source.slice(a - 2, a + 1) === "-->") {
                                break;
                            }
                            if (comment === "//" && source.charAt(a) === "\n") {
                                break;
                            }
                            if (comment === "/\u002a" && source.slice(a - 1, a + 1) === "\u002a/") {
                                break;
                            }
                        } else if (source.charAt(a) === quote && quote !== "${") {
                            quote = "";
                        } else if (quote === "`" && source.slice(a, a + 2) === "${") {
                            quote = "${";
                        } else if (quote === "${" && source.charAt(a) === "}") {
                            quote = "`";
                        }
                    }
                    a = a + 1;
                } while (a < len);
                if (b > 0) {
                    quote = source.slice(b, a + 1);
                    if (comment === "<!--") {
                        quote = quote.replace(/\s*-+>$/, "");
                    } else if (comment === "//") {
                        quote = quote.replace(/\s+$/, "");
                    } else {
                        quote = quote.replace(/\s*\u002a\/$/, "");
                    }
                    ops.push(quote);
                }
                a = ops.length;
                if (a > 0) {
                    do {
                        a = a - 1;
                        if (ops[a].indexOf("=") > 0 && ops[a].indexOf(":") > 0) {
                            if (ops[a].indexOf("=") < ops[a].indexOf(":")) {
                                op = [ops[a].slice(0, ops[a].indexOf("=")), ops[a].slice(ops[a].indexOf("=") + 1)];
                            }
                        } else if (ops[a].indexOf("=") > 0) {
                            op = [ops[a].slice(0, ops[a].indexOf("=")), ops[a].slice(ops[a].indexOf("=") + 1)];
                        } else if (ops[a].indexOf(":") > 0) {
                            op = [ops[a].slice(0, ops[a].indexOf(":")), ops[a].slice(ops[a].indexOf(":") + 1)];
                        } else if (prettydiff.api.optionDef[ops[a]] !== undefined && prettydiff.api.optionDef[ops[a]].type === "boolean") {
                            options[ops[a]] = true;
                        }
                        if (op.length === 2 && prettydiff.api.optionDef[op[0]] !== undefined) {
                            if ((op[1].charAt(0) === "\"" || op[1].charAt(0) === "'" || op[1].charAt(0) === "`") && op[1].charAt(op[1].length - 1) === op[1].charAt(0)) {
                                op[1] = op[1].slice(1, op[1].length - 1);
                            }
                            if (prettydiff.api.optionDef[op[0]].type === "number" && isNaN(Number(op[1])) === false) {
                                options[op[0]] = Number(op[1]);
                            } else if (prettydiff.api.optionDef[op[0]].type === "boolean") {
                                if (op[1] === "true") {
                                    options[op[0]] = true;
                                } else if (op[1] === "false") {
                                    options[op[0]] = false;
                                }
                            } else {
                                if (prettydiff.api.optionDef[op[0]].values !== undefined) {
                                    valkey = Object.keys(prettydiff.api.optionDef[op[0]].values);
                                    b = valkey.length;
                                    do {
                                        b = b - 1;
                                        if (valkey[b] === op[1]) {
                                            options[op[0]] = op[1];
                                            break;
                                        }
                                    } while (b > 0);
                                } else {
                                    if (op[0] === "language") {
                                        lang = op[1];
                                    } else if (op[0] === "lexer") {
                                        lex = op[1];
                                    }
                                    options[op[0]] = op[1];
                                }
                            }
                        }
                    } while (a > 0);
                    if (lex === "" && lang !== "") {
                        lex = prettydiff.api.language.setlexer(lang);
                    }
                }
            }
            if (options.mode === "diff") {
                modeValue = "beautify";
            }
            if (options.mode === "minify" && options.minify_wrap === false) {
                options.wrap = -1;
            }
            if (options.lexer === "script") {
                let styleguide = {
                        airbnb: function mode_pdcomment_styleairbnb() {
                            options.brace_padding = true;
                            options.correct      = true;
                            options.lexerOptions.script.end_comma     = "always";
                            options.indent_char       = " ";
                            options.indent_size       = 2;
                            options.preserve     = 1;
                            options.quote_convert = "single";
                            options.variable_list      = "each";
                            options.wrap         = 80;
                        },
                        crockford: function mode_pdcomment_stylecrockford() {
                            options.brace_padding  = false;
                            options.correct       = true;
                            options.else_line      = false;
                            options.lexerOptions.script.end_comma      = "never";
                            options.indent_char        = " ";
                            options.indent_size        = 4;
                            options.no_case_indent  = true;
                            options.space         = true;
                            options.variable_list      = "each";
                            options.vertical            = false;
                        },
                        google: function mode_pdcomment_stylegoogle() {
                            options.correct      = true;
                            options.indent_char       = " ";
                            options.indent_size       = 4;
                            options.preserve     = 1;
                            options.quote_convert = "single";
                            options.vertical           = false;
                            options.wrap         = -1;
                        },
                        jquery: function mode_pdcomment_stylejquery() {
                            options.brace_padding = true;
                            options.correct      = true;
                            options.indent_char       = "\u0009";
                            options.indent_size       = 1;
                            options.quote_convert = "double";
                            options.variable_list      = "each";
                            options.wrap         = 80;
                        },
                        jslint: function mode_pdcomment_stylejslint() {
                            options.brace_padding  = false;
                            options.correct       = true;
                            options.else_line      = false;
                            options.lexerOptions.script.end_comma      = "never";
                            options.indent_char        = " ";
                            options.indent_size        = 4;
                            options.no_case_indent  = true;
                            options.space         = true;
                            options.variable_list       = "each";
                            options.vertical            = false;
                        },
                        mrdoobs: function mode_pdcomment_stylemrdoobs() {
                            options.brace_line    = true;
                            options.brace_padding = true;
                            options.correct      = true;
                            options.indent_char       = "\u0009";
                            options.indent_size       = 1;
                            options.vertical           = false;
                        },
                        mediawiki: function mode_pdcomment_stylemediawiki() {
                            options.brace_padding = true;
                            options.correct      = true;
                            options.indent_char       = "\u0009";
                            options.indent_size       = 1;
                            options.preserve     = 1;
                            options.quote_convert = "single";
                            options.space        = false;
                            options.wrap         = 80;
                        },
                        meteor: function mode_pdcomment_stylemeteor() {
                            options.correct = true;
                            options.indent_char  = " ";
                            options.indent_size  = 2;
                            options.wrap    = 80;
                        },
                        semistandard: function mode_pdcomment_stylessemistandard() {
                            options.brace_line = false;
                            options.brace_padding = false;
                            options.braces = false;
                            options.correct = true;
                            options.end_comma = "never";
                            options.indent_char = " ";
                            options.indent_size = 2;
                            options.new_line = false;
                            options.no_semicolon = false;
                            options.preserve = 1;
                            options.quote_convert = "single";
                            options.space = true;
                            options.ternary_line = false;
                            options.variable_list = "each";
                            options.vertical = false;
                            options.wrap = 0;
                        },
                        standard: function mode_pdcomment_stylestandard() {
                            options.brace_line = false;
                            options.brace_padding = false;
                            options.braces = false;
                            options.correct = true;
                            options.end_comma = "never";
                            options.indent_char = " ";
                            options.indent_size = 2;
                            options.new_line = false;
                            options.no_semicolon = true;
                            options.preserve = 1;
                            options.quote_convert = "single";
                            options.space = true;
                            options.ternary_line = false;
                            options.variable_list = "each";
                            options.vertical = false;
                            options.wrap = 0;
                        },
                        yandex: function mode_pdcomment_styleyandex() {
                            options.brace_padding = false;
                            options.correct      = true;
                            options.quote_convert = "single";
                            options.variable_list      = "each";
                            options.vertical           = false;
                        }
                    },
                    brace_style = {
                        collapse: function mode_pdcomment_collapse() {
                            options.brace_line    = false;
                            options.brace_padding = false;
                            options.braces       = false;
                            options.format_object = "indent";
                            options.never_flatten = true;
                        },
                        "collapse-preserve-inline": function mode_pdcomment_collapseInline() {
                            options.brace_line    = false;
                            options.brace_padding = true;
                            options.braces       = false;
                            options.format_object = "inline";
                            options.never_flatten = false;
                        },
                        expand: function mode_pdcomment_expand() {
                            options.brace_line    = false;
                            options.brace_padding = false;
                            options.braces       = true;
                            options.format_object = "indent";
                            options.never_flatten = true;
                        }
                    };
                if (styleguide[options.styleguide] !== undefined) {
                    styleguide[options.styleguide]();
                }
                if (brace_style[options.brace_style] !== undefined) {
                    brace_style[options.brace_style]();
                }
                if (options.language === "json") {
                    options.wrap = 0;
                } else if (options.language === "titanium") {
                    options.correct = false;
                }
                if (options.language !== "javascript" && options.language !== "typescript" && options.language !== "jsx") {
                    options.jsscope = "none";
                }
            }
            if (options.lexer !== "markup" || options.language === "text") {
                options.diff_rendered_html = false;
            } else if (options.api === "node" && options.read_method !== "file") {
                options.diff_rendered_html = false;
            }
            def = prettydiff.sparser.libs.optionDef;
            keys = Object.keys(def);
            len = keys.length;
            do {
                if (options[keys[a]] !== undefined) {
                    if (def[keys[a]].lexer[0] === "all") {
                        ops[keys[a]] = options[keys[a]];
                    } else {
                        b = def[keys[a]].lexer.length;
                        do {
                            b = b - 1;
                            if (keys[a] !== "parse_space" || (options.mode === "parse" && keys[a] === "parse_space" && options[keys[a]] === true)) {
                                ops.lexer_options[def[keys[a]].lexer[b]][keys[a]] = options[keys[a]];
                            }
                        } while (b > 0);
                    }
                }
                a = a + 1;
            } while (a < len);
        },
        options:any = prettydiff.options,
        lf:string = (options.crlf === true)
            ? "\r\n"
            : "\n";
    let modeValue:"beautify"|"minify" = options.mode,
        result:string = "";
    if (options.api === "node" && (options.read_method === "directory" || options.read_method === "subdirectory")) {
        if (options.mode === "parse" && options.parse_format === "table") {
            return "Error: option parse_format with value 'table' is not available with read_method directory or subdirectory.";
        }
    }
    if (options.language === "text" && options.mode !== "diff") {
        options.language = "auto";
    }
    if (options.lexer === "text" && options.mode !== "diff") {
        options.lexer = "auto";
    }
    if (options.language === "text" || options.lexer === "text") {
        options.language = "text";
        options.language_name = "Plain Text";
        options.lexer = "text";
    } else if (options.language === "auto" || options.lexer === "auto") {
        const def:string = (options.language_default === "" || options.language_default === null || options.language_default === undefined)
                ? "javascript"
                : options.language_default;
        let lang:[string, string, string] = prettydiff.api.language.auto(options.source, def);
        if (lang[0] === "text") {
            if (options.mode === "diff") {
                lang[2] = "Plain Text";
            } else {
                lang = ["javascript", "script", "JavaScript"];
            }
        } else if (lang[0] === "csv") {
            lang[2] = "CSV";
        }
        if (options.language === "auto") {
            options.language = lang[0];
            options.language_name = lang[2];
        }
        if (options.lexer === "auto") {
            options.lexer = lang[1];
        }
    }

    pdcomment();
    if (options.mode === "parse") {
        const parse_format = (options.parse_format === "htmltable")
                ? "table"
                : options.parse_format,
            api = (options.parse_format === "htmltable")
                ? "dom"
                : options.api;

        options.parsed = prettydiff.sparser.parser();
        if (parse_format === "table") {
            if (api === "dom") {
                const parsLen:number = options.parsed.token.length,
                    keys = Object.keys(options.parsed),
                    keylen:number = keys.length,
                    headingString:string = (function mode_parseHeading():string {
                        const hout:string[] = ["<tr><th>index</th>"];
                        let b:number = 0;
                        do {
                            if (keys[b] !== "token") {
                                hout.push(`<th>${keys[b]}</th>`);
                            }
                            b = b + 1;
                        } while (b < keylen);
                        hout.push("<th>token</th></tr>");
                        return hout.join("");
                    }()),
                    row = function mode_parseRow():string {
                        const hout:string[] = ["<tr>"];
                        let b = 0;
                        hout.push(`<td>${a}</td>`);
                        do {
                            if (keys[b] !== "token") {
                                hout.push(`<td>${options.parsed[keys[b]][a].toString().replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</td>`);
                            }
                            b = b + 1;
                        } while (b < keylen);
                        hout.push(`<td>${options.parsed.token[a].replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</td></tr>`);
                        return hout.join("");
                    },
                    parsOut:string[] = [];
                parsOut.push(`<p><strong>${parsLen}</strong> total parsed tokens</p>`);
                parsOut.push("<table><thead>");
                parsOut.push(headingString);
                parsOut.push("</thead><tbody>");
                let a:number = 0;
                do {
                    if (a % 100 === 0 && a > 0) {
                        parsOut.push(headingString);
                    }
                    parsOut.push(row());
                    a = a + 1;
                } while (a < parsLen);
                parsOut.push("</tbody></table>");
                result = parsOut.join("");
            } else {
                let a:number   = 0,
                    str:string[] = [];
                const outputArrays:data = options.parsed,
                    nodeText:any     = {
                        angry    : "\u001b[1m\u001b[31m",
                        blue     : "\u001b[34m",
                        bold     : "\u001b[1m",
                        cyan     : "\u001b[36m",
                        green    : "\u001b[32m",
                        nocolor  : "\u001b[39m",
                        none     : "\u001b[0m",
                        purple   : "\u001b[35m",
                        red      : "\u001b[31m",
                        underline: "\u001b[4m",
                        yellow   : "\u001b[33m"
                    },
                    output:string[] = [],
                    b:number = outputArrays.token.length,
                    pad = function mode_parsePad(x:string, y:number):void {
                        const cc:string = x
                                .toString()
                                .replace(/\s/g, " ");
                        let dd:number = y - cc.length;
                        str.push(cc);
                        if (dd > 0) {
                            do {
                                str.push(" ");
                                dd = dd - 1;
                            } while (dd > 0);
                        }
                        str.push(" | ");
                    },
                    heading:string = "index | begin | ender | lexer  | lines | stack       | types       | token",
                    bar:string     = "------|-------|-------|--------|-------|-------------|-------------|------";
                output.push("");
                output.push(heading);
                output.push(bar);
                do {
                    if (a % 100 === 0 && a > 0) {
                        output.push("");
                        output.push(heading);
                        output.push(bar);
                    }
                    str = [];
                    if (outputArrays.lexer[a] === "markup") {
                        str.push(nodeText.red);
                    } else if (outputArrays.lexer[a] === "script") {
                        str.push(nodeText.green);
                    } else if (outputArrays.lexer[a] === "style") {
                        str.push(nodeText.yellow);
                    }
                    pad(a.toString(), 5);
                    pad(outputArrays.begin[a].toString(), 5);
                    pad(outputArrays.ender[a].toString(), 5);
                    pad(outputArrays.lexer[a].toString(), 5);
                    pad(outputArrays.lines[a].toString(), 5);
                    pad(outputArrays.stack[a].toString(), 11);
                    pad(outputArrays.types[a].toString(), 11);
                    str.push(outputArrays.token[a].replace(/\s/g, " "));
                    str.push(nodeText.none);
                    output.push(str.join(""));
                    a = a + 1;
                } while (a < b);
                result = output.join(lf);
            }
        } else {
            result = JSON.stringify(options.parsed);
        }
    } else {
        if (prettydiff[modeValue][options.lexer] === undefined && ((options.mode !== "diff" && options.language === "text") || options.language !== "text")) {
            result = `Error: Library prettydiff.${modeValue}.${options.lexer} does not exist.`;
        } else if (options.mode === "diff") {
            let diffoutput:[string, number, number];

            if (options.diff_format === "json") {
                options.complete_document = false;
            }
            if (options.language === "text") {
                diffoutput = prettydiff.api.diffview(options);
                result = diffoutput[0];
            } else {
                const ind:number = options.indent;
                if (options.diff_rendered_html === true) {
                    const lexers:any = {
                            del: 0,
                            insert: 0,
                            replace: 0
                        },
                        typeIgnore:string[] = [
                            "attribute",
                            "cdata",
                            "comment",
                            "conditional",
                            "ignore",
                            "jsx_attribute_end",
                            "jsx_attribute_start",
                            "script",
                            "sgml",
                            "style",
                            "xml"
                        ],
                        tab = function mode_diffhtmlTab(indentation:number):string {
                            const tabout:string[] = (options.crlf === true)
                                ? ["\r\n"]
                                : ["\n"];
                            let a:number = 0,
                                b:number = options.indent_size * indentation;
                            if (b > 1) {
                                do {
                                    tabout.push(options.indent_char);
                                    a = a + 1;
                                } while (a < b);
                            } else {
                                tabout.push(options.indent_char);
                                tabout.push(options.indent_char);
                            }
                            return tabout.join("");
                        },
                        css:string[] = [
                            `${tab(2)}<style type="text/css">`,
                            "#prettydiff_summary{background:#eef8ff;border:2px solid #069}",
                            ".prettydiff_rendered{border-style:solid;border-width:2px;display:inline-block}",
                            ".prettydiff_delete{background:#ffd8d8;border-color:#c44}",
                            ".prettydiff_insert{background:#d8ffd8;border-color:#090}",
                            ".prettydiff_replace{background:#fec;border-color:#a86}"
                        ],
                        insert = function mode_insert():void {
                            const inject:string[] = [`<span class="prettydiff_rendered prettydiff_insert">`];
                            if (json[a + 1][0] === "+") {
                                do {
                                    inject.push(json[a][1]);
                                    count[1] = count[1] + 1;
                                    a = a + 1;
                                } while (json[a + 1][0] === "+");
                            }
                            inject.push(json[a][1]);
                            inject.push("</span>");
                            options.parsed.token[count[0]] = `${inject.join("")} ${options.parsed.token[count[0]]}`;
                            lexers.insert = lexers.insert + 1;
                        },
                        del = function mode_del():void {
                            const symb:string = json[a][0],
                                change:string = (symb === "-")
                                    ? "delete"
                                    : "replace";
                            options.parsed.token[count[0]] = `<span class="prettydiff_rendered prettydiff_${change}">${options.parsed.token[count[0]]}`;
                            if (json[a + 1][0] === symb) {
                                do {
                                    count[0] = count[0] + 1;
                                    if (change === "replace") {
                                        count[1] = count[1] + 1;
                                    }
                                    a = a + 1;
                                } while (json[a + 1][0] === symb);
                            }
                            options.parsed.token[count[0]] = `${options.parsed.token[count[0]]}</span>`;
                            if (change === "delete") {
                                lexers.del = lexers.del + 1;
                            } else {
                                lexers.replace = lexers.replace + 1;
                            }
                        },
                        summary = function mode_summary():void {
                            const keys:string[] = Object.keys(lexers),
                                len:number = keys.length,
                                output:string[] = [],
                                lex:string[] = [];
                            let a:number = 0,
                                lextest:boolean = false;
                            output.push(`<div id="prettydiff_summary"><h1>Pretty Diff - Summary</h1>`);
                            output.push("<p>This is the count of identified differences starting with visual differences colored in the document first.</p><ul>");
                            output.push(`<li>Deletions - <strong>${lexers.del}</strong></li>`);
                            output.push(`<li>Insertions - <strong>${lexers.insert}</strong></li>`);
                            output.push(`<li>Replacements - <strong>${lexers.replace}</strong></li>`);
                            output.push("</ul>");
                            if (len > 3) {
                                lexers.del = 0;
                                lexers.insert = 0;
                                lexers.replace = 0;
                                lex.push("<hr/><p>This list of differences is not visible in the rendered HTML.</p><ul>");
                                do {
                                    if (lexers[keys[a]] > 0) {
                                        lextest = true;
                                        lex.push(`<li>${keys[a]} - ${lexers[keys[a]]}</li>`);
                                    }
                                    a = a + 1;
                                } while (a < len);
                                lex.push("</ul>");
                            }
                            if (lextest === true) {
                                output.push(lex.join(""));
                            }
                            output.push("</div>");
                            options.parsed.token[body] = `${options.parsed.token[body]} ${output.join("")}`;
                        };
                    let diff_parsed:data,
                        json:any,
                        a:number = 0,
                        count:[number, number] = [0, 0],
                        len:number = 0,
                        body:number = 0,
                        head:boolean = false;
                    options.diff_format = "json";
                    options.parsed = prettydiff.sparser.parser();
                    options.source = options.parsed.token;
                    prettydiff.start = 0;
                    prettydiff.end = 0;
                    options.indent_level = ind;
                    prettydiff.sparser.options.source = options.diff;
                    diff_parsed = prettydiff.sparser.parser();
                    options.diff = diff_parsed.token;
                    diffoutput = prettydiff.api.diffview(options);
                    json = JSON.parse(diffoutput[0]).diff;
                    len = json.length;
                    do {
                        if (head === false && options.parsed.types[count[0]] === "start" && options.parsed.lexer[count[0]] === "markup" && json[a][1].toLowerCase().indexOf("<head") === 0) {
                            options.parsed.token[count[0]] = `${options.parsed.token[count[0]] + css.join(tab(3)) + tab(2)}</style>${tab(0)}`;
                            head = true;
                        } else if (body < 1 && options.parsed.types[count[0]] === "start" && options.parsed.lexer[count[0]] === "markup" && options.parsed.token[count[0]].toLowerCase().indexOf("<body") === 0) {
                            body = count[0];
                        }
                        if (json[a][0] === "=") {
                            count[0] = count[0] + 1;
                            count[1] = count[1] + 1;
                        } else if (
                            body > 1 &&
                            options.parsed.lexer[count[0]] === "markup" &&
                            options.parsed.token[count[0]].indexOf(`<span class="prettydiff_`) !== 0 &&
                            ((json[a][0] === "+" && typeIgnore.indexOf(diff_parsed.types[count[1]]) < 0) || (json[a][0] !== "+" && typeIgnore.indexOf(options.parsed.types[count[0]]) < 0))
                        ) {
                            if (json[a][0] === "+") {
                                insert();
                            } else {
                                del();
                            }
                        } else {
                            if (json[a][0] === "-") {
                                count[0] = count[0] + 1;
                            } else if (json[a][0] === "+") {
                                count[1] = count[1] + 1;
                            } else {
                                count[0] = count[0] + 1;
                                count[1] = count[1] + 1;
                            }
                            if (lexers[options.parsed.lexer[count[0]]] === undefined) {
                                lexers[options.parsed.lexer[count[0]]] = 1;
                            } else {
                                lexers[options.parsed.lexer[count[0]]] = lexers[options.parsed.lexer[count[0]]] + 1;
                            }
                        }
                        a = a + 1;
                    } while (a < len);
                    summary();
                    result = prettydiff.beautify.markup(options);
                } else {
                    options.parsed = prettydiff.sparser.parser();
                    options.source = prettydiff.beautify[options.lexer](options);
                    prettydiff.start = 0;
                    prettydiff.end = 0;
                    options.indent_level = ind;
                    // diff text formatting
                    prettydiff.sparser.options.source = options.diff;
                    options.parsed = prettydiff.sparser.parser();
                    options.diff = prettydiff.beautify[options.lexer](options);
                    // comparison
                    diffoutput = prettydiff.api.diffview(options);
                    result = diffoutput[0];
                }
            }
            if (diffmeta !== undefined) {
                diffmeta.differences = diffoutput[1];
                diffmeta.lines = diffoutput[2];
            }
        } else {
            options.parsed = prettydiff.sparser.parser();
            result = prettydiff[modeValue][options.lexer](options);
        }
    }
    if (options.new_line === true) {
        result = result.replace(/\s*$/, lf);
    } else {
        result = result.replace(/\s+$/, "");
    }
    if (options.complete_document === true && options.jsscope !== "report") {
        let finalFile:finalFile = prettydiff.api.finalFile;
        finalFile.order[7] = options.color;
        finalFile.order[10] = result;
        if (options.crlf === true) {
            finalFile.order[12] = "\r\n";
            finalFile.order[15] = "\r\n";
        }
        if (options.mode === "diff") {
            finalFile.order[13] = finalFile.script.diff;
        } else if (options.mode === "beautify" && options.language === "javascript" && options.jsscope !== "none") {
            finalFile.order[13] = finalFile.script.beautify;
        } else {
            finalFile.order[13] = finalFile.script.minimal;
        }
        // escape changes characters that result in xml wellformedness errors
        prettydiff.end = 0;
        prettydiff.start = 0;
        return finalFile.order.join("");
    }
    prettydiff.end = 0;
    prettydiff.start = 0;
    return result;
}
mode();<file_sep>/minify/style.ts
/*global prettydiff*/
(function minify_style_init():void {
    "use strict";
    const style = function minify_style(options:any):string {
        const data:data = options.parsed,
            lf:"\r\n"|"\n"         = (options.crlf === true)
                ? "\r\n"
                : "\n",
            len:number      = (prettydiff.end < 1 || prettydiff.end > data.token.length)
                ? data.token.length
                : prettydiff.end + 1,
            build:string[]    = [];
        let a:number        = prettydiff.start,
            b:number        = 0,
            c:number        = 0,
            list:string[]   = [],
            count:number    = 0,
            countx:number   = 0;

        //beautification loop
        if (options.top_comments === true && options.minify_keep_comments === false && data.types[a] === "comment" && prettydiff.start === 0) {
            if (a > 0) {
                build.push(lf);
            }
            do {
                build.push(data.token[a]);
                build.push(lf);
                a = a + 1;
            } while (a < len && data.types[a] === "comment");
        }
        if (a < len) {
            do {
                if (data.types[a] === "comment" && options.minify_keep_comments === true) {
                    if (data.types[a - 1] !== "comment" && a > 0) {
                        build.push(lf);
                        build.push(lf);
                    }
                    build.push(data.token[a]);
                    if (data.types[a + 1] !== "comment") {
                        build.push(lf);
                    }
                    build.push(lf);
                } else if (data.types[a] !== "comment") {
                    build.push(data.token[a]);
                    if (options.wrap > 0 && options.minify_wrap === true) {
                        count = count + data.token[a].length;
                        if (a < len - 1) {
                            if (count + data.token[a + 1].length > options.wrap) {
                                countx = count;
                                count = 0;
                                if (data.types[a] === "property") {
                                    build.pop();
                                    a = a - 1;
                                } else if (data.token[a] === ":") {
                                    build.pop();
                                    build.pop();
                                    a = a - 2;
                                }
                                build.push(lf);
                            }
                            b = data.token[a + 1].indexOf(",");
                            if ((data.token[a + 1].length > options.wrap || (b > 0 && countx + b < options.wrap)) && data.types[a + 1] === "selector") {
                                list = data.token[a + 1].split(",");
                                b = 0;
                                c = list.length;
                                if (countx + list[0].length + 1 < options.wrap) {
                                    build.pop();
                                    do {
                                        countx = countx + list[b].length + 1;
                                        if (countx > options.wrap) {
                                            break;
                                        }
                                        build.push(list[b]);
                                        build.push(",");
                                        b = b + 1;
                                    } while (b < c);
                                } else {
                                    countx = 0;
                                }
                                if (b < c) {
                                    do {
                                        countx = countx + list[b].length + 1;
                                        if (countx > options.wrap) {
                                            countx = list[b].length + 1;
                                            build.push(lf);
                                        }
                                        build.push(list[b]);
                                        build.push(",");
                                        b = b + 1;
                                    } while (b < c);
                                    build.pop();
                                }
                                count = countx;
                                countx = 0;
                                a = a + 1;
                            }
                        }
                    }
                }
                a = a + 1;
            } while (a < len);
            prettydiff.iterator = len - 1;
        }
        if (options.new_line === true && a === data.token.length && build[build.length - 1].indexOf(lf) < 0) {
            build.push(lf);
        }
        return build.join("");
    };
    global.prettydiff.minify.style = style;
}());
<file_sep>/minify/markup.ts
/*global prettydiff*/
(function minify_markup_init():void {
    "use strict";
    const markup = function minify_markup(options:any):string {
        const data:data = options.parsed,
            lexer:string = "markup",
            c:number            = (prettydiff.end < 1 || prettydiff.end > data.token.length)
                ? data.token.length
                : prettydiff.end + 1,
            lf:"\r\n"|"\n"      = (options.crlf === true)
                ? "\r\n"
                : "\n",
            externalIndex:externalIndex = {},
            levels:number[] = (function minify_markup_levels():number[] {
                const level:number[]      = (prettydiff.start > 0)
                        ? Array(prettydiff.start).fill(0, 0, prettydiff.start)
                        : [],
                    nextIndex = function minify_markup_levels_next():number {
                        let x:number = a + 1,
                            y:number = 0;
                        if (data.types[x] === "comment" || data.types[x] === "attribute" || data.types[x] === "jsx_attribute_start") {
                            do {
                                if (data.types[x] === "jsx_attribute_start") {
                                    y = x;
                                    do {
                                        if (data.types[x] === "jsx_attribute_end" && data.begin[x] === y) {
                                            break;
                                        }
                                        x = x + 1;
                                    } while (x < c);
                                } else if (data.types[x] !== "comment" && data.types[x] !== "attribute") {
                                    return x;
                                }
                                x = x + 1;
                            } while (x < c);
                        }
                        return x;
                    },
                    external = function minify_markup_levels_external():void {
                        let skip = a;
                        do {
                            if (data.lexer[a + 1] === lexer && data.begin[a + 1] < skip && data.types[a + 1] !== "start" && data.types[a + 1] !== "singleton") {
                                break;
                            }
                            level.push(-20);
                            a = a + 1;
                        } while (a < c);
                        externalIndex[skip] = a;
                        level.push(-20);
                        next = nextIndex();
                    },
                    comment = function minify_markup_levels_comment():void {
                        let x:number = a,
                            test:boolean = false;
                        if (data.lines[a + 1] === 0) {
                            do {
                                if (data.lines[x] > 0) {
                                    test = true;
                                    break;
                                }
                                x = x - 1;
                            } while (x > comstart);
                            x = a;
                        } else {
                            test = true;
                        }
                        do {
                            level.push(-20);
                            x = x - 1;
                        } while (x > comstart);
                        if (test === true) {
                            if (data.types[x] === "attribute" || data.types[x] === "jsx_attribute_start") {
                                level[data.begin[x]] = -10;
                            } else {
                                level[x] = -10;
                            }
                        } else {
                            level[x] = -20;
                        }
                        comstart = -1;
                    };
                let a:number     = prettydiff.start,
                    next:number = 0,
                    comstart:number = -1;
                // data.lines -> space before token
                // level -> space after token
                do {
                    if (data.lexer[a] === lexer) {
                        if (data.types[a].indexOf("attribute") > -1) {
                            if (data.types[a] === "attribute") {
                                data.token[a] = data.token[a].replace(/\s+/g, " ");
                            }
                            if (data.types[a - 1].indexOf("attribute") < 0) {
                                level[a - 1] = -10;
                            }
                            if (data.types[a] === "comment_attribute" && data.token[a].slice(0, 2) === "//") {
                                level.push(-10);
                            } else if (data.types[a] === "jsx_attribute_start") {
                                level.push(-20);
                            } else if (data.types[a] === "jsx_attribute_end") {
                                level.push(-10);
                            } else if (a < c - 1 && data.types[a + 1].indexOf("attribute") < 0) {
                                if (data.lines[a + 1] > 0 && data.lexer[a + 1] === lexer && data.types[a + 1] !== "start" && data.types[a + 1] !== "xml" && data.types[a + 1] !== "sgml") {
                                    level.push(-10);
                                } else {
                                    level.push(-20);
                                }
                            } else {
                                level.push(-10);
                            }
                        } else if (data.types[a] === "comment") {
                            if (options.minify_keep_comments === true) {
                                level.push(0);
                            } else {
                                if (comstart < 0) {
                                    comstart = a;
                                }
                                if (data.types[a + 1] !== "comment") {
                                    comment();
                                }
                            }
                        } else if (data.types[a] !== "comment") {
                            if (data.types[a] === "content") {
                                data.token[a] = data.token[a].replace(/\s+/g, " ");
                            }
                            next = nextIndex();
                            if (data.lines[next] > 0 && (
                                data.types[a] === "content" ||
                                data.types[a] === "singleton" ||
                                data.types[next] === "content" ||
                                data.types[next] === "singleton" ||
                                (data.types[next] !== undefined && data.types[next].indexOf("attribute") > 0)
                            )) {
                                level.push(-10);
                            } else {
                                level.push(-20);
                            }
                        }
                    } else {
                        external();
                    }
                    a = a + 1;
                } while (a < c);
                return level;
            }());
        return (function minify_markup_apply():string {
            const build:string[]        = [],
                // a new line character plus the correct amount of identation for the given line
                // of code
                attributeEnd = function minify_markup_apply_attributeEnd():void {
                    const parent:string = data.token[a],
                        regend:RegExp = (/(\/|\?)?>$/),
                        end:string[]|null = regend.exec(parent);
                    let y:number = a + 1,
                        x:number = 0,
                        jsx:boolean = false;
                    if (end === null) {
                        return;
                    }
                    data.token[a] = parent.replace(regend, "");
                    do {
                        if (data.types[y] === "jsx_attribute_end" && data.begin[data.begin[y]] === a) {
                            jsx = false;
                        } else if (data.begin[y] === a) {
                            if (data.types[y] === "jsx_attribute_start") {
                                jsx = true;
                            } else if (data.types[y].indexOf("attribute") < 0 && jsx === false) {
                                break;
                            }
                        } else if (jsx === false && (data.begin[y] < a || data.types[y].indexOf("attribute") < 0)) {
                            break;
                        }
                        y = y + 1;
                    } while (y < c);
                    if (data.types[y - 1] === "comment_attribute") {
                        x = y;
                        do {
                            y = y - 1;
                        } while (y > a && data.types[y - 1] === "comment_attribute");
                        if (data.lines[x] < 1) {
                            levels[y - 1] = -20;
                        }
                    }
                    data.token[y - 1] = data.token[y - 1] + end[0];
                };
            let a:number            = prettydiff.start,
                b:number         = 0,
                next:number      = 0,
                external:string = "",
                lastLevel:number = 0,
                count:number     = 0,
                linelen:number   = 0,
                lines:string[]   = [];
            if (options.top_comments === true && data.types[a] === "comment" && prettydiff.start === 0) {
                if (a > 0) {
                    build.push(lf);
                }
                do {
                    build.push(data.token[a]);
                    build.push(lf);
                    a = a + 1;
                } while (a < c && data.types[a] === "comment");
            }
            do {
                if (data.lexer[a] === lexer || prettydiff.minify[data.lexer[a]] === undefined) {
                    if ((data.types[a] === "start" || data.types[a] === "singleton" || data.types[a] === "xml" || data.types[a] === "sgml") && data.types[a].indexOf("attribute") < 0 && a < c - 1 && data.types[a + 1] !== undefined && data.types[a + 1].indexOf("attribute") > -1) {
                        attributeEnd();
                    }
                    if (options.minify_keep_comments === true || (data.types[a] !== "comment" && data.types[a] !== "comment_attribute")) {
                        if (data.types[a] === "comment") {
                            if (data.types[a - 1] !== "comment") {
                                build.push(lf);
                                build.push(lf);
                            }
                            build.push(data.token[a]);
                            if (data.types[a + 1] !== "comment") {
                                build.push(lf);
                            }
                            build.push(lf);
                        } else {
                            build.push(data.token[a]);
                        }
                        count = count + data.token[a].length;
                        if ((data.types[a] === "template" || data.types[a] === "template_start") && data.types[a - 1] === "content" && options.mode === "minify" && levels[a] === -20) {
                            build.push(" ");
                            count = count + 1;
                        }
                        if (levels[a] > -1) {
                            lastLevel = levels[a];
                        } else if (levels[a] === -10 && data.types[a] !== "jsx_attribute_start") {
                            build.push(" ");
                            count = count + 1;
                        }
                    }
                    next = a + 1;
                    if (next < c - 1 && data.types[next].indexOf("comment") > -1 && options.minify_keep_comments === false) {
                        do {
                            next = next + 1;
                        } while (next < c - 1 && data.types[next].indexOf("comment") > -1);
                    }
                    if (next < c - 1 && count + data.token[next].length > options.wrap && options.wrap > 0 && options.minify_wrap === true) {
                        if (build[build.length - 1] === " ") {
                            build.pop();
                        }
                        if ((data.types[next] === "content" || data.types[next] === "attribute") && data.token[next].indexOf(" ") > 0) {
                            lines = data.token[next].split(" ");
                            b = 0;
                            linelen = lines.length;
                            if (count + lines[0] + 1 > options.wrap) {
                                build.push(lf);
                                count = 0;
                            }
                            do {
                                count = count + lines[b].length + 1;
                                if (count > options.wrap) {
                                    count = lines[b].length + 1;
                                    build.push(lf);
                                }
                                build.push(lines[b]);
                                build.push(" ");
                                b = b + 1;
                            } while (b < linelen);
                            if (next < c - 2 && count + data.token[next + 1].length > options.wrap) {
                                if (build[build.length - 1] === " ") {
                                    build.pop();
                                }
                                build.push(lf);
                                count = 0;
                            }
                            a = next;
                        } else {
                            build.push(lf);
                            count = 0;
                        }
                    }
                } else {
                    if (externalIndex[a] === a && data.types[a] !== "reference") {
                        if (data.types[a] !== "comment") {
                            build.push(data.token[a]);
                            count = count + data.token[a].length;
                        }
                    } else {
                        prettydiff.end = externalIndex[a];
                        options.indent_level = lastLevel;
                        prettydiff.start = a;
                        external = prettydiff.minify[data.lexer[a]](options).replace(/\s+$/, "");
                        if (options.wrap > 0 && options.minify_wrap === true) {
                            build.push(lf);
                        }
                        build.push(external);
                        if (levels[prettydiff.iterator] > -1 && externalIndex[a] > a) {
                            build.push(lf);
                        } else if (options.wrap > 0 && options.minify_wrap === true) {
                            build.push(lf);
                        }
                        a = prettydiff.iterator;
                    }
                }
                a = a + 1;
            } while (a < c);
            prettydiff.iterator = c - 1;
            if (build[0] === lf || build[0] === " ") {
                build[0] = "";
            }
            if (options.new_line === true && a === data.token.length && build[build.length - 1].indexOf(lf) < 0) {
                build.push(lf);
            }
            return build.join("");
        }());
    };
    global.prettydiff.minify.markup = markup;
}());<file_sep>/api/optionDef.ts
(function options_init(): void {
    "use strict";
    const optionDef:optionDef = {
        attribute_sort   : {
            api       : "any",
            default   : false,
            definition: "Alphanumerically sort markup attributes. Attribute sorting is ignored on tags that contain attributes template attributes.",
            label     : "Sort Attributes",
            lexer     : "markup",
            mode      : "any",
            type      : "boolean"
        },
        attribute_sort_list: {
            api:"any",
            default: "",
            definition: "A comma separated list of attribute names. Attributes will be sorted according to this list and then alphanumerically. This option requires 'attribute_sort' have a value of true.",
            label: "Sort Attribute List",
            lexer: "markup",
            mode : "any",
            type: "string"
        },
        brace_line       : {
            api       : "any",
            default   : false,
            definition: "If true an empty line will be inserted after opening curly braces and before clo" +
                    "sing curly braces.",
            label     : "Brace Lines",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        brace_padding    : {
            api       : "any",
            default   : false,
            definition: "Inserts a space after the start of a container and before the end of the contain" +
                    "er if the contents of that container are not indented; such as: conditions, func" +
                    "tion arguments, and escaped sequences of template strings.",
            label     : "Brace Padding",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        brace_style      : {
            api       : "any",
            default   : "none",
            definition: "Emulates JSBeautify's brace_style option using existing Pretty Diff options.",
            label     : "Brace Style",
            lexer     : "script",
            mode      : "beautify",
            type      : "string",
            values    : {
                "collapse"                : "Sets options.format_object to 'indent' and options.neverflatten to true.",
                "collapse-preserve-inline": "Sets options.bracepadding to true and options.format_object to 'inline'.",
                "expand"                  : "Sets options.braces to true, options.format_object to 'indent', and options.never" +
                        "flatten to true.",
                "none"                    : "Ignores this option"
            }
        },
        braces           : {
            api       : "any",
            default   : false,
            definition: "Determines if opening curly braces will exist on the same line as their conditio" +
                    "n or be forced onto a new line. (Allman style indentation).",
            label     : "Style of Indent",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        case_space        : {
            api       : "any",
            default   : false,
            definition: "If the colon separating a case's expression (of a switch/case block) from its statement should be followed by a space instead of indentation, thereby keeping the case on a single line of code.",
            label     : "Space Following Case",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        color            : {
            api       : "any",
            default   : "white",
            definition: "The color scheme of the reports.",
            label     : "Color",
            lexer     : "any",
            mode      : "any",
            type      : "string",
            values    : {
                "canvas": "A light brown color scheme",
                "shadow": "A black and ashen color scheme",
                "white" : "A white and pale grey color scheme"
            }
        },
        comment_line     : {
            api       : "any",
            default   : false,
            definition: "If a blank new line should be forced above comments.",
            label     : "Force an Empty Line Above Comments",
            lexer     : "markup",
            mode      : "beautify",
            type      : "boolean"
        },
        comments         : {
            api       : "any",
            default   : false,
            definition: "This will determine whether comments should always start at position 0 of each l" +
                    "ine or if comments should be indented according to the code.",
            label     : "Indent Comments",
            lexer     : "any",
            mode      : "beautify",
            type      : "boolean"
        },
        complete_document: {
            api       : "any",
            default   : false,
            definition: "Allows a preference for generating a complete HTML document instead of only gene" +
                    "rating content.",
            label     : "Generate A Complete HTML File",
            lexer     : "markup",
            mode      : "any",
            type      : "boolean"
        },
        compressed_css   : {
            api       : "any",
            default   : false,
            definition: "If CSS should be beautified in a style where the properties and values are minif" +
                    "ed for faster reading of selectors.",
            label     : "Compressed CSS",
            lexer     : "style",
            mode      : "beautify",
            type      : "boolean"
        },
        conditional      : {
            api       : "any",
            default   : false,
            definition: "If true then conditional comments used by Internet Explorer are preserved at min" +
                    "ification of markup.",
            label     : "IE Comments (HTML Only)",
            lexer     : "markup",
            mode      : "minify",
            type      : "boolean"
        },
        config           : {
            api       : "node",
            default   : "",
            definition: "By default Pretty Diff will look into the directory structure contain the value of option 'source' for a file named `.prettydiffrc` for saved option settings. This option allows a user to specify any file at any location in the local file system for configuration settings. A value of 'none' tells the application to bypass reading any configuration file.",
            label     : "Custom Config File Location",
            lexer     : "any",
            mode      : "any",
            type      : "string"
        },
        content          : {
            api       : "any",
            default   : false,
            definition: "This will normalize all string content to 'text' so as to eliminate some differe" +
                    "nces from the output.",
            label     : "Ignore Content",
            lexer     : "any",
            mode      : "diff",
            type      : "boolean"
        },
        correct          : {
            api       : "any",
            default   : false,
            definition: "Automatically correct some sloppiness in code.",
            label     : "Fix Sloppy Code",
            lexer     : "any",
            mode      : "any",
            type      : "boolean"
        },
        crlf             : {
            api       : "any",
            default   : false,
            definition: "If line termination should be Windows (CRLF) format.  Unix (LF) format is the de" +
                    "fault.",
            label     : "Line Termination",
            lexer     : "any",
            mode      : "any",
            type      : "boolean"
        },
        css_insert_lines : {
            api       : "any",
            default   : false,
            definition: "Inserts new line characters between every CSS code block.",
            label     : "Insert Empty Lines",
            lexer     : "style",
            mode      : "beautify",
            type      : "boolean"
        },
        diff             : {
            api       : "any",
            default   : "",
            definition: "The code sample to be compared to 'source' option.  This is required if mode is " +
                    "'" + "diff'.",
            label     : "Code to Compare",
            lexer     : "any",
            mode      : "diff",
            type      : "string"
        },
        diff_comments    : {
            api       : "any",
            default   : false,
            definition: "If true then comments will be preserved so that both code and comments are compa" +
                    "red by the diff engine.",
            label     : "Code Comments",
            lexer     : "any",
            mode      : "diff",
            type      : "boolean"
        },
        diff_context     : {
            api       : "any",
            default   : -1,
            definition: "This shortens the diff output by allowing a specified number of equivalent lines" +
                    " between each line of difference.  This option is only used with diff_format:htm" +
                    "l.",
            label     : "Context Size",
            lexer     : "any",
            mode      : "diff",
            type      : "number"
        },
        diff_format      : {
            api       : "any",
            default   : "text",
            definition: "The format of the output.  The command line output format is text, similar to Un" +
                    "ix 'diff'.",
            label     : "Diff Format",
            lexer     : "any",
            mode      : "diff",
            type      : "string",
            values    : {
                "html": "An HTML format for embedding in web pages, or as a complete web page if document" +
                        "_complete is true.",
                "json": "A JSON format.",
                "text": "Formatted similar to the Unix 'diff' command line utility."
            }
        },
        diff_label       : {
            api       : "any",
            default   : "New Sample",
            definition: "This allows for a descriptive label for the diff file code of the diff HTML outp" +
                    "ut.",
            label     : "Label for Diff Sample",
            lexer     : "any",
            mode      : "diff",
            type      : "string"
        },
        diff_rendered_html: {
            api: "any",
            default: false,
            definition: "Compares complete HTML documents and injects custom CSS so that the differences display not in the code, but in the rendered page in a browser.  This option is currently confined only to markup languages, read_method file, and mode diff.  Option diff_format is ignored.",
            label: "Compare Rendered HTML",
            lexer: "markup",
            mode: "diff",
            type: "boolean"
        },
        diff_space_ignore: {
            api       : "any",
            default   : false,
            definition: "If white space only differences should be ignored by the diff tool.",
            label     : "Remove White Space",
            lexer     : "any",
            mode      : "diff",
            type      : "boolean"
        },
        diff_view        : {
            api       : "any",
            default   : "sidebyside",
            definition: "This determines whether the diff HTML output should display as a side-by-side co" +
                    "mparison or if the differences should display in a single table column.",
            label     : "Diff View Type",
            lexer     : "any",
            mode      : "diff",
            type      : "string",
            values    : {
                "inline"    : "A single column where insertions and deletions are vertically adjacent.",
                "sidebyside": "Two column comparison of changes."
            }
        },
        else_line        : {
            api       : "any",
            default   : false,
            definition: "If else_line is true then the keyword 'else' is forced onto a new line.",
            label     : "Else On New Line",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        end_comma        : {
            api       : "any",
            default   : "never",
            definition: "If there should be a trailing comma in arrays and objects. Value \"multiline\" o" +
                    "nly applies to modes beautify and diff.",
            label     : "Trailing Comma",
            lexer     : "script",
            mode      : "beautify",
            type      : "string",
            values    : {
                "always"   : "Always ensure there is a tailing comma",
                "never"    : "Remove trailing commas",
                "none"     : "Ignore this option"
            }
        },
        end_quietly      : {
            api       : "node",
            default   : "default",
            definition: "A node only option to determine if terminal summary data should be logged to the" +
                    " console.",
            label     : "Log Summary to Console",
            lexer     : "any",
            mode      : "any",
            type      : "string",
            values    : {
                "default": "Default minimal summary",
                "log"    : "Verbose logging",
                "quiet"  : "No extraneous logging"
            }
        },
        force_attribute  : {
            api       : "any",
            default   : false,
            definition: "If all markup attributes should be indented each onto their own line.",
            label     : "Force Indentation of All Attributes",
            lexer     : "markup",
            mode      : "beautify",
            type      : "boolean"
        },
        force_indent     : {
            api       : "any",
            default   : false,
            definition: "Will force indentation upon all content and tags without regard for the creation" +
                    " of new text nodes.",
            label     : "Force Indentation of All Content",
            lexer     : "markup",
            mode      : "beautify",
            type      : "boolean"
        },
        format_array     : {
            api       : "any",
            default   : "default",
            definition: "Determines if all array indexes should be indented, never indented, or left to t" +
                    "he default.",
            label     : "Formatting Arrays",
            lexer     : "script",
            mode      : "beautify",
            type      : "string",
            values    : {
                "default": "Default formatting",
                "indent" : "Always indent each index of an array",
                "inline" : "Ensure all array indexes appear on a single line"
            }
        },
        format_object    : {
            api       : "any",
            default   : "default",
            definition: "Determines if all object keys should be indented, never indented, or left to the" +
                    " default.",
            label     : "Formatting Objects",
            lexer     : "script",
            mode      : "beautify",
            type      : "string",
            values    : {
                "default": "Default formatting",
                "indent" : "Always indent each key/value pair",
                "inline" : "Ensure all key/value pairs appear on the same single line"
            }
        },
        function_name    : {
            api       : "any",
            default   : false,
            definition: "If a space should follow a JavaScript function name.",
            label     : "Space After Function Name",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        help             : {
            api       : "node",
            default   : 80,
            definition: "A node only option to print documentation to the console. The value determines w" +
                    "here to wrap text.",
            label     : "Help Wrapping Limit",
            lexer     : "any",
            mode      : "any",
            type      : "number"
        },
        indent_char      : {
            api       : "any",
            default   : " ",
            definition: "The string characters to comprise a single indentation. Any string combination i" +
                    "s accepted.",
            label     : "Indentation Characters",
            lexer     : "any",
            mode      : "beautify",
            type      : "string"
        },
        indent_level     : {
            api       : "any",
            default   : 0,
            definition: "How much indentation padding should be applied to beautification? This option is" +
                    " internally used for code that requires switching between libraries.",
            label     : "Indentation Padding",
            lexer     : "any",
            mode      : "beautify",
            type      : "number"
        },
        indent_size      : {
            api       : "any",
            default   : 4,
            definition: "The number of 'indent_char' values to comprise a single indentation.",
            label     : "Indent Size",
            lexer     : "any",
            mode      : "beautify",
            type      : "number"
        },
        jsscope          : {
            api       : "any",
            default   : "none",
            definition: "An educational tool to generate HTML output of JavaScript code to identify scope" +
                    " regions and declared references by color.  This option is ignored unless the code language is JavaScript or TypeScript.",
            label     : "JavaScript Scope Identification",
            lexer     : "script",
            mode      : "beautify",
            type      : "string",
            values    : {
                html  : "generates HTML output with escaped angle braces and ampersands for embedding as " +
                        "code, which is handy in code producing tools",
                none  : "prevents use of this option",
                report: "generates HTML output that renders in web browsers"
            }
        },
        language         : {
            api       : "any",
            default   : "auto",
            definition: "The lowercase single word common name of the source code's programming language. The value 'auto' imposes language and lexer auto-detection, which ignores deliberately specified lexer values. The value 'text' is converted to 'auto' if options 'mode' is not 'diff'. Value 'text' allows literal comparisons.",
            label     : "Language",
            lexer     : "any",
            mode      : "any",
            type      : "string"
        },
        language_default : {
            api       : "any",
            default   : "text",
            definition: "The fallback option if option 'lang' is set to 'auto' and a language cannot be d" +
                    "etected.",
            label     : "Language Auto-Detection Default",
            lexer     : "any",
            mode      : "any",
            type      : "string"
        },
        language_name    : {
            api       : "any",
            default   : "JavaScript",
            definition: "The formatted proper name of the code sample's language for use in reports read " +
                    "by people.",
            label     : "Formatted Name of the Code's Language",
            lexer     : "any",
            mode      : "any",
            type      : "string"
        },
        lexer            : {
            api       : "any",
            default   : "auto",
            definition: "This option determines which sets of rules to use in the language parser. If opt" +
                    "ion 'language' has a value of 'auto', which is the default value, this option is" +
                    " ignored. The value 'text' is converted to 'auto' if options 'mode' is not 'diff'. Value 'text' allows literal comparisons.",
            label     : "Parsing Lexer",
            lexer     : "any",
            mode      : "any",
            type      : "string",
            values    : {
                auto  : "The value 'auto' imposes language and lexer auto-detection, which ignores deliberately specified language values.",
                markup: "parses languages like XML and HTML",
                script: "parses languages with a C style syntax, such as JavaScript",
                style : "parses CSS like languages"
            }
        },
        list_options     : {
            api       : "node",
            default   : false,
            definition: "A Node.js only option that writes current option settings to the console.",
            label     : "Options List",
            lexer     : "any",
            mode      : "any",
            type      : "boolean"
        },
        method_chain     : {
            api       : "any",
            default   : 3,
            definition: "When to break consecutively chained methods and properties onto separate lines. " +
                    "A negative value disables this option. A value of 0 ensures method chains are ne" +
                    "ver broken.",
            label     : "Method Chains",
            lexer     : "script",
            mode      : "beautify",
            type      : "number"
        },
        minify_keep_comments : {
            api       : "any",
            default   : false,
            definition: "Prevents minification from stripping out comments.",
            label     : "Keep Comments",
            lexer     : "any",
            mode      : "minify",
            type      : "boolean"
        },
        minify_wrap      : {
            api       : "any",
            default   : false,
            definition: "Whether minified script should wrap after a specified character width.  This opt" +
                    "ion requires a value from option 'wrap'.",
            label     : "Minification Wrapping",
            lexer     : "script",
            mode      : "minify",
            type      : "boolean"
        },
        mode             : {
            api       : "any",
            default   : "diff",
            definition: "The operation to be performed.",
            label     : "Mode",
            lexer     : "any",
            mode      : "any",
            type      : "string",
            values    : {
                beautify: "beautifies code and returns a string",
                diff    : "returns either command line list of differences or an HTML report",
                minify  : "minifies code and returns a string",
                parse   : "using option 'parseFormat' returns an object with shallow arrays, a multidimensi" +
                        "onal array, or an HTML report"
            }
        },
        never_flatten    : {
            api       : "any",
            default   : false,
            definition: "If destructured lists in script should never be flattend.",
            label     : "Never Flatten Destructured Lists",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        new_line         : {
            api       : "any",
            default   : false,
            definition: "Insert an empty line at the end of output.",
            label     : "New Line at End of Code",
            lexer     : "any",
            mode      : "any",
            type      : "boolean"
        },
        no_case_indent   : {
            api       : "any",
            default   : false,
            definition: "If a case statement should receive the same indentation as the containing switch" +
                    " block.",
            label     : "Case Indentation",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        no_lead_zero     : {
            api       : "any",
            default   : false,
            definition: "Whether leading 0s in CSS values immediately preceding a decimal should be remo" +
                    "ved or prevented.",
            label     : "Leading 0s",
            lexer     : "style",
            mode      : "any",
            type      : "boolean"
        },
        no_semicolon     : {
            api       : "any",
            default   : false,
            definition: "Removes semicolons that would be inserted by ASI. This option is in conflict with option 'correct' and takes precedence over conflicting features. Use of this option is a possible security/stability risk.",
            label     : "No Semicolons",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        node_error       : {
            api       : "node",
            default   : false,
            definition: "A Node.js only option if parse errors should be written to the console.",
            label     : "Write Parse Errors in Node",
            lexer     : "any",
            mode      : "any",
            type      : "boolean"
        },
        object_sort      : {
            api       : "any",
            default   : false,
            definition: "Sorts markup attributes and properties by key name in script and style.",
            label     : "Object/Attribute Sort",
            lexer     : "any",
            mode      : "beautify",
            type      : "boolean"
        },
        output           : {
            api       : "node",
            default   : "",
            definition: "A file path for which to write output. If this option is not specified output will be printed to the shell.",
            label     : "Output Location",
            lexer     : "any",
            mode      : "any",
            type      : "string"
        },
        parse_format     : {
            api       : "any",
            default   : "parallel",
            definition: "Determines the output format for 'parse' mode.",
            label     : "Parse Format",
            lexer     : "any",
            mode      : "parse",
            type      : "string",
            values    : {
                htmltable : "generates the 'table' type output for the DOM but escapes the HTML tags for rend" +
                        "ering as HTML code in a HTML tool",
                parallel  : "returns an object containing series of parallel arrays",
                sequential: "returns an array where each index is a child object containing the parsed token" +
                        " and all descriptive data",
                table     : "generates a colorful grid of output for either the dom or command line interface"
            }
        },
        parse_space      : {
            api       : "any",
            default   : false,
            definition: "Whether whitespace tokens should be included in markup parse output.",
            label     : "Retain White Space Tokens in Parse Output",
            lexer     : "markup",
            mode      : "parse",
            type      : "boolean"
        },
        preserve         : {
            api       : "any",
            default   : 0,
            definition: "The maximum number of consecutive empty lines to retain.",
            label     : "Preserve Consecutive New Lines",
            lexer     : "any",
            mode      : "beautify",
            type      : "number"
        },
        preserve_comment : {
            api       : "any",
            default   : false,
            definition: "Prevent comment reformatting due to option wrap.",
            label     : "Eliminate Word Wrap Upon Comments",
            lexer     : "any",
            mode      : "beautify",
            type      : "boolean"
        },
        preserve_text    : {
            api       : "any",
            default   : false,
            definition: "If text in the provided markup code should be preserved exactly as provided. Thi" +
                    "s option eliminates beautification and wrapping of text content.",
            label     : "Preserve Markup Text White Space",
            lexer     : "markup",
            mode      : "any",
            type      : "boolean"
        },
        quote            : {
            api       : "any",
            default   : false,
            definition: "If true and mode is 'diff' then all single quote characters will be replaced by " +
                    "double quote characters in both the source and diff file input so as to eliminat" +
                    "e some differences from the diff report HTML output.",
            label     : "Normalize Quotes",
            lexer     : "any",
            mode      : "diff",
            type      : "boolean"
        },
        quote_convert    : {
            api       : "any",
            default   : "none",
            definition: "If the quotes of script strings or markup attributes should be converted to sing" +
                    "le quotes or double quotes.",
            label     : "Indent Size",
            lexer     : "any",
            mode      : "any",
            type      : "string",
            values    : {
                "double": "Converts single quotes to double quotes",
                "none"  : "Ignores this option",
                "single": "Converts double quotes to single quotes"
            }
        },
        read_method      : {
            api       : "node",
            default   : "auto",
            definition: "The option determines how Node.js should receive input.  All output will be prin" +
                    "ted to the shell unless the option 'output' is specified, which will write outpu" +
                    "t to a file.",
            label     : "Read Method",
            lexer     : "any",
            mode      : "any",
            type      : "string",
            values    : {
                auto        : "changes to value subdirectory, file, or screen depending on source resolution",
                directory   : "process all files in the specified directory only",
                file        : "reads a file and outputs to a file.  file requires option 'output'",
                screen      : "reads from screen and outputs to screen",
                subdirectory: "process all files in a directory and its subdirectories"
            }
        },
        selector_list    : {
            api       : "any",
            default   : false,
            definition: "If comma separated CSS selectors should present on a single line of code.",
            label     : "Indent Size",
            lexer     : "style",
            mode      : "beautify",
            type      : "boolean"
        },
        semicolon        : {
            api       : "any",
            default   : false,
            definition: "If true and mode is 'diff' and lang is 'javascript' all semicolon characters tha" +
                    "t immediately precede any white space containing a new line character will be re" +
                    "moved so as to eliminate some differences from the code comparison.",
            label     : "Indent Size",
            lexer     : "script",
            mode      : "diff",
            type      : "boolean"
        },
        source           : {
            api       : "any",
            default   : "",
            definition: "The source code or location for interpretation. This option is required for all " +
                    "modes.",
            label     : "Source Sample",
            lexer     : "any",
            mode      : "any",
            type      : "string"
        },
        source_label     : {
            api       : "any",
            default   : "Source Sample",
            definition: "This allows for a descriptive label of the source file code for the diff HTML o" +
                    "utput.",
            label     : "Label for Source Sample",
            lexer     : "any",
            mode      : "diff",
            type      : "string"
        },
        space            : {
            api       : "any",
            default   : true,
            definition: "Inserts a space following the function keyword for anonymous functions.",
            label     : "Function Space",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        space_close      : {
            api       : "any",
            default   : false,
            definition: "Markup self-closing tags end will end with ' />' instead of '/>'.",
            label     : "Close Markup Self-Closing Tags with a Space",
            lexer     : "markup",
            mode      : "beautify",
            type      : "boolean"
        },
        styleguide       : {
            api       : "any",
            default   : "none",
            definition: "Provides a collection of option presets to easily conform to popular JavaScript " +
                    "style guides.",
            label     : "Script Styleguide",
            lexer     : "script",
            mode      : "beautify",
            type      : "string",
            values    : {
                "airbnb"   : "https://github.com/airbnb/javascript",
                "crockford": "http://jslint.com/",
                "google"   : "https://google.github.io/styleguide/jsguide.html",
                "jquery"   : "https://contribute.jquery.org/style-guide/js/",
                "jslint"   : "http://jslint.com/",
                "mediawiki": "https://www.mediawiki.org/wiki/Manual:Coding_conventions/JavaScript",
                "mrdoob"   : "https://github.com/mrdoob/three.js/wiki/Mr.doob's-Code-Style%E2%84%A2",
                "none"     : "Ignores this option",
                "semistandard": "https://github.com/Flet/semistandard",
                "standard" : "https://standardjs.com/",
                "yandex"   : "https://github.com/ymaps/codestyle/blob/master/javascript.md"
            }
        },
        summary_only     : {
            api       : "node",
            default   : false,
            definition: "Node only option to output only number of differences.",
            label     : "Output Diff Only Without A Summary",
            lexer     : "any",
            mode      : "diff",
            type      : "boolean"
        },
        tag_merge        : {
            api       : "any",
            default   : false,
            definition: "Allows immediately adjacement start and end markup tags of the same name to be c" +
                    "ombined into a single self-closing tag.",
            label     : "Merge Adjacent Start and End tags",
            lexer     : "markup",
            mode      : "any",
            type      : "boolean"
        },
        tag_sort         : {
            api       : "any",
            default   : false,
            definition: "Sort child items of each respective markup parent element.",
            label     : "Sort Markup Child Items",
            lexer     : "markup",
            mode      : "any",
            type      : "boolean"
        },
        ternary_line     : {
            api       : "any",
            default   : false,
            definition: "If ternary operators in JavaScript ? and : should remain on the same line.",
            label     : "Keep Ternary Statements On One Line",
            lexer     : "script",
            mode      : "beautify",
            type      : "boolean"
        },
        top_comments     : {
            api       : "any",
            default   : false,
            definition: "If mode is 'minify' this determines whether comments above the first line of cod" +
                    "e should be kept.",
            label     : "Retain Comment At Code Start",
            lexer     : "any",
            mode      : "minify",
            type      : "boolean"
        },
        unformatted      : {
            api       : "any",
            default   : false,
            definition: "If markup tags should have their insides preserved. This option is only available to markup and does not support child tokens that require a different lexer.",
            label     : "Markup Tag Preservation",
            lexer     : "markup",
            mode      : "any",
            type      : "boolean"
        },
        variable_list    : {
            api       : "any",
            default   : "none",
            definition: "If consecutive JavaScript variables should be merged into a comma separated list" +
                    " or if variables in a list should be separated.",
            label     : "Variable Declaration Lists",
            lexer     : "script",
            mode      : "any",
            type      : "string",
            values    : {
                "each": "Ensurce each reference is a single declaration statement.",
                "list": "Ensure consecutive declarations are a comma separated list.",
                "none": "Ignores this option."
            }
        },
        version          : {
            api       : "node",
            default   : false,
            definition: "A Node.js only option to write the version information to the console.",
            label     : "Version",
            lexer     : "any",
            mode      : "any",
            type      : "boolean"
        },
        vertical         : {
            api       : "any",
            default   : false,
            definition: "If lists of assignments and properties should be vertically aligned. This option" +
                    " is not used with the markup lexer.",
            label     : "Vertical Alignment",
            lexer     : "any",
            mode      : "beautify",
            type      : "boolean"
        },
        wrap             : {
            api       : "any",
            default   : 0,
            definition: "Character width limit before applying word wrap. A 0 value disables this option." +
                    " A negative value concatenates script strings.",
            label     : "Wrap",
            lexer     : "any",
            mode      : "any",
            type      : "number"
        }
    };
    global
        .prettydiff
        .api
        .optionDef  = optionDef;
}());<file_sep>/proxy.php
<?php
$referer = $_SERVER['HTTP_REFERER'];
$refpos = strpos($referer, 'prettydiff.com');
if ($refpos === 0 || $refpos === 7 || $refpos === 11) {
    $x = $_GET['x'];
    //$r = file_get_contents($x);
    //echo($r);
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $x);
    curl_setopt($ch, CURLOPT_HEADER, 0);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    $result = curl_exec($ch);
    curl_close($ch);
    header("Content-type: text/plain;charset=UTF-8");
    echo($result);
} else {
    header("HTTP/1.1 301 Moved Permanently");
    header("Location: http://prettydiff.com/"); 
}
?><file_sep>/api/finalFile.ts
(function finalFile_init(): void {
    "use strict";
    const finalFile: finalFile = {
        css   : {
            color  : {
                canvas: "#prettydiff.canvas{background:#986 url(\"data:image/png;base64,iVBORw0KGgoAAAANS" +
                        "UhEUgAAAAQAAAAECAIAAAAmkwkpAAAACXBIWXMAAC4jAAAuIwF4pT92AAAKT2lDQ1BQaG90b3Nob3AgS" +
                        "UNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AUkSYqIQkQSoghodkVUcERRUUEG" +
                        "8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeE" +
                        "eCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0k" +
                        "ThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEA" +
                        "Gg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8" +
                        "lc88SuuEOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHgg" +
                        "/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgugdfeLZrIPQ" +
                        "<KEY>5NhK<KEY>nwl/<KEY>/Pf14L7iJIEyXYFHBPjgwsz0T" +
                        "KUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKSKcUl0v9k4t8s+wM+3zUAsGo+A" +
                        "XuRLahdYwP2S<KEY>//<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>S<KEY>yBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+IoUspqShnlE" +
                        "OU05QZlmD<KEY>eo<KEY>h<KEY>" +
                        "9BX0svpR+iX6AP0dwwNhh<KEY>xl<KEY>4s<KEY>lv<KEY>" +
                        "<KEY>mq<KEY> +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        <KEY>" +
                        "<KEY>" +
                        "rxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFn<KEY>" +
                        <KEY>/<KEY>c<KEY>pzuP33F9JbpL2dYzxDP2DPjthPLKcRpnVOb00dnF" +
                        "2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/uNu5p7ofcn8w0nymeWTNz0MPIQ" +
                        "+BR5dE/C5+VMGvfrH5PQ0+BZ<KEY>FXrde<KEY>zw<KEY>C3yLfLT" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "AVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0dWOa9rGo5s" +
                        "jxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWFfevc1+1dT1gvWd+1Y" +
                        "fqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebeLZ5bDpaql+aXDm4N2dq0Dd9Wt" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>y<KEY>c<KEY>" +
                        "<KEY>" +
                        "/fF9/XfFt1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9DB" +
                        "Y+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl/erA6xmv2" +
                        "8bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz/GMzLdsAAEFdaVRYd" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "GYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgI" +
                        "<KEY>AgeG1sb" +
                        "nM6eG1wTU09<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>TWV0YWRhdGFEYXRlPjIwM" +
                        "<KEY>x<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "CAgPHhtcE1NOkhpc3Rvcnk+CiAgICAgICAgICAgIDxyZGY6U2VxPgogICAgICAgICAgICAgICA8cmRmO" +
                        "mx<KEY>YXJzZVR5cGU9IlJlc291cmNlIj4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OmFjdGlvb" +
                        "j5jcmVhdGVkPC9zdEV2dDphY3Rpb24+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDppbnN0YW5jZUlEP" +
                        "n<KEY>Nm<KEY>zdEV2dDppbnN0YW5jZ" +
                        "UlEPgogICAgICAgICAgICAgICAgICA8c3RFdnQ6d2hlbj4yMDE2LTAxLTEyVDEyOjI0OjM4LTA2OjAwP" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "n<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "3N0RXZ0OnBhcmFtZXRlcnM+CiAgICAgICAgICAgICAgIDwvcmRmOmxpPgogICAgICAgICAgICAgICA8c" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "Dwvc3RFdnQ6d2hl<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>IDxzdEV2dDp3a" +
                        "GVuPjIwMTYtMDEtMTNUMTM6MTg6MDctMDY6MDA8L3N0RXZ0OndoZW4+CiAgICAgICAgICAgICAgICAgI" +
                        "D<KEY>2Z0d<KEY>vc2hvc<KEY>I<KEY>zd" +
                        "EV2dDpzb2Z0d2FyZUFnZW50PgogICAgICAgICAgICAgICAgICA8c3RFdnQ6Y2hhbmdlZD4vPC9zdEV2d" +
                        "DpjaGFuZ2VkPgogICAgICAgICAgICAgICA8L3JkZjpsaT4KICAgICAgICAgICAgPC9yZGY6U2VxPgogI" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "WRmMzVhMTwvc3RSZWY6ZG9jdW1lbnRJRD4KICAgICAgICAgICAgPHN0UmVmOm9yaWdpbmFsRG9jdW1lb" +
                        "n<KEY>Gl<KEY>" +
                        "2luYWxEb2N1bWVudElEPgogICAgICAgICA8<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "AogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgC" +
                        "iAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "AogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgC" +
                        "iAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSJ3Ij8+bleIyQAAA" +
                        "CBjSFJNAAB6JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAANElEQVR42mJ89+4uAwMDA" +
                        "wPD6lkTGd69u/vu3d2ZHXnv3t1lgLPevbvLrCTIEJqWD1EJGADaTRll80WcLAAAAABJRU5ErkJggg==" +
                        "\");color:#420}#prettydiff.canvas *:focus{outline:0.1em dashed #f00}#prettydiff." +
                        "canvas a{color:#039}#prettydiff.canvas .contentarea,#prettydiff.canvas .data li," +
                        "#prettydiff.canvas .diff td,#prettydiff.canvas .diff-right,#prettydiff.canvas .r" +
                        "eport td,#prettydiff.canvas fieldset input,#prettydiff.canvas fieldset select,#p" +
                        "rettydiff.canvas legend{background:#eeeee8;border-color:#420}#prettydiff.canvas " +
                        "#report,#prettydiff.canvas #report .author,#prettydiff.canvas .beautify,#prettyd" +
                        "iff.canvas .beautify h3,#prettydiff.canvas .beautify h4,#prettydiff.canvas .diff" +
                        ",#prettydiff.canvas .diff h3,#prettydiff.canvas .diff h4,#prettydiff.canvas .rep" +
                        "ort,#prettydiff.canvas fieldset,#prettydiff.canvas input,#prettydiff.canvas sele" +
                        "ct{background:#ddddd8;border-color:#420}#prettydiff.canvas fieldset fieldset{bac" +
                        "kground:#eeeee8}#prettydiff.canvas fieldset fieldset input,#prettydiff.canvas fi" +
                        "eldset fieldset select{background:#ddddd8}#prettydiff.canvas h2,#prettydiff.canv" +
                        "as h2 button,#prettydiff.canvas h3,#prettydiff.canvas legend{color:#900}#prettyd" +
                        "iff.canvas #addOptions .disabled{background:#ccbbb8;color:#300}#prettydiff.canva" +
                        "s .contentarea{box-shadow:0 1em 1em #b8a899}#prettydiff.canvas .segment{backgrou" +
                        "nd:#fff}#prettydiff.canvas .options li,#prettydiff.canvas .segment,#prettydiff.c" +
                        "anvas h2 button,#prettydiff.canvas ol.segment li,#prettydiff.canvas th{border-co" +
                        "lor:#420}#prettydiff.canvas th{background:#e8ddcc}#prettydiff.canvas li h4{color" +
                        ":#06f}#prettydiff.canvas code{background:#eee;border-color:#eee;color:#00f}#pret" +
                        "tydiff.canvas ol.segment h4 strong{color:#c00}#prettydiff.canvas button{backgrou" +
                        "nd-color:#ddddd8;border-color:#420;box-shadow:0 0.25em 0.5em #b8a899;color:#900}" +
                        "#prettydiff.canvas button:hover{background-color:#ccb;border-color:#630;box-shad" +
                        "ow:0 0.25em 0.5em #b8a899;color:#630}#prettydiff.canvas td.nested{background:#cc" +
                        "ccc8}#prettydiff.canvas th,#prettydiff.canvas th.nested{background:#ddddd8}#pret" +
                        "tydiff.canvas tr:hover{background:#eee8ee}#prettydiff.canvas th.heading,#prettyd" +
                        "iff.canvas thead th,#prettydiff.canvas tr.header th{background:#ddc}#prettydiff." +
                        "canvas .diff h3{background:#ddd;border-color:#999}#prettydiff.canvas .count li,#" +
                        "prettydiff.canvas .data li,#prettydiff.canvas .data li span,#prettydiff.canvas ." +
                        "diff-right,#prettydiff.canvas .segment,#prettydiff.canvas td{border-color:#ccccc" +
                        "8}#prettydiff.canvas .count{background:#eed;border-color:#999}#prettydiff.canvas" +
                        " .count li.fold{color:#900}#prettydiff.canvas h2 button{background:#f8f8f8;box-s" +
                        "hadow:0.1em 0.1em 0.25em #ddd}#prettydiff.canvas li h4,#prettydiff.canvas li h5{" +
                        "color:#06c}#prettydiff.canvas code{background:#eee;border-color:#eee;color:#009}" +
                        "#prettydiff.canvas ol.segment h4 strong{color:#c00}#prettydiff.canvas .data .del" +
                        "ete{background:#ffd8d8}#prettydiff.canvas .data .delete em{background:#fff8f8;bo" +
                        "rder-color:#c44;color:#900}#prettydiff.canvas .data .insert{background:#d8ffd8}#" +
                        "prettydiff.canvas .data .insert em{background:#f8fff8;border-color:#090;color:#3" +
                        "63}#prettydiff.canvas .data .replace{background:#fec}#prettydiff.canvas .data .r" +
                        "eplace em{background:#ffe;border-color:#a86;color:#852}#prettydiff.canvas .data " +
                        ".empty{background:#ddd}#prettydiff.canvas .data em.s0{border-color:#000;color:#0" +
                        "00}#prettydiff.canvas .data em.s1{border-color:#f66;color:#f66}#prettydiff.canva" +
                        "s .data em.s2{border-color:#12f;color:#12f}#prettydiff.canvas .data em.s3{border" +
                        "-color:#090;color:#090}#prettydiff.canvas .data em.s4{border-color:#d6d;color:#d" +
                        "6d}#prettydiff.canvas .data em.s5{border-color:#7cc;color:#7cc}#prettydiff.canva" +
                        "s .data em.s6{border-color:#c85;color:#c85}#prettydiff.canvas .data em.s7{border" +
                        "-color:#737;color:#737}#prettydiff.canvas .data em.s8{border-color:#6d0;color:#6" +
                        "d0}#prettydiff.canvas .data em.s9{border-color:#dd0;color:#dd0}#prettydiff.canva" +
                        "s .data em.s10{border-color:#893;color:#893}#prettydiff.canvas .data em.s11{bord" +
                        "er-color:#b97;color:#b97}#prettydiff.canvas .data em.s12{border-color:#bbb;color" +
                        ":#bbb}#prettydiff.canvas .data em.s13{border-color:#cc3;color:#cc3}#prettydiff.c" +
                        "anvas .data em.s14{border-color:#333;color:#333}#prettydiff.canvas .data em.s15{" +
                        "border-color:#9d9;color:#9d9}#prettydiff.canvas .data em.s16{border-color:#880;c" +
                        "olor:#880}#prettydiff.canvas .data .l0{background:#eeeee8}#prettydiff.canvas .da" +
                        "ta .l1{background:#fed}#prettydiff.canvas .data .l2{background:#def}#prettydiff." +
                        "canvas .data .l3{background:#efe}#prettydiff.canvas .data .l4{background:#fef}#p" +
                        "rettydiff.canvas .data .l5{background:#eef}#prettydiff.canvas .data .l6{backgrou" +
                        "nd:#fff8cc}#prettydiff.canvas .data .l7{background:#ede}#prettydiff.canvas .data" +
                        " .l8{background:#efc}#prettydiff.canvas .data .l9{background:#ffd}#prettydiff.ca" +
                        "nvas .data .l10{background:#edc}#prettydiff.canvas .data .l11{background:#fdb}#p" +
                        "rettydiff.canvas .data .l12{background:#f8f8f8}#prettydiff.canvas .data .l13{bac" +
                        "kground:#ffb}#prettydiff.canvas .data .l14{background:#eec}#prettydiff.canvas .d" +
                        "ata .l15{background:#cfc}#prettydiff.canvas .data .l16{background:#eea}#prettydi" +
                        "ff.canvas .data .c0{background:inherit}#prettydiff.canvas #report p em{color:#06" +
                        "0}#prettydiff.canvas #report p strong{color:#009}#prettydiff.canvas .diffcli h3{" +
                        "color:#009}#prettydiff.canvas .diffcli del{background:#e8dddd;color:#a00}#pretty" +
                        "diff.canvas .diffcli ins{background:#dde8dd;color:#060}#prettydiff.canvas .diffc" +
                        "li p{color:#555}#prettydiff.canvas .diffcli li{border-bottom-color:#aaa}",
                shadow: "#prettydiff.shadow{background:#333 url(\"data:image/png;base64,iVBORw0KGgoAAAANS" +
                        "UhEUgAAAAQAAAAECAIAAAAmkwkpAAAACXBIWXMAAC4jAAAuIwF4pT92AAAKT2lDQ1BQaG90b3Nob3AgS" +
                        "UNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AUkSYqIQkQSoghodkVUcERRUUEG" +
                        "8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeE" +
                        "eCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0k" +
                        "ThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEA" +
                        "Gg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8" +
                        "<KEY>" +
                        <KEY>" +
                        "<KEY>" +
                        "<KEY>//<KEY>" +
                        "<KEY>" +
                        "KCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBCCmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uw" +
                        "<KEY>" +
                        "<KEY>LVDu<KEY>x<KEY>2" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>/" +
                        "<KEY>V/jvMYgC2MZs3gsIWsNq4Z1<KEY>Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZ" +
                        "j8H45hx+Jx0TgnnKKeX836K3hTvKeIpG6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx" +
                        "0onXCdHZ4/OBZ3nU9lT3acKpxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p" +
                        "/<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        <KEY>" +
                        "<KEY>JS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/uNu5p7ofcn8w0nyme<KEY>" +
                        "+BR5dE/C5+VMGvfrH<KEY>Iy9jL5FXrdewt6V3<KEY>M+4zw33jLeWV/MN8C3yLfLT" +
                        "8Nvnl+F30N/I/9k/3r/0QCngC<KEY>L7+Hp8Ib+OPzrbZf<KEY>QRVBj4KtguXBrSFoy" +
                        "OyQrSH355jOkc5pDoVQfujW0Adh5mGLw34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85r" +
                        "<KEY>qPNo3ujS6P8YuZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3i<KEY>p" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>//<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>7vPY07NXbW7z3/T7Jv" +
                        "ttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHtxwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vd" +
                        "y0NNg1VjZzG4iNwRHnk6fcJ3/ceDTradox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R" +
                        "9sfD5w0PFl5SvNUyWna6YLTk2fyz4ydlZ19fi7<KEY>d" +
                        "<KEY>" +
                        <KEY>" +
                        "<KEY>" +
                        "<KEY>/<KEY>" +
                        "FhNTDpjb20uYWRvYmUueG1wAAAAAAA8P3hwYWNrZXQgYmVna<KEY>IgaWQ9Ilc1TTBNcENlaGlIe" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "zEuMS8iCi<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "WZ5RGF0<KEY>" +
                        "<KEY>" +
                        "jU8L3htcE<KEY>2JlOmRvY2lkO" +
                        "nBob3Rvc2hvcDoxZmZhNDk1Yy1mYTU2LTExNzgtOWE5Yy1kODI1ZGZiMGE0NzA8L3htcE1NOkRvY3VtZ" +
                        "W<KEY>" +
                        "j<KEY>t<KEY>" +
                        "CAgPHhtcE1NOkhpc3Rvcnk+CiAgICAgICAgICAgIDxyZGY6U2VxPgogICAgICAgICAgICAgICA8cmRmO" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>QtNjgxMzExZDc0MDMxPC9zdEV2dDppbnN0YW5jZ" +
                        "UlEPgogICAgICAgICAgICAgICAgICA<KEY>MDE2LTAxLTEyVDEyOjI0OjM4LTA2OjAwP" +
                        "C9zdEV2dDp3aGVuPgogICAgICAgICAgICAgICAgICA<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "m<KEY>" +
                        "<KEY>vcG5nIHRvIGFwcGxpY2F0aW9<KEY>L" +
                        "3N0RXZ0OnBhcmFtZXRlcnM+CiAgICAgICAgICAgICAgIDwvcmRmOmxpPgogICAgICAgICAgICAgICA8c" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "CAgICAgICAgIDxzdEV2dDpjaGFuZ2VkPi88L3N0RXZ0OmNoYW5nZWQ+CiAgICAgICAgICAgICAgIDwvc" +
                        "mRmOmx<KEY>" +
                        "<KEY>I" +
                        "C<KEY>bXAuaWlkOjA0ZGYyNDk5LWE1NTktNDE4MC1iNjA1LWI2M" +
                        "Tk<KEY>M" +
                        "j<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>Z" +
                        "<KEY>Glvbj4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OnBhcmFt<KEY>vbSBhc" +
                        "<KEY>lvbi<KEY>ldGVyc" +
                        "z<KEY>" +
                        "HlwZT0iUmVzb3VyY2UiPgogICAgICAgICAgICAgICAgICA8c3RFdnQ6YWN0aW9uPmRlcml2ZWQ8L3N0R" +
                        "XZ0OmFjdGlvbj4KICAgICAgICAgICAgICAgICAg<KEY>" +
                        "<KEY>" +
                        "XRlcnM+CiAgICAgICAgICAgICAgIDwvcmRmOmxpPgogICAgICAgICAgICAgICA8cmRmOmxpIHJkZjpwY" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>xzd" +
                        "<KEY>uZ<KEY>I" +
                        "CAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwveG1wTU06SGlzdG9yeT4KICAgICAgICAgPHhtcE1NO" +
                        "kRlcml2<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>xvck1vZGU+CiAgICAgICAgIDxwaG90b3Nob" +
                        "<KEY>" +
                        "<KEY>yaWVud<KEY>YXRpb24+CiAgICAgICAgIDx0aWZmOlhSZ" +
                        "XNvbHV0aW9uPjMwMDAwMDAvMTAwMDA8L3RpZmY6WFJlc29sdXRpb24+CiAgICAgICAgIDx0aWZmOllSZ" +
                        "XNvbHV0aW9uPjMwMDAwMDAvMTAwMDA8L3RpZmY6WVJlc29sdXRpb24+CiAgICAgICAgIDx0aWZmOlJlc" +
                        "29sdXRpb25Vbml0PjI8L3RpZmY6UmVzb2x1dGlvblVuaXQ+CiAgICAgICAgIDxleGlmOkNvbG9yU3BhY" +
                        "2U+MTwvZXhpZjpDb2xvclNwYWNlPgogICAgICAgICA8ZXhpZjpQaXhlbFhEaW1lbnNpb24+NDwvZXhpZ" +
                        "jpQaXhlbFhEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWURpbWVuc2lvbj40PC9leGlmOlBpe" +
                        "GVsWURpbWVuc2lvbj4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94Onhtc" +
                        "G1ldGE+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "AogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgC" +
                        "iAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "AogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgC" +
                        "iAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI" +
                        "CAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY" +
                        "2tldCBlbmQ9InciPz5hSvvCAAAAIGNIUk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5Jfx" +
                        "UYAAAAlSURBVHjaPMYxAQAwDAMgVkv1VFFRuy9cvN0F7m66JNNhOvwBAPyqCtNeO5K2AAAAAElFTkSuQ" +
                        "mCC\");color:#fff}#prettydiff.shadow *:focus{outline:0.1em dashed #ff0}#prettydi" +
                        "ff.shadow a:visited{color:#f93}#prettydiff.shadow a{color:#cf3}#prettydiff.shado" +
                        "w .contentarea,#prettydiff.shadow .data li,#prettydiff.shadow .diff td,#prettydi" +
                        "ff.shadow .diff-right,#prettydiff.shadow .report td,#prettydiff.shadow fieldset " +
                        "input,#prettydiff.shadow fieldset select,#prettydiff.shadow legend{background:#3" +
                        "33;border-color:#666}#prettydiff.shadow #report,#prettydiff.shadow #report .auth" +
                        "or,#prettydiff.shadow .beautify,#prettydiff.shadow .beautify h3,#prettydiff.shad" +
                        "ow .beautify h4,#prettydiff.shadow .diff,#prettydiff.shadow .diff h3,#prettydiff" +
                        ".shadow .diff h4,#prettydiff.shadow .report,#prettydiff.shadow fieldset,#prettyd" +
                        "iff.shadow input,#prettydiff.shadow select{background:#222;border-color:#666}#pr" +
                        "ettydiff.shadow fieldset fieldset{background:#333}#prettydiff.shadow .nested td," +
                        "#prettydiff.shadow .segment,#prettydiff.shadow fieldset fieldset input,#prettydi" +
                        "ff.shadow fieldset fieldset select{background:#222}#prettydiff.shadow h2,#pretty" +
                        "diff.shadow h2 button,#prettydiff.shadow h3,#prettydiff.shadow input,#prettydiff" +
                        ".shadow legend,#prettydiff.shadow option,#prettydiff.shadow select{color:#ccc}#p" +
                        "rettydiff.shadow .contentarea{box-shadow:0 1em 1em #000}#prettydiff.shadow .opti" +
                        "ons li,#prettydiff.shadow .segment,#prettydiff.shadow h2 button,#prettydiff.shad" +
                        "ow ol.segment li,#prettydiff.shadow td,#prettydiff.shadow th{border-color:#666}#" +
                        "prettydiff.shadow .count li.fold{color:#cf3}#prettydiff.shadow th{background:#00" +
                        "0}#prettydiff.shadow h2 button{background:#585858;box-shadow:0.1em 0.1em 0.25em " +
                        "#000}#prettydiff.shadow li h4{color:#ff0}#prettydiff.shadow code{background:#585" +
                        "858;border-color:#585858;color:#ccf}#prettydiff.shadow ol.segment h4 strong{colo" +
                        "r:#f30}#prettydiff.shadow button{background-color:#333;border-color:#666;box-sha" +
                        "dow:0 0.25em 0.5em #000;color:#ccc}#prettydiff.shadow button:hover{background-co" +
                        "lor:#777;border-color:#aaa;box-shadow:0 0.25em 0.5em #222;color:#fff}#prettydiff" +
                        ".shadow tr:hover{background:#353}#prettydiff.shadow th,#prettydiff.shadow th.hea" +
                        "ding,#prettydiff.shadow thead th{background:#666;border-color:#999}#prettydiff.s" +
                        "hadow .nested td.nested,#prettydiff.shadow td.nested,#prettydiff.shadow th.neste" +
                        "d{background:#444}#prettydiff.shadow .diff h3{background:#000;border-color:#666}" +
                        "#prettydiff.shadow .beautify li span,#prettydiff.shadow .data li,#prettydiff.sha" +
                        "dow .diff-right,#prettydiff.shadow .segment{border-color:#888}#prettydiff.shadow" +
                        " .count li{border-color:#333}#prettydiff.shadow .count{background:#555;border-co" +
                        "lor:#333}#prettydiff.shadow li h4,#prettydiff.shadow li h5{color:#ff0}#prettydif" +
                        "f.shadow code{background:#000;border-color:#000;color:#ddd}#prettydiff.shadow #a" +
                        "ddOptions .disabled{background:#300;color:#fdd}#prettydiff.shadow ol.segment h4 " +
                        "strong{color:#c00}#prettydiff.shadow .data .delete{background:#300}#prettydiff.s" +
                        "hadow .data .delete em{background:#200;border-color:#c63;color:#c66}#prettydiff." +
                        "shadow .data .insert{background:#030}#prettydiff.shadow .data .insert em{backgro" +
                        "und:#010;border-color:#090;color:#6c0}#prettydiff.shadow .data .replace{backgrou" +
                        "nd:#345}#prettydiff.shadow .data .replace em{background:#023;border-color:#09c;c" +
                        "olor:#7cf}#prettydiff.shadow .data .empty{background:#111}#prettydiff.shadow .di" +
                        "ff .author{border-color:#666}#prettydiff.shadow .data em.s0{border-color:#fff;co" +
                        "lor:#fff}#prettydiff.shadow .data em.s1{border-color:#d60;color:#d60}#prettydiff" +
                        ".shadow .data em.s2{border-color:#aaf;color:#aaf}#prettydiff.shadow .data em.s3{" +
                        "border-color:#0c0;color:#0c0}#prettydiff.shadow .data em.s4{border-color:#f6f;co" +
                        "lor:#f6f}#prettydiff.shadow .data em.s5{border-color:#0cc;color:#0cc}#prettydiff" +
                        ".shadow .data em.s6{border-color:#dc3;color:#dc3}#prettydiff.shadow .data em.s7{" +
                        "border-color:#a7a;color:#a7a}#prettydiff.shadow .data em.s8{border-color:#7a7;co" +
                        "lor:#7a7}#prettydiff.shadow .data em.s9{border-color:#ff6;color:#ff6}#prettydiff" +
                        ".shadow .data em.s10{border-color:#33f;color:#33f}#prettydiff.shadow .data em.s1" +
                        "1{border-color:#933;color:#933}#prettydiff.shadow .data em.s12{border-color:#990" +
                        ";color:#990}#prettydiff.shadow .data em.s13{border-color:#987;color:#987}#pretty" +
                        "diff.shadow .data em.s14{border-color:#fc3;color:#fc3}#prettydiff.shadow .data e" +
                        "m.s15{border-color:#897;color:#897}#prettydiff.shadow .data em.s16{border-color:" +
                        "#f30;color:#f30}#prettydiff.shadow .data .l0{background:#333}#prettydiff.shadow " +
                        ".data .l1{background:#633}#prettydiff.shadow .data .l2{background:#335}#prettydi" +
                        "ff.shadow .data .l3{background:#353}#prettydiff.shadow .data .l4{background:#636" +
                        "}#prettydiff.shadow .data .l5{background:#366}#prettydiff.shadow .data .l6{backg" +
                        "round:#640}#prettydiff.shadow .data .l7{background:#303}#prettydiff.shadow .data" +
                        " .l8{background:#030}#prettydiff.shadow .data .l9{background:#660}#prettydiff.sh" +
                        "adow .data .l10{background:#003}#prettydiff.shadow .data .l11{background:#300}#p" +
                        "rettydiff.shadow .data .l12{background:#553}#prettydiff.shadow .data .l13{backgr" +
                        "ound:#432}#prettydiff.shadow .data .l14{background:#640}#prettydiff.shadow .data" +
                        " .l15{background:#562}#prettydiff.shadow .data .l16{background:#600}#prettydiff." +
                        "shadow .data .c0{background:inherit}#prettydiff.shadow .diffcli h3{color:#9cf}#p" +
                        "rettydiff.shadow .diffcli del{background:#382222;color:#f63}#prettydiff.shadow ." +
                        "diffcli ins{background:#223822;color:#cf3}#prettydiff.shadow .diffcli p{color:#a" +
                        "aa}#prettydiff.shadow .diffcli li{border-bottom-color:#666}",
                white : "#prettydiff.white{background:#f8f8f8 url(\"data:image/png;base64,iVBORw0KGgoAAAA" +
                        "NSUhEUgAAAAQAAAAECAIAAAAmkwkpAAAACXBIWXMAAC4jAAAuIwF4pT92AAAKT2lDQ1BQaG90b3Nob3A" +
                        "gSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AUkSYqIQkQSoghodkVUcERRUU" +
                        "EG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUI" +
                        "eEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB" +
                        "0kThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYh" +
                        "EAGg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABR" +
                        "G8lc88SuuEOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRH" +
                        "gg/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgugdfeLZrI" +
                        "PQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7iJIEyXYFHBPjgwsz" +
                        "<KEY>" +
                        <KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "IHfI9cgI5h1xGupE7yAAyg<KEY>3UDLVDuag3GoRGogvQZHQxmo8<KEY>" +
                        "P2o8+Q8cww<KEY>s<KEY>xd<KEY>" +
                        "MWE7YSKggHCQ0E<KEY>c<KEY>" +
                        "xpFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXk<KEY>Qh8lsKnWJAcaT4U+IoUspqShn" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>7TDt<KEY>mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRapln" +
                        "utrxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFnYhdnt8W" +
                        "<KEY>N/<KEY>t<KEY>j<KEY>d" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>5j<KEY>fujW0<KEY>4MJ4WHhVeGP45wiFga0<KEY>0T<KEY>" +
                        "<KEY>" +
                        "FpxapLhIsOpZATIhOOJTwQRA<KEY>" +
                        "<KEY>" +
                        "<KEY>//<KEY>" +
                        "<KEY> +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>/i+c7vDvOXPK" +
                        "4dPKy2+UTV7hXmq86X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN" +
                        "6b/fF9/XfFt1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9" +
                        "DBY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl/erA6xm" +
                        "<KEY>" +
                        "YdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGl" +
                        "<KEY>a2M5ZCI/Pgo8e<KEY>IH<KEY>" +
                        "rPSJBZG9iZSBYTVAgQ29yZSA1LjYtYzAxNCA3OS4xNTY3OTcsIDIwMTQvMDgvMjAtMDk6NTM6MDIgICA" +
                        "gICAgICI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d<KEY>cmcvMTk<KEY>" +
                        "yZGYtc3ludGF4LW5z<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "lYXRvclRvb2w+<KEY>LTA2OjA" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "kLTY<KEY>wveG1wTU06T3JpZ2luYWxEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06SGl" +
                        "zdG9yeT4KICAgICAgICAgICAgPHJkZjpTZXE+CiAgICAgICAgICAgICAgIDxyZGY6bGkgcmRmOnBhcnN" +
                        "lVHlwZT0iUmVzb3VyY2UiPgogICAgICAgICAgICAgICAgICA<KEY>Ny<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "+<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "tMDEtMTJUMTI6MjQ6MzgtMDY6MDA8L3N0RXZ0OndoZW4+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDp" +
                        "zb2Z0d<KEY>" +
                        "0d2FyZUFnZW50PgogICAgICAgICAgICAgICAgICA8c3RFdnQ6Y2hhbmdlZD4vPC9zdEV2dDpjaGFuZ2V" +
                        "kPgogICAgICAgICAgICAgICA8L3JkZjpsaT4KICAgICAgICAgICAgPC9yZGY6U2VxPgogICAgICAgICA" +
                        "8L3htcE1NOkhpc3Rvcnk+<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>" +
                        "<KEY>U3BhY2U+MTwvZXhpZjpDb2xvclNwYWNlPgogICAgICAgICA8ZXhpZjpQaXhlbFhEaW1lbnN" +
                        "pb24+NDwvZXhpZjpQaXhlbFhEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWURpbWVuc2lvbj4" +
                        "0PC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJ" +
                        "ERj4KPC94OnhtcG1ldGE+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAo" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAo" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICA" +
                        "gICAgCjw/eHBhY2tldCBlbmQ9InciPz5cKgaXAAAAIGNIUk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mA" +
                        "AADqYAAAXb5JfxUYAAAAkSURBVHjaPMahAQAwDMCg7P+/KnsPcq4oHqpqdwNmBt3QDX8AeAUmcrZLnM4" +
                        "AAAAASUVORK5CYII=\");}#prettydiff.white *:focus{outline:0.1em dashed #06f}#prett" +
                        "ydiff.white .contentarea,#prettydiff.white .data li,#prettydiff.white .diff td,#" +
                        "prettydiff.white .diff-right,#prettydiff.white .report td,#prettydiff.white fiel" +
                        "dset input,#prettydiff.white fieldset select,#prettydiff.white legend{background" +
                        ":#fff;border-color:#999}#prettydiff.white #pdsamples li div,#prettydiff.white #r" +
                        "eport,#prettydiff.white #report .author,#prettydiff.white .author,#prettydiff.wh" +
                        "ite .beautify,#prettydiff.white .beautify h3,#prettydiff.white .beautify h4,#pre" +
                        "ttydiff.white .diff,#prettydiff.white .diff h3,#prettydiff.white .diff h4,#prett" +
                        "ydiff.white .report,#prettydiff.white fieldset,#prettydiff.white input,#prettydi" +
                        "ff.white select{background:#eee;border-color:#999}#prettydiff.white .diff h3{bac" +
                        "kground:#ddd;border-color:#999}#prettydiff.white fieldset fieldset,#prettydiff.w" +
                        "hite th.nested{background:#ddd}#prettydiff.white .contentarea{box-shadow:0 1em 1" +
                        "em #999}#prettydiff.white button{background-color:#eee;border-color:#999;box-sha" +
                        "dow:0 0.25em 0.5em #ccc;color:#666}#prettydiff.white button:hover{background-col" +
                        "or:#def;border-color:#03c;box-shadow:0 0.25em 0.5em #ccf;color:#03c}#prettydiff." +
                        "white h2,#prettydiff.white h2 button,#prettydiff.white h3{color:#b00}#prettydiff" +
                        ".white th{background:#eee;color:#333}#prettydiff.white tr:hover{background:#efe}" +
                        "#prettydiff.white thead th,#prettydiff.white tr.header th{background:#eef}#prett" +
                        "ydiff.white .report strong{color:#009}#prettydiff.white .report em{color:#080}#p" +
                        "rettydiff.white .count li,#prettydiff.white .data li,#prettydiff.white .data li " +
                        "span,#prettydiff.white .diff-right,#prettydiff.white .options li,#prettydiff.whi" +
                        "te .segment,#prettydiff.white h2 button,#prettydiff.white ol.segment li,#prettyd" +
                        "iff.white td{border-color:#ccc}#prettydiff.white tbody th{border-color:#999}#pre" +
                        "ttydiff.white td.nested{background:#d8d8d8}#prettydiff.white th.nested{backgroun" +
                        "d:#eee}#prettydiff.white .count li.fold{color:#900}#prettydiff.white .count{back" +
                        "ground:#eed;border-color:#999}#prettydiff.white #addOptions .disabled{background" +
                        ":#fee;color:#300}#prettydiff.white h2 button{background:#f8f8f8;box-shadow:0.1em" +
                        " 0.1em 0.25em #ddd}#prettydiff.white li h4,#prettydiff.white li h5{color:#33c}#p" +
                        "rettydiff.white code{background:#eee;border-color:#eee;color:#009}#prettydiff.wh" +
                        "ite ol.segment h4 strong{color:#c00}#prettydiff.white .data .delete{background:#" +
                        "ffd8d8}#prettydiff.white .data .delete em{background:#fff8f8;border-color:#c44;c" +
                        "olor:#900}#prettydiff.white .data .insert{background:#d8ffd8}#prettydiff.white ." +
                        "data .insert em{background:#f8fff8;border-color:#090;color:#363}#prettydiff.whit" +
                        "e .data .replace{background:#fec}#prettydiff.white .data .replace em{background:" +
                        "#ffe;border-color:#a86;color:#852}#prettydiff.white .data .empty{background:#ddd" +
                        "}#prettydiff.white .data em.s0{border-color:#000;color:#000}#prettydiff.white .d" +
                        "ata em.s1{border-color:#f66;color:#f66}#prettydiff.white .data em.s2{border-colo" +
                        "r:#12f;color:#12f}#prettydiff.white .data em.s3{border-color:#090;color:#090}#pr" +
                        "ettydiff.white .data em.s4{border-color:#d6d;color:#d6d}#prettydiff.white .data " +
                        "em.s5{border-color:#7cc;color:#7cc}#prettydiff.white .data em.s6{border-color:#c" +
                        "85;color:#c85}#prettydiff.white .data em.s7{border-color:#737;color:#737}#pretty" +
                        "diff.white .data em.s8{border-color:#6d0;color:#6d0}#prettydiff.white .data em.s" +
                        "9{border-color:#dd0;color:#dd0}#prettydiff.white .data em.s10{border-color:#893;" +
                        "color:#893}#prettydiff.white .data em.s11{border-color:#b97;color:#b97}#prettydi" +
                        "ff.white .data em.s12{border-color:#bbb;color:#bbb}#prettydiff.white .data em.s1" +
                        "3{border-color:#cc3;color:#cc3}#prettydiff.white .data em.s14{border-color:#333;" +
                        "color:#333}#prettydiff.white .data em.s15{border-color:#9d9;color:#9d9}#prettydi" +
                        "ff.white .data em.s16{border-color:#880;color:#880}#prettydiff.white .data .l0{b" +
                        "ackground:#fff}#prettydiff.white .data .l1{background:#fed}#prettydiff.white .da" +
                        "ta .l2{background:#def}#prettydiff.white .data .l3{background:#efe}#prettydiff.w" +
                        "hite .data .l4{background:#fef}#prettydiff.white .data .l5{background:#eef}#pret" +
                        "tydiff.white .data .l6{background:#fff8cc}#prettydiff.white .data .l7{background" +
                        ":#ede}#prettydiff.white .data .l8{background:#efc}#prettydiff.white .data .l9{ba" +
                        "ckground:#ffd}#prettydiff.white .data .l10{background:#edc}#prettydiff.white .da" +
                        "ta .l11{background:#fdb}#prettydiff.white .data .l12{background:#f8f8f8}#prettyd" +
                        "iff.white .data .l13{background:#ffb}#prettydiff.white .data .l14{background:#ee" +
                        "c}#prettydiff.white .data .l15{background:#cfc}#prettydiff.white .data .l16{back" +
                        "ground:#eea}#prettydiff.white .data .c0{background:inherit}#prettydiff.white #re" +
                        "port p em{color:#080}#prettydiff.white #report p strong{color:#009}#prettydiff.w" +
                        "hite .diffcli h3{color:#009}#prettydiff.white .diffcli del{background:#f8eeee;co" +
                        "lor:#c00}#prettydiff.white .diffcli ins{background:#eef8ee;color:#070}#prettydif" +
                        "f.white .diffcli p{color:#666}#prettydiff.white .diffcli li{border-bottom-color:" +
                        "#ccc}"
            },
            global : "#prettydiff{text-align:center;font-size:10px;overflow-y:scroll}#prettydiff .cont" +
                    "entarea{border-style:solid;border-width:0.1em;font-family:\"Century Gothic\",\"T" +
                    "rebuchet MS\";margin:0 auto;max-width:93em;padding:1em;text-align:left}#prettydi" +
                    "ff dd,#prettydiff dt,#prettydiff p,#prettydiff li,#prettydiff td,#prettydiff blo" +
                    "ckquote,#prettydiff th{clear:both;font-family:\"Palatino Linotype\",\"Book Antiq" +
                    "ua\",Palatino,serif;font-size:1.6em;line-height:1.6em;text-align:left}#prettydif" +
                    "f blockquote{font-style:italic}#prettydiff dt{font-size:1.4em;font-weight:bold;l" +
                    "ine-height:inherit}#prettydiff li li,#prettydiff li p{font-size:1em}#prettydiff " +
                    "th,#prettydiff td{border-style:solid;border-width:0.1em;padding:0.1em 0.2em}#pre" +
                    "ttydiff td span{display:block}#prettydiff code,#prettydiff textarea{font-family:" +
                    "\"Courier New\",Courier,\"Lucida Console\",monospace}#prettydiff code,#prettydif" +
                    "f textarea{display:block;font-size:0.8em;width:100%}#prettydiff code span{displa" +
                    "y:block;white-space:pre}#prettydiff code{border-style:solid;border-width:0.2em;l" +
                    "ine-height:1em}#prettydiff textarea{line-height:1.4em}#prettydiff label{display:" +
                    "inline;font-size:1.4em}#prettydiff legend{border-radius:1em;border-style:solid;b" +
                    "order-width:0.1em;font-size:1.4em;font-weight:bold;margin-left:-0.25em;padding:0" +
                    " 0.5em}#prettydiff fieldset fieldset legend{font-size:1.2em}#prettydiff table{bo" +
                    "rder-collapse:collapse}#prettydiff div.report{border-style:none}#prettydiff h2,#" +
                    "prettydiff h3,#prettydiff h4{clear:both}#prettydiff table{margin:0 0 1em}#pretty" +
                    "diff .analysis .bad,#prettydiff .analysis .good{font-weight:bold}#prettydiff h1{" +
                    "font-size:3em;font-weight:normal;margin-top:0}#prettydiff h1 span{font-size:0.5e" +
                    "m}#prettydiff h1 svg{border-style:solid;border-width:0.05em;float:left;height:1." +
                    "5em;margin-right:0.5em;width:1.5em}#prettydiff h2{border-style:none;background:t" +
                    "ransparent;font-size:1em;box-shadow:none;margin:0}#prettydiff h2 button{backgrou" +
                    "nd:transparent;border-style:solid;cursor:pointer;display:block;font-size:2.5em;f" +
                    "ont-weight:normal;text-align:left;width:100%;border-width:0.05em;font-weight:nor" +
                    "mal;margin:1em 0 0;padding:0.1em}#prettydiff h2 span{display:block;float:right;f" +
                    "ont-size:0.5em}#prettydiff h3{font-size:2em;margin:0;background:transparent;box-" +
                    "shadow:none;border-style:none}#prettydiff h4{font-size:1.6em;font-family:\"Centu" +
                    "ry Gothic\",\"Trebuchet MS\";margin:0}#prettydiff li h4{font-size:1em}#prettydif" +
                    "f button,#prettydiff fieldset,#prettydiff div input,#prettydiff textarea{border-" +
                    "style:solid;border-width:0.1em}#prettydiff section{border-style:none}#prettydiff" +
                    " h2 button,#prettydiff select,#prettydiff option{font-family:inherit}#prettydiff" +
                    " select{border-style:inset;border-width:0.1em;width:13.5em}#prettydiff #dcolorSc" +
                    "heme{float:right;margin:-3em 0 0}#prettydiff #dcolorScheme label,#prettydiff #dc" +
                    "olorScheme label{display:inline-block;font-size:1em}#prettydiff .clear{clear:bot" +
                    "h;display:block}#prettydiff caption,#prettydiff .content-hide{height:1em;left:-1" +
                    "000em;overflow:hidden;position:absolute;top:-1000em;width:1em}",
            reports: "#prettydiff #report.contentarea{font-family:\"Lucida Sans Unicode\",\"Helvetica" +
                    "\",\"Arial\",sans-serif;max-width:none;overflow:scroll}#prettydiff .diff .delete" +
                    " em,#prettydiff .diff .insert em,#prettydiff .diff .replace em{border-style:soli" +
                    "d;border-width:0.1em}#prettydiff #report blockquote,#prettydiff #report dd,#pret" +
                    "tydiff #report dt,#prettydiff #report li,#prettydiff #report p,#prettydiff #repo" +
                    "rt td,#prettydiff #report th{font-family:\"Lucida Sans Unicode\",\"Helvetica\"," +
                    "\"Arial\",sans-serif;font-size:1.2em}#prettydiff div#webtool{background:transpar" +
                    "ent;font-size:inherit;margin:0;padding:0}#prettydiff #jserror span{display:block" +
                    "}#prettydiff #a11y{background:transparent;clear:both;padding:0}#prettydiff #a11y" +
                    " div{margin:0.5em 0;border-style:solid;border-width:0.1em}#prettydiff #a11y h4{m" +
                    "argin:0.25em 0}#prettydiff #a11y ol{border-style:solid;border-width:0.1em}#prett" +
                    "ydiff #cssreport.doc table{clear:none;float:left;margin-left:1em}#prettydiff #cs" +
                    "s-size{left:24em}#prettydiff #css-uri{left:40em}#prettydiff #css-uri td{text-ali" +
                    "gn:left}#prettydiff .report .analysis th{text-align:left}#prettydiff table.code " +
                    "td,#prettydiff table.code th{font-size:0.9em}#prettydiff .report .analysis .pars" +
                    "eData td,#prettydiff table.code td,#prettydiff table.code th{font-family:'Courie" +
                    "r New',Courier,'Lucida Console',monospace;text-align:left;white-space:pre}#prett" +
                    "ydiff .report .analysis td{text-align:right}#prettydiff .analysis{float:left;mar" +
                    "gin:0 1em 1em 0}#prettydiff .analysis td,#prettydiff .analysis th{padding:0.5em}" +
                    "#prettydiff .diffcli{font-size:Courier,'Courier New','Lucida Console',monospace;" +
                    "margin:0;padding:0;text-align:left;white-space:pre;}#prettydiff .diffcli li{bord" +
                    "er-bottom-style:solid;border-bottom-width:0.1em;list-style:none;padding-bottom:1" +
                    "em}#prettydiff #webtool .diffcli h3{font-size:1.4em;font-weight:normal;margin-to" +
                    "p:2em}#prettydiff #webtool .diffcli p,#prettydiff .diffcli del,#prettydiff .diff" +
                    "cli ins{display:block;font-family:Courier,'Courier New','Lucida Console',monospa" +
                    "ce;font-size:1.2em;font-style:normal;margin:0;text-decoration:none}#prettydiff ." +
                    "diffcli em{color:inherit;font-style:normal;font-weight:bold}#prettydiff .diffcli" +
                    " del em,#prettydiff .diffcli ins em{text-decoration:underline}#prettydiff #statr" +
                    "eport div{border-style:none}#prettydiff .beautify,#prettydiff .diff{border-style" +
                    ":solid;border-width:0.1em;display:inline-block;margin:0 1em 1em 0;position:relat" +
                    "ive}#prettydiff .beautify,#prettydiff .beautify h3,#prettydiff .beautify h4,#pre" +
                    "ttydiff .beautify li,#prettydiff .diff,#prettydiff .diff h4,#prettydiff .diff li" +
                    " #prettydiff .diff h3{font-family:'Courier New',Courier,'Lucida Console',monospa" +
                    "ce}#prettydiff .beautify h3,#prettydiff .beautify h4,#prettydiff .beautify li,#p" +
                    "rettydiff .diff h3,#prettydiff .diff h4,#prettydiff .diff li{border-style:none n" +
                    "one solid none;border-width:0 0 0.1em 0;box-shadow:none;display:block;font-size:" +
                    "1.2em;margin:0 0 0 -.1em;padding:0.2em 2em;text-align:left}#prettydiff .diff .sk" +
                    "ip{border-style:none none solid;border-width:0 0 0.1em}#prettydiff .diff .diff-l" +
                    "eft{border-style:none;display:table-cell}#prettydiff .diff .diff-right{border-st" +
                    "yle:none none none solid;border-width:0 0 0 0.1em;display:table-cell;margin-left" +
                    ":-.1em;min-width:16.5em;right:0;top:0}#prettydiff .diff-right .data{width:100%}#" +
                    "prettydiff .beautify .data li,#prettydiff .diff .data li{min-width:16.5em;paddin" +
                    "g:0.5em}#prettydiff .beautify h3,#prettydiff .beautify li,#prettydiff .beautify " +
                    "p,#prettydiff .diff h3,#prettydiff .diff li,#prettydiff .diff p{font-size:1.2em}" +
                    "#prettydiff .beautify li em,#prettydiff .diff li em{font-style:normal;font-weigh" +
                    "t:bold;margin:-0.5em -0.09em}#prettydiff .diff p.author{border-style:solid;borde" +
                    "r-width:0.2em 0.1em 0.1em;margin:0;overflow:hidden;padding:0.4em;text-align:righ" +
                    "t}#prettydiff .difflabel{display:block;height:0}#prettydiff .count{border-style:" +
                    "solid;border-width:0 0.1em 0 0;font-weight:normal;padding:0;text-align:right}#pr" +
                    "ettydiff .count li{padding:0.5em 1em;text-align:right}#prettydiff .count li.fold" +
                    "{cursor:pointer;font-weight:bold;padding-left:0.5em}#prettydiff .data{text-align" +
                    ":left;white-space:pre}#prettydiff .beautify .data span{display:inline-block;font" +
                    "-style:normal;font-weight:bold}#prettydiff .beautify li,#prettydiff .diff li{bor" +
                    "der-style:none none solid;border-width:0 0 0.1em;display:block;height:1em;line-h" +
                    "eight:1.2;list-style-type:none;margin:0;white-space:pre}#prettydiff .beautify ol" +
                    ",#prettydiff .diff ol{display:table-cell;margin:0;padding:0}#prettydiff .beautif" +
                    "y li em{border-style:none none solid;border-width:0 0 0.1em;padding:0 0 0.2em;po" +
                    "sition:relative;z-index:5}#prettydiff .beautify li .line{border-style:none}#pret" +
                    "tydiff .beautify li span{border-style:none none solid;border-width:0 0 0.1em;hei" +
                    "ght:2em;margin:0 0 -1em;position:relative;top:-0.5em}#prettydiff .beautify span." +
                    "l0{margin-left:-0.5em;padding-left:0.5em}#prettydiff #webtool table table{margin" +
                    ":0 -0.1em -0.1em;width:100%}#prettydiff #webtool table table td,#prettydiff #web" +
                    "tool table table th{font-size:1em}#prettydiff #webtool table td.nested{padding:0" +
                    ".5em}#prettydiff #report .beautify,#prettydiff #report .beautify li,#prettydiff " +
                    "#report .diff,#prettydiff #report .diff li{font-family:\"Courier New\",Courier," +
                    "\"Lucida Console\",monospace}#prettydiff #report .beautify{border-style:solid}#p" +
                    "rettydiff #report .beautify h3,#prettydiff #report .diff h3{border-top-style:sol" +
                    "id;border-top-width:0.1em;margin:0}#prettydiff #webtool #a11y,#prettydiff #webto" +
                    "ol #a11y div,#prettydiff #webtool #a11y ol,#prettydiff #webtool #a11y ul{border-" +
                    "style:none}"
        },
        html  : {
            body  : "/\u002a]]>\u002a/</style></head><body id=\"prettydiff\" class=\"",
            color : "white",
            htmlEnd: "</script></body></html>",
            head  : "<?xml version=\"1.0\" encoding=\"UTF-8\" ?><!DOCTYPE html PUBLIC \"-//W3C//DTD X" +
                    "HTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\"><html xmlns=\"ht" +
                    "tp://www.w3.org/1999/xhtml\" xml:lang=\"en\"><head><title>Pretty Diff - The diff" +
                    "erence tool</title><meta name=\"robots\" content=\"index, follow\"/> <meta name=" +
                    "\"DC.title\" content=\"Pretty Diff - The difference tool\"/> <link rel=\"canonic" +
                    "al\" href=\"https://prettydiff.com/\" type=\"application/xhtml+xml\"/><meta http-" +
                    "equiv=\"Content-Type\" content=\"application/xhtml+xml;charset=UTF-8\"/><meta ht" +
                    "tp-equiv=\"Content-Style-Type\" content=\"text/css\"/><style type=\"text/css\">/" +
                    "\u002a<![CDATA[\u002a/",
            intro : "\"><div class=\"contentarea\" id=\"report\"><section role=\"heading\"><h1><svg h" +
                    "eight=\"2000.000000pt\" id=\"pdlogo\" preserveAspectRatio=\"xMidYMid meet\" vers" +
                    "ion=\"1.0\" viewBox=\"0 0 2000.000000 2000.000000\" width=\"2000.000000pt\" xmln" +
                    "s=\"http://www.w3.org/2000/svg\"><g fill=\"#999\" stroke=\"none\" transform=\"tr" +
                    "anslate(0.000000,2000.000000) scale(0.100000,-0.100000)\"> <path d=\"M14871 1852" +
                    "3 c-16 -64 -611 -2317 -946 -3588 -175 -660 -319 -1202 -320 -1204 -2 -2 -50 39 -1" +
                    "07 91 -961 876 -2202 1358 -3498 1358 -1255 0 -2456 -451 -3409 -1279 -161 -140 -4" +
                    "24 -408 -560 -571 -507 -607 -870 -1320 -1062 -2090 -58 -232 -386 -1479 -2309 -87" +
                    "59 -148 -563 -270 -1028 -270 -1033 0 -4 614 -8 1365 -8 l1364 0 10 38 c16 63 611 " +
                    "2316 946 3587 175 660 319 1202 320 1204 2 2 50 -39 107 -91 543 -495 1169 -862 18" +
                    "63 -1093 1707 -568 3581 -211 4965 946 252 210 554 524 767 796 111 143 312 445 40" +
                    "8 613 229 406 408 854 525 1320 57 225 380 1451 2310 8759 148 563 270 1028 270 10" +
                    "33 0 4 -614 8 -1365 8 l-1364 0 -10 -37z m-4498 -5957 c477 -77 889 -256 1245 -542" +
                    " 523 -419 850 -998 954 -1689 18 -121 18 -549 0 -670 -80 -529 -279 -972 -612 -135" +
                    "9 -412 -480 -967 -779 -1625 -878 -121 -18 -549 -18 -670 0 -494 74 -918 255 -1283" +
                    " 548 -523 419 -850 998 -954 1689 -18 121 -18 549 0 670 104 691 431 1270 954 1689" +
                    " 365 293 828 490 1283 545 50 6 104 13 120 15 72 10 495 -3 588 -18z\"/></g></svg>" +
                    "<a href=\"prettydiff.com.xhtml\">Pretty Diff</a></h1><p id=\"dcolorScheme\"><lab" +
                    "el class=\"label\" for=\"colorScheme\">Color Scheme</label><select id=\"colorSch" +
                    "eme\"><option>Canvas</option><option>Shadow</option><option selected=\"selected" +
                    "\">White</option></select></p><p>Find <a href=\"https://github.com/prettydiff/pr" +
                    "ettydiff\">Pretty Diff on GitHub</a>.</p></section><section role=\"main\" class=" +
                    "\"report\">",
            scriptEnd  : "//]]>",
            scriptStart: "</section></div><script type=\"application/javascript\">//<![CDATA["
        },
        order : [],
        script: {
            beautify: "(function doc(){\"use strict\";let inca=0,incb=0,ol,li,lilen=0;const div=documen" +
                    "t.getElementsByTagName(\"div\"),len=div.length,body=document.getElementsByTagNam" +
                    "e(\"body\")[0],color=document.getElementById(\"colorScheme\"),change=function do" +
                    "c_colorChange(){const name=color[color.selectedIndex].innerHTML.toLowerCase();bo" +
                    "dy.setAttribute(\"class\",name" + ")},beaufold=function doc_beaufold(event){let a=0,b=\"\";const el=event.srcElemen" +
                    "t||event.target,title=el.getAttribute(\"title\").split(\"line \"),parent=[el.par" +
                    "entNode,el.parentNode.nextSibling],min=Number(title[1].substr(0,title[1].indexOf" +
                    "(\" \"))),max=Number(title[2]),list=[parent[0].getElementsByTagName(\"li\"),pare" +
                    "nt[1].getElementsByTagName(\"li\")];a=min;if(el.innerHTML.charAt(0)===\"-\"){do{" +
                    "list[0][a].style.display=\"none\";list[1][a].style.display=\"none\";a=a+1}while(" +
                    "a<max);el.innerHTML=\"+\"+el.innerHTML.substr(1)}else{do{list[0][a].style.displa" +
                    "y" + "=\"block\";list[1][a].style.display=\"block\";if(list[0][a].getAttribute(\"class" +
                    "\")===\"fold\"&&list[0][a].innerHTML.charAt(0)===\"+\"){b=list[0][a].getAttribut" +
                    "e(\"title\");b=b.substring(b.indexOf(\"to line \")+1);a=Number(b)-1}a=a+1}while(" +
                    "a<max);el.innerHTML=\"-\"+el.innerHTML.substr(1)}};inca=0;do{if(div[inca].getAtt" +
                    "r" + "ibute(\"class\")===\"beautify\"){ol=div[inca].getElementsByTagName(\"ol\");if(ol" +
                    "[0].getAttribute(\"class\")===\"count\"){li=ol[0].getElementsByTagName(\"li\");l" +
                    "ilen=li.length;incb=0;do{if(li[incb].getAttribute(\"class\")===\"fold\"){li[incb" +
                    "].onclick=beaufold}incb=incb+1}while(incb<lilen)}}inca=inca+1}while(inca<len);co" +
                    "lo" + "r.onchange=change}());",
            diff    : "(function doc(){\"use strict\";let diffList=[];const body=document.getElementsBy" +
                    "TagName(\"body\")[0],color=document.getElementById(\"colorScheme\"),change=funct" +
                    "ion doc_colorChange(){const name=color[color.selectedIndex].innerHTML.toLowerCas" +
                    "e();body.setAttribute(\"class\",name)},colSliderGrab=function doc_colSliderGrab(" +
                    "event){let subOffset=0,withinRange=false,offset=0,status=\"ew\",diffLeft,node=ev" +
                    "ent.srcElement||event.target;const touch=(event!==null&&event.type===\"touchstar" +
                    "t\"),diffRight=(function doc_colSliderGrab_nodeFix(){if(node.nodeName===\"li\"){" +
                    "node=node.parentNode}return node.parentNode}()),diff=diffRight.parentNode,lists=" +
                    "diff.getElementsByTagName(\"ol\"),par1=lists[2].parentNode,par2=lists[2].parentN" +
                    "ode.parentNode,counter=lists[0].clientWidth,data=lists[1].clientWidth,width=par1" +
                    ".clientWidth,total=par2.clientWidth,min=((total-counter-data-2)-width),max=(tota" +
                    "l-width-counter),minAdjust=min+15,maxAdjust=max-20;diffLeft=diffRight.previousSi" +
                    "bling;offset=par1.offsetLeft-par2.offsetLeft;event.preventDefault();subOffset=(p" +
                    "ar1.scrollLeft>document.body.scrollLeft)?par1.scrollLeft:document.body.scrollLef" +
                    "t;offset=offset-subOffset;offset=offset+node.clientWidth;node.style.cursor=\"ew-" +
                    "resize\";diff.style.width=(total/10)+\"em\";diff.style.display=\"inline-block\";" +
                    "if(diffLeft.nodeType!==1){do{diffLeft=diffLeft.previousSibling}while(diffLeft.no" +
                    "deType!==1)}diffLeft.style.display=\"block\";diffRight.style.width=(diffRight.cl" +
                    "ientWidth/10)+\"em\";diffRight.style.position=\"absolute\";if(touch===true){docu" +
                    "ment.ontouchmove=function doc_colSliderGrab_Touchboxmove(f){f.preventDefault();s" +
                    "ubOffset=offset-f.touches[0].clientX;if(subOffset>minAdjust&&subOffset<maxAdjust" +
                    "){withinRange=true}if(withinRange===true&&subOffset>maxAdjust){diffRight.style.w" +
                    "idth=((total-counter-2)/10)+\"em\";status=\"e\"}else if(withinRange===true&&subO" +
                    "ffset<minAdjust){diffRight.style.width=((total-counter-data-2)/10)+\"em\";status" +
                    "=\"w\"}else if(subOffset<max&&subOffset>min){diffRight.style.width=((width+subOf" +
                    "fset)/10)+\"em\";status=\"ew\"}document.ontouchend=function doc_colSliderGrab_To" +
                    "uchboxmove_drop(f){f.preventDefault();node.style.cursor=status+\"-resize\";docum" +
                    "ent.ontouchmove=null;document.ontouchend=null}};document.ontouchstart=null}else{" +
                    "document.onmousemove=function doc_colSliderGrab_Mouseboxmove(f){f.preventDefault" +
                    "();subOffset=offset-f.clientX;if(subOffset>minAdjust&&subOffset<maxAdjust){withi" +
                    "nRange=true}if(withinRange===true&&subOffset>maxAdjust){diffRight.style.width=((" +
                    "total-counter-2)/10)+\"em\";status=\"e\"}else if(withinRange===true&&subOffset<m" +
                    "inAdjust){diffRight.style.width=((total-counter-data-2)/10)+\"em\";status=\"w\"}" +
                    "else if(subOffset<max&&subOffset>min){diffRight.style.width=((width+subOffset)/1" +
                    "0)+\"em\";status=\"ew\"}document.onmouseup=function doc_colSliderGrab_Mouseboxmo" +
                    "ve_drop(f){f.preventDefault();node.style.cursor=status+\"-resize\";document.onmo" +
                    "usemove=null;document.onmouseup=null}};document.onmousedown=null}return false},d" +
                    "ifffold=function doc_difffold(event){let a=0,b=0,max,lists=[];const node=event.s" +
                    "rcElement||event.target,title=node.getAttribute(\"title\").split(\"line \"),min=" +
                    "Number(title[1].substr(0,title[1].indexOf(\" \"))),inner=node.innerHTML,parent=n" +
                    "ode.parentNode.parentNode,par1=parent.parentNode,listnodes=(parent.getAttribute(" +
                    "\"class\")===\"diff\")?parent.getElementsByTagName(\"ol\"):par1.getElementsByTag" +
                    "Name(\"ol\"),listLen=listnodes.length;do{lists.push(listnodes[a].getElementsByTa" +
                    "gName(\"li\"));a=a+1}while(a<listLen);max=(max>=lists[0].length)?lists[0].length" +
                    ":Number(title[2]);if(inner.charAt(0)===\"-\"){node.innerHTML=\"+\"+inner.substr(" +
                    "1);a=min;if(min<max){do{b=0;do{lists[b][a].style.display=\"none\";b=b+1}while(b<l" +
                    "istLen);a=a+1}while(a<max)}}else{node.innerHTML=\"-\"+inner.substr(1);a=min;if(m" +
                    "in<max){do{b=0;do{lists[b][a].style.display=\"block\";b=b+1}while(b<listLen);a=a+" +
                    "1}while(a<max)}}};diffList=document.getElementsByTagName(\"ol\");if(diffList.len" +
                    "gth>0){const cells=diffList[0].getElementsByTagName(\"li\"),len=cells.length;let" +
                    " a=0;do{if(cells[a].getAttribute(\"class\")===\"fold\"){cells[a].onclick=difffol" +
                    "d}a=a+1}while(a<len)}if(diffList.length>3){diffList[2].onmousedown=colSliderGrab" +
                    ";diffList[2].ontouchstart=colSliderGrab}color.onchange=change}());",
            minimal : "(function doc(){\"use strict\";const body=document.getElementsByTagName(\"body\"" +
                    ")[0],color" + "=document.getElementById(\"colorScheme\"),change=function doc_colorChange(){cons" +
                    "t name=color[color.selectedIndex].innerHTML.toLowerCase();body.setAttribute(\"cl" +
                    "ass\",name)};color.onchange=change}());"
        }
    };
    finalFile.order            = [
        finalFile.html.head, // 0
        finalFile
            .css
            .color
            .canvas, // 1
        finalFile
            .css
            .color
            .shadow, // 2
        finalFile
            .css
            .color
            .white, // 3
        finalFile.css.reports, // 4
        finalFile.css.global, // 5
        finalFile.html.body, // 6
        finalFile.html.color, // 7
        finalFile.html.intro, // 8
        "", // 9 - for meta analysis, like stats and accessibility
        "", // 10 - for generated report
        finalFile.html.scriptStart, // 11
        "\n", // 12 Empty line here from options.crlf
        finalFile.script.minimal, // 13
        finalFile.html.scriptEnd, // 14
        "\n", // 15 Empty line here from options.crlf
        finalFile.html.htmlEnd // 16
    ];
    global
        .prettydiff
        .api
        .finalFile = finalFile;
}());<file_sep>/beautify/style.ts
/*global prettydiff*/
(function beautify_style_init():void {
    "use strict";
    const style = function beautify_style(options:any):string {
        const data:data = options.parsed,
            lf:"\r\n"|"\n"         = (options.crlf === true)
                ? "\r\n"
                : "\n",
            len:number      = (prettydiff.end > 0)
                ? prettydiff.end + 1
                : data.token.length,
            build:string[]    = [],
            //a single unit of indentation
            tab:string      = (function beautify_style_tab():string {
                let aa:number = 0,
                    bb:string[] = [];
                do {
                    bb.push(options.indent_char);
                    aa = aa + 1;
                } while (aa < options.indent_size);
                return bb.join("");
            }()),
            pres:number = options.preserve + 1,
            //new lines plus indentation
            nl       = function beautify_style_nl(tabs:number):void {
                const linesout:string[] = [],
                    total:number = (function beautify_style_nl_total():number {
                        if (a === len - 1) {
                            return 1;
                        }
                        if (data.lines[a + 1] - 1 > pres) {
                            return pres;
                        }
                        if (data.lines[a + 1] > 1) {
                            return data.lines[a + 1] - 1;
                        }
                        return 1;
                    }());
                let index = 0;
                if (tabs < 0) {
                    tabs = 0;
                }
                do {
                    linesout.push(lf);
                    index = index + 1;
                } while (index < total);
                if (tabs > 0) {
                    index = 0;
                    do {
                        linesout.push(tab);
                        index = index + 1;
                    } while (index < tabs);
                }
                build.push(linesout.join(""));
            },
            vertical = function beautify_style_vertical():void {
                const start:number = data.begin[a],
                    startChar:string = data.token[start],
                    endChar:string = data.token[a],
                    store:compareStore = [];
                let b:number = a,
                    c:number = 0,
                    item:[number, number],
                    longest:number = 0;
                if (start < 0 || b <= start) {
                    return;
                }
                do {
                    b = b - 1;
                    if (data.begin[b] === start) {
                        if (data.token[b] === ":") {
                            item = [b - 1, 0];
                            do {
                                b = b - 1;
                                if ((((data.token[b] === ";" && startChar === "{") || (data.token[b] === "," && startChar === "(")) && data.begin[b] === start) || (data.token[b] === endChar && data.begin[data.begin[b]] === start)) {
                                    break;
                                }
                                if (data.types[b] !== "comment" && data.types[b] !== "selector" && data.token[b] !== startChar && data.begin[b] === start) {
                                    item[1] = data.token[b].length + item[1];
                                }
                            } while (b > start + 1);
                            if (item[1] > longest) {
                                longest = item[1];
                            }
                            store.push(item);
                        }
                    } else if (data.types[b] === "end") {
                        if (b < data.begin[b]) {
                            break;
                        }
                        b = data.begin[b];
                    }
                } while (b > start);
                b = store.length;
                if (b < 2) {
                    return;
                }
                do {
                    b = b - 1;
                    if (store[b][1] < longest) {
                        c = store[b][1];
                        do {
                            data.token[store[b][0]] = data.token[store[b][0]] + " ";
                            c = c + 1;
                        } while (c < longest);
                    }
                } while (b > 0);
            };
        let indent:number   = options.indent_level,
            a:number        = prettydiff.start,
            when:string[] = ["", ""];
        if (options.vertical === true && options.compressed_css === false) {
            a = len;
            do {
                a = a - 1;
                if (data.token[a] === "}" || data.token[a] === ")") {
                    vertical();
                }
            } while (a > 0);
            a = prettydiff.start;
        }

        //beautification loop
        do {
            if (data.types[a + 1] === "end" || data.types[a + 1] === "template_end" || data.types[a + 1] === "template_else") {
                indent = indent - 1;
            }
            if (data.types[a] === "template" && data.lines[a] > 0) {
                build.push(data.token[a]);
                nl(indent);
            } else if (data.types[a] === "template_else") {
                build.push(data.token[a]);
                indent = indent + 1;
                nl(indent);
            } else if (data.types[a] === "start" || data.types[a] === "template_start") {
                indent = indent + 1;
                build.push(data.token[a]);
                if (data.types[a + 1] !== "end" && data.types[a + 1] !== "template_end" && (options.compressed_css === false || (options.compressed_css === true && data.types[a + 1] === "selector"))) {
                    nl(indent);
                }
            } else if ((data.token[a] === ";" && (options.compressed_css === false || (options.compressed_css === true && data.types[a + 1] === "selector"))) || data.types[a] === "end" || data.types[a] === "template_end" || data.types[a] === "comment") {
                build.push(data.token[a]);
                if (data.types[a + 1] === "value") {
                    if (data.lines[a + 1] === 1) {
                        build.push(" ");
                    } else if (data.lines[a + 1] > 1) {
                        nl(indent);
                    }
                } else if (data.types[a + 1] !== "separator") {
                    if (data.types[a + 1] !== "comment" || (data.types[a + 1] === "comment" && data.lines[a + 1] > 1)) {
                        nl(indent);
                    } else {
                        build.push(" ");
                    }
                }
            } else if (data.token[a] === ":") {
                build.push(data.token[a]);
                if (options.compressed_css === false) {
                    build.push(" ");
                }
            } else if (data.types[a] === "selector") {
                if (options.css_insert_lines === true && data.types[a - 1] === "end" && data.lines[a] < 3) {
                    build.push(lf);
                }
                if (data.token[a].indexOf("when(") > 0) {
                    when = data.token[a].split("when(");
                    build.push(when[0].replace(/\s+$/, ""));
                    nl(indent + 1);
                    build.push(`when (${when[1]}`);
                } else {
                    build.push(data.token[a]);
                }
                if (data.types[a + 1] === "start") {
                    if (options.braces === true) {
                        nl(indent);
                    } else if (options.compressed_css === false) {
                        build.push(" ");
                    }
                }
            } else if (data.token[a] === ",") {
                build.push(data.token[a]);
                if (data.types[a + 1] === "selector" || data.types[a + 1] === "property") {
                    nl(indent);
                } else if (options.compressed_css === false) {
                    build.push(" ");
                }
            } else if (data.stack[a] === "map" && data.token[a + 1] === ")" && a - data.begin[a] > 5) {
                build.push(data.token[a]);
                nl(indent);
            } else if (data.token[a] === "x;") {
                nl(indent);
            } else if ((data.types[a] === "variable" || data.types[a] === "function") && options.css_insert_lines === true && data.types[a - 1] === "end" && data.lines[a] < 3) {
                build.push(lf);
                build.push(data.token[a]);
            } else if (data.token[a] !== ";" || (data.token[a] === ";" && (options.compressed_css === false || (options.compressed_css === true && data.token[a + 1] !== "}")))) {
                build.push(data.token[a]);
            }
            a = a + 1;
        } while (a < len);
        prettydiff.iterator = len - 1;
        return build.join("");
    };
    global.prettydiff.beautify.style = style;
}());
<file_sep>/readme.md
# [PrettyDiff](https://github.com/prettydiff/prettydiff) + [Sparser](https://github.com/unibeautify/sparser)

New generation PrettyDiff/Sparser formatting and beautification support.

### Forked

[<NAME>](https://github.com/prettydiff) is the original author of [PrettyDiff](https://github.com/prettydiff/prettydiff) and [Sparser](https://github.com/unibeautify/sparser). PrettyDiff was abandoned in 2019 and Austin has since created [Shared File Systems](https://github.com/prettydiff/share-file-systems) which is a privacy first point-to-point communication tool, please check it out and also have a read of [wisdom](https://github.com/prettydiff/wisdom) which personally helped me become a better developer. This fork will become the replacement of the original tool with bug and defect fixes.

This fork will be a slow process. It will undergo a large refactor. Some of the existing features shipped with PrettyDiff will be purged and some now legacy languages will have support dropped.

### Prettify and PrettyDiff

[Prettify](https://github.com/panoply/prettify) is a Liquid Language specific hard-forked variation that leverages the [Sparser](https://github.com/unibeautify/sparser) lexing engine. The Sparser and PrettyDiff parse approach has been adapted from the distributed source code of [PrettyDiff](https://github.com/prettydiff/prettydiff) but support for all other languages outside of Liquid and Liquid infused with existing lexers are stripped. It is Liquid Specific and different from this fork and PrettyDiff.

The [Prettify](https://github.com/panoply/prettify) project will be implemented into the [Liquify IDE](https://liquify.dev) extension. I am mentioning it here as it will give those of you who are curious a glimpse of what to expect in terms of architecture in the new generation PrettyDiff. Unlike Prettify, this fork will support multiple languages (not just Liquid).

### Timeline

As of right now, I am working on [Liquify](https://liquify.dev) and only upon completion of this project will I begin to implement the refactors and approaches employed in [Prettify](https://github.com/panoply/prettify). Once a stable variation is available, I will begin tackling the existing issues.

### Why

Because PrettyDiff and Sparser are fucking brilliant projects and I was lucky enough to become familiar with the code bases. These projects despite going widely are feature full and not formatter today is able to provide the unique rule sets and options that PrettyDiff has supported for the better part of a decade.
<file_sep>/beautify/markup.ts
/*global prettydiff*/
(function beautify_markup_init():void {
    "use strict";
    const markup = function beautify_markup(options:any):string {
        const data:data = options.parsed,
            lexer:string = "markup",
            c:number            = (prettydiff.end < 1 || prettydiff.end > data.token.length)
                ? data.token.length
                : prettydiff.end + 1,
            lf:"\r\n"|"\n"      = (options.crlf === true)
                ? "\r\n"
                : "\n",
            externalIndex:externalIndex = {},
            levels:number[] = (function beautify_markup_levels():number[] {
                const level:number[]      = (prettydiff.start > 0)
                        ? Array(prettydiff.start).fill(0, 0, prettydiff.start)
                        : [],
                    nextIndex = function beautify_markup_levels_next():number {
                        let x:number = a + 1,
                            y:number = 0;
                        if (data.types[x] === undefined) {
                            return x - 1;
                        }
                        if (data.types[x] === "comment" || (a < c - 1 && data.types[x].indexOf("attribute") > -1)) {
                            do {
                                if (data.types[x] === "jsx_attribute_start") {
                                    y = x;
                                    do {
                                        if (data.types[x] === "jsx_attribute_end" && data.begin[x] === y) {
                                            break;
                                        }
                                        x = x + 1;
                                    } while (x < c);
                                } else if (data.types[x] !== "comment" && data.types[x].indexOf("attribute") < 0) {
                                    return x;
                                }
                                x = x + 1;
                            } while (x < c);
                        }
                        return x;
                    },
                    anchorList = function beautify_markup_levels_anchorList():void {
                        let aa:number = a;
                        const stop:number = data.begin[a];
                        // verify list is only a link list before making changes
                        do {
                            aa = aa - 1;
                            if (data.token[aa] === "</li>" && data.begin[data.begin[aa]] === stop && data.token[aa - 1] === "</a>" && data.begin[aa - 1] === data.begin[aa] + 1) {
                                aa = data.begin[aa];
                            } else {
                                return;
                            }
                        } while (aa > stop + 1);

                        // now make the changes
                        aa = a;
                        do {
                            aa = aa - 1;
                            if (data.types[aa + 1] === "attribute") {
                                level[aa] = -10;
                            } else if (data.token[aa] !== "</li>") {
                                level[aa] = -20;
                            }
                        } while (aa > stop + 1);
                    },
                    comment = function beautify_markup_levels_comment():void {
                        let x:number = a,
                            test:boolean = false;
                        if (data.lines[a + 1] === 0 && options.force_indent === false) {
                            do {
                                if (data.lines[x] > 0) {
                                    test = true;
                                    break;
                                }
                                x = x - 1;
                            } while (x > comstart);
                            x = a;
                        } else {
                            test = true;
                        }

                        // the first condition applies indentation while the else block does not
                        if (test === true) {
                            let ind = (data.types[next] === "end" || data.types[next] === "template_end")
                                ? indent + 1
                                : indent;
                            do {
                                level.push(ind);
                                x = x - 1;
                            } while (x > comstart);

                            // correction so that a following end tag is not indented 1 too much
                            if (ind === indent + 1) {
                                level[a] = indent;
                            }

                            // indentation must be applied to the tag preceeding the comment
                            if (data.types[x] === "attribute" || data.types[x] === "template_attribute" || data.types[x] === "jsx_attribute_start") {
                                level[data.begin[x]] = ind;
                            } else {
                                level[x] = ind;
                            }
                        } else {
                            do {
                                level.push(-20);
                                x = x - 1;
                            } while (x > comstart);
                            level[x] = -20;
                        }
                        comstart = -1;
                    },
                    content = function beautify_markup_levels_content():void {
                        let ind:number = indent;
                        if (options.force_indent === true || options.force_attribute === true) {
                            level.push(indent);
                            return;
                        }
                        if (next < c && (data.types[next].indexOf("end") > -1 || data.types[next].indexOf("start") > -1) && data.lines[next] > 0) {
                            level.push(indent);
                            ind = ind + 1;
                            if (data.types[a] === "singleton" && a > 0 && data.types[a - 1].indexOf("attribute") > -1 && data.types[data.begin[a - 1]] === "singleton") {
                                if (data.begin[a] < 0 || (data.types[data.begin[a - 1]] === "singleton" && data.begin[data.ender[a] - 1] !== a)) {
                                    level[a - 1] = indent;
                                } else {
                                    level[a - 1] = indent + 1;
                                }
                            }
                        } else if (data.types[a] === "singleton" && a > 0 && data.types[a - 1].indexOf("attribute") > -1) {
                            level[a - 1] = indent;
                            count = data.token[a].length;
                            level.push(-10);
                        } else if (data.lines[next] === 0) {
                            level.push(-20);
                        } else if (
                            // wrap if
                            // * options.wrap is 0
                            // * next token is singleton with an attribute and exceeds wrap
                            // * next token is template or singleton and exceeds wrap
                            (
                                options.wrap === 0 ||
                                (a < c - 2 && data.token[a].length + data.token[a + 1].length + data.token[a + 2].length + 1 > options.wrap && data.types[a + 2].indexOf("attribute") > -1) ||
                                (data.token[a].length + data.token[a + 1].length > options.wrap)
                            ) &&
                            (data.types[a + 1] === "singleton" || data.types[a + 1] === "template")) {
                            level.push(indent);
                        } else {
                            count = count + 1;
                            level.push(-10);
                        }
                        if (a > 0 && data.types[a - 1].indexOf("attribute") > -1 && data.lines[a] < 1) {
                            level[a - 1] = -20;
                        }
                        if (count > options.wrap) {
                            let d:number = a,
                                e:number = Math.max(data.begin[a], 0);
                            if (data.types[a] === "content" && options.preserve_text === false) {
                                let countx:number = 0,
                                    chars:string[] = data.token[a].replace(/\s+/g, " ").split(" ");
                                do {
                                    d = d - 1;
                                    if (level[d] < 0) {
                                        countx = countx + data.token[d].length;
                                        if (level[d] === -10) {
                                            countx = countx + 1;
                                        }
                                    } else {
                                        break;
                                    }
                                } while (d > 0);
                                d = 0;
                                e = chars.length;
                                do {
                                    if (chars[d].length + countx > options.wrap) {
                                        chars[d] = lf + chars[d];
                                        countx = chars[d].length;
                                    } else {
                                        chars[d] = ` ${chars[d]}`;
                                        countx = countx + chars[d].length;
                                    }
                                    d = d + 1;
                                } while (d < e);
                                if (chars[0].charAt(0) === " ") {
                                    data.token[a] = chars.join("").slice(1);
                                } else {
                                    level[a - 1] = ind;
                                    data.token[a] = chars.join("").replace(lf, "");
                                }
                                if (data.token[a].indexOf(lf) > 0) {
                                    count = data.token[a].length - data.token[a].lastIndexOf(lf);
                                }
                            } else {
                                do {
                                    d = d - 1;
                                    if (level[d] > -1) {
                                        count = data.token[a].length;
                                        if (data.lines[a + 1] > 0) {
                                            count = count + 1;
                                        }
                                        return;
                                    }
                                    if (data.types[d].indexOf("start") > -1) {
                                        count = 0;
                                        return;
                                    }
                                    if ((data.types[d] !== "attribute" || (data.types[d] === "attribute" && data.types[d + 1] !== "attribute")) && data.lines[d + 1] > 0) {
                                        if (data.types[d] !== "singleton" || (data.types[d] === "singleton" && data.types[d + 1] !== "attribute")) {
                                            count = data.token[a].length;
                                            if (data.lines[a + 1] > 0) {
                                                count = count + 1;
                                            }
                                            break;
                                        }
                                    }
                                } while (d > e);
                                level[d] = ind;
                            }
                        }
                    },
                    external = function beautify_markup_levels_external():void {
                        let skip:number = a;
                        do {
                            if (data.lexer[a + 1] === lexer && data.begin[a + 1] < skip && data.types[a + 1] !== "start" && data.types[a + 1] !== "singleton") {
                                break;
                            }
                            level.push(0);
                            a = a + 1;
                        } while (a < c);
                        externalIndex[skip] = a;
                        level.push(indent - 1);
                        next = nextIndex();
                        if (data.lexer[next] === lexer && data.stack[a].indexOf("attribute") < 0 && (data.types[next] === "end" || data.types[next] === "template_end")) {
                            indent = indent - 1;
                        }
                    },
                    attribute = function beautify_markup_levels_attribute():void {
                        const parent:number = a - 1,
                            wrap = function beautify_markup_levels_attribute_wrap(index:number):void {
                                const item:string[] = data.token[index].replace(/\s+/g, " ").split(" "),
                                    ilen:number = item.length;
                                let bb:number = 1,
                                    acount:number = item[0].length;
                                if ((/=("|')?(<|(\{(\{|%|#|@|!|\?|^))|(\[%))/).test(data.token[index]) === true) {
                                    return;
                                }
                                do {
                                    if (acount + item[bb].length > options.wrap) {
                                        acount = item[bb].length;
                                        item[bb] = lf + item[bb];
                                    } else {
                                        item[bb] = ` ${item[bb]}`;
                                        acount = acount + item[bb].length;
                                    }
                                    bb = bb + 1;
                                } while (bb < ilen);
                                data.token[index] = item.join("");
                            };
                        let y:number = a,
                            len:number = data.token[parent].length + 1,
                            plural:boolean = false,
                            lev:number = (function beautify_markup_levels_attribute_level():number {
                                if (data.types[a].indexOf("start") > 0) {
                                    let x:number = a;
                                    do {
                                        if (data.types[x].indexOf("end") > 0 && data.begin[x] === a) {
                                            if (x < c - 1 && data.types[x + 1].indexOf("attribute") > -1) {
                                                plural = true;
                                                break;
                                            }
                                        }
                                        x = x + 1;
                                    } while (x < c);
                                } else if (a < c - 1 && data.types[a + 1].indexOf("attribute") > -1) {
                                    plural = true;
                                }
                                if (data.types[next] === "end" || data.types[next] === "template_end") {
                                    if (data.types[parent] === "singleton") {
                                        return indent + 2;
                                    }
                                    return indent + 1;
                                }
                                if (data.types[parent] === "singleton") {
                                    return indent + 1;
                                }
                                return indent;
                            }()),
                            earlyexit:boolean = false,
                            attStart:boolean = false;
                        
                        if (plural === false && data.types[a] === "comment_attribute") {
                            // lev must be indent unless the "next" type is end then its indent + 1
                            level.push(indent);
                            if (data.types[parent] === "singleton") {
                                level[parent] = indent + 1;
                            } else {
                                level[parent] = indent;
                            }
                            return;
                        }

                        if (lev < 1) {
                            lev = 1;
                        }

                        // first, set levels and determine if there are template attributes
                        do {
                            count = count + data.token[a].length + 1;
                            if (data.types[a].indexOf("attribute") > 0) {
                                if (data.types[a] === "template_attribute") {
                                    level.push(-10);
                                } else if (data.types[a] === "comment_attribute") {
                                    level.push(lev);
                                } else if (data.types[a].indexOf("start") > 0) {
                                    attStart = true;
                                    if (a < c - 2 && data.types[a + 2].indexOf("attribute") > 0) {
                                        level.push(-20);
                                        a = a + 1;
                                        externalIndex[a] = a;
                                    } else {
                                        if (parent === a - 1 && plural === false) {
                                            level.push(lev);
                                        } else {
                                            level.push(lev + 1);
                                        }
                                        if (data.lexer[a + 1] !== lexer) {
                                            a = a + 1;
                                            external();
                                        }
                                    }
                                } else if (data.types[a].indexOf("end") > 0) {
                                    if (level[a - 1] !== -20) {
                                        level[a - 1] = level[data.begin[a]] - 1;
                                    }
                                    if (data.lexer[a + 1] !== lexer) {
                                        level.push(-20);
                                    } else {
                                        level.push(lev);
                                    }
                                } else {
                                    level.push(lev);
                                }
                                earlyexit = true;
                            } else if (data.types[a] === "attribute") {
                                len = len + data.token[a].length + 1;
                                if (options.unformatted === true) {
                                    level.push(-10);
                                } else if (options.force_attribute === true || attStart === true || (a < c - 1 && data.types[a + 1] !== "template_attribute" && data.types[a + 1].indexOf("attribute") > 0)) {
                                    level.push(lev);
                                } else {
                                    level.push(-10);
                                }
                            } else if (data.begin[a] < parent + 1) {
                                break;
                            }
                            a = a + 1;
                        } while (a < c);

                        a = a - 1;
                        if (level[a - 1] > 0 && data.types[a].indexOf("end") > 0 && data.types[a].indexOf("attribute") > 0 && data.types[parent] !== "singleton" && plural === true) {
                            level[a - 1] = level[a - 1] - 1;
                        }
                        if (level[a] !== -20) {
                            if (options.language === "jsx" && data.types[parent].indexOf("start") > -1 && data.types[a + 1] === "script_start") {
                                level[a] = lev;
                            } else {
                                level[a] = level[parent];
                            }
                        }
                        if (options.force_attribute === true) {
                            count = 0;
                            level[parent] = lev;
                        } else {
                            level[parent] = -10;
                        }
                        if (earlyexit === true || options.unformatted === true || data.token[parent] === "<%xml%>" || data.token[parent] === "<?xml?>") {
                            count = 0;
                            return;
                        }
                        y = a;

                        // second, ensure tag contains more than one attribute
                        if (y > parent + 1) {

                            // finally, indent attributes if tag length exceeds the wrap limit
                            if (options.space_close === false) {
                                len = len - 1;
                            }
                            if (len > options.wrap && options.wrap > 0 && options.force_attribute === false) {
                                count = data.token[a].length;
                                do {
                                    if (data.token[y].length > options.wrap && (/\s/).test(data.token[y]) === true) {
                                        wrap(y);
                                    }
                                    y = y - 1;
                                    level[y] = lev;
                                } while (y > parent);
                            }
                        } else if (options.wrap > 0 && data.types[a] === "attribute" && data.token[a].length > options.wrap && (/\s/).test(data.token[a]) === true) {
                            wrap(a);
                        }
                    };
                let a:number     = prettydiff.start,
                    comstart:number = -1,
                    next:number = 0,
                    count:number = 0,
                    indent:number       = (isNaN(options.indent_level) === true)
                        ? 0
                        : Number(options.indent_level);
                // data.lines -> space before token
                // level -> space after token
                do {
                    if (data.lexer[a] === lexer) {
                        if (data.token[a].toLowerCase().indexOf("<!doctype") === 0) {
                            level[a - 1] = indent;
                        }
                        if (data.types[a].indexOf("attribute") > -1) {
                            attribute();
                        } else if (data.types[a] === "comment") {
                            if (comstart < 0) {
                                comstart = a;
                            }
                            if (data.types[a + 1] !== "comment" || (a > 0 && data.types[a - 1].indexOf("end") > -1)) {
                                comment();
                            }
                        } else if (data.types[a] !== "comment") {
                            next = nextIndex();
                            if (data.types[next] === "end" || data.types[next] === "template_end") {
                                indent = indent - 1;
                                if (data.types[next] === "template_end" && data.types[data.begin[next] + 1] === "template_else") {
                                    indent = indent - 1;
                                }
                                if (data.token[a] === "</ol>" || data.token[a] === "</ul>") {
                                    anchorList();
                                }
                            }
                            if (data.types[a] === "script_end" && data.types[a + 1] === "end") {
                                if (data.lines[a + 1] < 1) {
                                    level.push(-20);
                                } else {
                                    level.push(-10);
                                }
                            } else if ((options.force_indent === false || (options.force_indent === true && data.types[next] === "script_start")) && (data.types[a] === "content" || data.types[a] === "singleton" || data.types[a] === "template")) {
                                count = count + data.token[a].length;
                                if (data.lines[next] > 0 && data.types[next] === "script_start") {
                                    level.push(-10);
                                } else if (options.wrap > 0 && (data.types[a].indexOf("template") < 0 || (next < c && data.types[a].indexOf("template") > -1 && data.types[next].indexOf("template") < 0))) {
                                    content();
                                } else if (next < c && (data.types[next].indexOf("end") > -1 || data.types[next].indexOf("start") > -1) && (data.lines[next] > 0 || data.types[next].indexOf("template_") > -1)) {
                                    level.push(indent);
                                } else if (data.lines[next] === 0) {
                                    level.push(-20);
                                } else {
                                    level.push(indent);
                                }
                            } else if (data.types[a] === "start" || data.types[a] === "template_start") {
                                indent = indent + 1;
                                if (data.types[a] === "template_start" && data.types[a + 1] === "template_else") {
                                    indent = indent + 1;
                                }
                                if (options.language === "jsx" && data.token[a + 1] === "{") {
                                    if (data.lines[a + 1] === 0) {
                                        level.push(-20);
                                    } else {
                                        level.push(-10);
                                    }
                                } else if (data.types[a] === "start" && data.types[next] === "end") {
                                    level.push(-20);
                                } else if (data.types[a] === "start" && data.types[next] === "script_start") {
                                    level.push(-10);
                                } else if (options.force_indent === true) {
                                    level.push(indent);
                                } else if (data.types[a] === "template_start" && data.types[next] === "template_end") {
                                    level.push(-20);
                                } else if (data.lines[next] === 0 && (data.types[next] === "content" || data.types[next] === "singleton" || (data.types[a] === "start" && data.types[next] === "template"))) {
                                    level.push(-20);
                                } else {
                                    level.push(indent);
                                }
                            } else if (options.force_indent === false && data.lines[next] === 0 && (data.types[next] === "content" || data.types[next] === "singleton")) {
                                level.push(-20);
                            } else if (data.types[a + 2] === "script_end") {
                                level.push(-20);
                            } else if (data.types[a] === "template_else") {
                                if (data.types[next] === "template_end") {
                                    level[a - 1] = indent + 1;
                                } else {
                                    level[a - 1] = indent - 1;
                                }
                                level.push(indent);
                            } else {
                                level.push(indent);
                            }
                        }
                        if (data.types[a] !== "content" && data.types[a] !== "singleton" && data.types[a] !== "template" && data.types[a] !== "attribute") {
                            count = 0;
                        }
                    } else {
                        count = 0;
                        external();
                    }
                    a = a + 1;
                } while (a < c);
                return level;
            }());
        return (function beautify_markup_apply():string {
            const build:string[]        = [],
                ind:string          = (function beautify_markup_apply_tab():string {
                    const indy:string[] = [options.indent_char],
                        size:number = options.indent_size - 1;
                    let aa:number   = 0;
                    if (aa < size) {
                        do {
                            indy.push(options.indent_char);
                            aa = aa + 1;
                        } while (aa < size);
                    }
                    return indy.join("");
                }()),
                // a new line character plus the correct amount of identation for the given line
                // of code
                nl           = function beautify_markup_apply_nl(tabs:number):string {
                    const linesout:string[] = [],
                        pres:number = options.preserve + 1,
                        total:number = Math.min(data.lines[a + 1] - 1, pres);
                    let index = 0;
                    if (tabs < 0) {
                        tabs = 0;
                    }
                    do {
                        linesout.push(lf);
                        index = index + 1;
                    } while (index < total);
                    if (tabs > 0) {
                        index = 0;
                        do {
                            linesout.push(ind);
                            index = index + 1;
                        } while (index < tabs);
                    }
                    return linesout.join("");
                },
                multiline = function beautify_markup_apply_multiline():void {
                    const lines:string[] = data.token[a].split(lf),
                        line:number = data.lines[a + 1],
                        lev:number = (levels[a - 1] > -1)
                            ? (data.types[a] === "attribute")
                                ? levels[a - 1] + 1
                                : levels[a - 1]
                            : (function beautify_markup_apply_multiline_lev():number {
                                let bb:number = a - 1,
                                    start:boolean = (bb > -1 && data.types[bb].indexOf("start") > -1);
                                if (levels[a] > -1 && data.types[a] === "attribute") {
                                    return levels[a] + 1;
                                }
                                do {
                                    bb = bb - 1;
                                    if (levels[bb] > -1) {
                                        if (data.types[a] === "content" && start === false) {
                                            return levels[bb];
                                        }
                                        return levels[bb] + 1;
                                    }
                                    if (data.types[bb].indexOf("start") > -1) {
                                        start = true;
                                    }
                                } while (bb > 0);
                                return 1;
                            }());
                    let aa:number = 0,
                        len:number = lines.length - 1;
                    data.lines[a + 1] = 0;
                    do {
                        build.push(lines[aa]);
                        build.push(nl(lev));
                        aa = aa + 1;
                    } while (aa < len);
                    data.lines[a + 1] = line;
                    build.push(lines[len]);
                    if (levels[a] === -10) {
                        build.push(" ");
                    } else if (levels[a] > -1) {
                        build.push(nl(levels[a]));
                    }
                },
                attributeEnd = function beautify_markup_apply_attributeEnd():void {
                    const parent:string = data.token[a],
                        regend:RegExp = (/(\/|\?)?>$/),
                        end:string[]|null = regend.exec(parent);
                    let y:number = a + 1,
                        space:string = (options.space_close === true && end !== null && end[0] === "/>")
                            ? " "
                            : "",
                        jsx:boolean = false;
                    if (end === null) {
                        return;
                    }
                    data.token[a] = parent.replace(regend, "");
                    do {
                        if (data.types[y] === "jsx_attribute_end" && data.begin[data.begin[y]] === a) {
                            jsx = false;
                        } else if (data.begin[y] === a) {
                            if (data.types[y] === "jsx_attribute_start") {
                                jsx = true;
                            } else if (data.types[y].indexOf("attribute") < 0 && jsx === false) {
                                break;
                            }
                        } else if (jsx === false && (data.begin[y] < a || data.types[y].indexOf("attribute") < 0)) {
                            break;
                        }
                        y = y + 1;
                    } while (y < c);
                    if (data.types[y - 1] === "comment_attribute") {
                        space = nl(levels[y - 2] - 1);
                    }
                    data.token[y - 1] = data.token[y - 1] + space + end[0];
                };
            let a:number            = prettydiff.start,
                external:string = "",
                lastLevel:number = options.indent_level;
            do {
                if (data.lexer[a] === lexer || prettydiff.beautify[data.lexer[a]] === undefined) {
                    if ((data.types[a] === "start" || data.types[a] === "singleton" || data.types[a] === "xml" || data.types[a] === "sgml") && data.types[a].indexOf("attribute") < 0 && a < c - 1 && data.types[a + 1] !== undefined && data.types[a + 1].indexOf("attribute") > -1) {
                        attributeEnd();
                    }
                    if (data.token[a] !== undefined && data.token[a].indexOf(lf) > 0 && ((data.types[a] === "content" && options.preserve_text === false) || data.types[a] === "comment" || data.types[a] === "attribute")) {
                        multiline();
                    } else {
                        build.push(data.token[a]);
                        if (levels[a] === -10 && a < c - 1) {
                            build.push(" ");
                        } else if (levels[a] > -1) {
                            lastLevel = levels[a];
                            build.push(nl(levels[a]));
                        }
                    }
                } else {
                    if (externalIndex[a] === a && data.types[a] !== "reference") {
                        build.push(data.token[a]);
                    } else {
                        prettydiff.end = externalIndex[a];
                        options.indent_level = lastLevel;
                        prettydiff.start = a;
                        external = prettydiff.beautify[data.lexer[a]](options).replace(/\s+$/, "");
                        build.push(external);
                        if (levels[prettydiff.iterator] > -1 && externalIndex[a] > a) {
                            build.push(nl(levels[prettydiff.iterator]));
                        }
                        a = prettydiff.iterator;
                    }
                }
                a = a + 1;
            } while (a < c);
            prettydiff.iterator = c - 1;
            if (build[0] === lf || build[0] === " ") {
                build[0] = "";
            }
            return build.join("");
        }());
    };
    global.prettydiff.beautify.markup = markup;
}());