img function

ReactNode img({
  1. String? alt,
  2. String? src,
  3. String? srcset,
  4. String? sizes,
  5. String? crossOrigin,
  6. String? useMap,
  7. bool? isMap,
  8. int? width,
  9. int? height,
  10. String? referrerPolicy,
  11. String? decoding,
  12. String? loading,
  13. String? fetchPriority,
  14. String? title,
  15. String? lang,
  16. bool? translate,
  17. String? dir,
  18. Object? hidden,
  19. bool? inert,
  20. String? accessKey,
  21. bool? draggable,
  22. bool? spellcheck,
  23. String? writingSuggestions,
  24. String? autocapitalize,
  25. String? popover,
  26. String? id,
  27. String? className,
  28. String? slot,
  29. String? tabIndex,
  30. String? role,
  31. Map<String, Object?>? style,
  32. void onClick(
    1. ReactMouseEvent<EventTarget>
    )?,
  33. void onClickCapture(
    1. ReactMouseEvent<EventTarget>
    )?,
  34. void onDoubleClick(
    1. ReactMouseEvent<EventTarget>
    )?,
  35. void onDoubleClickCapture(
    1. ReactMouseEvent<EventTarget>
    )?,
  36. void onMouseDown(
    1. ReactMouseEvent<EventTarget>
    )?,
  37. void onMouseDownCapture(
    1. ReactMouseEvent<EventTarget>
    )?,
  38. void onMouseUp(
    1. ReactMouseEvent<EventTarget>
    )?,
  39. void onMouseUpCapture(
    1. ReactMouseEvent<EventTarget>
    )?,
  40. void onMouseMove(
    1. ReactMouseEvent<EventTarget>
    )?,
  41. void onMouseMoveCapture(
    1. ReactMouseEvent<EventTarget>
    )?,
  42. void onMouseEnter(
    1. ReactMouseEvent<EventTarget>
    )?,
  43. void onMouseEnterCapture(
    1. ReactMouseEvent<EventTarget>
    )?,
  44. void onMouseLeave(
    1. ReactMouseEvent<EventTarget>
    )?,
  45. void onMouseLeaveCapture(
    1. ReactMouseEvent<EventTarget>
    )?,
  46. void onInput(
    1. ReactInputEvent<EventTarget>
    )?,
  47. void onInputCapture(
    1. ReactInputEvent<EventTarget>
    )?,
  48. void onChange(
    1. ReactChangeEvent<EventTarget>
    )?,
  49. void onChangeCapture(
    1. ReactChangeEvent<EventTarget>
    )?,
  50. void onSubmit(
    1. ReactFormEvent<EventTarget>
    )?,
  51. void onSubmitCapture(
    1. ReactFormEvent<EventTarget>
    )?,
  52. void onKeyDown(
    1. ReactKeyboardEvent<EventTarget>
    )?,
  53. void onKeyDownCapture(
    1. ReactKeyboardEvent<EventTarget>
    )?,
  54. void onKeyUp(
    1. ReactKeyboardEvent<EventTarget>
    )?,
  55. void onKeyUpCapture(
    1. ReactKeyboardEvent<EventTarget>
    )?,
  56. void onFocus(
    1. ReactFocusEvent<EventTarget>
    )?,
  57. void onFocusCapture(
    1. ReactFocusEvent<EventTarget>
    )?,
  58. void onBlur(
    1. ReactFocusEvent<EventTarget>
    )?,
  59. void onBlurCapture(
    1. ReactFocusEvent<EventTarget>
    )?,
  60. void onPointerDown(
    1. ReactPointerEvent<EventTarget>
    )?,
  61. void onPointerDownCapture(
    1. ReactPointerEvent<EventTarget>
    )?,
  62. void onPointerUp(
    1. ReactPointerEvent<EventTarget>
    )?,
  63. void onPointerUpCapture(
    1. ReactPointerEvent<EventTarget>
    )?,
  64. void onPointerMove(
    1. ReactPointerEvent<EventTarget>
    )?,
  65. void onPointerMoveCapture(
    1. ReactPointerEvent<EventTarget>
    )?,
  66. void onTouchStart(
    1. ReactTouchEvent<EventTarget>
    )?,
  67. void onTouchStartCapture(
    1. ReactTouchEvent<EventTarget>
    )?,
  68. void onTouchEnd(
    1. ReactTouchEvent<EventTarget>
    )?,
  69. void onTouchEndCapture(
    1. ReactTouchEvent<EventTarget>
    )?,
  70. void onTouchMove(
    1. ReactTouchEvent<EventTarget>
    )?,
  71. void onTouchMoveCapture(
    1. ReactTouchEvent<EventTarget>
    )?,
  72. void onWheel(
    1. ReactWheelEvent<EventTarget>
    )?,
  73. void onWheelCapture(
    1. ReactWheelEvent<EventTarget>
    )?,
  74. void onDrag(
    1. ReactDragEvent<EventTarget>
    )?,
  75. void onDragCapture(
    1. ReactDragEvent<EventTarget>
    )?,
  76. void onDrop(
    1. ReactDragEvent<EventTarget>
    )?,
  77. void onDropCapture(
    1. ReactDragEvent<EventTarget>
    )?,
  78. void ref(
    1. HTMLImageElement?
    )?,
  79. String? key,
  80. Map<String, Object?> additionalProps = const {},
})

Implementation

ReactNode img({
  String? alt,
  String? src,
  String? srcset,
  String? sizes,
  String? crossOrigin,
  String? useMap,
  bool? isMap,
  int? width,
  int? height,
  String? referrerPolicy,
  String? decoding,
  String? loading,
  String? fetchPriority,
  String? title,
  String? lang,
  bool? translate,
  String? dir,
  Object? hidden,
  bool? inert,
  String? accessKey,
  bool? draggable,
  bool? spellcheck,
  String? writingSuggestions,
  String? autocapitalize,
  String? popover,
  String? id,
  String? className,
  String? slot,
  String? tabIndex,
  String? role,
  Map<String, Object?>? style,
  void Function(ReactMouseEvent)? onClick,
  void Function(ReactMouseEvent)? onClickCapture,
  void Function(ReactMouseEvent)? onDoubleClick,
  void Function(ReactMouseEvent)? onDoubleClickCapture,
  void Function(ReactMouseEvent)? onMouseDown,
  void Function(ReactMouseEvent)? onMouseDownCapture,
  void Function(ReactMouseEvent)? onMouseUp,
  void Function(ReactMouseEvent)? onMouseUpCapture,
  void Function(ReactMouseEvent)? onMouseMove,
  void Function(ReactMouseEvent)? onMouseMoveCapture,
  void Function(ReactMouseEvent)? onMouseEnter,
  void Function(ReactMouseEvent)? onMouseEnterCapture,
  void Function(ReactMouseEvent)? onMouseLeave,
  void Function(ReactMouseEvent)? onMouseLeaveCapture,
  void Function(ReactInputEvent)? onInput,
  void Function(ReactInputEvent)? onInputCapture,
  void Function(ReactChangeEvent)? onChange,
  void Function(ReactChangeEvent)? onChangeCapture,
  void Function(ReactFormEvent)? onSubmit,
  void Function(ReactFormEvent)? onSubmitCapture,
  void Function(ReactKeyboardEvent)? onKeyDown,
  void Function(ReactKeyboardEvent)? onKeyDownCapture,
  void Function(ReactKeyboardEvent)? onKeyUp,
  void Function(ReactKeyboardEvent)? onKeyUpCapture,
  void Function(ReactFocusEvent)? onFocus,
  void Function(ReactFocusEvent)? onFocusCapture,
  void Function(ReactFocusEvent)? onBlur,
  void Function(ReactFocusEvent)? onBlurCapture,
  void Function(ReactPointerEvent)? onPointerDown,
  void Function(ReactPointerEvent)? onPointerDownCapture,
  void Function(ReactPointerEvent)? onPointerUp,
  void Function(ReactPointerEvent)? onPointerUpCapture,
  void Function(ReactPointerEvent)? onPointerMove,
  void Function(ReactPointerEvent)? onPointerMoveCapture,
  void Function(ReactTouchEvent)? onTouchStart,
  void Function(ReactTouchEvent)? onTouchStartCapture,
  void Function(ReactTouchEvent)? onTouchEnd,
  void Function(ReactTouchEvent)? onTouchEndCapture,
  void Function(ReactTouchEvent)? onTouchMove,
  void Function(ReactTouchEvent)? onTouchMoveCapture,
  void Function(ReactWheelEvent)? onWheel,
  void Function(ReactWheelEvent)? onWheelCapture,
  void Function(ReactDragEvent)? onDrag,
  void Function(ReactDragEvent)? onDragCapture,
  void Function(ReactDragEvent)? onDrop,
  void Function(ReactDragEvent)? onDropCapture,
  void Function(HTMLImageElement?)? ref,
  String? key,
  Map<String, Object?> additionalProps = const {},
}) {
  return HostNode<Map<String, Object?>>(_imgHost, {
    if (alt != null) 'alt': alt,
    if (src != null) 'src': src,
    if (srcset != null) 'srcset': srcset,
    if (sizes != null) 'sizes': sizes,
    if (crossOrigin != null) 'crossOrigin': crossOrigin,
    if (useMap != null) 'useMap': useMap,
    if (isMap != null) 'isMap': isMap,
    if (width != null) 'width': width,
    if (height != null) 'height': height,
    if (referrerPolicy != null) 'referrerPolicy': referrerPolicy,
    if (decoding != null) 'decoding': decoding,
    if (loading != null) 'loading': loading,
    if (fetchPriority != null) 'fetchPriority': fetchPriority,
    if (title != null) 'title': title,
    if (lang != null) 'lang': lang,
    if (translate != null) 'translate': translate,
    if (dir != null) 'dir': dir,
    if (hidden != null) 'hidden': hidden,
    if (inert != null) 'inert': inert,
    if (accessKey != null) 'accessKey': accessKey,
    if (draggable != null) 'draggable': draggable,
    if (spellcheck != null) 'spellcheck': spellcheck,
    if (writingSuggestions != null) 'writingSuggestions': writingSuggestions,
    if (autocapitalize != null) 'autocapitalize': autocapitalize,
    if (popover != null) 'popover': popover,
    if (id != null) 'id': id,
    if (className != null) 'className': className,
    if (slot != null) 'slot': slot,
    if (tabIndex != null) 'tabIndex': tabIndex,
    if (role != null) 'role': role,
    if (style != null) 'style': style,
    if (onClick != null)
      'onClick': ReactEventProp(
        ReactCallback(
          debugName: 'img.onClick',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onClick(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onClickCapture != null)
      'onClickCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onClickCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onClickCapture(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onDoubleClick != null)
      'onDoubleClick': ReactEventProp(
        ReactCallback(
          debugName: 'img.onDoubleClick',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onDoubleClick(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onDoubleClickCapture != null)
      'onDoubleClickCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onDoubleClickCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onDoubleClickCapture(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseDown != null)
      'onMouseDown': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseDown',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseDown(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseDownCapture != null)
      'onMouseDownCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseDownCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseDownCapture(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseUp != null)
      'onMouseUp': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseUp',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseUp(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseUpCapture != null)
      'onMouseUpCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseUpCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseUpCapture(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseMove != null)
      'onMouseMove': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseMove',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseMove(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseMoveCapture != null)
      'onMouseMoveCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseMoveCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseMoveCapture(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseEnter != null)
      'onMouseEnter': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseEnter',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseEnter(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseEnterCapture != null)
      'onMouseEnterCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseEnterCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseEnterCapture(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseLeave != null)
      'onMouseLeave': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseLeave',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseLeave(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onMouseLeaveCapture != null)
      'onMouseLeaveCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onMouseLeaveCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactMouseEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onMouseLeaveCapture(args[0] as ReactMouseEvent);
            return null;
          },
        ),
      ),
    if (onInput != null)
      'onInput': ReactEventProp(
        ReactCallback(
          debugName: 'img.onInput',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactInputEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onInput(args[0] as ReactInputEvent);
            return null;
          },
        ),
      ),
    if (onInputCapture != null)
      'onInputCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onInputCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactInputEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onInputCapture(args[0] as ReactInputEvent);
            return null;
          },
        ),
      ),
    if (onChange != null)
      'onChange': ReactEventProp(
        ReactCallback(
          debugName: 'img.onChange',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactChangeEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onChange(args[0] as ReactChangeEvent);
            return null;
          },
        ),
      ),
    if (onChangeCapture != null)
      'onChangeCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onChangeCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactChangeEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onChangeCapture(args[0] as ReactChangeEvent);
            return null;
          },
        ),
      ),
    if (onSubmit != null)
      'onSubmit': ReactEventProp(
        ReactCallback(
          debugName: 'img.onSubmit',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactFormEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onSubmit(args[0] as ReactFormEvent);
            return null;
          },
        ),
      ),
    if (onSubmitCapture != null)
      'onSubmitCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onSubmitCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactFormEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onSubmitCapture(args[0] as ReactFormEvent);
            return null;
          },
        ),
      ),
    if (onKeyDown != null)
      'onKeyDown': ReactEventProp(
        ReactCallback(
          debugName: 'img.onKeyDown',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactKeyboardEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onKeyDown(args[0] as ReactKeyboardEvent);
            return null;
          },
        ),
      ),
    if (onKeyDownCapture != null)
      'onKeyDownCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onKeyDownCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactKeyboardEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onKeyDownCapture(args[0] as ReactKeyboardEvent);
            return null;
          },
        ),
      ),
    if (onKeyUp != null)
      'onKeyUp': ReactEventProp(
        ReactCallback(
          debugName: 'img.onKeyUp',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactKeyboardEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onKeyUp(args[0] as ReactKeyboardEvent);
            return null;
          },
        ),
      ),
    if (onKeyUpCapture != null)
      'onKeyUpCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onKeyUpCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactKeyboardEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onKeyUpCapture(args[0] as ReactKeyboardEvent);
            return null;
          },
        ),
      ),
    if (onFocus != null)
      'onFocus': ReactEventProp(
        ReactCallback(
          debugName: 'img.onFocus',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactFocusEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onFocus(args[0] as ReactFocusEvent);
            return null;
          },
        ),
      ),
    if (onFocusCapture != null)
      'onFocusCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onFocusCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactFocusEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onFocusCapture(args[0] as ReactFocusEvent);
            return null;
          },
        ),
      ),
    if (onBlur != null)
      'onBlur': ReactEventProp(
        ReactCallback(
          debugName: 'img.onBlur',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactFocusEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onBlur(args[0] as ReactFocusEvent);
            return null;
          },
        ),
      ),
    if (onBlurCapture != null)
      'onBlurCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onBlurCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactFocusEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onBlurCapture(args[0] as ReactFocusEvent);
            return null;
          },
        ),
      ),
    if (onPointerDown != null)
      'onPointerDown': ReactEventProp(
        ReactCallback(
          debugName: 'img.onPointerDown',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactPointerEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onPointerDown(args[0] as ReactPointerEvent);
            return null;
          },
        ),
      ),
    if (onPointerDownCapture != null)
      'onPointerDownCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onPointerDownCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactPointerEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onPointerDownCapture(args[0] as ReactPointerEvent);
            return null;
          },
        ),
      ),
    if (onPointerUp != null)
      'onPointerUp': ReactEventProp(
        ReactCallback(
          debugName: 'img.onPointerUp',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactPointerEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onPointerUp(args[0] as ReactPointerEvent);
            return null;
          },
        ),
      ),
    if (onPointerUpCapture != null)
      'onPointerUpCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onPointerUpCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactPointerEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onPointerUpCapture(args[0] as ReactPointerEvent);
            return null;
          },
        ),
      ),
    if (onPointerMove != null)
      'onPointerMove': ReactEventProp(
        ReactCallback(
          debugName: 'img.onPointerMove',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactPointerEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onPointerMove(args[0] as ReactPointerEvent);
            return null;
          },
        ),
      ),
    if (onPointerMoveCapture != null)
      'onPointerMoveCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onPointerMoveCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactPointerEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onPointerMoveCapture(args[0] as ReactPointerEvent);
            return null;
          },
        ),
      ),
    if (onTouchStart != null)
      'onTouchStart': ReactEventProp(
        ReactCallback(
          debugName: 'img.onTouchStart',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactTouchEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onTouchStart(args[0] as ReactTouchEvent);
            return null;
          },
        ),
      ),
    if (onTouchStartCapture != null)
      'onTouchStartCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onTouchStartCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactTouchEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onTouchStartCapture(args[0] as ReactTouchEvent);
            return null;
          },
        ),
      ),
    if (onTouchEnd != null)
      'onTouchEnd': ReactEventProp(
        ReactCallback(
          debugName: 'img.onTouchEnd',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactTouchEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onTouchEnd(args[0] as ReactTouchEvent);
            return null;
          },
        ),
      ),
    if (onTouchEndCapture != null)
      'onTouchEndCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onTouchEndCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactTouchEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onTouchEndCapture(args[0] as ReactTouchEvent);
            return null;
          },
        ),
      ),
    if (onTouchMove != null)
      'onTouchMove': ReactEventProp(
        ReactCallback(
          debugName: 'img.onTouchMove',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactTouchEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onTouchMove(args[0] as ReactTouchEvent);
            return null;
          },
        ),
      ),
    if (onTouchMoveCapture != null)
      'onTouchMoveCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onTouchMoveCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactTouchEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onTouchMoveCapture(args[0] as ReactTouchEvent);
            return null;
          },
        ),
      ),
    if (onWheel != null)
      'onWheel': ReactEventProp(
        ReactCallback(
          debugName: 'img.onWheel',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactWheelEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onWheel(args[0] as ReactWheelEvent);
            return null;
          },
        ),
      ),
    if (onWheelCapture != null)
      'onWheelCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onWheelCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactWheelEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onWheelCapture(args[0] as ReactWheelEvent);
            return null;
          },
        ),
      ),
    if (onDrag != null)
      'onDrag': ReactEventProp(
        ReactCallback(
          debugName: 'img.onDrag',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactDragEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onDrag(args[0] as ReactDragEvent);
            return null;
          },
        ),
      ),
    if (onDragCapture != null)
      'onDragCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onDragCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactDragEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onDragCapture(args[0] as ReactDragEvent);
            return null;
          },
        ),
      ),
    if (onDrop != null)
      'onDrop': ReactEventProp(
        ReactCallback(
          debugName: 'img.onDrop',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactDragEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onDrop(args[0] as ReactDragEvent);
            return null;
          },
        ),
      ),
    if (onDropCapture != null)
      'onDropCapture': ReactEventProp(
        ReactCallback(
          debugName: 'img.onDropCapture',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: false,
                hostNamespace: 'web',
                typeId: 'ReactDragEvent',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            onDropCapture(args[0] as ReactDragEvent);
            return null;
          },
        ),
      ),
    if (ref != null)
      'ref': ReactRefProp(
        ReactCallback(
          debugName: 'img.ref',
          signature: const (
            positional: [
              (
                kind: ReactValueKind.hostValue,
                nullable: true,
                hostNamespace: 'web',
                typeId: 'HTMLImageElement',
                codecId: null,
              ),
            ],
            result: reactVoid,
            asynchronous: false,
          ),
          invoke: (args) {
            ref(args[0] as HTMLImageElement?);
            return null;
          },
        ),
      ),
    ...additionalProps,
  }, key: key);
}