function CellEvent(gridX, gridY) {
        // remaining instance vars are non-enumerable so `CellEditor` constructor won't mix them in (for mustache use).
        Object.defineProperties(this, {
            /**
             * @name visibleColumn
             * @type {visibleColumnArray}
             * @memberOf CellEvent#
             */
            visibleColumn: writableDescriptor,

            /**
             * @name visibleRow
             * @type {visibleRowArray}
             * @memberOf CellEvent#
             */
            visibleRow: writableDescriptor,

            /**
             * @name subgrid
             * @type {DataModel}
             * @memberOf CellEvent#
             */
            subgrid: writableDescriptor,

            /**
             * @name gridCell
             * @type {gridCellCoords}
             * @memberOf CellEvent#
             */
            gridCell: {
                value: new WritablePoint
            },

            /**
             * @name dataCell
             * @type {dataCellCoords}
             * @memberOf CellEvent#
             */
            dataCell: {
                value: new WritablePoint
            },

            /**
             * A reference to the cell's {@link Column} object.
             *
             * This property is enumerable so that it will be copied to cell editor on {@link CellEditor} instantiation.
             * @name column
             * @type {Column}
             * @memberOf CellEvent#
             */
            column: enumerableDescriptor,

            // getter caches
            _columnProperties: writableDescriptor,
            _cellOwnProperties: writableDescriptor,
            _bounds: writableDescriptor,

            // Following supports cell renderers' "partial render" capability:
            snapshot: writableDescriptor,
            minWidth: writableDescriptor,
            disabled: writableDescriptor
        });

        if (arguments.length) {
            this.resetGridCY(gridX, gridY);
        }
    }
@summary Create a new CellEvent object.

@classdesc `CellEvent` is a very low-level object that needs to be super-efficient. JavaScript objects are well known to be light weight in general, but at this level we need to be careful.

These objects were originally only being created on mouse events. This was no big deal as mouse events are few and far between. However, as of v1.2.0, the renderer now also creates one for each visible cell on each and every grid paint.

For this reason, to maintain performance, each grid gets a custom definition of `CellEvent`, created by this class factory, with the following optimizations:

* Use of `extend-me` is avoided because its `initialize` chain is a bit too heavy here.
* Custom versions of `CellEvent` for each grid lightens the load on the constructor.

@desc All own enumerable properties are mixed into cell editor:
* Includes `this.column` defined by constructor (as enumerable).
* Excludes all other properties defined by constructor and prototype, all of which are non-enumerable.
* Any additional (enumerable) members mixed in by application's `getCellEditorAt` override.

Including the params calls {@link CellEvent#resetGridCY resetGridCY(gridX, gridY)}.
Alternatively, instantiate without params and/or later call one of these:
* {@link CellEvent#resetGridXY resetGridXY(...)}
* {@link CellEvent#resetDataXY resetDataXY(...)}
* {@link CellEvent#resetGridXDataY resetGridXDataY(...)}

@param {number} [gridX] - grid cell coordinate (adjusted for horizontal scrolling after fixed columns).
@param {number} [gridY] - grid cell coordinate, adjusted (adjusted for vertical scrolling if data subgrid)
@constructor CellEvent