---
source: crates/biome_formatter_test/src/snapshot_builder.rs
info: ts/expression/bracket-spacing/expression_bracket_spacing.ts
---

# Input

```ts
import * as assert from "assert";

type W = { a: string; b: symbol; c: symbol;d: symbol;e: symbol;f: symbol;g: symbol; };
type X = { a: string; b: symbol; }
type Z = {
    a: string
    b: symbol
}
type A = {
    a: string
}

type OptionsFlags
    <Type> =
    {
  +
        readonly [Property
        in
        keyof
            Type
        as              string]
        -?: boolean;
};


type TupleA
    = [     string      ]

type TupleB = [   ...string[  ]     ]

type TupleC = [ surname  ?:
    string[],
    ...name: string[],  ]

type TupleD = [
    address: string,
    address2: string,
    address3: string,
    address4: string,
    address5: string,
    surname  ?:
    string[],
    ...name: string[],  ]

type PA = (
    string
    )


type FunctionType = <Aaaaaaaaaaaaaaaaaaaaa,bvvvvvvvvvvvvvvvvvvvvvv,ceeeeeee,deeeeeeeeeeeeee,deeeeeeeeeeeeeee,deeeeeeeeeeeeeeee,deeeeeeeewweeeeee,>(Lorem: string, ipsum: symbol,  dolor: number, sit: boolean, amet: string, consectetur: symbol) => {
    Lorem: string, ipsum: symbol, dolor: number, sit: boolean, amet: string, consectetur: symbol
}

type ShortFunctionType = <A,B,C,D,E,>(Lorem: string, ipsum: symbol,  dolor: number, sit: boolean, amet: string, consectetur: symbol) => {
    a: string;
}

function test(a: string):
    a is  string   { return true }


type AbstractCompositeThingamabobberFactoryProvider = string;

type ConstructorType = new ( options: { a: string, b: AbstractCompositeThingamabobberFactoryProvider },
) => {};

type GenericTypeExpression<A extends { a: string }> = Foo<A, {  bar: string }>;
type GenericTypeExpression<A extends { a: string }> = AbstractCompositeThingamabobberFactoryProvider<{  bar: string, foo: symbol; baz: number; zzz: boolean }>;
```


=============================

# Outputs

## Output 1

-----
Indent style: Tab
Indent width: 2
Line ending: LF
Line width: 80
Quote style: Double Quotes
JSX quote style: Double Quotes
Quote properties: As needed
Trailing comma: All
Semicolons: Always
Arrow parentheses: Always
Bracket spacing: true
Bracket same line: false
Attribute Position: Auto
-----

```ts
import * as assert from "assert";

type W = {
	a: string;
	b: symbol;
	c: symbol;
	d: symbol;
	e: symbol;
	f: symbol;
	g: symbol;
};
type X = { a: string; b: symbol };
type Z = {
	a: string;
	b: symbol;
};
type A = {
	a: string;
};

type OptionsFlags<Type> = {
	+readonly [Property in keyof Type as string]-?: boolean;
};

type TupleA = [string];

type TupleB = [...string[]];

type TupleC = [surname?: string[], ...name: string[]];

type TupleD = [
	address: string,
	address2: string,
	address3: string,
	address4: string,
	address5: string,
	surname?: string[],
	...name: string[],
];

type PA = string;

type FunctionType = <
	Aaaaaaaaaaaaaaaaaaaaa,
	bvvvvvvvvvvvvvvvvvvvvvv,
	ceeeeeee,
	deeeeeeeeeeeeee,
	deeeeeeeeeeeeeee,
	deeeeeeeeeeeeeeee,
	deeeeeeeewweeeeee,
>(
	Lorem: string,
	ipsum: symbol,
	dolor: number,
	sit: boolean,
	amet: string,
	consectetur: symbol,
) => {
	Lorem: string;
	ipsum: symbol;
	dolor: number;
	sit: boolean;
	amet: string;
	consectetur: symbol;
};

type ShortFunctionType = <A, B, C, D, E>(
	Lorem: string,
	ipsum: symbol,
	dolor: number,
	sit: boolean,
	amet: string,
	consectetur: symbol,
) => {
	a: string;
};

function test(a: string): a is string {
	return true;
}

type AbstractCompositeThingamabobberFactoryProvider = string;

type ConstructorType = new (options: {
	a: string;
	b: AbstractCompositeThingamabobberFactoryProvider;
}) => {};

type GenericTypeExpression<A extends { a: string }> = Foo<A, { bar: string }>;
type GenericTypeExpression<A extends { a: string }> =
	AbstractCompositeThingamabobberFactoryProvider<{
		bar: string;
		foo: symbol;
		baz: number;
		zzz: boolean;
	}>;
```

## Output 2

-----
Indent style: Tab
Indent width: 2
Line ending: LF
Line width: 80
Quote style: Double Quotes
JSX quote style: Double Quotes
Quote properties: As needed
Trailing comma: All
Semicolons: Always
Arrow parentheses: Always
Bracket spacing: false
Bracket same line: false
Attribute Position: Auto
-----

```ts
import * as assert from "assert";

type W = {
	a: string;
	b: symbol;
	c: symbol;
	d: symbol;
	e: symbol;
	f: symbol;
	g: symbol;
};
type X = {a: string; b: symbol};
type Z = {
	a: string;
	b: symbol;
};
type A = {
	a: string;
};

type OptionsFlags<Type> = {
	+readonly [Property in keyof Type as string]-?: boolean;
};

type TupleA = [string];

type TupleB = [...string[]];

type TupleC = [surname?: string[], ...name: string[]];

type TupleD = [
	address: string,
	address2: string,
	address3: string,
	address4: string,
	address5: string,
	surname?: string[],
	...name: string[],
];

type PA = string;

type FunctionType = <
	Aaaaaaaaaaaaaaaaaaaaa,
	bvvvvvvvvvvvvvvvvvvvvvv,
	ceeeeeee,
	deeeeeeeeeeeeee,
	deeeeeeeeeeeeeee,
	deeeeeeeeeeeeeeee,
	deeeeeeeewweeeeee,
>(
	Lorem: string,
	ipsum: symbol,
	dolor: number,
	sit: boolean,
	amet: string,
	consectetur: symbol,
) => {
	Lorem: string;
	ipsum: symbol;
	dolor: number;
	sit: boolean;
	amet: string;
	consectetur: symbol;
};

type ShortFunctionType = <A, B, C, D, E>(
	Lorem: string,
	ipsum: symbol,
	dolor: number,
	sit: boolean,
	amet: string,
	consectetur: symbol,
) => {
	a: string;
};

function test(a: string): a is string {
	return true;
}

type AbstractCompositeThingamabobberFactoryProvider = string;

type ConstructorType = new (options: {
	a: string;
	b: AbstractCompositeThingamabobberFactoryProvider;
}) => {};

type GenericTypeExpression<A extends {a: string}> = Foo<A, {bar: string}>;
type GenericTypeExpression<A extends {a: string}> =
	AbstractCompositeThingamabobberFactoryProvider<{
		bar: string;
		foo: symbol;
		baz: number;
		zzz: boolean;
	}>;
```