message: Clarify comment on Jsonable
diff: */
  /**
  - * Used to constrain a type `T` to types that are serializable as JSON. Produces a
  - * compile-time error if `T` contains non-Jsonable members.
  + * Used to constrain a type `T` to types that are serializable as JSON.
  + * Produces a compile-time error if `T` contains non-Jsonable members.
  *
  * Typical usage:
  * ```ts
  * function foo<T>(value: Jsonable<T>) { ... }
  * ```
  *
  - * Important: `T extends Jsonable<T>` is generally incorrect. (Any value of `T`
  - * extends the JSON serializable subset of itself.)
  + * Note that this does NOT prevent using of values with non-json compatible data,
  + * it only prevents using values with types that include non-json compatible data.
  + * This means that one can, for example, pass an a value typed with json compatible
  + * interface into this function,
  + * that could actually be a class with lots on non-json compatible fields and methods.
  + *
  + * Important: `T extends Jsonable<T>` is incorrect (does not even compile).
  + * `T extends Jsonable` is also incorrect since `Jsonable` is just `any` and thus applies no constraint at all.
  *
  * The optional 'TReplaced' parameter may be used to permit additional leaf types to support
  * situations where a `replacer` is used to handle special values (e.g., `Jsonable<{ x: IFluidHandle }, IFluidHandle>`).
  *
  - * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing
  - * `undefined` and non-finite numbers:
  + * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing with JSON.stringify():
  *
  * - `undefined` properties on objects are omitted (i.e., properties become undefined instead of equal to undefined).
  * - When `undefined` appears as the root object or as an array element it is coerced to `null`.
  * - Non-finite numbers (`NaN`, `+/-Infinity`) are also coerced to `null`.
  + * - prototypes and non-enumerable properties are lost.
  *
  * Also, `Jsonable<T>` does not prevent the construction of circular references.
  + *
  + * Using `Jsonable` (with no type parameters) or `Jsonable<any>` is just a type alias for `any`
  + * and should not be used if type safety is desired.
  */
  export type Jsonable<T = any, TReplaced = void> =
  T extends undefined | null | boolean | number | string | TReplaced
  