TypeScript (and JavaScript) Plugin

Rules for linting JavaScript and TypeScript code, including the latest and greatest powerful typed linting rules.
This plugin comes packaged with the flint npm package.

Presets

Flint’s TypeScript plugin provides the following presets:

Preset	Recommended	Description
`logical`	✅ Always	Common rules for finding bugs and enforcing good logical practices.
`logicalStrict`	☑️ When Ready	Additional rules for finding bugs and enforcing good logical practices.
`stylistic`	✅ Always	Common rules for consistent styling and best stylistic practices.
`stylisticStrict`	☑️ When Ready	Additional rules for consistent styling and best stylistic practices.
`untyped`		Extra rules for files that aren’t type-checked by TypeScript.

If you are just getting started with linting, Flint recommends using the logical and stylistic presets:

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: [ts.presets.logical, ts.presets.stylistic],
    },
  ],
});

If you are experienced with both JavaScript/TypeScript and linting, Flint recommends using the logicalStrict and stylisticStrict presets:

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: [ts.presets.logicalStrict, ts.presets.stylisticStrict],
    },
  ],
});

`logical`

Rules that find bugs and enforce good logical practices for most-to-all JavaScript and TypeScript files.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.logical,
    },
  ],
});

`logicalStrict`

Additional logical rules that enforce best practices which are not always straightforward to implement. These rules are recommended for projects where a majority of developers are experienced with both JavaScript/TypeScript and using a linter.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.logicalStrict,
    },
  ],
});

This preset’s rules are a superset of those in logical.

`stylistic`

Rules that enforce consistent styling and best stylistic practices for most-to-all JavaScript and TypeScript files.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.stylistic,
    },
  ],
});

`stylisticStrict`

Additional stylistic rules that enforce best practices which are not always straightforward to implement. These rules are recommended for projects where a majority of developers are experienced with both JavaScript/TypeScript and using a linter.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.stylisticStrict,
    },
  ],
});

This preset’s rules are a superset of those in stylistic.

`untyped`

Rules that fill in rudimentary safety practices that would normally be caught by TypeScript.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.untyped,
    },
  ],
});

The untyped preset is broadly applicable for JavaScript files that aren’t type-checked by TypeScript. For long-lived projects, Flint recommends using this only as a stopgap measure pending converting files fully to TypeScript.

Rules

Implemented: 92 of 399 (23%)

Flint Rule	Preset
`anyArguments`Reports calling a function with a value typed as `any` as an argument.	logical
`anyAssignments`Reports assigning a value with type `any` to variables and properties.	logical
`anyCalls`Reports calling a value with type `any`.	logical
`anyMemberAccess`Reports member access on a value with type `any`.	logical
`anyReturns`Reports returning a value with type `any` from a function.	logical
`arguments`Reports using the arguments object instead of rest parameters.	logical
`arrayConstructors`Reports using the `Array` constructor to create arrays instead of array literal syntax.	logical
`arrayElementDeletions`	logical
`arrayEmptyCallbackSlots`	logical
`arrayMapIdentities`Reports using `.flatMap()` with an identity function that returns its argument unchanged.	logical
`arrayUnnecessaryLengthChecks`Reports unnecessary array length checks before `.some()` or `.every()` calls.	logical
`asyncFunctionAwaits`	logical
`asyncPromiseExecutors`Reports using async functions as Promise executor functions.	logical
`asyncUnnecessaryPromiseWrappers`Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.	logical
`awaitThenable`	logical
`caseDuplicates`Reports switch statements with duplicate case clause test expressions.	logical
`caseFallthroughs`	logical
`catchCallbackTypes`	logical
`charAtComparisons`	logical
`constVariables`	logical
`dateConstructorClones`Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.	logical
`debuggerStatements`Reports using debugger statements.	logical
`defaultCaseLast`Reports switch statements where the default clause is not last.	logical
`deprecated`Disallow using code marked as @deprecated.	logical
`dynamicDeletes`Disallow using the delete operator on computed key expressions.	logical
`elseIfDuplicates`Reports duplicate conditions in if-else-if chains that make code unreachable.	logical
`emptyDestructures`Reports using empty destructuring patterns that destructure no values.	logical
`emptyEnums`	logical
`emptyExports`	logical
`emptyObjectTypes`	logical
`enumMemberLiterals`	logical
`enumMixedValues`	logical
`enumValueConsistency`	logical
`enumValueDuplicates`	logical
`equalityOperators`	logical
`errorUnnecessaryCaptureStackTraces`	logical
`evals`	logical
`exceptionAssignments`Reports reassigning exception parameters in catch clauses.	logical
`explicitAnys`	logical
`exportMutables`	logical
`fetchMethodBodies`Disallow providing a body with GET or HEAD fetch requests.	logical
`finallyStatementSafety`Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.	logical
`floatingPromises`	logical
`forInArrays`Reports iterating over an array with a for-in loop.	logical
`functionCurryingRedundancy`Reports using `.apply()` or `.call()` or when the context (`this` value) provides no benefit.	logical
`functionNewCalls`Reports using the Function constructor to create functions from strings.	logical
`generatorFunctionYields`Reports generator functions that do not yield values.	logical
`getterSetterPairedTypes`	logical
`impliedEvals`	logical
`importEmptyBlocks`	logical
`instanceOfArrays`	logical
`irregularWhitespaces`	logical
`isNaNComparisons`	logical
`meaninglessVoidOperators`	logical
`misleadingVoidExpressions`	logical
`misusedPromises`	logical
`moduleSpecifierLists`	logical
`namespaceDeclarations`Reports using legacy `namespace` declarations.	logical
`negativeZeroComparisons`Reports comparisons with -0 that may not behave as expected.	logical
`newDefinitions`	logical
`newExpressions`Reports standalone new expressions that don't use the constructed object.	logical
`nonNullAssertedOptionalChains`	logical
`nonOctalDecimalEscapes`Reports non-octal decimal escape sequences (\8 and \9) in string literals.	logical
`numberMethodRanges`	logical
`numericErasingOperations`	logical
`numericPrecision`	logical
`objectCalls`Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.	logical
`objectPrototypeBuiltIns`Reports direct calls to Object.prototype methods on object instances.	logical
`objectSpreadUnnecessaryFallbacks`	logical
`parameterPropertyAssignment`	logical
`parseIntRadixes`	logical
`plusOperands`	logical
`promiseExecutorReturns`	logical
`promiseFinallyReturns`	logical
`promiseMethodSingleArrayArguments`	logical
`promiseRejectErrors`	logical
`recursionOnlyArguments`	logical
`redundantTypeConstituents`	logical
`regexAllGlobalFlags`	logical
`regexAmbiguousInvalidity`	logical
`regexContradictoryAssertions`	logical
`regexControlCharacterEscapes`	logical
`regexControlCharacters`	logical
`regexDuplicateCharacterClassCharacters`	logical
`regexDuplicateDisjunctions`	logical
`regexEmptyAlternatives`	logical
`regexEmptyCapturingGroups`	logical
`regexEmptyCharacterClasses`	logical
`regexEmptyGroups`	logical
`regexEmptyLazyQuantifiers`	logical
`regexEmptyLookaroundsAssertions`	logical
`regexEmptyStringLiterals`	logical
`regexEscapeBackspaces`	logical
`regexIgnoreCaseFlags`	logical
`regexInvisibleCharacters`	logical
`regexLegacyFeatures`	logical
`regexLiterals`	logical
`regexLookaroundQuantifierOptimizations`	logical
`regexMisleadingCapturingGroups`	logical
`regexMisleadingQuantifiers`	logical
`regexMisleadingUnicodeCharacters`	logical
`regexNamedCaptureGroups`	logical
`regexNonStandardFlags`	logical
`regexObscureRanges`	logical
`regexOctalEscapes`	logical
`regexQuantifierOptimizations`	logical
`regexSetOperationOptimizations`	logical
`regexStandaloneBackslashes`	logical
`regexSuperLinearBacktracking`	logical
`regexSuperLinearMoves`	logical
`regexUnnecessaryAssertions`	logical
`regexUnnecessaryBackreferences`	logical
`regexUnnecessaryCharacterClasses`	logical
`regexUnnecessaryCharacterRanges`	logical
`regexUnnecessaryDisjunctions`	logical
`regexUnnecessaryDollarReplacements`	logical
`regexUnnecessaryLookaroundAssertions`	logical
`regexUnnecessaryNestedAssertions`	logical
`regexUnnecessaryNestedQuantifiers`	logical
`regexUnnecessaryNumericQuantifiers`	logical
`regexUnnecessaryOptionalAssertions`	logical
`regexUnnecessaryReferentialBackreferences`	logical
`regexUnnecessarySetOperands`	logical
`regexUnusedCapturingGroups`	logical
`regexUnusedFlags`	logical
`regexUnusedLazyQuantifiers`	logical
`regexUnusedQuantifiers`	logical
`regexValidity`	logical
`regexZeroQuantifiers`	logical
`requireImports`	logical
`returnAwaitPromises`	logical
`selfAssignments`Reports self-assignments which have no effect and are likely errors.	logical
`singleVariableDeclarations`	logical
`sparseArrays`Reports array literals with holes (sparse arrays).	logical
`strictBooleanExpressions`	logical
`stringCaseMismatches`	logical
`templateExpressionValues`	logical
`thisAliases`	logical
`throwErrors`	logical
`tripleSlashReferences`	logical
`tripleSlashReferenceValidity`	logical
`tsComments`	logical
`typeConstituentDuplicates`	logical
`unboundMethods`	logical
`unnecessaryBind`	logical
`unnecessaryCatches`Reports catch clauses that only rethrow the caught error without modification.	logical
`unnecessaryComparisons`	logical
`unnecessaryConditions`	logical
`unnecessaryContinues`	logical
`unnecessaryLogicalComparisons`	logical
`unnecessaryMathClamps`	logical
`unnecessaryNumericFractions`	logical
`unnecessarySpreads`	logical
`unnecessaryTemplateExpressions`	logical
`unnecessaryTypeArguments`	logical
`unnecessaryTypeAssertions`	logical
`unnecessaryTypeConstraints`	logical
`unnecessaryTypeConversions`	logical
`unnecessaryTypeParameters`	logical
`unnecessaryUndefinedDefaults`	logical
`unnecessaryUseStricts`	logical
`unsafeDeclarationmerging`	logical
`unsafeEnumComparisons`	logical
`unsafeFunctionTypes`	logical
`unsafeToString`	logical
`unsafeTypeAssertions`	logical
`unsafeUnaryNegations`	logical
`unusedExpressions`	logical
`unusedPrivateClassMembers`	logical
`unusedSwitchStatements`	logical
`unusedValues`	logical
`unusedVariables`	logical
`uselessDefaultAssignments`	logical
`wrapperObjects`	logical
`wrapperObjectTypes`	logical
`accessorThisRecursion`	logical (strict)
`awaitInsidePromiseMethods`	logical (strict)
`caughtErrorCauses`	logical (strict)
`dateNowTimestamps`Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.	logical (strict)
`directivePairs`	logical (strict)
`errorMessages`	logical (strict)
`errorSubclassProperties`	logical (strict)
`extraneousClasses`	logical (strict)
`invalidVoidTypes`	logical (strict)
`nonNullAssertedNullishCoalesces`	logical (strict)
`nonNullAssertions`	logical (strict)
`reduceTypeParameters`	logical (strict)
`regexGraphemeStringLiterals`	logical (strict)
`returnThisTypes`	logical (strict)
`selfComparisons`Reports comparing a value to itself.	logical (strict)
`stringCodePoints`	logical (strict)
`unifiedSignatures`	logical (strict)
`importExtraneousDependencies`	none
`arrayDeleteUnnecessaryCounts`Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.	stylistic
`arrayExistenceChecksConsistency`Reports inconsistent styles for checking element existence using index methods.	stylistic
`arrayFinds`Reports using `.filter()[0]` instead of `.find()` when looking for a single element.	stylistic
`arrayFlatUnnecessaryDepths`	stylistic
`arrayIncludes`	stylistic
`arrayLoops`	stylistic
`arrayMutableReverses`Reports `.reverse()` calls on arrays that mutate the original array.	stylistic
`arrayMutableSorts`Reports `.sort()` calls on arrays that mutate the original array.	stylistic
`arraySliceUnnecessaryEnd`Reports unnecessary `end` argument in `.slice()` calls when it equals the length or is `Infinity`.	stylistic
`arrayTernarySpreadingConsistency`Reports inconsistent types when spreading a ternary in an array literal.	stylistic
`arrayTypes`	stylistic
`asConstAssertions`Reports using explicit literal types when `as const` can be used.	stylistic
`assignmentOperatorShorthands`Prefer logical assignment operator shorthand expressions.	stylistic
`builtinConstructorNews`Enforces using new for constructors that require it, and disallows new for primitive coercion functions.	stylistic
`chainedAssignments`Reports using chained assignment expressions (e.g., a = b = c).	stylistic
`classLiteralProperties`Reports getters that return literal values instead of using readonly class fields.	stylistic
`consecutiveNonNullAssertions`Reports unnecessary extra non-null assertions.	stylistic
`emptyBlocks`Reports empty block statements that should contain code.	stylistic
`emptyModuleAttributes`	stylistic
`emptyStaticBlocks`Reports empty static initialization blocks within class declarations.	stylistic
`emptyTypeParameterLists`	stylistic
`exponentiationOperators`	stylistic
`exportFromImports`	stylistic
`forDirections`Reports for loops with counter variables that move in the wrong direction.	stylistic
`functionApplySpreads`Prefer the spread operator over `.apply()` calls.	stylistic
`functionTypeDeclarations`	stylistic
`genericConstructorCalls`	stylistic
`groupedAccessorPairs`	stylistic
`importCycles`	stylistic
`importDuplicates`	stylistic
`importSelf`	stylistic
`importUnnecessaryPathSegments`	stylistic
`indexedObjectTypes`	stylistic
`jsdocAccessTags`	stylistic
`jsdocEmptyBlocks`	stylistic
`jsdocEmptyTags`	stylistic
`jsdocImplementsTags`	stylistic
`jsdocParameterNames`	stylistic
`jsdocPropertyNames`	stylistic
`jsdocRedundantTypes`	stylistic
`jsdocTemplateNames`	stylistic
`jsdocTypesSyntax`	stylistic
`jsdocUnnecessaryReturns`	stylistic
`jsdocUnnecessaryYields`	stylistic
`jsdocValidTypes`	stylistic
`jsdocValues`	stylistic
`jsdocYields`	stylistic
`literalConstructorWrappers`	stylistic
`methodSignatureStyles`	stylistic
`multilineAmbiguities`Reports ambiguous multiline expressions that could be misinterpreted.	stylistic
`namespaceKeywords`	stylistic
`nestedStandaloneIfs`	stylistic
`nonNullableTypeAssertions`	stylistic
`nullishCoalescingOperators`	stylistic
`numericLiteralParsing`Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.	stylistic
`objectAssignSpreads`	stylistic
`objectHasOwns`Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.	stylistic
`objectShorthand`	stylistic
`objectTypeDefinitions`	stylistic
`operatorAssignmentShorthand`	stylistic
`optionalChainOperators`	stylistic
`overloadSignaturesAdjacent`	stylistic
`promiseFunctionAsync`	stylistic
`propertyAccessNotation`	stylistic
`regexCharacterClassRanges`	stylistic
`regexCharacterClassSetOperations`	stylistic
`regexConciseCharacterClassNegations`	stylistic
`regexDollarEscapes`	stylistic
`regexPredefinedAssertions`	stylistic
`regexRepeatQuantifiers`	stylistic
`regexTestMethods`	stylistic
`regexUnicodeEscapes`	stylistic
`regexUnicodeProperties`	stylistic
`regexUnnecessaryEscapes`	stylistic
`responseMethods`	stylistic
`returnAssignments`Reports using assignment expressions in return statements.	stylistic
`shadows`	stylistic
`stringStartsEndsWith`	stylistic
`symbolDescriptions`Reports Symbol() calls without description arguments.	stylistic
`tslintComments`	stylistic
`typeAssertions`	stylistic
`typeExports`	stylistic
`typeImports`	stylistic
`undefinedInitialValues`	stylistic
`unicodeBOMs`Reports files with Unicode Byte Order Marks (BOMs).	stylistic
`unnecessaryBlocks`Reports standalone block statements that don't create a meaningful scope.	stylistic
`unnecessaryBooleanCasts`	stylistic
`unnecessaryComputedKeys`	stylistic
`unnecessaryConcatenation`Reports string concatenation using the + operator when both operands are string literals.	stylistic
`unnecessaryConstructors`	stylistic
`unnecessaryEscapes`	stylistic
`unnecessaryQualifiers`	stylistic
`unnecessaryRenames`	stylistic
`unnecessaryReturns`	stylistic
`unnecessaryTypeAnnotations`	stylistic
`unusedLabels`	stylistic
`varDeclarations`	stylistic
`voidOperator`Reports using the void operator.	stylistic
`arrayFilteredFinds`	stylistic (strict)
`arrayFlatMapMethods`	stylistic (strict)
`arrayFlatMethods`	stylistic (strict)
`arrayIncludesMethods`	stylistic (strict)
`arrayIndexOfMethods`	stylistic (strict)
`arraySomeMethods`Reports patterns that can be replaced with `.some()` for checking array element existence.	stylistic (strict)
`atAccesses`Prefer using .at() for accessing elements at negative indices.	stylistic (strict)
`builtinCoercions`Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.	stylistic (strict)
`caughtVariableNames`	stylistic (strict)
`classMethodsThis`	stylistic (strict)
`combinedPushes`Reports consecutive array.push() calls that could be combined into a single call.	stylistic (strict)
`destructuringConsistency`Use destructured variables over properties for consistency.	stylistic (strict)
`directiveRequireDescriptions`	stylistic (strict)
`elseReturns`	stylistic (strict)
`emptyFiles`	stylistic (strict)
`emptyFunctions`	stylistic (strict)
`escapeSequenceCasing`	stylistic (strict)
`functionDefinitionScopeConsistency`	stylistic (strict)
`globalThisAliases`	stylistic (strict)
`jsdocAsterisks`	stylistic (strict)
`jsdocInformativeDocs`	stylistic (strict)
`jsdocMisleadingBlocks`	stylistic (strict)
`jsdocMultilineBlocks`	stylistic (strict)
`jsdocParameterDescriptionHyphens`	stylistic (strict)
`jsdocTagNames`	stylistic (strict)
`mathMethods`	stylistic (strict)
`namedDefaultExports`	stylistic (strict)
`namespaceImplicitAmbientImports`	stylistic (strict)
`negativeIndexLengthMethods`	stylistic (strict)
`nonNullAssertionPlacement`	stylistic (strict)
`numberStaticMethods`	stylistic (strict)
`numericLiteralCasing`	stylistic (strict)
`numericSeparatorGroups`	stylistic (strict)
`objectEntriesMethods`	stylistic (strict)
`parameterReassignments`	stylistic (strict)
`regexCharacterClasses`	stylistic (strict)
`regexDigitMatchers`	stylistic (strict)
`regexExecutors`	stylistic (strict)
`regexHexadecimalEscapes`	stylistic (strict)
`regexLetterCasing`	stylistic (strict)
`regexLookaroundAssertions`	stylistic (strict)
`regexMatchNotation`	stylistic (strict)
`regexNamedBackreferences`	stylistic (strict)
`regexNamedReplacements`	stylistic (strict)
`regexPlusQuantifiers`	stylistic (strict)
`regexQuestionQuantifiers`	stylistic (strict)
`regexResultArrayGroups`	stylistic (strict)
`regexStarQuantifiers`	stylistic (strict)
`regexUnicodeCodepointEscapes`	stylistic (strict)
`regexUnnecessaryNonCapturingGroups`	stylistic (strict)
`regexWordMatchers`	stylistic (strict)
`setHasExistenceChecks`	stylistic (strict)
`setSizeLengthChecks`	stylistic (strict)
`sizeComparisonOperators`	stylistic (strict)
`staticMemberOnlyClasses`	stylistic (strict)
`stringSliceMethods`	stylistic (strict)
`stringTrimMethods`	stylistic (strict)
`structuredCloneMethods`	stylistic (strict)
`topLevelAwaits`	stylistic (strict)
`undefinedTypeofChecks`	stylistic (strict)
`unnecessaryTernaries`	stylistic (strict)
`arrayCallbackReturns`Reports missing return statements in callbacks of array methods.	untyped
`caseDeclarations`Reports lexical declarations in case clauses without wrapping them in blocks.	untyped
`classAssignments`Reports reassigning class declarations.	untyped
`classFieldDeclarations`Reports assigning literal values to `this` in constructors instead of using class field declarations.	untyped
`classMemberDuplicates`Reports duplicate class member names that will be overwritten.	untyped
`constantAssignments`Reports attempting to reassign variables declared with const.	untyped
`constructorReturns`Reports returning values from constructor functions.	untyped
`constructorSupers`	untyped
`defaultParameterLast`Enforce default parameters to be last.	untyped
`duplicateArguments`Reports functions with duplicate parameter names in their signatures.	untyped
`functionAssignments`Reports reassigning variables declared with function declarations.	untyped
`getterReturns`	untyped
`globalAssignments`Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.	untyped
`globalObjectCalls`Reports calling global objects like Math, JSON, or Reflect as functions.	untyped
`importAssignments`	untyped
`invalidThis`	untyped
`nativeObjectExtensions`	untyped
`newNativeNonConstructors`Disallows using `new` with global non-constructor functions like Symbol and BigInt.	untyped
`objectKeyDuplicates`Reports unnecessary duplicate keys that override previous values.	untyped
`objectProto`Reports using the deprecated proto property to access or modify an object's prototype.	untyped
`octalEscapes`Reports using octal escape sequences in string literals.	untyped
`octalNumbers`Reports using legacy octal numeric literals.	untyped
`sequences`Reports using the comma operator in expressions.	untyped
`setterReturns`	untyped
`shadowedRestrictedNames`Reports variable declarations that shadow JavaScript's restricted names.	untyped
`thisBeforeSuper`	untyped
`typeofComparisons`Reports typeof expressions that compare impossible string literals.	untyped
`unassignedVariables`Reports variables that are declared but never assigned a value.	untyped
`undefinedVariables`Reports using variables that are not defined.	untyped
`unreachableStatements`	untyped
`unsafeNegations`Reports negating the left operand of `in` or `instanceof` relations.	untyped
`unsafeOptionalChains`	untyped
`usageBeforeDefinition`	untyped
`useStrictDirectives`	untyped
`variableBlockScopeUsage`	untyped
`variableDeletions`Reports attempting to delete variables with the delete operator.	untyped
`variableRedeclarations`	untyped
`withStatements`Reports using with statements	untyped
`consoleCalls`	(none)
`importTypeSideEffects`	(none)
`regexUnicodeFlag`	(none)
`restrictedGlobals`	(none)
`restrictedIdentifiers`	(none)
`restrictedImports`	(none)
`restrictedProperties`	(none)
`restrictedSyntax`	(none)
`restrictedTypes`	(none)

Selectors

Flint’s TypeScript plugin provides the following file selector:

all: **/*.{cjs,js,jsx,mjs,ts,tsx}

Made with ❤️‍🔥 in Boston by Josh Goldberg and contributors.