Locals stored as private symbols on non-native JS types breaks JS semantics about scala-js HOT 3 OPEN

  private val privateFieldsSymbol = {
    // Check that there is only one private fields symbol.
    // This might break if Scala.js changes the way this is implemented and we want to know when that happens.
    val first = scala.scalajs.runtime.privateFieldsSymbol()
    val second = scala.scalajs.runtime.privateFieldsSymbol()
    if (first != second) throw new UnsupportedOperationException("Unable to determine privateFieldSymbol.")
    first.asInstanceOf[String | js.Symbol]
  }

  private def isObject(a: Any): Boolean =
    a != null && js.typeOf(a) == "object"

  private def combinePropertyDescriptor(first: PropertyDescriptor, second: PropertyDescriptor): PropertyDescriptor = {
    // This only updates the value on the descriptor not the property on the object that the descriptor came from.
    val newValue = first.value.fold(second.value) { firstValue =>
      if (isObject(firstValue) && isObject(second.value)) {
        combineOwnProperties[js.Object, js.Object](firstValue.asInstanceOf[js.Object], second.value.asInstanceOf[js.Object])
      } else {
        second.value
      }
    }
    combineOwnProperties(second, new PropertyDescriptor {
      value = newValue
    })
  }

  /**
   * Combines all the own properties – enumerable and not enumerable, strings and symbols — of two objects.
   *
   * Properties from the `second` object will be created after properties from the `first`. When a property is not
   * unique, the one from the `second` object will replace the one from the `first`.
   *
   * @return a new object with the combined properties from both the `first` and `second` objects
   */
  def combineOwnProperties[A <: js.Object, B <: js.Object](first: A, second: B): A with B = {
    val result = js.Object()
    val firstKeys = Reflect.ownKeys(first)
    val secondKeys = Reflect.ownKeys(second)
    val secondKeysSet = secondKeys.toSet
    // We want to be careful with property order.
    // Some things may provide a deterministic order in the order that the properties are created.
    // All unique keys from the first object will retain their relative order and will come before all other keys.
    // Keys from the second object (unique or not) will retain their relative order.
    // This means that the position of non-unique keys will move position (unless they are all at the end of the first
    // and the start of the second).
    firstKeys.foreach { key =>
      if (!secondKeysSet.contains(key)) {
        val descriptor = Reflect.getOwnPropertyDescriptor(first, key).get
        Reflect.defineProperty(result, key, descriptor)
      }
    }
    secondKeys.foreach { key =>
      val maybeFirstDescriptor = Reflect.getOwnPropertyDescriptor(first, key)
      val secondDescriptor = Reflect.getOwnPropertyDescriptor(second, key).get
      val descriptor = maybeFirstDescriptor.fold(secondDescriptor) { firstDescriptor =>
        if (key == privateFieldsSymbol) combinePropertyDescriptor(firstDescriptor, secondDescriptor)
        else secondDescriptor
      }
      Reflect.defineProperty(result, key, descriptor)
    }
    result.asInstanceOf[A with B]
  }