Detecting Edge browser version (using Javascript or C#)

Edge user agent looks something like this:

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36 Edge/15.15063

(Notice Edge/15.15063 at the end)

Now when I look up actual browser version in Edge, I see this info about app:

Microsoft Edge 40.15063.674.0

Microsoft EdgeHTML 15.15063

So you see, user agent actually responds with EdgeHTML version.

My question is, how do I get Edge version? (not EdgeHTML version)

C# is even worse: His Request.Browser static class responds with Browser: "Chrome", Version: "52.0", so this is out of the question.

This code worked for me:

await ms_edge_version();

async function ms_edge_version() {
    let command = 'reg query "HKEY_CURRENT_USER\\Software\\Microsoft\\Edge\\BLBeacon" /v version';
    let r = await command_line_exec(command);
    let stdout = object_property_get(r, "stdout");
    let match = stdout.match(/version\s+REG_SZ\s+(.*)/);
    if (match && match[1]) {
        let v = match[1].trim();
        return v;
    } else {
        error("Edge version not found in registry.");
    }
}
function error(message) {
    throw new Error(message);
}
function object_property_get(object, property_name) {
    let result = object[property_name];
    let v = assert_get_result(result, property_name, object);
    return v;
}
function assert_get_result(result, key, object) {
    assert_message(undefined_not_is, [result], function () {
        let v = {
            key,
            object
        };
        return v;
    });
    return result;
}
function undefined_not_is(previous_token) {
    return !undefined_is(previous_token);
}
function undefined_is(input) {
    return typeof input === "undefined";
}
function assert_message(fn, args, message_get) {
    let v = assert_message_string(fn, args, function () {
        let j = json_to(message_get());
        let limit = 1000;
        let v2 = string_take_soft(j, limit);
        return v2;
    });
    return v;
}
function string_take_soft(j, limit) {
    if (string_size(j) > limit) {
        let v = string_take(j, limit);
        return v;
    }
    return j;
}
function string_take(input, count) {
    let length = string_size(input);
    assert_message(less_than_equal, [count, length], () => ({
        input,
        count,
        length
    }));
    return string_substring(input, 0, count);
}
function string_size(input) {
    return input.length;
}
function less_than_equal(a, b) {
    return a <= b;
}
function string_substring(input, start, end) {
    assert_arguments_length(arguments, 3);
    return input.substring(start, end);
}
function assert_arguments_length(args, expected) {
    assert(equal, [arguments.length, 2]);
    let actual = args.length;
    assert_message(equal, [actual, expected], () => ({
        message: "expecting different argument count",
        expected,
        actual
    }));
}
function equal(a, b) {
    return a === b;
}
function assert(fn, args) {
    returns(fn, true, args);
}
function returns(fn, expected, args) {
    returns_message(fn, expected, args, message_get);
    function message_get() {
        return json_to(args);
    }
}
function returns_message(fn, expected, args, message_get) {
    let actual = fn(...args);
    let e = equal(actual, expected);
    assert_boolean_message(e, message_get);
}
function assert_boolean_message(condition, message_get) {
    if (condition === false) {
        error(message_get());
    }
}
function json_to(object) {
    return JSON.stringify(object);
}
function assert_message_string(fn, args, message_get) {
    returns_message(fn, true, args, message_get);
}
async function command_line_exec(command) {
    return await command_line_exec_generic(command, {});
}
async function command_line_exec_generic(command, options) {
    let c = await import_node("child_process");
    let {exec} = c;
    let v = await new Promise(function (resolve) {
        exec(command, options, function (error, stdout, stderr) {
            let r = {
                error,
                stdout,
                stderr
            };
            resolve(r);
        });
    });
    return v;
}
async function import_node(libary_to_import) {
    let a;
    if (web_not_is()) {
        a = await import(libary_to_import);
    }
    return a;
}
function web_not_is() {
    return typeof window === "undefined";
}