diff --git a/types/leaflet/index.d.ts b/types/leaflet/index.d.ts
index 135fa8b93f..80adf4bc3f 100644
--- a/types/leaflet/index.d.ts
+++ b/types/leaflet/index.d.ts
@@ -390,6 +390,7 @@ declare namespace L {
 
     interface LayerOptions {
         pane?: string;
+        attribution?: string;
     }
 
     interface InteractiveLayerOptions extends LayerOptions {
diff --git a/types/node/index.d.ts b/types/node/index.d.ts
index 2fd023b56b..178a8920e1 100644
--- a/types/node/index.d.ts
+++ b/types/node/index.d.ts
@@ -495,6 +495,7 @@ declare namespace NodeJS {
         on(event: "uncaughtException", listener: (error: Error) => void): this;
         on(event: "unhandledRejection", listener: (reason: any, promise: Promise<any>) => void): this;
         on(event: "warning", listener: (warning: Error) => void): this;
+        on(event: "message", listener: (message: any, sendHandle: any) => void): this;
         on(event: Signals, listener: () => void): this;
 
         once(event: "beforeExit", listener: (code: number) => void): this;
diff --git a/types/node/node-tests.ts b/types/node/node-tests.ts
index de401eb0fc..35260b138b 100644
--- a/types/node/node-tests.ts
+++ b/types/node/node-tests.ts
@@ -1890,6 +1890,9 @@ namespace process_tests {
         var module: NodeModule | undefined;
         module = process.mainModule;
     }
+    {
+        process.on("message", (req: any) => { });
+    }
 }
 
 ///////////////////////////////////////////////////////////
diff --git a/types/react-leaflet/index.d.ts b/types/react-leaflet/index.d.ts
index 7b14e0ec1f..db3dc44e7c 100644
--- a/types/react-leaflet/index.d.ts
+++ b/types/react-leaflet/index.d.ts
@@ -1,8 +1,8 @@
 // Type definitions for react-leaflet 1.1
 // Project: https://github.com/PaulLeCam/react-leaflet
-// Definitions by: Dave Leaver <https://github.com/danzel>, David Schneider <https://github.com/davschne>
+// Definitions by: Dave Leaver <https://github.com/danzel>, David Schneider <https://github.com/davschne>, Yui T. <https://github.com/yuit>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.2
+// TypeScript Version: 2.3
 
 import * as Leaflet from 'leaflet';
 import * as React from 'react';
@@ -143,7 +143,7 @@ export interface MapProps extends MapEvents, Leaflet.MapOptions, Leaflet.LocateO
     zoom?: number;
 }
 
-export class Map<P extends MapProps, E extends Leaflet.Map> extends MapComponent<P, E> {
+export class Map<P extends MapProps = MapProps, E extends Leaflet.Map = Leaflet.Map> extends MapComponent<P, E> {
     className?: string;
     container: HTMLDivElement;
     getChildContext(): { layerContainer: E, map: E };
@@ -165,7 +165,7 @@ export interface PaneProps {
 export interface PaneState {
     name?: string;
 }
-export class Pane<P extends PaneProps, S extends PaneState> extends React.Component<P, S> {
+export class Pane<P extends PaneProps = PaneProps, S extends PaneState = PaneState> extends React.Component<P, S> {
     getChildContext(): { pane: string };
     createPane(props: P): void;
     removePane(): void;
@@ -181,7 +181,7 @@ export interface LayerContainer {
     addLayer(layer: Leaflet.Layer): this;
     removeLayer(layer: number | Leaflet.Layer): this;
 }
-export class MapLayer<P extends MapLayerProps, E extends Leaflet.Class> extends MapComponent<P, E> {
+export class MapLayer<P extends MapLayerProps = MapLayerProps, E extends Leaflet.Class = Leaflet.Class> extends MapComponent<P, E> {
     createLeafletElement(props: P): E;
     updateLeafletElement(fromProps: P, toProps: P): void;
     readonly layerContainer: LayerContainer | Leaflet.Map;
@@ -190,33 +190,33 @@ export class MapLayer<P extends MapLayerProps, E extends Leaflet.Class> extends
 export interface GridLayerProps extends Leaflet.GridLayerOptions {
     children?: Children;
 }
-export class GridLayer<P extends GridLayerProps, E extends Leaflet.GridLayer> extends MapLayer<P, E> {}
+export class GridLayer<P extends GridLayerProps = GridLayerProps, E extends Leaflet.GridLayer = Leaflet.GridLayer> extends MapLayer<P, E> {}
 
 export interface TileLayerProps extends TileLayerEvents, Leaflet.TileLayerOptions {
     children?: Children;
     url: string;
 }
-export class TileLayer<P extends TileLayerProps, E extends Leaflet.TileLayer> extends GridLayer<P, E> { }
+export class TileLayer<P extends TileLayerProps = TileLayerProps, E extends Leaflet.TileLayer = Leaflet.TileLayer> extends GridLayer<P, E> { }
 
 export interface WMSTileLayerProps extends TileLayerEvents, Leaflet.WMSOptions {
     children?: Children;
     url: string;
 }
-export class WMSTileLayer<P extends WMSTileLayerProps, E extends Leaflet.TileLayer.WMS> extends GridLayer<P, E> { }
+export class WMSTileLayer<P extends WMSTileLayerProps = WMSTileLayerProps,  E extends Leaflet.TileLayer.WMS = Leaflet.TileLayer.WMS> extends GridLayer<P, E> { }
 
 export interface ImageOverlayProps extends Leaflet.ImageOverlayOptions {
     bounds: Leaflet.LatLngBoundsExpression;
     children?: Children;
     url: string;
 }
-export class ImageOverlay<P extends ImageOverlayProps, E extends Leaflet.ImageOverlay> extends MapLayer<P, E> {
+export class ImageOverlay<P extends ImageOverlayProps = ImageOverlayProps, E extends Leaflet.ImageOverlay = Leaflet.ImageOverlay> extends MapLayer<P, E> {
     getChildContext(): { popupContainer: E };
 }
 
 export interface LayerGroupProps {
     children?: Children;
 }
-export class LayerGroup<P extends LayerGroupProps, E extends Leaflet.LayerGroup> extends MapLayer<P, E> {
+export class LayerGroup<P extends LayerGroupProps = LayerGroupProps, E extends Leaflet.LayerGroup = Leaflet.LayerGroup> extends MapLayer<P, E> {
     getChildContext(): { layerContainer: E };
 }
 
@@ -224,7 +224,7 @@ export interface MarkerProps extends MarkerEvents, Leaflet.MarkerOptions {
     children?: Children;
     position: Leaflet.LatLngExpression;
 }
-export class Marker<P extends MarkerProps, E extends Leaflet.Marker> extends MapLayer<P, E> {
+export class Marker<P extends MarkerProps = MarkerProps, E extends Leaflet.Marker = Leaflet.Marker> extends MapLayer<P, E> {
     getChildContext(): { popupContainer: E };
 }
 
@@ -241,19 +241,19 @@ export interface CircleProps extends PathEvents, Leaflet.CircleMarkerOptions {
     children?: Children;
     radius: number;
 }
-export class Circle<P extends CircleProps, E extends Leaflet.Circle> extends Path<P, E> { }
+export class Circle<P extends CircleProps = CircleProps, E extends Leaflet.Circle = Leaflet.Circle> extends Path<P, E> { }
 
 export interface CircleMarkerProps extends PathEvents, Leaflet.CircleMarkerOptions {
     center: Leaflet.LatLngExpression;
     children?: Children;
     radius: number;
 }
-export class CircleMarker<P extends CircleMarkerProps, E extends Leaflet.CircleMarker> extends Path<P, E> { }
+export class CircleMarker<P extends CircleMarkerProps = CircleMarkerProps, E extends Leaflet.CircleMarker = Leaflet.CircleMarker> extends Path<P, E> { }
 
 export interface FeatureGroupProps extends FeatureGroupEvents, Leaflet.PathOptions {
     children?: Children;
 }
-export class FeatureGroup<P extends FeatureGroupProps, E extends Leaflet.FeatureGroup> extends Path<P, E> {
+export class FeatureGroup<P extends FeatureGroupProps = FeatureGroupProps, E extends Leaflet.FeatureGroup = Leaflet.FeatureGroup> extends Path<P, E> {
     getChildContext(): { layerContainer: E, popupContainer: E };
 }
 
@@ -262,33 +262,33 @@ export interface GeoJSONProps extends FeatureGroupEvents, Leaflet.GeoJSONOptions
     data: GeoJSON.GeoJsonObject;
     style?: Leaflet.StyleFunction;
 }
-export class GeoJSON<P extends GeoJSONProps, E extends Leaflet.GeoJSON> extends Path<P, E> { }
+export class GeoJSON<P extends GeoJSONProps = GeoJSONProps, E extends Leaflet.GeoJSON = Leaflet.GeoJSON> extends Path<P, E> { }
 
 export interface PolylineProps extends PathEvents, Leaflet.PolylineOptions {
     children?: Children;
     positions: Leaflet.LatLngExpression[] | Leaflet.LatLngExpression[][];
 }
-export class Polyline<P extends PolylineProps, E extends Leaflet.Polyline> extends Path<P, E> { }
+export class Polyline<P extends PolylineProps = PolylineProps, E extends Leaflet.Polyline = Leaflet.Polyline> extends Path<P, E> { }
 
 export interface PolygonProps extends PathEvents, Leaflet.PolylineOptions {
     children?: Children;
     popupContainer?: Leaflet.FeatureGroup;
     positions: Leaflet.LatLngExpression[] | Leaflet.LatLngExpression[][] | Leaflet.LatLngExpression[][][];
 }
-export class Polygon<P extends PolygonProps, E extends Leaflet.Polygon> extends Path<P, E> { }
+export class Polygon<P extends PolygonProps = PolygonProps, E extends Leaflet.Polygon = Leaflet.Polygon> extends Path<P, E> { }
 
 export interface RectangleProps extends PathEvents, Leaflet.PolylineOptions {
     children?: Children;
     bounds: Leaflet.LatLngBoundsExpression;
     popupContainer?: Leaflet.FeatureGroup;
 }
-export class Rectangle<P extends RectangleProps, E extends Leaflet.Rectangle> extends Path<P, E> { }
+export class Rectangle<P extends RectangleProps = RectangleProps, E extends Leaflet.Rectangle = Leaflet.Rectangle> extends Path<P, E> { }
 
 export interface PopupProps extends Leaflet.PopupOptions {
     children?: Children;
     position?: Leaflet.LatLngExpression;
 }
-export class Popup<P extends PopupProps, E extends Leaflet.Popup> extends MapComponent<P, E> {
+export class Popup<P extends PopupProps = PopupProps, E extends Leaflet.Popup = Leaflet.Popup> extends MapComponent<P, E> {
     onPopupOpen(arg: { popup: E }): void;
     onPopupClose(arg: { popup: E }): void;
     renderPopupContent(): void;
@@ -298,7 +298,7 @@ export class Popup<P extends PopupProps, E extends Leaflet.Popup> extends MapCom
 export interface TooltipProps extends Leaflet.TooltipOptions {
     children?: Children;
 }
-export class Tooltip<P extends TooltipProps, E extends Leaflet.Tooltip> extends MapComponent<P, E> {
+export class Tooltip<P extends TooltipProps = TooltipProps, E extends Leaflet.Tooltip = Leaflet.Tooltip> extends MapComponent<P, E> {
     onTooltipOpen(arg: { tooltip: E }): void;
     onTooltipClose(arg: { tooltip: E }): void;
     renderTooltipContent(): void;
@@ -306,21 +306,21 @@ export class Tooltip<P extends TooltipProps, E extends Leaflet.Tooltip> extends
 }
 
 export type MapControlProps = Leaflet.ControlOptions;
-export class MapControl<P extends MapControlProps, E extends Leaflet.Control> extends React.Component<P, {}> {
+export class MapControl<P extends MapControlProps = MapControlProps, E extends Leaflet.Control = Leaflet.Control> extends React.Component<P, {}> {
     leafletElement: E;
     createLeafletElement(props: P): E;
     updateLeafletElement(fromProps: P, toProps: P): void;
 }
 
 export type AttributionControlProps = Leaflet.Control.AttributionOptions;
-export class AttributionControl<P extends AttributionControlProps, E extends Leaflet.Control.Attribution> extends MapControl<P, E> { }
+export class AttributionControl<P extends AttributionControlProps = AttributionControlProps, E extends Leaflet.Control.Attribution = Leaflet.Control.Attribution> extends MapControl<P, E> { }
 
 export interface LayersControlProps extends LayersControlEvents, Leaflet.Control.LayersOptions {
     baseLayers?: Leaflet.Control.LayersObject;
     children?: Children;
     overlays?: Leaflet.Control.LayersObject;
 }
-export class LayersControl<P extends AttributionControlProps, E extends Leaflet.Control.Layers> extends MapControl<P, E> { }
+export class LayersControl<P extends LayersControlProps = LayersControlProps, E extends Leaflet.Control.Layers = Leaflet.Control.Layers> extends MapControl<P, E> { }
 
 export namespace LayersControl {
     interface BaseControlledLayerProps {
@@ -334,18 +334,18 @@ export namespace LayersControl {
         addOverlay?(layer: Leaflet.Layer, name: string, checked: boolean): void;
         name: string;
     }
-    class ControlledLayer<P extends BaseControlledLayerProps> extends React.Component<P, {}> {
+    class ControlledLayer<P extends BaseControlledLayerProps = BaseControlledLayerProps> extends React.Component<P, {}> {
         layer?: Leaflet.Layer;
         getChildContext(): { layerContainer: LayerContainer };
         addLayer(): void;
         removeLayer(layer: Leaflet.Layer): void;
     }
-    class BaseLayer<P extends ControlledLayerProps> extends ControlledLayer<P> { }
-    class Overlay<P extends ControlledLayerProps> extends ControlledLayer<P> { }
+    class BaseLayer<P extends ControlledLayerProps = ControlledLayerProps> extends ControlledLayer<P> { }
+    class Overlay<P extends ControlledLayerProps = ControlledLayerProps> extends ControlledLayer<P> { }
 }
 
 export type ScaleControlProps = Leaflet.Control.ScaleOptions;
-export class ScaleControl<P extends ScaleControlProps, E extends Leaflet.Control.Scale> extends MapControl<P, E> { }
+export class ScaleControl<P extends ScaleControlProps = ScaleControlProps, E extends Leaflet.Control.Scale = Leaflet.Control.Scale> extends MapControl<P, E> { }
 
 export type ZoomControlProps = Leaflet.Control.ZoomOptions;
-export class ZoomControl<P extends ZoomControlProps, E extends Leaflet.Control.Zoom> extends MapControl<P, E> { }
+export class ZoomControl<P extends ZoomControlProps = ZoomControlProps, E extends Leaflet.Control.Zoom = Leaflet.Control.Zoom> extends MapControl<P, E> { }
diff --git a/types/react-leaflet/react-leaflet-tests.tsx b/types/react-leaflet/react-leaflet-tests.tsx
index 667d92d6ea..d87d4f995e 100644
--- a/types/react-leaflet/react-leaflet-tests.tsx
+++ b/types/react-leaflet/react-leaflet-tests.tsx
@@ -686,7 +686,7 @@ class CenterControl extends MapControl<MapControlProps, Leaflet.Control> {  // n
         const centerControl = new L.Control({ position: 'bottomright' });  // see http://leafletjs.com/reference.html#control-positions for other positions
         const jsx = (
             // PUT YOUR JSX FOR THE COMPONENT HERE:
-            <div {...this.props}>
+            <div>
                 {/* add your JSX */}
             </div>
         );
@@ -713,7 +713,7 @@ class LegendControl extends MapControl<MapControlProps & { className?: string },
     componentWillMount() {
         const legend = new L.Control({ position: 'bottomright' });
         const jsx = (
-            <div {...this.props}>
+            <div>
                 {this.props.children}
             </div>
         );