react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ColorPropConverter.java

@@ -34,7 +34,7 @@ public class ColorPropConverter {
   private static final String ATTR_SEGMENT = "attr/";
 
   @Nullable
-  private static Integer getColorInteger(Object value, Context context) {
+  private static Integer getColorInteger(@Nullable Object value, Context context) {
     if (value == null) {
       return null;
     }
@@ -84,7 +84,7 @@ public class ColorPropConverter {
   }
 
   @Nullable
-  public static Color getColorInstance(Object value, Context context) {
+  public static Color getColorInstance(@Nullable Object value, Context context) {
     if (value == null) {
       return null;
     }
@@ -136,7 +136,7 @@ public class ColorPropConverter {
         "ColorValue: the value must be a number or Object.");
   }
 
-  public static Integer getColor(Object value, Context context) {
+  public static Integer getColor(@Nullable Object value, Context context) {
     try {
       if (supportWideGamut()) {
         Color color = getColorInstance(value, context);
@@ -150,7 +150,7 @@ public class ColorPropConverter {
     return getColorInteger(value, context);
   }
 
-  public static Integer getColor(Object value, Context context, int defaultInt) {
+  public static Integer getColor(@Nullable Object value, Context context, int defaultInt) {
     try {
       return getColor(value, context);
     } catch (JSApplicationCausedNativeException e) {

package/ReactAndroid/src/main/java/com/facebook/react/bridge/CxxCallbackImpl.java

@@ -9,18 +9,15 @@ package com.facebook.react.bridge;
 
 import static com.facebook.react.bridge.Arguments.*;
 
-import com.facebook.jni.HybridData;
+import com.facebook.jni.HybridClassBase;
 import com.facebook.proguard.annotations.DoNotStrip;
 
 /** Callback impl that calls directly into the cxx bridge. Created from C++. */
 @DoNotStrip
-public class CxxCallbackImpl implements Callback {
-  @DoNotStrip private final HybridData mHybridData;
+public class CxxCallbackImpl extends HybridClassBase implements Callback {
 
   @DoNotStrip
-  private CxxCallbackImpl(HybridData hybridData) {
-    mHybridData = hybridData;
-  }
+  private CxxCallbackImpl() {}
 
   @Override
   public void invoke(Object... args) {

package/ReactAndroid/src/main/java/com/facebook/react/bridge/DynamicNative.kt

@@ -7,8 +7,7 @@
 
 package com.facebook.react.bridge
 
-import com.facebook.jni.HybridData
-import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.jni.HybridClassBase
 import com.facebook.proguard.annotations.DoNotStripAny
 
 /**
@@ -18,9 +17,7 @@ import com.facebook.proguard.annotations.DoNotStripAny
  * and are using [Dynamic] as a parameter type.
  */
 @DoNotStripAny
-private class DynamicNative(
-    @Suppress("NoHungarianNotation") @field:DoNotStrip private val mHybridData: HybridData?
-) : Dynamic {
+private class DynamicNative : HybridClassBase(), Dynamic {
 
   override val type: ReadableType
     get() = getTypeNative()

package/ReactAndroid/src/main/java/com/facebook/react/bridge/{InvalidIteratorException.java → InvalidIteratorException.kt}

@@ -5,19 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.bridge;
+package com.facebook.react.bridge
 
-import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.proguard.annotations.DoNotStrip
 
 /**
  * Exception thrown by {@link ReadableMapKeySetIterator#nextKey()} when the iterator tries to
  * iterate over elements after the end of the key set.
  */
 @DoNotStrip
-public class InvalidIteratorException extends RuntimeException {
-
-  @DoNotStrip
-  public InvalidIteratorException(String msg) {
-    super(msg);
-  }
-}
+public class InvalidIteratorException public @DoNotStrip constructor(msg: String) :
+    RuntimeException(msg) {}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/{JSApplicationCausedNativeException.java → JSApplicationCausedNativeException.kt}

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.bridge;
-
-import androidx.annotation.Nullable;
+package com.facebook.react.bridge
 
 /**
  * A special RuntimeException that should be thrown by native code if it has reached an exceptional
@@ -19,25 +17,18 @@ import androidx.annotation.Nullable;
  * this catalyst instance?
  *
  * <p>Examples where this class is appropriate to throw:
- *
  * <ul>
- *   <li>JS tries to update a view with a tag that hasn't been created yet
- *   <li>JS tries to show a static image that isn't in resources
- *   <li>JS tries to use an unsupported view class
+ * <li>JS tries to update a view with a tag that hasn't been created yet
+ * <li>JS tries to show a static image that isn't in resources
+ * <li>JS tries to use an unsupported view class
  * </ul>
  *
  * <p>Examples where this class **isn't** appropriate to throw: - Failed to write to localStorage
  * because disk is full - Assertions about internal state (e.g. that
  * child.getParent().indexOf(child) != -1)
  */
-public class JSApplicationCausedNativeException extends RuntimeException {
-
-  public JSApplicationCausedNativeException(String detailMessage) {
-    super(detailMessage);
-  }
+public open class JSApplicationCausedNativeException : RuntimeException {
+  public constructor(detailMessage: String) : super(detailMessage)
 
-  public JSApplicationCausedNativeException(
-      @Nullable String detailMessage, @Nullable Throwable throwable) {
-    super(detailMessage, throwable);
-  }
+  public constructor(detailMessage: String, throwable: Throwable?) : super(detailMessage, throwable)
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/JSApplicationIllegalArgumentException.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+/** An illegal argument Exception caused by an argument passed from JS. */
+public class JSApplicationIllegalArgumentException : JSApplicationCausedNativeException {
+
+  public constructor(detailMessage: String) : super(detailMessage)
+
+  public constructor(detailMessage: String, t: Throwable) : super(detailMessage, t)
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/JavaOnlyArray.kt

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+import com.facebook.react.bridge.JavaOnlyMap.Companion.deepClone
+import java.util.ArrayList
+
+/**
+ * Java [ArrayList] backed implementation of [ReadableArray] and [WritableArray] Instances of this
+ * class SHOULD NOT be used for communication between java and JS, use instances of
+ * [WritableNativeArray] created via [Arguments#createArray] or just [ReadableArray] interface if
+ * you want your "native" module method to take an array from JS as an argument.
+ *
+ * Main purpose for this class is to be used in java-only unit tests, but could also be used outside
+ * of tests in the code that operates only in java and needs to communicate with RN modules via
+ * their JS-exposed API.
+ */
+public class JavaOnlyArray : ReadableArray, WritableArray {
+
+  public companion object {
+    @JvmStatic public fun from(list: List<*>): JavaOnlyArray = JavaOnlyArray(list)
+
+    @JvmStatic public fun of(vararg values: Any?): JavaOnlyArray = JavaOnlyArray(*values)
+
+    @JvmStatic
+    public fun deepClone(array: ReadableArray?): JavaOnlyArray {
+      val res = JavaOnlyArray()
+      if (array == null) {
+        return res
+      }
+
+      repeat(array.size()) { i ->
+        val type = array.getType(i)
+        when (type) {
+          ReadableType.Null -> res.pushNull()
+          ReadableType.Boolean -> res.pushBoolean(array.getBoolean(i))
+          ReadableType.Number -> res.pushDouble(array.getDouble(i))
+          ReadableType.String -> res.pushString(array.getString(i))
+          ReadableType.Map -> res.pushMap(deepClone(array.getMap(i)))
+          ReadableType.Array -> res.pushArray(deepClone(array.getArray(i)))
+        }
+      }
+      return res
+    }
+  }
+
+  private val backingList: MutableList<Any?>
+
+  private constructor(vararg values: Any?) {
+    backingList = mutableListOf(*values)
+  }
+
+  private constructor(list: List<*>) {
+    backingList = ArrayList(list)
+  }
+
+  public constructor() {
+    backingList = mutableListOf()
+  }
+
+  override fun size(): Int = backingList.size
+
+  override fun isNull(index: Int): Boolean = backingList[index] == null
+
+  override fun getDouble(index: Int): Double = (backingList[index] as Number).toDouble()
+
+  override fun getInt(index: Int): Int = (backingList[index] as Number).toInt()
+
+  override fun getLong(index: Int): Long = (backingList[index] as Number).toLong()
+
+  override fun getString(index: Int): String? = backingList[index] as String?
+
+  override fun getArray(index: Int): ReadableArray? = backingList[index] as ReadableArray?
+
+  override fun getBoolean(index: Int): Boolean = backingList[index] as Boolean
+
+  override fun getMap(index: Int): ReadableMap? = backingList[index] as ReadableMap?
+
+  override fun getDynamic(index: Int): Dynamic = DynamicFromArray.create(this, index)
+
+  override fun getType(index: Int): ReadableType {
+    return when (val value = backingList[index]) {
+      null -> ReadableType.Null
+      is Boolean -> ReadableType.Boolean
+      is Double,
+      is Float,
+      is Int,
+      is Long -> ReadableType.Number
+      is String -> ReadableType.String
+      is ReadableArray -> ReadableType.Array
+      is ReadableMap -> ReadableType.Map
+      else -> throw IllegalStateException("Invalid type ${value.javaClass})")
+    }
+  }
+
+  override fun pushBoolean(value: Boolean) {
+    backingList.add(value)
+  }
+
+  override fun pushDouble(value: Double) {
+    backingList.add(value)
+  }
+
+  override fun pushInt(value: Int) {
+    backingList.add(value.toDouble())
+  }
+
+  override fun pushLong(value: Long) {
+    backingList.add(value.toDouble())
+  }
+
+  override fun pushString(value: String?) {
+    backingList.add(value)
+  }
+
+  override fun pushArray(array: ReadableArray?) {
+    backingList.add(array)
+  }
+
+  override fun pushMap(map: ReadableMap?) {
+    backingList.add(map)
+  }
+
+  override fun pushNull() {
+    backingList.add(null)
+  }
+
+  override fun toArrayList(): ArrayList<Any?> = ArrayList(backingList)
+
+  override fun toString(): String = backingList.toString()
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) {
+      return true
+    } else if (other == null || javaClass != other.javaClass) {
+      return false
+    } else {
+      return backingList == (other as JavaOnlyArray).backingList
+    }
+  }
+
+  override fun hashCode(): Int = backingList.hashCode()
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/JavaOnlyMap.kt

@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+import java.util.HashMap
+import kotlin.collections.Iterator
+import kotlin.collections.Map
+
+/**
+ * Java [HashMap] backed implementation of [ReadableMap] and [WritableMap] Instances of this class
+ * SHOULD NOT be used for communication between java and JS, use instances of [WritableNativeMap]
+ * created via [Arguments#createMap] or just [ReadableMap] interface if you want your "native"
+ * module method to take a map from JS as an argument.
+ *
+ * Main purpose for this class is to be used in java-only unit tests, but could also be used outside
+ * of tests in the code that operates only in java and needs to communicate with RN modules via
+ * their JS-exposed API.
+ */
+public class JavaOnlyMap() : ReadableMap, WritableMap {
+  public companion object {
+    @JvmStatic public fun of(vararg keysAndValues: Any?): JavaOnlyMap = JavaOnlyMap(*keysAndValues)
+
+    @JvmStatic public fun from(map: Map<String, Any?>): JavaOnlyMap = JavaOnlyMap(map)
+
+    @JvmStatic
+    public fun deepClone(map: ReadableMap?): JavaOnlyMap {
+      val res = JavaOnlyMap()
+      if (map == null) {
+        return res
+      }
+      val iter = map.keySetIterator()
+      while (iter.hasNextKey()) {
+        val propKey = iter.nextKey()
+        val type = map.getType(propKey)
+        when (type) {
+          ReadableType.Null -> res.putNull(propKey)
+          ReadableType.Boolean -> res.putBoolean(propKey, map.getBoolean(propKey))
+          ReadableType.Number -> res.putDouble(propKey, map.getDouble(propKey))
+          ReadableType.String -> res.putString(propKey, map.getString(propKey))
+          ReadableType.Map -> res.putMap(propKey, deepClone(map.getMap(propKey)))
+          ReadableType.Array ->
+              res.putArray(propKey, JavaOnlyArray.deepClone(map.getArray(propKey)))
+        }
+      }
+      return res
+    }
+  }
+
+  private val backingMap: MutableMap<String, Any?> = HashMap()
+
+  /** @param keysAndValues keys and values, interleaved */
+  private constructor(vararg keysAndValues: Any?) : this() {
+    require(keysAndValues.size % 2 == 0) { "You must provide the same number of keys and values" }
+    for (i in keysAndValues.indices step 2) {
+      var value = keysAndValues[i + 1]
+      if (value is Number) {
+        // all values from JS are doubles, so emulate that here for tests.
+        value = value.toDouble()
+      }
+      backingMap[keysAndValues[i] as String] = value
+    }
+  }
+
+  override fun hasKey(name: String): Boolean = backingMap.containsKey(name)
+
+  override fun isNull(name: String): Boolean = backingMap[name] == null
+
+  override fun getBoolean(name: String): Boolean = backingMap[name] as Boolean
+
+  override fun getDouble(name: String): Double = (backingMap[name] as Number).toDouble()
+
+  override fun getInt(name: String): Int = (backingMap[name] as Number).toInt()
+
+  override fun getLong(name: String): Long = (backingMap[name] as Number).toLong()
+
+  override fun getString(name: String): String? = backingMap[name] as String?
+
+  override fun getMap(name: String): ReadableMap? = backingMap[name] as ReadableMap?
+
+  override fun getArray(name: String): ReadableArray? = backingMap[name] as ReadableArray?
+
+  override fun getDynamic(name: String): Dynamic = DynamicFromMap.create(this, name)
+
+  override fun getType(name: String): ReadableType {
+    val value = backingMap[name]
+    return when {
+      value == null -> ReadableType.Null
+      value is Number -> ReadableType.Number
+      value is String -> ReadableType.String
+      value is Boolean -> ReadableType.Boolean
+      value is ReadableMap -> ReadableType.Map
+      value is ReadableArray -> ReadableType.Array
+      value is Dynamic -> value.type
+      else -> {
+        throw IllegalArgumentException(
+            "Invalid value $value for key $name contained in JavaOnlyMap")
+      }
+    }
+  }
+
+  override val entryIterator: Iterator<Map.Entry<String, Any?>>
+    get() = backingMap.entries.iterator()
+
+  override fun keySetIterator(): ReadableMapKeySetIterator {
+    return object : ReadableMapKeySetIterator {
+      private val iterator = backingMap.entries.iterator()
+
+      override fun hasNextKey(): Boolean = iterator.hasNext()
+
+      override fun nextKey(): String = iterator.next().key
+    }
+  }
+
+  override fun putBoolean(key: String, value: Boolean) {
+    backingMap[key] = value
+  }
+
+  override fun putDouble(key: String, value: Double) {
+    backingMap[key] = value
+  }
+
+  override fun putInt(key: String, value: Int) {
+    backingMap[key] = value.toDouble()
+  }
+
+  override fun putLong(key: String, value: Long) {
+    backingMap[key] = value.toDouble()
+  }
+
+  override fun putString(key: String, value: String?) {
+    backingMap[key] = value
+  }
+
+  override fun putNull(key: String) {
+    backingMap[key] = null
+  }
+
+  override fun putMap(key: String, value: ReadableMap?) {
+    backingMap[key] = value
+  }
+
+  override fun merge(source: ReadableMap) {
+    backingMap.putAll((source as JavaOnlyMap).backingMap)
+  }
+
+  override fun copy(): WritableMap {
+    val target = JavaOnlyMap()
+    target.merge(this)
+    return target
+  }
+
+  override fun putArray(key: String, value: ReadableArray?) {
+    backingMap[key] = value
+  }
+
+  public fun remove(key: String) {
+    backingMap.remove(key)
+  }
+
+  override fun toHashMap(): HashMap<String, Any?> = HashMap<String, Any?>(backingMap)
+
+  override fun toString(): String = backingMap.toString()
+
+  override fun equals(other: Any?): Boolean {
+    return if (this === other) {
+      true
+    } else if (other == null || javaClass != other.javaClass) {
+      false
+    } else {
+      backingMap == (other as JavaOnlyMap).backingMap
+    }
+  }
+
+  override fun hashCode(): Int = backingMap.hashCode()
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/NativeArgumentsParseException.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+/** Exception thrown when a native module method call receives unexpected arguments from JS. */
+internal class NativeArgumentsParseException : JSApplicationCausedNativeException {
+
+  public constructor(detailMessage: String) : super(detailMessage)
+
+  public constructor(detailMessage: String, throwable: Throwable?) : super(detailMessage, throwable)
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/NativeArray.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+import com.facebook.jni.HybridClassBase
+import com.facebook.proguard.annotations.DoNotStrip
+
+/** Base class for an array whose members are stored in native code (C++). */
+@DoNotStrip
+public abstract class NativeArray protected constructor() :
+    HybridClassBase(), NativeArrayInterface {
+
+  external override fun toString(): String
+
+  private companion object {
+    init {
+      ReactBridge.staticInit()
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/NativeMap.kt

@@ -7,12 +7,12 @@
 
 package com.facebook.react.bridge
 
-import com.facebook.jni.HybridData
+import com.facebook.jni.HybridClassBase
 import com.facebook.proguard.annotations.DoNotStrip
 
 /** Base class for a Map whose keys and values are stored in native code (C++). */
 @DoNotStrip
-public abstract class NativeMap(@field:DoNotStrip private val mHybridData: HybridData?) {
+public abstract class NativeMap : HybridClassBase() {
   external override fun toString(): String
 
   private companion object {

package/ReactAndroid/src/main/java/com/facebook/react/bridge/NoSuchKeyException.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+/** Exception thrown by [ReadableNativeMap] when a key that does not exist is requested. */
+@DoNotStrip
+public class NoSuchKeyException @DoNotStrip constructor(msg: String) : RuntimeException(msg)

package/ReactAndroid/src/main/java/com/facebook/react/bridge/{ObjectAlreadyConsumedException.java → ObjectAlreadyConsumedException.kt}

@@ -5,9 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.bridge;
+package com.facebook.react.bridge
 
-import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.proguard.annotations.DoNotStrip
 
 /**
  * Exception thrown when a caller attempts to modify or use a {@link WritableNativeArray} or {@link
@@ -15,10 +15,5 @@ import com.facebook.proguard.annotations.DoNotStrip;
  * we reuse the native memory so the underlying array/map is no longer valid.
  */
 @DoNotStrip
-public class ObjectAlreadyConsumedException extends RuntimeException {
-
-  @DoNotStrip
-  public ObjectAlreadyConsumedException(String detailMessage) {
-    super(detailMessage);
-  }
-}
+internal class ObjectAlreadyConsumedException
+public @DoNotStrip constructor(detailMessage: String) : RuntimeException(detailMessage) {}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactContext.java

@@ -25,7 +25,6 @@ import com.facebook.react.bridge.interop.InteropModuleRegistry;
 import com.facebook.react.bridge.queue.MessageQueueThread;
 import com.facebook.react.bridge.queue.ReactQueueConfiguration;
 import com.facebook.react.common.LifecycleState;
-import com.facebook.react.common.annotations.DeprecatedInNewArchitecture;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
 import java.lang.ref.WeakReference;
 import java.util.Collection;
@@ -63,6 +62,8 @@ public abstract class ReactContext extends ContextWrapper {
   private @Nullable JSExceptionHandler mExceptionHandlerWrapper;
   private @Nullable WeakReference<Activity> mCurrentActivity;
 
+  // NOTE: When converted to Kotlin, this field should be made internal due to
+  // visibility restriction on InteropModuleRegistry otherwise it will be exposed to the public API.
   protected @Nullable InteropModuleRegistry mInteropModuleRegistry;
   private boolean mIsInitialized = false;
 
@@ -501,8 +502,8 @@ public abstract class ReactContext extends ContextWrapper {
    */
   public abstract @Nullable CallInvokerHolder getJSCallInvokerHolder();
 
-  @DeprecatedInNewArchitecture(
-      message =
+  @Deprecated(
+      since =
           "This method will be deprecated later as part of Stable APIs with bridge removal and not"
               + " encouraged usage.")
   /**

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactIgnorableMountingException.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+/**
+ * If thrown during a MountItem execution, FabricUIManager will print diagnostics and ignore the
+ * error. Use this carefully and sparingly!
+ */
+public class ReactIgnorableMountingException : RuntimeException {
+
+  public constructor(m: String) : super(m)
+
+  public constructor(e: Throwable) : super(e)
+
+  public constructor(m: String, e: Throwable) : super(m, e)
+
+  public companion object {
+    @JvmStatic
+    public fun isIgnorable(e: Throwable): Boolean {
+      var cause: Throwable? = e
+      while (cause != null) {
+        if (cause is ReactIgnorableMountingException) {
+          return true
+        }
+        cause = cause.cause
+      }
+      return false
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactNoCrashBridgeNotAllowedSoftException.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+public class ReactNoCrashBridgeNotAllowedSoftException : ReactNoCrashSoftException {
+
+  public constructor(m: String) : super(m)
+
+  public constructor(e: Throwable) : super(e)
+
+  public constructor(m: String, e: Throwable) : super(m, e)
+}