diff --git a/ChangeLog.md b/ChangeLog.md
index 33d5d11d78141..1b3f5172f00ff 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -16,6 +16,13 @@ full changeset diff at the end of each section.
 Current Trunk
 -------------
  - Remove deprecated Pointer_stringify (use UTF8ToString instead). See #8011
+ - Added a new option -s DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1 that
+   changes the lookup semantics of DOM elements in html5.h event handler
+   callback and WebGL context creation. New behavior is to use CSS selector
+   strings to look up DOM elements over the old behavior, which was somewhat
+   ad hoc constructed rules around default Emscripten uses. The old behavior
+   will be deprecated and removed in the future. Build with -s ASSERTIONS=1
+   to get diagnostics messages related to this transition.
 
 v1.38.26: 02/04/2019
 --------------------
diff --git a/src/library_html5.js b/src/library_html5.js
index c71e30ef11c21..9ab15e5803c0b 100644
--- a/src/library_html5.js
+++ b/src/library_html5.js
@@ -48,37 +48,6 @@ var LibraryJSEvents = {
     },
 #endif
 
-    // Find a DOM element with the given ID.
-    findEventTarget: function(target) {
-      try {
-        // The sensible "default" target varies between events, but use window as the default
-        // since DOM events mostly can default to that. Specific callback registrations
-        // override their own defaults.
-        if (!target) return window;
-        if (typeof target === "number") target = UTF8ToString(target);
-        if (target === '#window') return window;
-        else if (target === '#document') return document;
-        else if (target === '#screen') return window.screen;
-        else if (target === '#canvas') return Module['canvas'];
-        return (typeof target === 'string') ? document.getElementById(target) : target;
-      } catch(e) {
-        // In Web Workers, some objects above, such as '#document' do not exist. Gracefully
-        // return null for them.
-        return null;
-      }
-    },
-
-    // Like findEventTarget, but looks for OffscreenCanvas elements first
-    findCanvasEventTarget: function(target) {
-      if (typeof target === 'number') target = UTF8ToString(target);
-      if (!target || target === '#canvas') {
-        if (typeof GL !== 'undefined' && GL.offscreenCanvases['canvas']) return GL.offscreenCanvases['canvas']; // TODO: Remove this line, target '#canvas' should refer only to Module['canvas'], not to GL.offscreenCanvases['canvas'] - but need stricter tests to be able to remove this line.
-        return Module['canvas'];
-      }
-      if (typeof GL !== 'undefined' && GL.offscreenCanvases[target]) return GL.offscreenCanvases[target];
-      return JSEvents.findEventTarget(target);
-    },
-
     deferredCalls: [],
 
     // Queues the given function call to occur the next time we enter an event handler.
@@ -237,7 +206,7 @@ var LibraryJSEvents = {
     getNodeNameForTarget: function(target) {
       if (!target) return '';
       if (target == window) return '#window';
-      if (target == window.screen) return '#screen';
+      if (target == screen) return '#screen';
       return (target && target.nodeName) ? target.nodeName : '';
     },
 
@@ -251,7 +220,7 @@ var LibraryJSEvents = {
     },
   },
 
-  _registerKeyEventCallback__deps: ['$JSEvents'],
+  _registerKeyEventCallback__deps: ['$JSEvents', '_findEventTarget'],
   _registerKeyEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
@@ -288,7 +257,7 @@ var LibraryJSEvents = {
     };
 
     var eventHandler = {
-      target: JSEvents.findEventTarget(target),
+      target: __findEventTarget(target),
       allowsDeferredCalls: JSEvents.isInternetExplorer() ? false : true, // MSIE doesn't allow fullscreen and pointerlock requests from key handlers, others do.
       eventTypeString: eventTypeString,
       callbackfunc: callbackfunc,
@@ -298,6 +267,92 @@ var LibraryJSEvents = {
     JSEvents.registerOrRemoveHandler(eventHandler);
   },
 
+  // In DOM capturing and bubbling sequence, there are two special elements at the top of the event chain that can be of interest
+  // to register many events to: document and window. These cannot be addressed by using document.querySelector(), so
+  // a special mechanism to address them is needed. (For any other special object, such as screen.orientation, no general access
+  // scheme should be needed, but the object-specific event callback registration functions should handle them individually)
+#if ENVIRONMENT_MAY_BE_WORKER || ENVIRONMENT_MAY_BE_NODE || ENVIRONMENT_MAY_BE_SHELL || USE_PTHREADS
+  _specialEventTargets: "[0, typeof document !== 'undefined' ? document : 0, typeof window !== 'undefined' ? window : 0]",
+#else
+  _specialEventTargets: "[0, document, window]",
+#endif
+
+#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
+  _maybeCStringToJsString: function(cString) {
+    return cString === cString + 0 ? UTF8ToString(cString) : cString;
+  },
+
+  _findEventTarget__deps: ['_maybeCStringToJsString', '_specialEventTargets'],
+  _findEventTarget: function(target) {
+    var domElement = __specialEventTargets[target] || document.querySelector(__maybeCStringToJsString(target));
+#if ASSERTIONS
+    // TODO: Remove this check in the future, or move it to some kind of debugging mode, because it may be perfectly fine behavior
+    // for one to query an event target to test if any DOM element with given CSS selector exists. However for a migration period
+    // from old lookup over to new, it is very useful to get diagnostics messages related to a lookup failing.
+    if (!domElement) err('No DOM element was found with CSS selector "' + __maybeCStringToJsString(target) + '"');
+#endif
+    return domElement;
+  },
+
+#if OFFSCREENCANVAS_SUPPORT
+  _findCanvasEventTarget__deps: ['$GL', '_maybeCStringToJsString'],
+  _findCanvasEventTarget: function(target) {
+    target = __maybeCStringToJsString(target);
+
+    // First look up if there exists an OffscreenCanvas with the given name.
+    var offscreenCanvas;
+    // TODO: Once Module['canvas'] is removed, clean up the following line:
+    if (target == '#canvas') offscreenCanvas = GL.offscreenCanvases['canvas'];
+    if (!offscreenCanvas) offscreenCanvas = GL.offscreenCanvases[target] || (target == 'canvas' && Object.keys(GL.offscreenCanvases)[0]); // First looks up by DOM ID ("#myCanvasElement"), second looks up by DOM element name (first found element of type <canvas>)
+    if (offscreenCanvas) return offscreenCanvas;
+
+#if USE_PTHREADS
+    return (typeof document !== 'undefined') ? document.querySelector(target) : null;
+#endif
+  },
+#else
+  _findCanvasEventTarget__deps: ['_findEventTarget'],
+  _findCanvasEventTarget: function(target) { return __findEventTarget(target); },
+#endif
+
+#else
+  // Find a DOM element with the given ID.
+  _findEventTarget__deps: ['_specialEventTargets'],
+  _findEventTarget: function(target) {
+#if ASSERTIONS
+    warnOnce('Rules for selecting event targets in HTML5 API are changing: instead of using document.getElementById() that only can refer to elements by their DOM ID, new event target selection mechanism uses the more flexible function document.querySelector() that can look up element names, classes, and complex CSS selectors. Build with -s DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1 to change to the new lookup rules. See https://github.com/emscripten-core/emscripten/pull/7977 for more details.');
+#endif
+    try {
+      // The sensible "default" target varies between events, but use window as the default
+      // since DOM events mostly can default to that. Specific callback registrations
+      // override their own defaults.
+      if (!target) return window;
+      if (typeof target === "number") target = __specialEventTargets[target] || UTF8ToString(target);
+      if (target === '#window') return window;
+      else if (target === '#document') return document;
+      else if (target === '#screen') return screen;
+      else if (target === '#canvas') return Module['canvas'];
+      return (typeof target === 'string') ? document.getElementById(target) : target;
+    } catch(e) {
+      // In Web Workers, some objects above, such as '#document' do not exist. Gracefully
+      // return null for them.
+      return null;
+    }
+  },
+
+  // Like findEventTarget, but looks for OffscreenCanvas elements first
+  _findCanvasEventTarget__deps: ['_findEventTarget'],
+  _findCanvasEventTarget: function(target) {
+    if (typeof target === 'number') target = UTF8ToString(target);
+    if (!target || target === '#canvas') {
+      if (typeof GL !== 'undefined' && GL.offscreenCanvases['canvas']) return GL.offscreenCanvases['canvas']; // TODO: Remove this line, target '#canvas' should refer only to Module['canvas'], not to GL.offscreenCanvases['canvas'] - but need stricter tests to be able to remove this line.
+      return Module['canvas'];
+    }
+    if (typeof GL !== 'undefined' && GL.offscreenCanvases[target]) return GL.offscreenCanvases[target];
+    return __findEventTarget(target);
+  },
+#endif
+
   emscripten_set_keypress_callback_on_thread__proxy: 'sync',
   emscripten_set_keypress_callback_on_thread__sig: 'iiiiii',
   emscripten_set_keypress_callback_on_thread__deps: ['_registerKeyEventCallback'],
@@ -342,6 +397,7 @@ var LibraryJSEvents = {
     {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.movementX, 'e["movementX"] || e["mozMovementX"] || e["webkitMovementX"] || (e.screenX-JSEvents.previousScreenX)', 'i32') }}};
     {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.movementY, 'e["movementY"] || e["mozMovementY"] || e["webkitMovementY"] || (e.screenY-JSEvents.previousScreenY)', 'i32') }}};
 
+#if !DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
     if (Module['canvas']) {
       var rect = Module['canvas'].getBoundingClientRect();
       {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.canvasX, 'e.clientX - rect.left', 'i32') }}};
@@ -350,6 +406,7 @@ var LibraryJSEvents = {
       {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.canvasX, '0', 'i32') }}};
       {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.canvasY, '0', 'i32') }}};
     }
+#endif
     if (target) {
       var rect = JSEvents.getBoundingClientRectOrZeros(target);
       {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.targetX, 'e.clientX - rect.left', 'i32') }}};
@@ -367,13 +424,13 @@ var LibraryJSEvents = {
     }
   },
 
-  _registerMouseEventCallback__deps: ['$JSEvents', '_fillMouseEventData'],
+  _registerMouseEventCallback__deps: ['$JSEvents', '_fillMouseEventData', '_findEventTarget'],
   _registerMouseEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
     if (!JSEvents.mouseEvent) JSEvents.mouseEvent = _malloc( {{{ C_STRUCTS.EmscriptenMouseEvent.__size__ }}} );
-    target = JSEvents.findEventTarget(target);
+    target = __findEventTarget(target);
 
     var mouseEventHandlerFunc = function(event) {
       var e = event || window.event;
@@ -488,14 +545,12 @@ var LibraryJSEvents = {
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
-  _registerWheelEventCallback__deps: ['$JSEvents', '_fillMouseEventData'],
+  _registerWheelEventCallback__deps: ['$JSEvents', '_fillMouseEventData', '_findEventTarget'],
   _registerWheelEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
     if (!JSEvents.wheelEvent) JSEvents.wheelEvent = _malloc( {{{ C_STRUCTS.EmscriptenWheelEvent.__size__ }}} );
-    target = JSEvents.findEventTarget(target);
-
 
     // The DOM Level 3 events spec event 'wheel'
     var wheelHandlerFunc = function(event) {
@@ -543,9 +598,9 @@ var LibraryJSEvents = {
 
   emscripten_set_wheel_callback_on_thread__proxy: 'sync',
   emscripten_set_wheel_callback_on_thread__sig: 'iiiiii',
-  emscripten_set_wheel_callback_on_thread__deps: ['$JSEvents', '_registerWheelEventCallback'],
+  emscripten_set_wheel_callback_on_thread__deps: ['$JSEvents', '_registerWheelEventCallback', '_findEventTarget'],
   emscripten_set_wheel_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {
-    target = JSEvents.findEventTarget(target);
+    target = __findEventTarget(target);
     if (typeof target.onwheel !== 'undefined') {
       __registerWheelEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WHEEL') }}}, "wheel", targetThread);
       return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
@@ -557,18 +612,23 @@ var LibraryJSEvents = {
     }
   },
 
-  _registerUiEventCallback__deps: ['$JSEvents'],
+  _registerUiEventCallback__deps: ['$JSEvents', '_findEventTarget'],
   _registerUiEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
     if (!JSEvents.uiEvent) JSEvents.uiEvent = _malloc( {{{ C_STRUCTS.EmscriptenUiEvent.__size__ }}} );
 
+#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
+    target = __findEventTarget(target);
+#else
     if (eventTypeString == "scroll" && !target) {
       target = document; // By default read scroll events on document rather than window.
     } else {
-      target = JSEvents.findEventTarget(target);
+      target = __findEventTarget(target);
     }
+#else
+#endif
 
     var uiEventHandlerFunc = function(event) {
       var e = event || window.event;
@@ -629,7 +689,7 @@ var LibraryJSEvents = {
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
-  _registerFocusEventCallback__deps: ['$JSEvents'],
+  _registerFocusEventCallback__deps: ['$JSEvents', '_findEventTarget'],
   _registerFocusEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
@@ -658,7 +718,7 @@ var LibraryJSEvents = {
     };
 
     var eventHandler = {
-      target: JSEvents.findEventTarget(target),
+      target: __findEventTarget(target),
       allowsDeferredCalls: false,
       eventTypeString: eventTypeString,
       callbackfunc: callbackfunc,
@@ -709,7 +769,7 @@ var LibraryJSEvents = {
     {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceOrientationEvent.absolute, 'e.absolute', 'i32') }}};
   },
 
-  _registerDeviceOrientationEventCallback__deps: ['$JSEvents', '_fillDeviceOrientationEventData'],
+  _registerDeviceOrientationEventCallback__deps: ['$JSEvents', '_fillDeviceOrientationEventData', '_findEventTarget'],
   _registerDeviceOrientationEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
@@ -732,7 +792,7 @@ var LibraryJSEvents = {
     };
 
     var eventHandler = {
-      target: JSEvents.findEventTarget(target),
+      target: __findEventTarget(target),
       allowsDeferredCalls: false,
       eventTypeString: eventTypeString,
       callbackfunc: callbackfunc,
@@ -746,7 +806,7 @@ var LibraryJSEvents = {
   emscripten_set_deviceorientation_callback_on_thread__sig: 'iiiii',
   emscripten_set_deviceorientation_callback_on_thread__deps: ['_registerDeviceOrientationEventCallback'],
   emscripten_set_deviceorientation_callback_on_thread: function(userData, useCapture, callbackfunc, targetThread) {
-    __registerDeviceOrientationEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEORIENTATION') }}}, "deviceorientation", targetThread);
+    __registerDeviceOrientationEventCallback({{{ cDefine('EMSCRIPTEN_EVENT_TARGET_WINDOW') }}}, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEORIENTATION') }}}, "deviceorientation", targetThread);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
@@ -776,7 +836,7 @@ var LibraryJSEvents = {
     {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.rotationRateGamma, 'e.rotationRate.gamma', 'double') }}};
   },
 
-  _registerDeviceMotionEventCallback__deps: ['$JSEvents', '_fillDeviceMotionEventData'],
+  _registerDeviceMotionEventCallback__deps: ['$JSEvents', '_fillDeviceMotionEventData', '_findEventTarget'],
   _registerDeviceMotionEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
@@ -799,7 +859,7 @@ var LibraryJSEvents = {
     };
 
     var eventHandler = {
-      target: JSEvents.findEventTarget(target),
+      target: __findEventTarget(target),
       allowsDeferredCalls: false,
       eventTypeString: eventTypeString,
       callbackfunc: callbackfunc,
@@ -813,7 +873,7 @@ var LibraryJSEvents = {
   emscripten_set_devicemotion_callback_on_thread__sig: 'iiiii',
   emscripten_set_devicemotion_callback_on_thread__deps: ['_registerDeviceMotionEventCallback'],
   emscripten_set_devicemotion_callback_on_thread: function(userData, useCapture, callbackfunc, targetThread) {
-    __registerDeviceMotionEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEMOTION') }}}, "devicemotion", targetThread);
+    __registerDeviceMotionEventCallback({{{ cDefine('EMSCRIPTEN_EVENT_TARGET_WINDOW') }}}, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEMOTION') }}}, "devicemotion", targetThread);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
@@ -830,8 +890,8 @@ var LibraryJSEvents = {
   },
 
   _screenOrientation: function() {
-    if (!window.screen) return undefined;
-    return window.screen.orientation || window.screen.mozOrientation || window.screen.webkitOrientation || window.screen.msOrientation;
+    if (!screen) return undefined;
+    return screen.orientation || screen.mozOrientation || screen.webkitOrientation || screen.msOrientation;
   },
 
   _fillOrientationChangeEventData__deps: ['_screenOrientation'],
@@ -849,19 +909,13 @@ var LibraryJSEvents = {
     {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenOrientationChangeEvent.orientationAngle, 'window.orientation', 'i32') }}};
   },
 
-  _registerOrientationChangeEventCallback__deps: ['$JSEvents', '_fillOrientationChangeEventData'],
+  _registerOrientationChangeEventCallback__deps: ['$JSEvents', '_fillOrientationChangeEventData', '_findEventTarget'],
   _registerOrientationChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
     if (!JSEvents.orientationChangeEvent) JSEvents.orientationChangeEvent = _malloc( {{{ C_STRUCTS.EmscriptenOrientationChangeEvent.__size__ }}} );
 
-    if (!target) {
-      target = window.screen; // Orientation events need to be captured from 'window.screen' instead of 'window'
-    } else {
-      target = JSEvents.findEventTarget(target);
-    }
-
     var orientationChangeEventHandlerFunc = function(event) {
       var e = event || window.event;
 
@@ -880,7 +934,7 @@ var LibraryJSEvents = {
       if ({{{ makeDynCall('iiii') }}}(callbackfunc, eventTypeId, orientationChangeEvent, userData)) e.preventDefault();
     };
 
-    if (eventTypeString == "orientationchange" && window.screen.mozOrientation !== undefined) {
+    if (eventTypeString == "orientationchange" && screen.mozOrientation !== undefined) {
       eventTypeString = "mozorientationchange";
     }
 
@@ -899,8 +953,8 @@ var LibraryJSEvents = {
   emscripten_set_orientationchange_callback_on_thread__sig: 'iiiii',
   emscripten_set_orientationchange_callback_on_thread__deps: ['_registerOrientationChangeEventCallback'],
   emscripten_set_orientationchange_callback_on_thread: function(userData, useCapture, callbackfunc, targetThread) {
-    if (!window.screen || !window.screen.addEventListener) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    __registerOrientationChangeEventCallback(window.screen, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_ORIENTATIONCHANGE') }}}, "orientationchange", targetThread);
+    if (!screen || !screen.addEventListener) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    __registerOrientationChangeEventCallback(screen, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_ORIENTATIONCHANGE') }}}, "orientationchange", targetThread);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
@@ -922,14 +976,14 @@ var LibraryJSEvents = {
     if (allowedOrientations & 4) orientations.push("landscape-primary");
     if (allowedOrientations & 8) orientations.push("landscape-secondary");
     var succeeded;
-    if (window.screen.lockOrientation) {
-      succeeded = window.screen.lockOrientation(orientations);
-    } else if (window.screen.mozLockOrientation) {
-      succeeded = window.screen.mozLockOrientation(orientations);
-    } else if (window.screen.webkitLockOrientation) {
-      succeeded = window.screen.webkitLockOrientation(orientations);
-    } else if (window.screen.msLockOrientation) {
-      succeeded = window.screen.msLockOrientation(orientations);
+    if (screen.lockOrientation) {
+      succeeded = screen.lockOrientation(orientations);
+    } else if (screen.mozLockOrientation) {
+      succeeded = screen.mozLockOrientation(orientations);
+    } else if (screen.webkitLockOrientation) {
+      succeeded = screen.webkitLockOrientation(orientations);
+    } else if (screen.msLockOrientation) {
+      succeeded = screen.msLockOrientation(orientations);
     } else {
       return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     }
@@ -943,14 +997,14 @@ var LibraryJSEvents = {
   emscripten_unlock_orientation__proxy: 'sync',
   emscripten_unlock_orientation__sig: 'i',
   emscripten_unlock_orientation: function() {
-    if (window.screen.unlockOrientation) {
-      window.screen.unlockOrientation();
-    } else if (window.screen.mozUnlockOrientation) {
-      window.screen.mozUnlockOrientation();
-    } else if (window.screen.webkitUnlockOrientation) {
-      window.screen.webkitUnlockOrientation();
-    } else if (window.screen.msUnlockOrientation) {
-      window.screen.msUnlockOrientation();
+    if (screen.unlockOrientation) {
+      screen.unlockOrientation();
+    } else if (screen.mozUnlockOrientation) {
+      screen.mozUnlockOrientation();
+    } else if (screen.webkitUnlockOrientation) {
+      screen.webkitUnlockOrientation();
+    } else if (screen.msUnlockOrientation) {
+      screen.msUnlockOrientation();
     } else {
       return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     }
@@ -979,16 +1033,13 @@ var LibraryJSEvents = {
     }
   },
 
-  _registerFullscreenChangeEventCallback__deps: ['$JSEvents', '_fillFullscreenChangeEventData'],
+  _registerFullscreenChangeEventCallback__deps: ['$JSEvents', '_fillFullscreenChangeEventData', '_findEventTarget'],
   _registerFullscreenChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
     if (!JSEvents.fullscreenChangeEvent) JSEvents.fullscreenChangeEvent = _malloc( {{{ C_STRUCTS.EmscriptenFullscreenChangeEvent.__size__ }}} );
 
-    if (!target) target = document; // Fullscreen change events need to be captured from 'document' by default instead of 'window'
-    else target = JSEvents.findEventTarget(target);
-
     var fullscreenChangeEventhandlerFunc = function(event) {
       var e = event || window.event;
 
@@ -1020,14 +1071,15 @@ var LibraryJSEvents = {
 
   emscripten_set_fullscreenchange_callback_on_thread__proxy: 'sync',
   emscripten_set_fullscreenchange_callback_on_thread__sig: 'iiiiii',
-  emscripten_set_fullscreenchange_callback_on_thread__deps: ['$JSEvents', '_registerFullscreenChangeEventCallback'],
+  emscripten_set_fullscreenchange_callback_on_thread__deps: ['$JSEvents', '_registerFullscreenChangeEventCallback', '_findEventTarget', '_specialEventTargets'],
   emscripten_set_fullscreenchange_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {
     if (typeof JSEvents.fullscreenEnabled() === 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    if (!target) target = document;
-    else {
-      target = JSEvents.findEventTarget(target);
-      if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
-    }
+#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
+    target = __findEventTarget(target);
+#else
+    target = target ? __findEventTarget(target) : __specialEventTargets[{{{ cDefine('EMSCRIPTEN_EVENT_TARGET_DOCUMENT') }}}];
+#endif
+    if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
     __registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "fullscreenchange", targetThread);
     __registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "mozfullscreenchange", targetThread);
     __registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "webkitfullscreenchange", targetThread);
@@ -1318,12 +1370,14 @@ var LibraryJSEvents = {
   },
 
   // https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Using_full_screen_mode  
-  _emscripten_do_request_fullscreen__deps: ['$JSEvents', '_setLetterbox', 'emscripten_set_canvas_element_size', 'emscripten_get_canvas_element_size', '_get_canvas_element_size', '_set_canvas_element_size', 'JSEvents_requestFullscreen'],
+  _emscripten_do_request_fullscreen__deps: ['$JSEvents', '_setLetterbox', 'emscripten_set_canvas_element_size', 'emscripten_get_canvas_element_size', '_get_canvas_element_size', '_set_canvas_element_size', 'JSEvents_requestFullscreen', '_findEventTarget'],
   _emscripten_do_request_fullscreen: function(target, strategy) {
     if (typeof JSEvents.fullscreenEnabled() === 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     if (!JSEvents.fullscreenEnabled()) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+#if !DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
     if (!target) target = '#canvas';
-    target = JSEvents.findEventTarget(target);
+#endif
+    target = __findEventTarget(target);
     if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
 
     if (!target.requestFullscreen && !target.msRequestFullscreen && !target.mozRequestFullScreen && !target.mozRequestFullscreen && !target.webkitRequestFullscreen) {
@@ -1379,12 +1433,14 @@ var LibraryJSEvents = {
     return __emscripten_do_request_fullscreen(target, strategy);
   },
 
-  emscripten_enter_soft_fullscreen__deps: ['$JSEvents', '_setLetterbox', '_hideEverythingExceptGivenElement', '_restoreOldWindowedStyle', '_registerRestoreOldStyle', '_restoreHiddenElements', '_currentFullscreenStrategy', '_softFullscreenResizeWebGLRenderTarget', '_get_canvas_element_size', '_set_canvas_element_size', 'JSEvents_resizeCanvasForFullscreen'],
+  emscripten_enter_soft_fullscreen__deps: ['$JSEvents', '_setLetterbox', '_hideEverythingExceptGivenElement', '_restoreOldWindowedStyle', '_registerRestoreOldStyle', '_restoreHiddenElements', '_currentFullscreenStrategy', '_softFullscreenResizeWebGLRenderTarget', '_get_canvas_element_size', '_set_canvas_element_size', 'JSEvents_resizeCanvasForFullscreen', '_findEventTarget'],
   emscripten_enter_soft_fullscreen__proxy: 'sync',
   emscripten_enter_soft_fullscreen__sig: 'iii',
   emscripten_enter_soft_fullscreen: function(target, fullscreenStrategy) {
+#if !DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
     if (!target) target = '#canvas';
-    target = JSEvents.findEventTarget(target);
+#endif
+    target = __findEventTarget(target);
     if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
 
     var strategy = {};
@@ -1418,6 +1474,7 @@ var LibraryJSEvents = {
 #endif
         {{{ makeDynCall('iiii') }}}(strategy.canvasResizedCallback, {{{ cDefine('EMSCRIPTEN_EVENT_CANVASRESIZED') }}}, 0, strategy.canvasResizedCallbackUserData);
       }
+      __currentFullscreenStrategy = 0;
     }
     __restoreOldWindowedStyle = restoreWindowedState;
     __currentFullscreenStrategy = strategy;
@@ -1445,7 +1502,7 @@ var LibraryJSEvents = {
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
-  emscripten_exit_fullscreen__deps: ['$JSEvents', '_currentFullscreenStrategy', 'JSEvents_requestFullscreen'],
+  emscripten_exit_fullscreen__deps: ['$JSEvents', '_currentFullscreenStrategy', 'JSEvents_requestFullscreen', '_specialEventTargets'],
   emscripten_exit_fullscreen__proxy: 'sync',
   emscripten_exit_fullscreen__sig: 'i',
   emscripten_exit_fullscreen: function() {
@@ -1453,14 +1510,15 @@ var LibraryJSEvents = {
     // Make sure no queued up calls will fire after this.
     JSEvents.removeDeferredCalls(_JSEvents_requestFullscreen);
 
-    if (document.exitFullscreen) {
-      document.exitFullscreen();
-    } else if (document.msExitFullscreen) {
-      document.msExitFullscreen();
-    } else if (document.mozCancelFullScreen) {
-      document.mozCancelFullScreen();
-    } else if (document.webkitExitFullscreen) {
-      document.webkitExitFullscreen();
+    var d = __specialEventTargets[{{{ cDefine('EMSCRIPTEN_EVENT_TARGET_DOCUMENT') }}}];
+    if (d.exitFullscreen) {
+      d.fullscreenElement && d.exitFullscreen();
+    } else if (d.msExitFullscreen) {
+      d.msFullscreenElement && d.msExitFullscreen();
+    } else if (d.mozCancelFullScreen) {
+      d.mozFullScreenElement && d.mozCancelFullScreen();
+    } else if (d.webkitExitFullscreen) {
+      d.webkitFullscreenElement && d.webkitExitFullscreen();
     } else {
       return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     }
@@ -1471,6 +1529,7 @@ var LibraryJSEvents = {
         else
 #endif
       {{{ makeDynCall('iiii') }}}(__currentFullscreenStrategy.canvasResizedCallback, {{{ cDefine('EMSCRIPTEN_EVENT_CANVASRESIZED') }}}, 0, __currentFullscreenStrategy.canvasResizedCallbackUserData);
+      __currentFullscreenStrategy = 0;
     }
 
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
@@ -1487,16 +1546,13 @@ var LibraryJSEvents = {
     stringToUTF8(id, eventStruct + {{{ C_STRUCTS.EmscriptenPointerlockChangeEvent.id }}}, {{{ cDefine('EM_HTML5_LONG_STRING_LEN_BYTES') }}});
   },
 
-  _registerPointerlockChangeEventCallback__deps: ['$JSEvents', '_fillPointerlockChangeEventData'],
+  _registerPointerlockChangeEventCallback__deps: ['$JSEvents', '_fillPointerlockChangeEventData', '_findEventTarget'],
   _registerPointerlockChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
     if (!JSEvents.pointerlockChangeEvent) JSEvents.pointerlockChangeEvent = _malloc( {{{ C_STRUCTS.EmscriptenPointerlockChangeEvent.__size__ }}} );
 
-    if (!target) target = document; // Pointer lock change events need to be captured from 'document' by default instead of 'window'
-    else target = JSEvents.findEventTarget(target);
-
     var pointerlockChangeEventHandlerFunc = function(event) {
       var e = event || window.event;
 
@@ -1527,17 +1583,19 @@ var LibraryJSEvents = {
 
   emscripten_set_pointerlockchange_callback_on_thread__proxy: 'sync',
   emscripten_set_pointerlockchange_callback_on_thread__sig: 'iiiiii',
-  emscripten_set_pointerlockchange_callback_on_thread__deps: ['$JSEvents', '_registerPointerlockChangeEventCallback'],
+  emscripten_set_pointerlockchange_callback_on_thread__deps: ['$JSEvents', '_registerPointerlockChangeEventCallback', '_findEventTarget', '_specialEventTargets'],
   emscripten_set_pointerlockchange_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {
     // TODO: Currently not supported in pthreads or in --proxy-to-worker mode. (In pthreads mode, document object is not defined)
     if (!document || !document.body || (!document.body.requestPointerLock && !document.body.mozRequestPointerLock && !document.body.webkitRequestPointerLock && !document.body.msRequestPointerLock)) {
       return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     }
-    if (!target) target = document;
-    else {
-      target = JSEvents.findEventTarget(target);
-      if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
-    }
+
+#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
+    target = __findEventTarget(target);
+#else
+    target = target ? __findEventTarget(target) : __specialEventTargets[{{{ cDefine('EMSCRIPTEN_EVENT_TARGET_DOCUMENT') }}}]; // Pointer lock change events need to be captured from 'document' by default instead of 'window'
+#endif
+    if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
     __registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "pointerlockchange", targetThread);
     __registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "mozpointerlockchange", targetThread);
     __registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "webkitpointerlockchange", targetThread);
@@ -1545,11 +1603,8 @@ var LibraryJSEvents = {
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
-  _registerPointerlockErrorEventCallback__deps: ['$JSEvents'],
+  _registerPointerlockErrorEventCallback__deps: ['$JSEvents', '_findEventTarget', '_specialEventTargets'],
   _registerPointerlockErrorEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-    if (!target) target = document; // Pointer lock events need to be captured from 'document' by default instead of 'window'
-    else target = JSEvents.findEventTarget(target);
-
     var pointerlockErrorEventHandlerFunc = function(event) {
       var e = event || window.event;
 
@@ -1573,17 +1628,20 @@ var LibraryJSEvents = {
 
   emscripten_set_pointerlockerror_callback_on_thread__proxy: 'sync',
   emscripten_set_pointerlockerror_callback_on_thread__sig: 'iiiiii',
-  emscripten_set_pointerlockerror_callback_on_thread__deps: ['$JSEvents', '_registerPointerlockErrorEventCallback'],
+  emscripten_set_pointerlockerror_callback_on_thread__deps: ['$JSEvents', '_registerPointerlockErrorEventCallback', '_findEventTarget', '_specialEventTargets'],
   emscripten_set_pointerlockerror_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {
     // TODO: Currently not supported in pthreads or in --proxy-to-worker mode. (In pthreads mode, document object is not defined)
     if (!document || !document.body.requestPointerLock && !document.body.mozRequestPointerLock && !document.body.webkitRequestPointerLock && !document.body.msRequestPointerLock) {
       return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     }
-    if (!target) target = document;
-    else {
-      target = JSEvents.findEventTarget(target);
-      if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
-    }
+
+#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
+    target = __findEventTarget(target);
+#else
+    target = target ? __findEventTarget(target) : __specialEventTargets[{{{ cDefine('EMSCRIPTEN_EVENT_TARGET_DOCUMENT') }}}]; // Pointer lock change events need to be captured from 'document' by default instead of 'window'
+#endif
+
+    if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
     __registerPointerlockErrorEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKERROR') }}}, "pointerlockerror", targetThread);
     __registerPointerlockErrorEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKERROR') }}}, "mozpointerlockerror", targetThread);
     __registerPointerlockErrorEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKERROR') }}}, "webkitpointerlockerror", targetThread);
@@ -1625,10 +1683,12 @@ var LibraryJSEvents = {
 
   emscripten_request_pointerlock__proxy: 'sync',
   emscripten_request_pointerlock__sig: 'iii',
-  emscripten_request_pointerlock__deps: ['$JSEvents', '_requestPointerLock'],
+  emscripten_request_pointerlock__deps: ['$JSEvents', '_requestPointerLock', '_findEventTarget'],
   emscripten_request_pointerlock: function(target, deferUntilInEventHandler) {
+#if !DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
     if (!target) target = '#canvas';
-    target = JSEvents.findEventTarget(target);
+#endif
+    target = __findEventTarget(target);
     if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
     if (!target.requestPointerLock && !target.mozRequestPointerLock && !target.webkitRequestPointerLock && !target.msRequestPointerLock) {
       return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
@@ -1700,16 +1760,13 @@ var LibraryJSEvents = {
     {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenVisibilityChangeEvent.visibilityState, 'visibilityState', 'i32') }}};
   },
 
-  _registerVisibilityChangeEventCallback__deps: ['$JSEvents', '_fillVisibilityChangeEventData'],
+  _registerVisibilityChangeEventCallback__deps: ['$JSEvents', '_fillVisibilityChangeEventData', '_findEventTarget'],
   _registerVisibilityChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
     if (!JSEvents.visibilityChangeEvent) JSEvents.visibilityChangeEvent = _malloc( {{{ C_STRUCTS.EmscriptenVisibilityChangeEvent.__size__ }}} );
 
-    if (!target) target = document; // Visibility change events need to be captured from 'document' by default instead of 'window'
-    else target = JSEvents.findEventTarget(target);
-
     var visibilityChangeEventHandlerFunc = function(event) {
       var e = event || window.event;
 
@@ -1741,9 +1798,14 @@ var LibraryJSEvents = {
 
   emscripten_set_visibilitychange_callback_on_thread__proxy: 'sync',
   emscripten_set_visibilitychange_callback_on_thread__sig: 'iiiii',
-  emscripten_set_visibilitychange_callback_on_thread__deps: ['_registerVisibilityChangeEventCallback'],
+  emscripten_set_visibilitychange_callback_on_thread__deps: ['_registerVisibilityChangeEventCallback', '_specialEventTargets'],
   emscripten_set_visibilitychange_callback_on_thread: function(userData, useCapture, callbackfunc, targetThread) {
-    __registerVisibilityChangeEventCallback(document, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_VISIBILITYCHANGE') }}}, "visibilitychange", targetThread);
+#if ENVIRONMENT_MAY_BE_WORKER || ENVIRONMENT_MAY_BE_NODE || ENVIRONMENT_MAY_BE_SHELL
+  if (!__specialEventTargets[{{{ cDefine('EMSCRIPTEN_EVENT_TARGET_DOCUMENT') }}}]) {
+    return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
+  }
+#endif
+    __registerVisibilityChangeEventCallback(__specialEventTargets[{{{ cDefine('EMSCRIPTEN_EVENT_TARGET_DOCUMENT') }}}], userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_VISIBILITYCHANGE') }}}, "visibilitychange", targetThread);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
@@ -1758,14 +1820,14 @@ var LibraryJSEvents = {
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
-  _registerTouchEventCallback__deps: ['$JSEvents'],
+  _registerTouchEventCallback__deps: ['$JSEvents', '_findEventTarget'],
   _registerTouchEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
     if (!JSEvents.touchEvent) JSEvents.touchEvent = _malloc( {{{ C_STRUCTS.EmscriptenTouchEvent.__size__ }}} );
 
-    target = JSEvents.findEventTarget(target);
+    target = __findEventTarget(target);
 
     var touchEventHandlerFunc = function(event) {
       var e = event || window.event;
@@ -1796,7 +1858,9 @@ var LibraryJSEvents = {
       {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchEvent.altKey, 'e.altKey', 'i32') }}};
       {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchEvent.metaKey, 'e.metaKey', 'i32') }}};
       ptr += {{{ C_STRUCTS.EmscriptenTouchEvent.touches }}}; // Advance to the start of the touch array.
+#if !DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
       var canvasRect = Module['canvas'] ? Module['canvas'].getBoundingClientRect() : undefined;
+#endif
       var targetRect = JSEvents.getBoundingClientRectOrZeros(target);
       var numTouches = 0;
       for(var i in touches) {
@@ -1810,6 +1874,7 @@ var LibraryJSEvents = {
         {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.pageY, 't.pageY', 'i32') }}};
         {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.isChanged, 't.changed', 'i32') }}};
         {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.onTarget, 't.onTarget', 'i32') }}};
+#if !DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
         if (canvasRect) {
           {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.canvasX, 't.clientX - canvasRect.left', 'i32') }}};
           {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.canvasY, 't.clientY - canvasRect.top', 'i32') }}};
@@ -1817,6 +1882,7 @@ var LibraryJSEvents = {
           {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.canvasX, '0', 'i32') }}};
           {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.canvasY, '0', 'i32') }}};            
         }
+#endif
         {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.targetX, 't.clientX - targetRect.left', 'i32') }}};
         {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.targetY, 't.clientY - targetRect.top', 'i32') }}};
 
@@ -1905,7 +1971,7 @@ var LibraryJSEvents = {
     stringToUTF8(e.mapping, eventStruct + {{{ C_STRUCTS.EmscriptenGamepadEvent.mapping }}}, {{{ cDefine('EM_HTML5_MEDIUM_STRING_LEN_BYTES') }}});
   },
 
-  _registerGamepadEventCallback__deps: ['$JSEvents', '_fillGamepadEventData'],
+  _registerGamepadEventCallback__deps: ['$JSEvents', '_fillGamepadEventData', '_findEventTarget'],
   _registerGamepadEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
@@ -1930,7 +1996,7 @@ var LibraryJSEvents = {
     };
 
     var eventHandler = {
-      target: JSEvents.findEventTarget(target),
+      target: __findEventTarget(target),
       allowsDeferredCalls: true,
       eventTypeString: eventTypeString,
       callbackfunc: callbackfunc,
@@ -1945,7 +2011,7 @@ var LibraryJSEvents = {
   emscripten_set_gamepadconnected_callback_on_thread__deps: ['_registerGamepadEventCallback'],
   emscripten_set_gamepadconnected_callback_on_thread: function(userData, useCapture, callbackfunc, targetThread) {
     if (!navigator.getGamepads && !navigator.webkitGetGamepads) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    __registerGamepadEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_GAMEPADCONNECTED') }}}, "gamepadconnected", targetThread);
+    __registerGamepadEventCallback({{{ cDefine('EMSCRIPTEN_EVENT_TARGET_WINDOW') }}}, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_GAMEPADCONNECTED') }}}, "gamepadconnected", targetThread);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
@@ -1954,7 +2020,7 @@ var LibraryJSEvents = {
   emscripten_set_gamepaddisconnected_callback_on_thread__deps: ['_registerGamepadEventCallback'],
   emscripten_set_gamepaddisconnected_callback_on_thread: function(userData, useCapture, callbackfunc, targetThread) {
     if (!navigator.getGamepads && !navigator.webkitGetGamepads) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    __registerGamepadEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_GAMEPADDISCONNECTED') }}}, "gamepaddisconnected", targetThread);
+    __registerGamepadEventCallback({{{ cDefine('EMSCRIPTEN_EVENT_TARGET_WINDOW') }}}, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_GAMEPADDISCONNECTED') }}}, "gamepaddisconnected", targetThread);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
@@ -1999,7 +2065,7 @@ var LibraryJSEvents = {
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
-  _registerBeforeUnloadEventCallback__deps: ['$JSEvents'],
+  _registerBeforeUnloadEventCallback__deps: ['$JSEvents', '_findEventTarget'],
   _registerBeforeUnloadEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
     var beforeUnloadEventHandlerFunc = function(event) {
       var e = event || window.event;
@@ -2018,7 +2084,7 @@ var LibraryJSEvents = {
     };
 
     var eventHandler = {
-      target: JSEvents.findEventTarget(target),
+      target: __findEventTarget(target),
       allowsDeferredCalls: false,
       eventTypeString: eventTypeString,
       callbackfunc: callbackfunc,
@@ -2036,7 +2102,7 @@ var LibraryJSEvents = {
     // beforeunload callback can only be registered on the main browser thread, because the page will go away immediately after returning from the handler,
     // and there is no time to start proxying it anywhere.
     if (targetThread !== {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD') }}}) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
-    __registerBeforeUnloadEventCallback(window, userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BEFOREUNLOAD') }}}, "beforeunload"); 
+    __registerBeforeUnloadEventCallback({{{ cDefine('EMSCRIPTEN_EVENT_TARGET_WINDOW') }}}, userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BEFOREUNLOAD') }}}, "beforeunload");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
@@ -2049,7 +2115,7 @@ var LibraryJSEvents = {
 
   _battery: function() { return navigator.battery || navigator.mozBattery || navigator.webkitBattery; },
 
-  _registerBatteryEventCallback__deps: ['$JSEvents', '_fillBatteryEventData', '_battery'],
+  _registerBatteryEventCallback__deps: ['$JSEvents', '_fillBatteryEventData', '_battery', '_findEventTarget'],
   _registerBatteryEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
@@ -2074,7 +2140,7 @@ var LibraryJSEvents = {
     };
 
     var eventHandler = {
-      target: JSEvents.findEventTarget(target),
+      target: __findEventTarget(target),
       allowsDeferredCalls: false,
       eventTypeString: eventTypeString,
       callbackfunc: callbackfunc,
@@ -2146,7 +2212,7 @@ var LibraryJSEvents = {
   emscripten_webgl_commit_frame: 'emscripten_webgl_do_commit_frame',
 #endif
 
-  emscripten_webgl_do_create_context__deps: ['$GL', '$JSEvents', '_emscripten_webgl_power_preferences'],
+  emscripten_webgl_do_create_context__deps: ['$GL', '$JSEvents', '_emscripten_webgl_power_preferences', '_findEventTarget', '_findCanvasEventTarget'],
   // This function performs proxying manually, depending on the style of context that is to be created.
   emscripten_webgl_do_create_context: function(target, attributes) {
     var contextAttributes = {};
@@ -2167,13 +2233,11 @@ var LibraryJSEvents = {
     contextAttributes.proxyContextToMainThread = HEAP32[a + ({{{ C_STRUCTS.EmscriptenWebGLContextAttributes.proxyContextToMainThread }}}>>2)];
     contextAttributes.renderViaOffscreenBackBuffer = HEAP32[a + ({{{ C_STRUCTS.EmscriptenWebGLContextAttributes.renderViaOffscreenBackBuffer }}}>>2)];
 
-    target = UTF8ToString(target);
-    var canvas;
-    if ((!target || target === '#canvas') && Module['canvas']) {
-      canvas = (Module['canvas'].id && GL.offscreenCanvases[Module['canvas'].id]) ? (GL.offscreenCanvases[Module['canvas'].id].offscreenCanvas || JSEvents.findEventTarget(Module['canvas'].id)) : Module['canvas'];
-    } else {
-      canvas = GL.offscreenCanvases[target] ? GL.offscreenCanvases[target].offscreenCanvas : JSEvents.findEventTarget(target);
-    }
+    var canvas = __findCanvasEventTarget(target);
+
+#if GL_DEBUG
+    var targetStr = UTF8ToString(target);
+#endif
 
 #if USE_PTHREADS
     // Create a WebGL context that is proxied to main thread if canvas was not found on worker, or if explicitly requested to do so.
@@ -2185,7 +2249,7 @@ var LibraryJSEvents = {
         // then this can be avoided, since OffscreenCanvas enables explicit swap control.
 #if GL_DEBUG
         if (contextAttributes.proxyContextToMainThread === {{{ cDefine('EMSCRIPTEN_WEBGL_CONTEXT_PROXY_ALWAYS') }}}) console.error('EMSCRIPTEN_WEBGL_CONTEXT_PROXY_ALWAYS enabled, proxying WebGL rendering from pthread to main thread.');
-        if (!canvas && contextAttributes.proxyContextToMainThread === {{{ cDefine('EMSCRIPTEN_WEBGL_CONTEXT_PROXY_FALLBACK') }}}) console.error('Specified canvas target "' + target + '" is not an OffscreenCanvas in the current pthread, but EMSCRIPTEN_WEBGL_CONTEXT_PROXY_FALLBACK is set. Proxying WebGL rendering from pthread to main thread.');
+        if (!canvas && contextAttributes.proxyContextToMainThread === {{{ cDefine('EMSCRIPTEN_WEBGL_CONTEXT_PROXY_FALLBACK') }}}) console.error('Specified canvas target "' + targetStr + '" is not an OffscreenCanvas in the current pthread, but EMSCRIPTEN_WEBGL_CONTEXT_PROXY_FALLBACK is set. Proxying WebGL rendering from pthread to main thread.');
         console.error('Performance warning: forcing renderViaOffscreenBackBuffer=true and preserveDrawingBuffer=true since proxying WebGL rendering.');
 #endif
         // We will be proxying - if OffscreenCanvas is supported, we can proxy a bit more efficiently by avoiding having to create an Offscreen FBO.
@@ -2200,15 +2264,17 @@ var LibraryJSEvents = {
 
     if (!canvas) {
 #if GL_DEBUG
-      console.error('emscripten_webgl_create_context failed: Unknown canvas target "' + target + '"!');
+      console.error('emscripten_webgl_create_context failed: Unknown canvas target "' + targetStr + '"!');
 #endif
       return 0;
     }
 
 #if OFFSCREENCANVAS_SUPPORT
+    canvas = canvas.offscreenCanvas;
+
 #if GL_DEBUG
-    if (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas) console.log('emscripten_webgl_create_context: Creating an OffscreenCanvas-based WebGL context on target "' + target + '"');
-    else if (typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement) console.log('emscripten_webgl_create_context: Creating an HTMLCanvasElement-based WebGL context on target "' + target + '"');
+    if (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas) console.log('emscripten_webgl_create_context: Creating an OffscreenCanvas-based WebGL context on target "' + targetStr + '"');
+    else if (typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement) console.log('emscripten_webgl_create_context: Creating an HTMLCanvasElement-based WebGL context on target "' + targetStr + '"');
 #endif
 
     if (contextAttributes.explicitSwapControl) {
@@ -2232,12 +2298,15 @@ var LibraryJSEvents = {
 
       if (canvas.transferControlToOffscreen) {
 #if GL_DEBUG
-        console.log('explicitSwapControl requested: canvas.transferControlToOffscreen() on canvas "' + target + '" to get .commit() function and not rely on implicit WebGL swap');
+        console.log('explicitSwapControl requested: canvas.transferControlToOffscreen() on canvas "' + targetStr + '" to get .commit() function and not rely on implicit WebGL swap');
 #endif
         if (!canvas.controlTransferredOffscreen) {
-          GL.offscreenCanvases[canvas.id] = canvas.transferControlToOffscreen();
+          GL.offscreenCanvases[canvas.id] = {
+            canvas: canvas.transferControlToOffscreen(),
+            canvasSharedPtr: _malloc(12),
+            id: canvas.id
+          };
           canvas.controlTransferredOffscreen = true;
-          GL.offscreenCanvases[canvas.id].id = canvas.id;
         } else if (!GL.offscreenCanvases[canvas.id]) {
 #if GL_DEBUG
           console.error('OffscreenCanvas is supported, and canvas "' + canvas.id + '" has already before been transferred offscreen, but there is no known OffscreenCanvas with that name!');
@@ -2440,12 +2509,15 @@ var LibraryJSEvents = {
   emscripten_webgl_enable_extension: 'emscripten_webgl_enable_extension_calling_thread',
 #endif
 
-  _registerWebGlEventCallback__deps: ['$JSEvents'],
+  _registerWebGlEventCallback__deps: ['$JSEvents', '_findEventTarget'],
   _registerWebGlEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 #if USE_PTHREADS
     targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);
 #endif
+
+#if !DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
     if (!target) target = Module['canvas'];
+#endif
 
     var webGlEventHandlerFunc = function(event) {
       var e = event || window.event;
@@ -2458,7 +2530,7 @@ var LibraryJSEvents = {
     };
 
     var eventHandler = {
-      target: JSEvents.findEventTarget(target),
+      target: __findEventTarget(target),
       allowsDeferredCalls: false,
       eventTypeString: eventTypeString,
       callbackfunc: callbackfunc,
@@ -2496,9 +2568,9 @@ var LibraryJSEvents = {
   },
 
 #if USE_PTHREADS
-  emscripten_set_canvas_element_size_calling_thread__deps: ['$JSEvents', 'emscripten_set_offscreencanvas_size_on_target_thread'],
+  emscripten_set_canvas_element_size_calling_thread__deps: ['$JSEvents', 'emscripten_set_offscreencanvas_size_on_target_thread', '_findCanvasEventTarget'],
   emscripten_set_canvas_element_size_calling_thread: function(target, width, height) {
-    var canvas = JSEvents.findCanvasEventTarget(target);
+    var canvas = __findCanvasEventTarget(target);
     if (!canvas) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
 
     if (canvas.canvasSharedPtr) {
@@ -2583,22 +2655,22 @@ var LibraryJSEvents = {
   emscripten_set_canvas_element_size_main_thread__deps: ['emscripten_set_canvas_element_size_calling_thread'],
   emscripten_set_canvas_element_size_main_thread: function(target, width, height) { return _emscripten_set_canvas_element_size_calling_thread(target, width, height); },
 
-  emscripten_set_canvas_element_size__deps: ['$JSEvents', 'emscripten_set_canvas_element_size_calling_thread', 'emscripten_set_canvas_element_size_main_thread'],
+  emscripten_set_canvas_element_size__deps: ['$JSEvents', 'emscripten_set_canvas_element_size_calling_thread', 'emscripten_set_canvas_element_size_main_thread', '_findCanvasEventTarget'],
   emscripten_set_canvas_element_size: function(target, width, height) {
 #if GL_DEBUG
     console.error('emscripten_set_canvas_element_size(target='+target+',width='+width+',height='+height);
 #endif
-    var canvas = JSEvents.findCanvasEventTarget(target);
+    var canvas = __findCanvasEventTarget(target);
     if (canvas) return _emscripten_set_canvas_element_size_calling_thread(target, width, height);
     else return _emscripten_set_canvas_element_size_main_thread(target, width, height);
   }, 
 #else
-  emscripten_set_canvas_element_size__deps: ['$JSEvents'],
+  emscripten_set_canvas_element_size__deps: ['$JSEvents', '_findCanvasEventTarget'],
   emscripten_set_canvas_element_size: function(target, width, height) {
 #if GL_DEBUG
     console.error('emscripten_set_canvas_element_size(target='+target+',width='+width+',height='+height);
 #endif
-    var canvas = JSEvents.findCanvasEventTarget(target);
+    var canvas = __findCanvasEventTarget(target);
     if (!canvas) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
     canvas.width = width;
     canvas.height = height;
@@ -2633,9 +2705,9 @@ var LibraryJSEvents = {
   }, 
 
 #if USE_PTHREADS
-  emscripten_get_canvas_element_size_calling_thread__deps: ['$JSEvents'],
+  emscripten_get_canvas_element_size_calling_thread__deps: ['$JSEvents', '_findCanvasEventTarget'],
   emscripten_get_canvas_element_size_calling_thread: function(target, width, height) {
-    var canvas = JSEvents.findCanvasEventTarget(target);
+    var canvas = __findCanvasEventTarget(target);
     if (!canvas) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
 
     if (canvas.canvasSharedPtr) {
@@ -2666,16 +2738,16 @@ var LibraryJSEvents = {
   emscripten_get_canvas_element_size_main_thread__deps: ['emscripten_get_canvas_element_size_calling_thread'],
   emscripten_get_canvas_element_size_main_thread: function(target, width, height) { return _emscripten_get_canvas_element_size_calling_thread(target, width, height); },
 
-  emscripten_get_canvas_element_size__deps: ['$JSEvents', 'emscripten_get_canvas_element_size_calling_thread', 'emscripten_get_canvas_element_size_main_thread'],
+  emscripten_get_canvas_element_size__deps: ['$JSEvents', 'emscripten_get_canvas_element_size_calling_thread', 'emscripten_get_canvas_element_size_main_thread', '_findCanvasEventTarget'],
   emscripten_get_canvas_element_size: function(target, width, height) {
-    var canvas = JSEvents.findCanvasEventTarget(target);
+    var canvas = __findCanvasEventTarget(target);
     if (canvas) return _emscripten_get_canvas_element_size_calling_thread(target, width, height);
     else return _emscripten_get_canvas_element_size_main_thread(target, width, height);
   }, 
 #else
-  emscripten_get_canvas_element_size__deps: ['$JSEvents'],
+  emscripten_get_canvas_element_size__deps: ['$JSEvents', '_findCanvasEventTarget'],
   emscripten_get_canvas_element_size: function(target, width, height) {
-    var canvas = JSEvents.findCanvasEventTarget(target);
+    var canvas = __findCanvasEventTarget(target);
     if (!canvas) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
     {{{ makeSetValue('width', '0', 'canvas.width', 'i32') }}};
     {{{ makeSetValue('height', '0', 'canvas.height', 'i32') }}};
@@ -2703,10 +2775,13 @@ var LibraryJSEvents = {
 
   emscripten_set_element_css_size__proxy: 'sync',
   emscripten_set_element_css_size__sig: 'iiii',
-  emscripten_set_element_css_size__deps: ['$JSEvents'],
+  emscripten_set_element_css_size__deps: ['$JSEvents', '_findEventTarget'],
   emscripten_set_element_css_size: function(target, width, height) {
-    if (target) target = JSEvents.findEventTarget(target);
-    else target = Module['canvas'];
+#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
+    target = __findEventTarget(target);
+#else
+    target = target ? __findEventTarget(target) : Module['canvas'];
+#endif
     if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
 
     target.style.width = width + "px";
@@ -2717,10 +2792,13 @@ var LibraryJSEvents = {
 
   emscripten_get_element_css_size__proxy: 'sync',
   emscripten_get_element_css_size__sig: 'iiii',
-  emscripten_get_element_css_size__deps: ['$JSEvents'],
+  emscripten_get_element_css_size__deps: ['$JSEvents', '_findEventTarget'],
   emscripten_get_element_css_size: function(target, width, height) {
-    if (target) target = JSEvents.findEventTarget(target);
-    else target = Module['canvas'];
+#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
+    target = __findEventTarget(target);
+#else
+    target = target ? __findEventTarget(target) : Module['canvas'];
+#endif
     if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
 
     if (target.getBoundingClientRect) {
diff --git a/src/settings.js b/src/settings.js
index df770e460d751..b5ebc72559c55 100644
--- a/src/settings.js
+++ b/src/settings.js
@@ -1419,3 +1419,7 @@ var TARGET_BASENAME = '';
 // this to 0 to save a little bit of code size and performance when catching exceptions.
 var SUPPORT_LONGJMP = 1;
 
+// If set to 1, disables old deprecated HTML5 API event target lookup behavior. When enabled,
+// there is no "Module.canvas" object, no magic "null" default handling, and DOM element
+// 'target' parameters are taken to refer to CSS selectors, instead of referring to DOM IDs.
+var DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR = 0;
diff --git a/src/struct_info.json b/src/struct_info.json
index f00c2defe1b9f..e8891634d965e 100644
--- a/src/struct_info.json
+++ b/src/struct_info.json
@@ -1222,6 +1222,12 @@
             "EMSCRIPTEN_RESULT_NOT_SUPPORTED",
             "EMSCRIPTEN_RESULT_FAILED",
             "EMSCRIPTEN_RESULT_NO_DATA",
+            "EMSCRIPTEN_RESULT_TIMED_OUT",
+
+            "EMSCRIPTEN_EVENT_TARGET_INVALID",
+            "EMSCRIPTEN_EVENT_TARGET_DOCUMENT",
+            "EMSCRIPTEN_EVENT_TARGET_WINDOW",
+            "EMSCRIPTEN_EVENT_TARGET_SCREEN",
 
             "EMSCRIPTEN_FULLSCREEN_SCALE_DEFAULT",
             "EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH",
diff --git a/system/include/emscripten/html5.h b/system/include/emscripten/html5.h
index 66f15f38dd0e6..afdfe2a7750ce 100644
--- a/system/include/emscripten/html5.h
+++ b/system/include/emscripten/html5.h
@@ -88,6 +88,11 @@ extern "C" {
 #define EMSCRIPTEN_RESULT_NO_DATA             -7
 #define EMSCRIPTEN_RESULT_TIMED_OUT           -8
 
+#define EMSCRIPTEN_EVENT_TARGET_INVALID        0
+#define EMSCRIPTEN_EVENT_TARGET_DOCUMENT       ((const char*)1)
+#define EMSCRIPTEN_EVENT_TARGET_WINDOW         ((const char*)2)
+#define EMSCRIPTEN_EVENT_TARGET_SCREEN         ((const char*)3)
+
 #define EM_BOOL int
 #define EM_TRUE 1
 #define EM_FALSE 0
@@ -141,6 +146,7 @@ typedef struct EmscriptenMouseEvent {
   long movementY;
   long targetX;
   long targetY;
+  // canvasX and canvasY are deprecated - there no longer exists a Module['canvas'] object, so canvasX/Y are no longer reported (register a listener on canvas directly to get canvas coordinates, or translate manually)
   long canvasX;
   long canvasY;
   long padding;
@@ -356,6 +362,7 @@ typedef struct EmscriptenTouchPoint
   EM_BOOL onTarget;
   long targetX;
   long targetY;
+  // canvasX and canvasY are deprecated - there no longer exists a Module['canvas'] object, so canvasX/Y are no longer reported (register a listener on canvas directly to get canvas coordinates, or translate manually)
   long canvasX;
   long canvasY;
 } EmscriptenTouchPoint;
diff --git a/tests/canvas_animate_resize.cpp b/tests/canvas_animate_resize.cpp
index e041f8cffae96..4d2d27eccde89 100644
--- a/tests/canvas_animate_resize.cpp
+++ b/tests/canvas_animate_resize.cpp
@@ -125,7 +125,7 @@ int main()
 #if TEST_EXPLICIT_CONTEXT_SWAP
   attr.explicitSwapControl = EM_TRUE;
 #endif
-  ctx = emscripten_webgl_create_context(0, &attr);
+  ctx = emscripten_webgl_create_context("#canvas", &attr);
   printf("Created context with handle %u\n", (unsigned int)ctx);
   if (!ctx)
   {
diff --git a/tests/gl_in_mainthread_after_pthread.cpp b/tests/gl_in_mainthread_after_pthread.cpp
index ed6121a812d36..31440058891a2 100644
--- a/tests/gl_in_mainthread_after_pthread.cpp
+++ b/tests/gl_in_mainthread_after_pthread.cpp
@@ -27,7 +27,7 @@ void *ThreadMain(void *arg)
   EmscriptenWebGLContextAttributes attr;
   emscripten_webgl_init_context_attributes(&attr);
   attr.explicitSwapControl = EM_TRUE;
-  ctx = emscripten_webgl_create_context(0, &attr);
+  ctx = emscripten_webgl_create_context("#canvas", &attr);
   emscripten_webgl_make_context_current(ctx);
 
   double color = 0;
@@ -103,7 +103,7 @@ void PollThreadExit(void *)
 #ifdef TEST_MAIN_THREAD_EXPLICIT_COMMIT
     attr.explicitSwapControl = EM_TRUE;
 #endif
-    ctx = emscripten_webgl_create_context(0, &attr);
+    ctx = emscripten_webgl_create_context("#canvas", &attr);
     emscripten_webgl_make_context_current(ctx);
     printf("Main thread rendering. You should see the WebGL canvas fade from black to green.\n");
     emscripten_set_main_loop(MainThreadRender, 0, 0);
diff --git a/tests/gl_in_proxy_pthread.cpp b/tests/gl_in_proxy_pthread.cpp
index c4a66676b6766..57a4931cff0ca 100644
--- a/tests/gl_in_proxy_pthread.cpp
+++ b/tests/gl_in_proxy_pthread.cpp
@@ -33,7 +33,7 @@ int main()
   EmscriptenWebGLContextAttributes attr;
   emscripten_webgl_init_context_attributes(&attr);
   attr.explicitSwapControl = EM_TRUE;
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(0, &attr);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context("#canvas", &attr);
   printf("Created context with handle %u\n", (unsigned int)ctx);
   emscripten_webgl_make_context_current(ctx);
 
diff --git a/tests/gl_in_pthread.cpp b/tests/gl_in_pthread.cpp
index d878ec9b34d4c..c3238537871e7 100644
--- a/tests/gl_in_pthread.cpp
+++ b/tests/gl_in_pthread.cpp
@@ -35,7 +35,7 @@ void *ThreadMain(void *arg)
   EmscriptenWebGLContextAttributes attr;
   emscripten_webgl_init_context_attributes(&attr);
   attr.explicitSwapControl = EM_TRUE;
-  ctx = emscripten_webgl_create_context(0, &attr);
+  ctx = emscripten_webgl_create_context("#canvas", &attr);
   emscripten_webgl_make_context_current(ctx);
 
   double color = 0;
diff --git a/tests/gl_in_two_pthreads.cpp b/tests/gl_in_two_pthreads.cpp
index 6ed86201d9275..692e03dddfb2f 100644
--- a/tests/gl_in_two_pthreads.cpp
+++ b/tests/gl_in_two_pthreads.cpp
@@ -76,7 +76,7 @@ int main()
   EmscriptenWebGLContextAttributes attr;
   emscripten_webgl_init_context_attributes(&attr);
   attr.explicitSwapControl = EM_TRUE;
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(0, &attr);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context("#canvas", &attr);
   assert(ctx);
 
   // Activate it
diff --git a/tests/gl_only_in_pthread.cpp b/tests/gl_only_in_pthread.cpp
index b396a8badef19..785715d9cb783 100644
--- a/tests/gl_only_in_pthread.cpp
+++ b/tests/gl_only_in_pthread.cpp
@@ -27,7 +27,7 @@ void *ThreadMain(void *arg)
   EmscriptenWebGLContextAttributes attr;
   emscripten_webgl_init_context_attributes(&attr);
   attr.explicitSwapControl = EM_TRUE;
-  ctx = emscripten_webgl_create_context(0, &attr);
+  ctx = emscripten_webgl_create_context("#canvas", &attr);
   emscripten_webgl_make_context_current(ctx);
 
   double color = 0;
diff --git a/tests/gl_textures.cpp b/tests/gl_textures.cpp
index 1f2f9b7e37326..1b68b3fd3f5a3 100644
--- a/tests/gl_textures.cpp
+++ b/tests/gl_textures.cpp
@@ -65,7 +65,7 @@ int main()
   attr.premultipliedAlpha = 0;
   attr.majorVersion = 1;
   attr.minorVersion = 0;
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(0, &attr);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context("#canvas", &attr);
   emscripten_webgl_make_context_current(ctx);
   GLuint vs = glCreateShader(GL_VERTEX_SHADER);
   const char *vss = "attribute vec4 vPosition; uniform mat4 mat; varying vec2 texCoord; void main() { gl_Position = vPosition; texCoord = (vPosition.xy + vec2(1.0)) * vec2(0.5); }";
diff --git a/tests/html5_callbacks_on_calling_thread.c b/tests/html5_callbacks_on_calling_thread.c
index e9461d0255e4b..c1bd4b2bfa4ef 100644
--- a/tests/html5_callbacks_on_calling_thread.c
+++ b/tests/html5_callbacks_on_calling_thread.c
@@ -41,7 +41,7 @@ void *threadMain(void *arg)
 {
   registeringThreadId = pthread_self();
 
-  EMSCRIPTEN_RESULT ret = emscripten_set_mousemove_callback(0, (void*)0x42, 1, mouse_callback);
+  EMSCRIPTEN_RESULT ret = emscripten_set_mousemove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, (void*)0x42, 1, mouse_callback);
   assert(ret == EMSCRIPTEN_RESULT_SUCCESS);
 
   printf("Please move the mouse cursor.\n");
diff --git a/tests/preinitialized_webgl_context.cpp b/tests/preinitialized_webgl_context.cpp
index 6545157b76e66..7851add28d021 100644
--- a/tests/preinitialized_webgl_context.cpp
+++ b/tests/preinitialized_webgl_context.cpp
@@ -12,7 +12,7 @@ int main()
 {
   EmscriptenWebGLContextAttributes attrs;
   emscripten_webgl_init_context_attributes(&attrs);
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(0, &attrs);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context("#canvas", &attrs);
   assert(context);
   EMSCRIPTEN_RESULT res = emscripten_webgl_make_context_current(context);
   assert(res >= 0);
diff --git a/tests/resize_offscreencanvas_from_main_thread.cpp b/tests/resize_offscreencanvas_from_main_thread.cpp
index 51d349f0585dc..0c07de52f6d9f 100644
--- a/tests/resize_offscreencanvas_from_main_thread.cpp
+++ b/tests/resize_offscreencanvas_from_main_thread.cpp
@@ -40,7 +40,7 @@ void *thread_main(void *arg)
   EmscriptenWebGLContextAttributes attr;
   emscripten_webgl_init_context_attributes(&attr);
   attr.explicitSwapControl = EM_TRUE;
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(0, &attr);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context("#canvas", &attr);
   assert(ctx);
 
   // To start off, change the size of the OffscreenCanvas, main thread will test that it sees this change.
diff --git a/tests/test_browser.py b/tests/test_browser.py
index b64359842cb60..b783c9f1c101a 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -2512,13 +2512,13 @@ def test_doublestart_bug(self):
   def test_html5(self):
     for opts in [[], ['-O2', '-g1', '--closure', '1'], ['-s', 'USE_PTHREADS=1', '-s', 'PROXY_TO_PTHREAD=1']]:
       print(opts)
-      self.btest(path_from_root('tests', 'test_html5.c'), args=opts, expected='0', timeout=20)
+      self.btest(path_from_root('tests', 'test_html5.c'), args=['-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1'] + opts, expected='0', timeout=20)
 
   @requires_threads
   def test_html5_gamepad(self):
     for opts in [[], ['-O2', '-g1', '--closure', '1'], ['-s', 'USE_PTHREADS=1', '-s', 'PROXY_TO_PTHREAD=1']]:
       print(opts)
-      self.btest(path_from_root('tests', 'test_gamepad.c'), args=opts, expected='0', timeout=20)
+      self.btest(path_from_root('tests', 'test_gamepad.c'), args=['-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1'] + opts, expected='0', timeout=20)
 
   @requires_graphics_hardware
   def test_html5_webgl_create_context_no_antialias(self):
@@ -2543,7 +2543,7 @@ def test_html5_webgl_create_context2(self):
   def test_html5_webgl_destroy_context(self):
     for opts in [[], ['-O2', '-g1'], ['-s', 'FULL_ES2=1']]:
       print(opts)
-      self.btest(path_from_root('tests', 'webgl_destroy_context.cpp'), args=opts + ['--shell-file', path_from_root('tests/webgl_destroy_context_shell.html'), '-lGL'], expected='0', timeout=20)
+      self.btest(path_from_root('tests', 'webgl_destroy_context.cpp'), args=opts + ['-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1', '--shell-file', path_from_root('tests/webgl_destroy_context_shell.html'), '-lGL'], expected='0', timeout=20)
 
   @no_chrome('see #7373')
   @requires_graphics_hardware
@@ -2599,7 +2599,7 @@ def test_sdl_touch(self):
   def test_html5_mouse(self):
     for opts in [[], ['-O2', '-g1', '--closure', '1']]:
       print(opts)
-      self.btest(path_from_root('tests', 'test_html5_mouse.c'), args=opts + ['-DAUTOMATE_SUCCESS=1'], expected='0')
+      self.btest(path_from_root('tests', 'test_html5_mouse.c'), args=opts + ['-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1', '-DAUTOMATE_SUCCESS=1'], expected='0')
 
   def test_sdl_mousewheel(self):
     for opts in [[], ['-O2', '-g1', '--closure', '1']]:
@@ -4017,7 +4017,7 @@ def test_TextDecoder(self):
   @requires_threads
   def test_webgl_offscreen_canvas_in_pthread(self):
     for args in [[], ['-DTEST_CHAINED_WEBGL_CONTEXT_PASSING']]:
-      self.btest('gl_in_pthread.cpp', expected='1', args=args + ['-s', 'USE_PTHREADS=1', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL'])
+      self.btest('gl_in_pthread.cpp', expected='1', args=args + ['-s', 'USE_PTHREADS=1', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL', '-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1'])
 
   # Tests that it is possible to render WebGL content on a <canvas> on the main thread, after it has once been used to render WebGL content in a pthread first
   # -DTEST_MAIN_THREAD_EXPLICIT_COMMIT: Test the same (WebGL on main thread after pthread), but by using explicit .commit() to swap on the main thread instead of implicit "swap when rAF ends" logic
@@ -4025,12 +4025,12 @@ def test_webgl_offscreen_canvas_in_pthread(self):
   @requires_threads
   def test_webgl_offscreen_canvas_in_mainthread_after_pthread(self):
     for args in [[], ['-DTEST_MAIN_THREAD_EXPLICIT_COMMIT']]:
-      self.btest('gl_in_mainthread_after_pthread.cpp', expected='0', args=args + ['-s', 'USE_PTHREADS=1', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL'])
+      self.btest('gl_in_mainthread_after_pthread.cpp', expected='0', args=args + ['-s', 'USE_PTHREADS=1', '-s', 'PTHREAD_POOL_SIZE=2', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL', '-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1'])
 
   @no_chrome('see #7374')
   @requires_threads
   def test_webgl_offscreen_canvas_only_in_pthread(self):
-    self.btest('gl_only_in_pthread.cpp', expected='0', args=['-s', 'USE_PTHREADS=1', '-s', 'PTHREAD_POOL_SIZE=1', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL'])
+    self.btest('gl_only_in_pthread.cpp', expected='0', args=['-s', 'USE_PTHREADS=1', '-s', 'PTHREAD_POOL_SIZE=1', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL', '-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1'])
 
   # Tests that rendering from client side memory without default-enabling extensions works.
   @requires_graphics_hardware
@@ -4064,12 +4064,10 @@ def test_webgl_workaround_webgl_uniform_upload_bug(self):
   # Tests that if a WebGL context is created in a pthread on a canvas that has not been transferred to that pthread, WebGL calls are then proxied to the main thread
   # -DTEST_OFFSCREEN_CANVAS=1: Tests that if a WebGL context is created on a pthread that has the canvas transferred to it via using Emscripten's EMSCRIPTEN_PTHREAD_TRANSFERRED_CANVASES="#canvas", then OffscreenCanvas is used
   # -DTEST_OFFSCREEN_CANVAS=2: Tests that if a WebGL context is created on a pthread that has the canvas transferred to it via automatic transferring of Module.canvas when EMSCRIPTEN_PTHREAD_TRANSFERRED_CANVASES is not defined, then OffscreenCanvas is also used
-  @requires_threads
-  @requires_graphics_hardware
   @no_chrome('see #7374')
   def test_webgl_offscreen_canvas_in_proxied_pthread(self):
     for args in [[], ['-DTEST_OFFSCREEN_CANVAS=1'], ['-DTEST_OFFSCREEN_CANVAS=2']]:
-      cmd = args + ['-s', 'USE_PTHREADS=1', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL', '-s', 'GL_DEBUG=1', '-s', 'PROXY_TO_PTHREAD=1']
+      cmd = args + ['-s', 'USE_PTHREADS=1', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL', '-s', 'GL_DEBUG=1', '-s', 'PROXY_TO_PTHREAD=1', '-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1']
       print(str(cmd))
       self.btest('gl_in_proxy_pthread.cpp', expected='1', args=cmd)
 
@@ -4079,7 +4077,7 @@ def test_webgl_offscreen_canvas_in_proxied_pthread(self):
   def test_webgl_resize_offscreencanvas_from_main_thread(self):
     for args1 in [[], ['-s', 'PROXY_TO_PTHREAD=1']]:
       for args2 in [[], ['-DTEST_SYNC_BLOCKING_LOOP=1']]:
-        cmd = args1 + args2 + ['-s', 'USE_PTHREADS=1', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL', '-s', 'GL_DEBUG=1']
+        cmd = args1 + args2 + ['-s', 'USE_PTHREADS=1', '-s', 'OFFSCREENCANVAS_SUPPORT=1', '-lGL', '-s', 'GL_DEBUG=1', '-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1']
         print(str(cmd))
         self.btest('resize_offscreencanvas_from_main_thread.cpp', expected='1', args=cmd)
 
diff --git a/tests/test_html5.c b/tests/test_html5.c
index 039cc263a13af..7e769034707c2 100644
--- a/tests/test_html5.c
+++ b/tests/test_html5.c
@@ -243,47 +243,47 @@ void report_result(void *arg)
 int main()
 {
 
-  EMSCRIPTEN_RESULT ret = emscripten_set_keypress_callback(0, 0, 1, key_callback);
+  EMSCRIPTEN_RESULT ret = emscripten_set_keypress_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, key_callback);
   TEST_RESULT(emscripten_set_keypress_callback);
-  ret = emscripten_set_keydown_callback(0, 0, 1, key_callback);
+  ret = emscripten_set_keydown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, key_callback);
   TEST_RESULT(emscripten_set_keydown_callback);
-  ret = emscripten_set_keyup_callback(0, 0, 1, key_callback);
+  ret = emscripten_set_keyup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, key_callback);
   TEST_RESULT(emscripten_set_keyup_callback);
 
-  ret = emscripten_set_click_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_click_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_click_callback);
-  ret = emscripten_set_mousedown_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mousedown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mousedown_callback);
-  ret = emscripten_set_mouseup_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mouseup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mouseup_callback);
-  ret = emscripten_set_dblclick_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_dblclick_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_dblclick_callback);
-  ret = emscripten_set_mousemove_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mousemove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mousemove_callback);
-  ret = emscripten_set_mouseenter_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mouseenter_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mouseenter_callback);
-  ret = emscripten_set_mouseleave_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mouseleave_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mouseleave_callback);
-  ret = emscripten_set_mouseover_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mouseover_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mouseover_callback);
-  ret = emscripten_set_mouseout_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mouseout_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mouseout_callback);
 
-  ret = emscripten_set_wheel_callback(0, 0, 1, wheel_callback);
+  ret = emscripten_set_wheel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, wheel_callback);
   TEST_RESULT(emscripten_set_wheel_callback);
 
-  ret = emscripten_set_resize_callback(0, 0, 1, uievent_callback);
+  ret = emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, uievent_callback);
   TEST_RESULT(emscripten_set_resize_callback);
-  ret = emscripten_set_scroll_callback(0, 0, 1, uievent_callback);
+  ret = emscripten_set_scroll_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, 0, 1, uievent_callback);
   TEST_RESULT(emscripten_set_scroll_callback);
 
-  ret = emscripten_set_blur_callback(0, 0, 1, focusevent_callback);
+  ret = emscripten_set_blur_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, focusevent_callback);
   TEST_RESULT(emscripten_set_blur_callback);
-  ret = emscripten_set_focus_callback(0, 0, 1, focusevent_callback);
+  ret = emscripten_set_focus_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, focusevent_callback);
   TEST_RESULT(emscripten_set_focus_callback);
-  ret = emscripten_set_focusin_callback(0, 0, 1, focusevent_callback);
+  ret = emscripten_set_focusin_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, focusevent_callback);
   TEST_RESULT(emscripten_set_focusin_callback);
-  ret = emscripten_set_focusout_callback(0, 0, 1, focusevent_callback);
+  ret = emscripten_set_focusout_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, focusevent_callback);
   TEST_RESULT(emscripten_set_focusout_callback);
 
   ret = emscripten_set_deviceorientation_callback(0, 1, deviceorientation_callback);
@@ -333,12 +333,12 @@ int main()
     fullscreenchange_callback(EMSCRIPTEN_EVENT_FULLSCREENCHANGE, &fsce, 0);
   }
 
-  ret = emscripten_set_fullscreenchange_callback(0, 0, 1, fullscreenchange_callback);
+  ret = emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, 0, 1, fullscreenchange_callback);
   TEST_RESULT(emscripten_set_fullscreenchange_callback);
 
   // These won't do anything, since fullscreen must be requested in an event handler,
   // but call these anyways to confirm that they don't crash in an exception in the test suite.
-  ret = emscripten_request_fullscreen(0, 1);
+  ret = emscripten_request_fullscreen("#canvas", 1);
   TEST_RESULT(emscripten_request_fullscreen);
   ret = emscripten_exit_fullscreen();
   TEST_RESULT(emscripten_exit_fullscreen);
@@ -351,12 +351,12 @@ int main()
     pointerlockchange_callback(EMSCRIPTEN_EVENT_POINTERLOCKCHANGE, &plce, 0);
   }
 
-  ret = emscripten_set_pointerlockchange_callback(0, 0, 1, pointerlockchange_callback);
+  ret = emscripten_set_pointerlockchange_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, 0, 1, pointerlockchange_callback);
   TEST_RESULT(emscripten_set_pointerlockchange_callback);
 
   // These won't do anything, since pointer lock must be requested in an event handler,
   // but call these anyways to confirm that they don't crash in an exception in the test suite.
-  ret = emscripten_request_pointerlock(0, 1);
+  ret = emscripten_request_pointerlock("#canvas", 1);
   TEST_RESULT(emscripten_request_pointerlock);
   ret = emscripten_exit_pointerlock();
   TEST_RESULT(emscripten_exit_pointerlock);
@@ -380,13 +380,13 @@ int main()
   ret = emscripten_set_visibilitychange_callback(0, 1, visibilitychange_callback);
   TEST_RESULT(emscripten_set_visibilitychange_callback);
 
-  ret = emscripten_set_touchstart_callback(0, 0, 1, touch_callback);
+  ret = emscripten_set_touchstart_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, touch_callback);
   TEST_RESULT(emscripten_set_touchstart_callback);
-  ret = emscripten_set_touchend_callback(0, 0, 1, touch_callback);
+  ret = emscripten_set_touchend_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, touch_callback);
   TEST_RESULT(emscripten_set_touchend_callback);
-  ret = emscripten_set_touchmove_callback(0, 0, 1, touch_callback);
+  ret = emscripten_set_touchmove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, touch_callback);
   TEST_RESULT(emscripten_set_touchmove_callback);
-  ret = emscripten_set_touchcancel_callback(0, 0, 1, touch_callback);
+  ret = emscripten_set_touchcancel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, touch_callback);
   TEST_RESULT(emscripten_set_touchcancel_callback);
 
   ret = emscripten_set_beforeunload_callback(0, beforeunload_callback);
@@ -405,9 +405,9 @@ int main()
     battery_callback(EMSCRIPTEN_EVENT_BATTERYLEVELCHANGE, &bs, 0);
   }
 
-  ret = emscripten_set_webglcontextlost_callback(0, 0, 1, webglcontext_callback);
+  ret = emscripten_set_webglcontextlost_callback("#canvas", 0, 1, webglcontext_callback);
   TEST_RESULT(emscripten_set_webglcontextlost_callback);
-  ret = emscripten_set_webglcontextrestored_callback(0, 0, 1, webglcontext_callback);
+  ret = emscripten_set_webglcontextrestored_callback("#canvas", 0, 1, webglcontext_callback);
   TEST_RESULT(emscripten_set_webglcontextrestored_callback);
 
   /* For the events to function, one must either call emscripten_set_main_loop or enable Module.noExitRuntime by some other means. 
diff --git a/tests/test_html5_fullscreen.c b/tests/test_html5_fullscreen.c
index e3cafb89fa102..ead06e2fe783b 100644
--- a/tests/test_html5_fullscreen.c
+++ b/tests/test_html5_fullscreen.c
@@ -193,7 +193,7 @@ int main()
   attr.premultipliedAlpha = 0;
   attr.majorVersion = 1;
   attr.minorVersion = 0;
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(0, &attr);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context("#canvas", &attr);
   emscripten_webgl_make_context_current(ctx);
   GLuint vs = glCreateShader(GL_VERTEX_SHADER);
   const char *vss = "attribute vec4 vPosition; uniform mat4 mat; void main() { gl_Position = mat * vPosition; }";
@@ -219,42 +219,42 @@ int main()
   glVertexAttribPointer(0, 3, GL_FLOAT, 0, 0, 0);
   glEnableVertexAttribArray(0);
 
-  EMSCRIPTEN_RESULT ret = emscripten_set_keypress_callback(0, 0, 1, key_callback);
+  EMSCRIPTEN_RESULT ret = emscripten_set_keypress_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, key_callback);
   TEST_RESULT(emscripten_set_keypress_callback);
 
-  ret = emscripten_set_fullscreenchange_callback(0, 0, 1, fullscreenchange_callback);
+  ret = emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, 0, 1, fullscreenchange_callback);
   TEST_RESULT(emscripten_set_fullscreenchange_callback);
 
   // For Internet Explorer, fullscreen and pointer lock requests cannot be run
   // from inside keyboard event handlers. Therefore we must register a callback to
   // mouse events (any other than mousedown) to activate deferred fullscreen/pointerlock
   // requests to occur for IE. The callback itself can be a no-op.
-  ret = emscripten_set_click_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_click_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_click_callback);
-  ret = emscripten_set_mousedown_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mousedown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mousedown_callback);
-  ret = emscripten_set_mouseup_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mouseup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mouseup_callback);
-  ret = emscripten_set_dblclick_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_dblclick_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_dblclick_callback);
 
-  emscripten_set_click_callback("b0", (void*)0, 1, on_button_click);
-  emscripten_set_click_callback("b1", (void*)1, 1, on_button_click);
-  emscripten_set_click_callback("b2", (void*)2, 1, on_button_click);
-  emscripten_set_click_callback("b3", (void*)3, 1, on_button_click);
-  emscripten_set_click_callback("b4", (void*)4, 1, on_button_click);
-  emscripten_set_click_callback("b5", (void*)5, 1, on_button_click);
-  emscripten_set_click_callback("b6", (void*)6, 1, on_button_click);
-  emscripten_set_click_callback("b7", (void*)7, 1, on_button_click);
-  emscripten_set_click_callback("b8", (void*)8, 1, on_button_click);
-  emscripten_set_click_callback("b9", (void*)9, 1, on_button_click);
-  emscripten_set_click_callback("b10", (void*)10, 1, on_button_click);
-  emscripten_set_click_callback("b11", (void*)11, 1, on_button_click);
-  emscripten_set_click_callback("b12", (void*)12, 1, on_button_click);
-  emscripten_set_click_callback("b13", (void*)13, 1, on_button_click);
-  emscripten_set_click_callback("b14", (void*)14, 1, on_button_click);
-  emscripten_set_click_callback("b15", (void*)15, 1, on_button_click);
-  emscripten_set_click_callback("b16", (void*)16, 1, on_button_click);
+  emscripten_set_click_callback("#b0", (void*)0, 1, on_button_click);
+  emscripten_set_click_callback("#b1", (void*)1, 1, on_button_click);
+  emscripten_set_click_callback("#b2", (void*)2, 1, on_button_click);
+  emscripten_set_click_callback("#b3", (void*)3, 1, on_button_click);
+  emscripten_set_click_callback("#b4", (void*)4, 1, on_button_click);
+  emscripten_set_click_callback("#b5", (void*)5, 1, on_button_click);
+  emscripten_set_click_callback("#b6", (void*)6, 1, on_button_click);
+  emscripten_set_click_callback("#b7", (void*)7, 1, on_button_click);
+  emscripten_set_click_callback("#b8", (void*)8, 1, on_button_click);
+  emscripten_set_click_callback("#b9", (void*)9, 1, on_button_click);
+  emscripten_set_click_callback("#b10", (void*)10, 1, on_button_click);
+  emscripten_set_click_callback("#b11", (void*)11, 1, on_button_click);
+  emscripten_set_click_callback("#b12", (void*)12, 1, on_button_click);
+  emscripten_set_click_callback("#b13", (void*)13, 1, on_button_click);
+  emscripten_set_click_callback("#b14", (void*)14, 1, on_button_click);
+  emscripten_set_click_callback("#b15", (void*)15, 1, on_button_click);
+  emscripten_set_click_callback("#b16", (void*)16, 1, on_button_click);
 
   printf("To finish this test, press f to enter fullscreen mode, and then exit it.\n");
   printf("On IE, press a mouse key over the canvas after pressing f to activate the fullscreen request event.\n");
diff --git a/tests/test_html5_mouse.c b/tests/test_html5_mouse.c
index 661a84674cc0d..08dacce33eec6 100644
--- a/tests/test_html5_mouse.c
+++ b/tests/test_html5_mouse.c
@@ -69,12 +69,12 @@ void instruction()
 
 EM_BOOL mouse_callback(int eventType, const EmscriptenMouseEvent *e, void *userData)
 {
-  printf("%s, screen: (%ld,%ld), client: (%ld,%ld),%s%s%s%s button: %hu, buttons: %hu, movement: (%ld,%ld), canvas: (%ld,%ld), target: (%ld, %ld)\n",
+  printf("%s, screen: (%ld,%ld), client: (%ld,%ld),%s%s%s%s button: %hu, buttons: %hu, movement: (%ld,%ld), target: (%ld, %ld)\n",
     emscripten_event_type_to_string(eventType), e->screenX, e->screenY, e->clientX, e->clientY,
     e->ctrlKey ? " CTRL" : "", e->shiftKey ? " SHIFT" : "", e->altKey ? " ALT" : "", e->metaKey ? " META" : "", 
-    e->button, e->buttons, e->movementX, e->movementY, e->canvasX, e->canvasY, e->targetX, e->targetY);
+    e->button, e->buttons, e->movementX, e->movementY, e->targetX, e->targetY);
 
-  if (e->screenX != 0 && e->screenY != 0 && e->clientX != 0 && e->clientY != 0 && e->canvasX != 0 && e->canvasY != 0 && e->targetX != 0 && e->targetY != 0)
+  if (e->screenX != 0 && e->screenY != 0 && e->clientX != 0 && e->clientY != 0 && e->targetX != 0 && e->targetY != 0)
   {
     if (eventType == EMSCRIPTEN_EVENT_CLICK) gotClick = 1;
     if (eventType == EMSCRIPTEN_EVENT_MOUSEDOWN && e->buttons != 0) gotMouseDown = 1;
@@ -96,10 +96,10 @@ EM_BOOL mouse_callback(int eventType, const EmscriptenMouseEvent *e, void *userD
 
 EM_BOOL wheel_callback(int eventType, const EmscriptenWheelEvent *e, void *userData)
 {
-  printf("%s, screen: (%ld,%ld), client: (%ld,%ld),%s%s%s%s button: %hu, buttons: %hu, canvas: (%ld,%ld), target: (%ld, %ld), delta:(%g,%g,%g), deltaMode:%lu\n",
+  printf("%s, screen: (%ld,%ld), client: (%ld,%ld),%s%s%s%s button: %hu, buttons: %hu, target: (%ld, %ld), delta:(%g,%g,%g), deltaMode:%lu\n",
     emscripten_event_type_to_string(eventType), e->mouse.screenX, e->mouse.screenY, e->mouse.clientX, e->mouse.clientY,
     e->mouse.ctrlKey ? " CTRL" : "", e->mouse.shiftKey ? " SHIFT" : "", e->mouse.altKey ? " ALT" : "", e->mouse.metaKey ? " META" : "", 
-    e->mouse.button, e->mouse.buttons, e->mouse.canvasX, e->mouse.canvasY, e->mouse.targetX, e->mouse.targetY,
+    e->mouse.button, e->mouse.buttons, e->mouse.targetX, e->mouse.targetY,
     (float)e->deltaX, (float)e->deltaY, (float)e->deltaZ, e->deltaMode);
 
   if (e->deltaY > 0.f || e->deltaY < 0.f)
@@ -115,18 +115,18 @@ int main()
   emscripten_set_canvas_element_size("#canvas", 400, 300);
   EM_ASM(Module['canvas'].style.backgroundColor = 'black';);
 
-  EMSCRIPTEN_RESULT ret = emscripten_set_click_callback(0, 0, 1, mouse_callback);
+  EMSCRIPTEN_RESULT ret = emscripten_set_click_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_click_callback);
-  ret = emscripten_set_mousedown_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mousedown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mousedown_callback);
-  ret = emscripten_set_mouseup_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mouseup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mouseup_callback);
-  ret = emscripten_set_dblclick_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_dblclick_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_dblclick_callback);
-  ret = emscripten_set_mousemove_callback(0, 0, 1, mouse_callback);
+  ret = emscripten_set_mousemove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, mouse_callback);
   TEST_RESULT(emscripten_set_mousemove_callback);
 
-  ret = emscripten_set_wheel_callback(0, 0, 1, wheel_callback);
+  ret = emscripten_set_wheel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, wheel_callback);
   TEST_RESULT(emscripten_set_wheel_callback);
 
 #ifdef AUTOMATE_SUCCESS
@@ -153,7 +153,7 @@ int main()
   }
 
   // Test that unregistering a callback works. Clicks should no longer be received.
-  ret = emscripten_set_click_callback(0, 0, 1, 0);
+  ret = emscripten_set_click_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, 0);
   TEST_RESULT(emscripten_set_click_callback);
 
   EM_ASM(
diff --git a/tests/test_html5_pointerlockerror.c b/tests/test_html5_pointerlockerror.c
index cb7ae7dadbf0d..fad65a5516f2f 100644
--- a/tests/test_html5_pointerlockerror.c
+++ b/tests/test_html5_pointerlockerror.c
@@ -87,11 +87,11 @@ int main()
   emscripten_set_canvas_element_size( "#canvas", 400, 300 );
   EM_ASM(Module['canvas'].style.backgroundColor = 'black';);
 
-  EMSCRIPTEN_RESULT ret = emscripten_set_click_callback(0, 0, 1, click_callback);
+  EMSCRIPTEN_RESULT ret = emscripten_set_click_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, click_callback);
   TEST_RESULT(emscripten_set_click_callback);
-  ret = emscripten_set_pointerlockchange_callback("#window", 0, 1, pointerlockchange_callback);
+  ret = emscripten_set_pointerlockchange_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, pointerlockchange_callback);
   TEST_RESULT(emscripten_set_pointerlockchange_callback);
-  ret = emscripten_set_pointerlockerror_callback("#window", 0, 1, pointerlockerror_callback);
+  ret = emscripten_set_pointerlockerror_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, pointerlockerror_callback);
   TEST_RESULT(emscripten_set_pointerlockerror_callback);
 
   /* For the events to function, one must either call emscripten_set_main_loop or enable Module.noExitRuntime by some other means. 
diff --git a/tests/test_interactive.py b/tests/test_interactive.py
index f9e8aabbb4fc6..4090e95610225 100644
--- a/tests/test_interactive.py
+++ b/tests/test_interactive.py
@@ -24,13 +24,13 @@ def setUpClass(self):
     print()
 
   def test_html5_fullscreen(self):
-    self.btest(path_from_root('tests', 'test_html5_fullscreen.c'), expected='0', args=['-s', 'EXPORTED_FUNCTIONS=["_requestFullscreen","_enterSoftFullscreen","_main"]', '--shell-file', path_from_root('tests', 'test_html5_fullscreen.html')])
+    self.btest(path_from_root('tests', 'test_html5_fullscreen.c'), expected='0', args=['-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1', '-s', 'EXPORTED_FUNCTIONS=["_requestFullscreen","_enterSoftFullscreen","_main"]', '--shell-file', path_from_root('tests', 'test_html5_fullscreen.html')])
 
   def test_html5_mouse(self):
-    self.btest(path_from_root('tests', 'test_html5_mouse.c'), expected='0')
+    self.btest(path_from_root('tests', 'test_html5_mouse.c'), expected='0', args=['-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1'])
 
   def test_html5_pointerlockerror(self):
-    self.btest(path_from_root('tests', 'test_html5_pointerlockerror.c'), expected='0')
+    self.btest(path_from_root('tests', 'test_html5_pointerlockerror.c'), expected='0', args=['-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1'])
 
   def test_sdl_mousewheel(self):
     self.btest(path_from_root('tests', 'test_sdl_mousewheel.c'), expected='0')
@@ -211,7 +211,7 @@ def test_threadprofiler(self):
   def test_html5_callbacks_on_calling_thread(self):
     # TODO: Make this automatic by injecting mouse event in e.g. shell html file.
     for args in [[], ['-DTEST_SYNC_BLOCKING_LOOP=1']]:
-      self.btest('html5_callbacks_on_calling_thread.c', expected='1', args=args + ['-s', 'USE_PTHREADS=1', '-s', 'PROXY_TO_PTHREAD=1'])
+      self.btest('html5_callbacks_on_calling_thread.c', expected='1', args=args + ['-s', 'DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1', '-s', 'USE_PTHREADS=1', '-s', 'PROXY_TO_PTHREAD=1'])
 
   # Test that it is possible to register HTML5 event callbacks on either main browser thread, or application main thread,
   # and that the application can manually proxy the event from main browser thread to the application main thread, to
diff --git a/tests/test_keyboard_codes.c b/tests/test_keyboard_codes.c
index 9c29c2787c191..743c8f14bf82c 100644
--- a/tests/test_keyboard_codes.c
+++ b/tests/test_keyboard_codes.c
@@ -76,8 +76,8 @@ EM_BOOL key_callback(int eventType, const EmscriptenKeyboardEvent *e, void *user
 int main()
 {
   printf("Press any keys on the keyboard to test the appropriate generated EmscriptenKeyboardEvent structure.\n");
-  emscripten_set_keydown_callback(0, 0, 1, key_callback);
-  emscripten_set_keyup_callback(0, 0, 1, key_callback);
-  emscripten_set_keypress_callback(0, 0, 1, key_callback);
+  emscripten_set_keydown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, key_callback);
+  emscripten_set_keyup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, key_callback);
+  emscripten_set_keypress_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, 0, 1, key_callback);
   EM_ASM(Module['noExitRuntime'] = true);
 }
diff --git a/tests/test_other.py b/tests/test_other.py
index 54dba4ba3e48a..41bad66205112 100644
--- a/tests/test_other.py
+++ b/tests/test_other.py
@@ -7930,7 +7930,7 @@ def test_binaryen_metadce_hello(self):
                    0, [],        [],           8,   0,    0,  0), # noqa; totally empty!
         # we don't metadce with linkable code! other modules may want stuff
         (['-O3', '-s', 'MAIN_MODULE=1'],
-                1556, [],        [],      226057,  28,   75, None), # noqa; don't compare the # of functions in a main module, which changes a lot
+                1558, [],        [],      226057,  28,   75, None), # noqa; don't compare the # of functions in a main module, which changes a lot
       ]) # noqa
 
   # ensures runtime exports work, even with metadce
@@ -8885,8 +8885,8 @@ def test_minimal_runtime_code_size(self):
     test_cases = [
       (asmjs + opts, hello_world_sources, {'a.html': 665, 'a.js': 289, 'a.asm.js': 113, 'a.mem': 6}),
       (opts, hello_world_sources, {'a.html': 623, 'a.js': 624, 'a.wasm': 86}),
-      (asmjs + opts, hello_webgl_sources, {'a.html': 665, 'a.js': 5307, 'a.asm.js': 10932, 'a.mem': 321}),
-      (opts, hello_webgl_sources, {'a.html': 623, 'a.js': 5380, 'a.wasm': 8978})
+      (asmjs + opts, hello_webgl_sources, {'a.html': 665, 'a.js': 5249, 'a.asm.js': 10965, 'a.mem': 321}),
+      (opts, hello_webgl_sources, {'a.html': 623, 'a.js': 5313, 'a.wasm': 8978})
     ]
 
     success = True
diff --git a/tests/webgl2.cpp b/tests/webgl2.cpp
index b8b58d64f2ab0..40736623fa036 100644
--- a/tests/webgl2.cpp
+++ b/tests/webgl2.cpp
@@ -29,7 +29,7 @@ int main()
 
   int result = 0;
 
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(0, &attrs);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context("#canvas", &attrs);
   if (context)
   {
     memset(&attrs, -1, sizeof(attrs));
diff --git a/tests/webgl2_backwards_compatibility_emulation.cpp b/tests/webgl2_backwards_compatibility_emulation.cpp
index f2cec2c2ce05d..cff395c0b3a1b 100644
--- a/tests/webgl2_backwards_compatibility_emulation.cpp
+++ b/tests/webgl2_backwards_compatibility_emulation.cpp
@@ -23,7 +23,7 @@ int main()
 
   int result = 0;
 
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(0, &attrs);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context("#canvas", &attrs);
   assert(context);
   EMSCRIPTEN_RESULT res = emscripten_webgl_make_context_current(context);
   assert(res == EMSCRIPTEN_RESULT_SUCCESS);
diff --git a/tests/webgl2_garbage_free_entrypoints.cpp b/tests/webgl2_garbage_free_entrypoints.cpp
index ad4199117a3ee..01423f2212d52 100644
--- a/tests/webgl2_garbage_free_entrypoints.cpp
+++ b/tests/webgl2_garbage_free_entrypoints.cpp
@@ -33,7 +33,7 @@ int main(int argc, char *argv[])
   attr.majorVersion = 1;
 #endif
   attr.minorVersion = 0;
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(0, &attr);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context("#canvas", &attr);
   emscripten_webgl_make_context_current(ctx);
 
   GLuint vs = CompileShader(GL_VERTEX_SHADER,
diff --git a/tests/webgl_color_buffer_readpixels.cpp b/tests/webgl_color_buffer_readpixels.cpp
index 95f156879a37e..20792d776f62a 100644
--- a/tests/webgl_color_buffer_readpixels.cpp
+++ b/tests/webgl_color_buffer_readpixels.cpp
@@ -21,7 +21,7 @@ int main()
   EmscriptenWebGLContextAttributes attrs;
   emscripten_webgl_init_context_attributes(&attrs);
   attrs.enableExtensionsByDefault = true;
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(0, &attrs);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context("#canvas", &attrs);
   emscripten_webgl_make_context_current(context);
 
   // Test what the return values of GL_IMPLEMENTATION_COLOR_READ_TYPE and GL_IMPLEMENTATION_COLOR_READ_FORMAT are.
diff --git a/tests/webgl_create_context.cpp b/tests/webgl_create_context.cpp
index 090d2f0bf0f33..6a9dcb4031b18 100644
--- a/tests/webgl_create_context.cpp
+++ b/tests/webgl_create_context.cpp
@@ -61,7 +61,7 @@ void loop()
       Module.canvas = canvas2;
     );
     assert(emscripten_webgl_get_current_context() == 0);
-    context = emscripten_webgl_create_context(0, &attrs);
+    context = emscripten_webgl_create_context("#canvas", &attrs);
 
     assert(context > 0); // Must have received a valid context.
     res = emscripten_webgl_make_context_current(context);
diff --git a/tests/webgl_create_context2.cpp b/tests/webgl_create_context2.cpp
index b979ed410267f..9403b106cb599 100644
--- a/tests/webgl_create_context2.cpp
+++ b/tests/webgl_create_context2.cpp
@@ -14,7 +14,7 @@ int main()
 {
   EmscriptenWebGLContextAttributes attrs;
   emscripten_webgl_init_context_attributes(&attrs);
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(0, &attrs);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context("#canvas", &attrs);
   assert(context > 0); // Must have received a valid context.
   EMSCRIPTEN_RESULT res = emscripten_webgl_make_context_current(context);
   assert(res == EMSCRIPTEN_RESULT_SUCCESS);
diff --git a/tests/webgl_destroy_context.cpp b/tests/webgl_destroy_context.cpp
index 48e05132df057..fada8aaae53c5 100644
--- a/tests/webgl_destroy_context.cpp
+++ b/tests/webgl_destroy_context.cpp
@@ -46,9 +46,9 @@ int main()
 {
   EmscriptenWebGLContextAttributes attrs;
   emscripten_webgl_init_context_attributes(&attrs);
-  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context(0, &attrs);
-  emscripten_set_webglcontextlost_callback(0, 0, 0, context_lost);
-  emscripten_set_webglcontextrestored_callback(0, 0, 0, context_restored);
+  EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context("#canvas", &attrs);
+  emscripten_set_webglcontextlost_callback("#canvas", 0, 0, context_lost);
+  emscripten_set_webglcontextrestored_callback("#canvas", 0, 0, context_restored);
   // When we force a context loss, we should get an event, i.e. context_lost_desired() should get called.
   EM_ASM({
       // The GL object is accessed here in a closure unsafe manner, so this test should not be run with closure enabled.