test.ts.fix

import ast = AST;
module M {
    export var ast = AST;

    var x: number;

    var y = (x === 10) ? 1 : 2;

    var zz = (y === 4);

    var z = y;

    var a, b;

    switch (x) {
        case 1: break;
        default: break;
    }

    for (x = 1; x < 2; ++x) {
        goto: console.log("hi");
    }

    for (x = 2; x--;) {}
    for (;;) {}

    while (i < 1) {
        ++i;
    }

    var q;
    q.forEach(() => 3);
    q.forEach(() => {
        return 3;
    });

    var r: () => string;
    var s: new () => string;
    var a = <number> "10";
    var a = <number> "10";
}

var a;

export = a;

a.then(() => {
    return 1;
}).if(() => {
    return 1;
});

var name = "something";
var test = `
<sl-property-group label=${name} Axes">
  <div class="repeat"
`;

var withinTemplateExpression = `${name === "something" ? "foo" : "bar"}`;
var withinTemplateExpression = `${name === "something" ? "foo" : "bar"}`;

var objectInsideTemplateExpression = `${({foo: "bar"}).foo}`;
var objectInsideTemplateExpression = `${({foo: "bar"}).foo}`;

import { importA } from "libA";
import { importB } from "libB";
import { importC } from "libC";
import moduleD, { importD } from "libD";
import { importD, importE } from "libD";
import { importF as F } from "libF";
import { importF as F, importG as G } from "libF";

import {
  importA,
  importB
} from "libC";

export default 123;

const D = 123;
export { D as default }; // failure

export function each(obj, iterator, context) {
    //
}

export { each as forEach };
import "libE";

const E = 123;
const F = 123;
export { E, F };

function foobar() {}

function foorbar()
{}

if () {
    //
} else {}

if ()
{}
else
{}

/* some comment */{
    // some code with a preceding comment
}

{
    const foo = 123;
    // code that just wants to be encapsulated in a block scope
}

const foo = { ...bar };

const foo = [ ...bar ];

function foo (bar, ...baz) {}

const { foo, ...bar } = baz;

type A = number | string;

type B = number | string | {result: string};

type C = {result: string} & {type: "A" | "B"};

class a {
    private x = 1;
    y = 1;
    public z = 0;
}