@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_unicorn_no_keyword_prefix.go

@@ -20,17 +20,17 @@ type unicornNoKeywordPrefix struct{}
 
 func (unicornNoKeywordPrefix) Name() string { return "unicorn/no-keyword-prefix" }
 func (unicornNoKeywordPrefix) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIdentifier}
+  return []shimast.Kind{shimast.KindIdentifier}
 }
 func (unicornNoKeywordPrefix) Check(ctx *Context, node *shimast.Node) {
-	name := identifierText(node)
-	if !hasKeywordPrefix(name) {
-		return
-	}
-	if !isUnicornDeclarationPositionIdentifier(node) {
-		return
-	}
-	ctx.Report(node, "Don't prefix identifiers with a reserved word (`new` / `class`).")
+  name := identifierText(node)
+  if !hasKeywordPrefix(name) {
+    return
+  }
+  if !isUnicornDeclarationPositionIdentifier(node) {
+    return
+  }
+  ctx.Report(node, "Don't prefix identifiers with a reserved word (`new` / `class`).")
 }
 
 // hasKeywordPrefix reports whether `name` starts with `new` or `class`
@@ -40,19 +40,19 @@ func (unicornNoKeywordPrefix) Check(ctx *Context, node *shimast.Node) {
 // share the prefix bytes but not the camelCase break and are out of
 // scope.
 func hasKeywordPrefix(name string) bool {
-	for _, prefix := range []string{"new", "class"} {
-		if len(name) <= len(prefix) {
-			continue
-		}
-		if name[:len(prefix)] != prefix {
-			continue
-		}
-		next := name[len(prefix)]
-		if next >= 'A' && next <= 'Z' {
-			return true
-		}
-	}
-	return false
+  for _, prefix := range []string{"new", "class"} {
+    if len(name) <= len(prefix) {
+      continue
+    }
+    if name[:len(prefix)] != prefix {
+      continue
+    }
+    next := name[len(prefix)]
+    if next >= 'A' && next <= 'Z' {
+      return true
+    }
+  }
+  return false
 }
 
 // isUnicornDeclarationPositionIdentifier reports whether `node` (a bare
@@ -61,41 +61,41 @@ func hasKeywordPrefix(name string) bool {
 // property keys on accesses, type references, and labels are filtered
 // out so the rule only fires on declarations.
 func isUnicornDeclarationPositionIdentifier(node *shimast.Node) bool {
-	if node == nil || node.Kind != shimast.KindIdentifier || node.Parent == nil {
-		return false
-	}
-	parent := node.Parent
-	switch parent.Kind {
-	case shimast.KindVariableDeclaration:
-		decl := parent.AsVariableDeclaration()
-		return decl != nil && decl.Name() == node
-	case shimast.KindBindingElement:
-		elem := parent.AsBindingElement()
-		return elem != nil && elem.Name() == node
-	case shimast.KindParameter:
-		param := parent.AsParameterDeclaration()
-		return param != nil && param.Name() == node
-	case shimast.KindFunctionDeclaration:
-		fn := parent.AsFunctionDeclaration()
-		return fn != nil && fn.Name() == node
-	case shimast.KindFunctionExpression:
-		fn := parent.AsFunctionExpression()
-		return fn != nil && fn.Name() == node
-	case shimast.KindClassDeclaration:
-		cls := parent.AsClassDeclaration()
-		return cls != nil && cls.Name() == node
-	case shimast.KindClassExpression:
-		cls := parent.AsClassExpression()
-		return cls != nil && cls.Name() == node
-	case shimast.KindMethodDeclaration,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-		shimast.KindPropertyDeclaration:
-		return true
-	}
-	return false
+  if node == nil || node.Kind != shimast.KindIdentifier || node.Parent == nil {
+    return false
+  }
+  parent := node.Parent
+  switch parent.Kind {
+  case shimast.KindVariableDeclaration:
+    decl := parent.AsVariableDeclaration()
+    return decl != nil && decl.Name() == node
+  case shimast.KindBindingElement:
+    elem := parent.AsBindingElement()
+    return elem != nil && elem.Name() == node
+  case shimast.KindParameter:
+    param := parent.AsParameterDeclaration()
+    return param != nil && param.Name() == node
+  case shimast.KindFunctionDeclaration:
+    fn := parent.AsFunctionDeclaration()
+    return fn != nil && fn.Name() == node
+  case shimast.KindFunctionExpression:
+    fn := parent.AsFunctionExpression()
+    return fn != nil && fn.Name() == node
+  case shimast.KindClassDeclaration:
+    cls := parent.AsClassDeclaration()
+    return cls != nil && cls.Name() == node
+  case shimast.KindClassExpression:
+    cls := parent.AsClassExpression()
+    return cls != nil && cls.Name() == node
+  case shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+    shimast.KindPropertyDeclaration:
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(unicornNoKeywordPrefix{})
+  Register(unicornNoKeywordPrefix{})
 }

package/linthost/rules_unicorn_no_lonely_if.go

@@ -17,28 +17,28 @@ type unicornNoLonelyIf struct{}
 func (unicornNoLonelyIf) Name() string           { return "unicorn/no-lonely-if" }
 func (unicornNoLonelyIf) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIfStatement} }
 func (unicornNoLonelyIf) Check(ctx *Context, node *shimast.Node) {
-	parent := node.Parent
-	if parent == nil || parent.Kind != shimast.KindBlock {
-		return
-	}
-	block := parent.AsBlock()
-	if block == nil || block.Statements == nil {
-		return
-	}
-	if len(block.Statements.Nodes) != 1 {
-		return
-	}
-	grand := parent.Parent
-	if grand == nil || grand.Kind != shimast.KindIfStatement {
-		return
-	}
-	gif := grand.AsIfStatement()
-	if gif == nil || gif.ElseStatement != parent {
-		return
-	}
-	ctx.Report(node, "Use `else if` instead of an `if` as the only statement inside an `else` block.")
+  parent := node.Parent
+  if parent == nil || parent.Kind != shimast.KindBlock {
+    return
+  }
+  block := parent.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  if len(block.Statements.Nodes) != 1 {
+    return
+  }
+  grand := parent.Parent
+  if grand == nil || grand.Kind != shimast.KindIfStatement {
+    return
+  }
+  gif := grand.AsIfStatement()
+  if gif == nil || gif.ElseStatement != parent {
+    return
+  }
+  ctx.Report(node, "Use `else if` instead of an `if` as the only statement inside an `else` block.")
 }
 
 func init() {
-	Register(unicornNoLonelyIf{})
+  Register(unicornNoLonelyIf{})
 }

package/linthost/rules_unicorn_no_magic_array_flat_depth.go

@@ -21,31 +21,31 @@ type unicornNoMagicArrayFlatDepth struct{}
 
 func (unicornNoMagicArrayFlatDepth) Name() string { return "unicorn/no-magic-array-flat-depth" }
 func (unicornNoMagicArrayFlatDepth) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornNoMagicArrayFlatDepth) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil || identifierText(access.Name()) != "flat" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil || arg.Kind != shimast.KindNumericLiteral {
-		return
-	}
-	if numericLiteralText(arg) == "1" {
-		return
-	}
-	ctx.Report(node, "Don't use a magic-number depth in `Array#flat()` — use `Infinity` or a named constant.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "flat" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindNumericLiteral {
+    return
+  }
+  if numericLiteralText(arg) == "1" {
+    return
+  }
+  ctx.Report(node, "Don't use a magic-number depth in `Array#flat()` — use `Infinity` or a named constant.")
 }
 
 func init() {
-	Register(unicornNoMagicArrayFlatDepth{})
+  Register(unicornNoMagicArrayFlatDepth{})
 }

package/linthost/rules_unicorn_no_named_default.go

@@ -21,34 +21,34 @@ type unicornNoNamedDefault struct{}
 
 func (unicornNoNamedDefault) Name() string { return "unicorn/no-named-default" }
 func (unicornNoNamedDefault) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindImportDeclaration}
+  return []shimast.Kind{shimast.KindImportDeclaration}
 }
 func (unicornNoNamedDefault) Check(ctx *Context, node *shimast.Node) {
-	decl := node.AsImportDeclaration()
-	if decl == nil || decl.ImportClause == nil {
-		return
-	}
-	clause := decl.ImportClause.AsImportClause()
-	if clause == nil || clause.NamedBindings == nil ||
-		clause.NamedBindings.Kind != shimast.KindNamedImports {
-		return
-	}
-	named := clause.NamedBindings.AsNamedImports()
-	if named == nil || named.Elements == nil {
-		return
-	}
-	for _, spec := range named.Elements.Nodes {
-		s := spec.AsImportSpecifier()
-		if s == nil || s.PropertyName == nil {
-			continue
-		}
-		if moduleExportNameText(s.PropertyName) != "default" {
-			continue
-		}
-		ctx.Report(spec, "Don't import a default export under a named alias — use `import X from \"...\"` instead.")
-	}
+  decl := node.AsImportDeclaration()
+  if decl == nil || decl.ImportClause == nil {
+    return
+  }
+  clause := decl.ImportClause.AsImportClause()
+  if clause == nil || clause.NamedBindings == nil ||
+    clause.NamedBindings.Kind != shimast.KindNamedImports {
+    return
+  }
+  named := clause.NamedBindings.AsNamedImports()
+  if named == nil || named.Elements == nil {
+    return
+  }
+  for _, spec := range named.Elements.Nodes {
+    s := spec.AsImportSpecifier()
+    if s == nil || s.PropertyName == nil {
+      continue
+    }
+    if moduleExportNameText(s.PropertyName) != "default" {
+      continue
+    }
+    ctx.Report(spec, "Don't import a default export under a named alias — use `import X from \"...\"` instead.")
+  }
 }
 
 func init() {
-	Register(unicornNoNamedDefault{})
+  Register(unicornNoNamedDefault{})
 }

package/linthost/rules_unicorn_no_negated_condition.go

@@ -17,69 +17,69 @@ type unicornNoNegatedCondition struct{}
 
 func (unicornNoNegatedCondition) Name() string { return "unicorn/no-negated-condition" }
 func (unicornNoNegatedCondition) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIfStatement, shimast.KindConditionalExpression}
+  return []shimast.Kind{shimast.KindIfStatement, shimast.KindConditionalExpression}
 }
 func (unicornNoNegatedCondition) Check(ctx *Context, node *shimast.Node) {
-	var condition *shimast.Node
-	switch node.Kind {
-	case shimast.KindIfStatement:
-		stmt := node.AsIfStatement()
-		if stmt == nil || stmt.ElseStatement == nil {
-			return
-		}
-		// An `else if` chain (else is itself an IfStatement) reads
-		// fine after inversion only when the else has its own else;
-		// otherwise inverting reshapes the chain. Keep the rule
-		// conservative and only fire when else is a Block.
-		if stmt.ElseStatement.Kind == shimast.KindIfStatement {
-			return
-		}
-		condition = stmt.Expression
-	case shimast.KindConditionalExpression:
-		cond := node.AsConditionalExpression()
-		if cond == nil || cond.WhenTrue == nil || cond.WhenFalse == nil {
-			return
-		}
-		condition = cond.Condition
-	}
-	if condition == nil {
-		return
-	}
-	condition = stripParens(condition)
-	if condition == nil {
-		return
-	}
-	if !unicornNoNegatedConditionIsNegated(condition) {
-		return
-	}
-	ctx.Report(node, "Avoid negated conditions in `if` / `else` and ternaries when the positive form is shorter.")
+  var condition *shimast.Node
+  switch node.Kind {
+  case shimast.KindIfStatement:
+    stmt := node.AsIfStatement()
+    if stmt == nil || stmt.ElseStatement == nil {
+      return
+    }
+    // An `else if` chain (else is itself an IfStatement) reads
+    // fine after inversion only when the else has its own else;
+    // otherwise inverting reshapes the chain. Keep the rule
+    // conservative and only fire when else is a Block.
+    if stmt.ElseStatement.Kind == shimast.KindIfStatement {
+      return
+    }
+    condition = stmt.Expression
+  case shimast.KindConditionalExpression:
+    cond := node.AsConditionalExpression()
+    if cond == nil || cond.WhenTrue == nil || cond.WhenFalse == nil {
+      return
+    }
+    condition = cond.Condition
+  }
+  if condition == nil {
+    return
+  }
+  condition = stripParens(condition)
+  if condition == nil {
+    return
+  }
+  if !unicornNoNegatedConditionIsNegated(condition) {
+    return
+  }
+  ctx.Report(node, "Avoid negated conditions in `if` / `else` and ternaries when the positive form is shorter.")
 }
 
 // unicornNoNegatedConditionIsNegated reports whether `node` is a `!`
 // prefix-unary expression or a `!=` / `!==` binary expression — the
 // two shapes the rule treats as "negated".
 func unicornNoNegatedConditionIsNegated(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	switch node.Kind {
-	case shimast.KindPrefixUnaryExpression:
-		prefix := node.AsPrefixUnaryExpression()
-		return prefix != nil && prefix.Operator == shimast.KindExclamationToken
-	case shimast.KindBinaryExpression:
-		bin := node.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return false
-		}
-		switch bin.OperatorToken.Kind {
-		case shimast.KindExclamationEqualsToken,
-			shimast.KindExclamationEqualsEqualsToken:
-			return true
-		}
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindPrefixUnaryExpression:
+    prefix := node.AsPrefixUnaryExpression()
+    return prefix != nil && prefix.Operator == shimast.KindExclamationToken
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindExclamationEqualsToken,
+      shimast.KindExclamationEqualsEqualsToken:
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(unicornNoNegatedCondition{})
+  Register(unicornNoNegatedCondition{})
 }

package/linthost/rules_unicorn_no_negation_in_equality_check.go

@@ -17,34 +17,34 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoNegationInEqualityCheck struct{}
 
 func (unicornNoNegationInEqualityCheck) Name() string {
-	return "unicorn/no-negation-in-equality-check"
+  return "unicorn/no-negation-in-equality-check"
 }
 func (unicornNoNegationInEqualityCheck) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornNoNegationInEqualityCheck) Check(ctx *Context, node *shimast.Node) {
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil || bin.Left == nil {
-		return
-	}
-	switch bin.OperatorToken.Kind {
-	case shimast.KindEqualsEqualsEqualsToken,
-		shimast.KindEqualsEqualsToken,
-		shimast.KindExclamationEqualsEqualsToken,
-		shimast.KindExclamationEqualsToken:
-	default:
-		return
-	}
-	if bin.Left.Kind != shimast.KindPrefixUnaryExpression {
-		return
-	}
-	prefix := bin.Left.AsPrefixUnaryExpression()
-	if prefix == nil || prefix.Operator != shimast.KindExclamationToken {
-		return
-	}
-	ctx.Report(node, "Don't negate the left operand of an equality check — use `!==` directly, or wrap in parens.")
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil {
+    return
+  }
+  switch bin.OperatorToken.Kind {
+  case shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindEqualsEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken:
+  default:
+    return
+  }
+  if bin.Left.Kind != shimast.KindPrefixUnaryExpression {
+    return
+  }
+  prefix := bin.Left.AsPrefixUnaryExpression()
+  if prefix == nil || prefix.Operator != shimast.KindExclamationToken {
+    return
+  }
+  ctx.Report(node, "Don't negate the left operand of an equality check — use `!==` directly, or wrap in parens.")
 }
 
 func init() {
-	Register(unicornNoNegationInEqualityCheck{})
+  Register(unicornNoNegationInEqualityCheck{})
 }

package/linthost/rules_unicorn_no_nested_ternary.go

@@ -17,27 +17,27 @@ type unicornNoNestedTernary struct{}
 
 func (unicornNoNestedTernary) Name() string { return "unicorn/no-nested-ternary" }
 func (unicornNoNestedTernary) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindConditionalExpression}
+  return []shimast.Kind{shimast.KindConditionalExpression}
 }
 func (unicornNoNestedTernary) Check(ctx *Context, node *shimast.Node) {
-	cond := node.AsConditionalExpression()
-	if cond == nil {
-		return
-	}
-	if hasUnicornNestedConditional(cond.WhenTrue) {
-		ctx.Report(stripParens(cond.WhenTrue), "Do not nest ternary expressions.")
-		return
-	}
-	if hasUnicornNestedConditional(cond.WhenFalse) {
-		ctx.Report(stripParens(cond.WhenFalse), "Do not nest ternary expressions.")
-	}
+  cond := node.AsConditionalExpression()
+  if cond == nil {
+    return
+  }
+  if hasUnicornNestedConditional(cond.WhenTrue) {
+    ctx.Report(stripParens(cond.WhenTrue), "Do not nest ternary expressions.")
+    return
+  }
+  if hasUnicornNestedConditional(cond.WhenFalse) {
+    ctx.Report(stripParens(cond.WhenFalse), "Do not nest ternary expressions.")
+  }
 }
 
 func hasUnicornNestedConditional(node *shimast.Node) bool {
-	expr := stripParens(node)
-	return expr != nil && expr.Kind == shimast.KindConditionalExpression
+  expr := stripParens(node)
+  return expr != nil && expr.Kind == shimast.KindConditionalExpression
 }
 
 func init() {
-	Register(unicornNoNestedTernary{})
+  Register(unicornNoNestedTernary{})
 }

package/linthost/rules_unicorn_no_new_array.go

@@ -19,12 +19,12 @@ type unicornNoNewArray struct{}
 func (unicornNoNewArray) Name() string           { return "unicorn/no-new-array" }
 func (unicornNoNewArray) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNewExpression} }
 func (unicornNoNewArray) Check(ctx *Context, node *shimast.Node) {
-	ne := node.AsNewExpression()
-	if ne != nil && identifierText(ne.Expression) == "Array" {
-		ctx.Report(node, "Don't use `new Array(...)` — use an array literal or `Array.from`/`Array.of` instead.")
-	}
+  ne := node.AsNewExpression()
+  if ne != nil && identifierText(ne.Expression) == "Array" {
+    ctx.Report(node, "Don't use `new Array(...)` — use an array literal or `Array.from`/`Array.of` instead.")
+  }
 }
 
 func init() {
-	Register(unicornNoNewArray{})
+  Register(unicornNoNewArray{})
 }

package/linthost/rules_unicorn_no_new_buffer.go

@@ -20,12 +20,12 @@ type unicornNoNewBuffer struct{}
 func (unicornNoNewBuffer) Name() string           { return "unicorn/no-new-buffer" }
 func (unicornNoNewBuffer) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNewExpression} }
 func (unicornNoNewBuffer) Check(ctx *Context, node *shimast.Node) {
-	ne := node.AsNewExpression()
-	if ne != nil && identifierText(ne.Expression) == "Buffer" {
-		ctx.Report(node, "`new Buffer()` is deprecated, use `Buffer.from()` or `Buffer.alloc()` instead.")
-	}
+  ne := node.AsNewExpression()
+  if ne != nil && identifierText(ne.Expression) == "Buffer" {
+    ctx.Report(node, "`new Buffer()` is deprecated, use `Buffer.from()` or `Buffer.alloc()` instead.")
+  }
 }
 
 func init() {
-	Register(unicornNoNewBuffer{})
+  Register(unicornNoNewBuffer{})
 }

package/linthost/rules_unicorn_no_null.go

@@ -16,9 +16,9 @@ type unicornNoNull struct{}
 func (unicornNoNull) Name() string           { return "unicorn/no-null" }
 func (unicornNoNull) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNullKeyword} }
 func (unicornNoNull) Check(ctx *Context, node *shimast.Node) {
-	ctx.Report(node, "Use `undefined` instead of `null`.")
+  ctx.Report(node, "Use `undefined` instead of `null`.")
 }
 
 func init() {
-	Register(unicornNoNull{})
+  Register(unicornNoNull{})
 }

package/linthost/rules_unicorn_no_object_as_default_parameter.go

@@ -19,30 +19,30 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornNoObjectAsDefaultParameter struct{}
 
 func (unicornNoObjectAsDefaultParameter) Name() string {
-	return "unicorn/no-object-as-default-parameter"
+  return "unicorn/no-object-as-default-parameter"
 }
 func (unicornNoObjectAsDefaultParameter) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindParameter}
+  return []shimast.Kind{shimast.KindParameter}
 }
 func (unicornNoObjectAsDefaultParameter) Check(ctx *Context, node *shimast.Node) {
-	param := node.AsParameterDeclaration()
-	if param == nil || param.Initializer == nil || param.Name() == nil {
-		return
-	}
-	if param.Name().Kind != shimast.KindIdentifier {
-		return
-	}
-	init := stripParens(param.Initializer)
-	if init == nil || init.Kind != shimast.KindObjectLiteralExpression {
-		return
-	}
-	obj := init.AsObjectLiteralExpression()
-	if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) == 0 {
-		return
-	}
-	ctx.Report(node, "Don't use an object literal as a default parameter — destructure the option instead.")
+  param := node.AsParameterDeclaration()
+  if param == nil || param.Initializer == nil || param.Name() == nil {
+    return
+  }
+  if param.Name().Kind != shimast.KindIdentifier {
+    return
+  }
+  init := stripParens(param.Initializer)
+  if init == nil || init.Kind != shimast.KindObjectLiteralExpression {
+    return
+  }
+  obj := init.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) == 0 {
+    return
+  }
+  ctx.Report(node, "Don't use an object literal as a default parameter — destructure the option instead.")
 }
 
 func init() {
-	Register(unicornNoObjectAsDefaultParameter{})
+  Register(unicornNoObjectAsDefaultParameter{})
 }