/*                     __                                               *\
**     ________ ___   / /  ___      __ ____  Scala.js API               **
**    / __/ __// _ | / /  / _ | __ / // __/  (c) 2013, LAMP/EPFL        **
**  __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \    http://scala-lang.org/     **
** /____/\___/_/ |_/____/_/ | |__/ /____/                               **
**                          |/____/                                     **
\*                                                                      */


/**
 * All doc-comments marked as "MDN" are by Mozilla Contributors,
 * distributed under the Creative Commons Attribution-ShareAlike license from
 * https://developer.mozilla.org/en-US/docs/Web/Reference/API
 */
package scala.scalajs.js

import annotation.JSBracketAccess

import scala.language.{ dynamics, implicitConversions }
import scala.reflect.ClassTag
import scala.collection.{ immutable, mutable }
import scala.collection.generic.CanBuildFrom

/** Super-type of all JavaScript values.
 *
 *  All values of a subtype of this trait represent JavaScript values, without
 *  boxing of proxying of any kind.
 */
sealed trait Any extends scala.AnyRef {
}

/** Provides implicit conversions from Scala values to JavaScript values. */
object Any extends LowPrioAnyImplicits {
  @inline implicit def fromUnit(value: Unit): prim.Undefined =
    value.asInstanceOf[prim.Undefined]
  @inline implicit def fromBoolean(value: scala.Boolean): prim.Boolean =
    value.asInstanceOf[prim.Boolean]
  @inline implicit def fromByte(value: scala.Byte): prim.Number =
    value.asInstanceOf[prim.Number]
  @inline implicit def fromShort(value: scala.Short): prim.Number =
    value.asInstanceOf[prim.Number]
  @inline implicit def fromInt(value: scala.Int): prim.Number =
    value.asInstanceOf[prim.Number]
  @inline implicit def fromLong(value: scala.Long): prim.Number =
    value.toDouble.asInstanceOf[prim.Number]
  @inline implicit def fromFloat(value: scala.Float): prim.Number =
    value.asInstanceOf[prim.Number]
  @inline implicit def fromDouble(value: scala.Double): prim.Number =
    value.asInstanceOf[prim.Number]
  @inline implicit def fromString(s: java.lang.String): prim.String =
    s.asInstanceOf[prim.String]

  @inline implicit def toDouble(value: prim.Number): scala.Double =
    value.asInstanceOf[scala.Double]
  @inline implicit def toBoolean(value: prim.Boolean): scala.Boolean =
    value.asInstanceOf[scala.Boolean]
  @inline implicit def toScalaString(value: prim.String): java.lang.String =
    value.asInstanceOf[java.lang.String]

  implicit def jsArrayOps[A](array: Array[A]): ArrayOps[A] =
    new ArrayOps(array)

  implicit def canBuildFromArray[A]: CanBuildFrom[Array[_], A, Array[A]] = {
    @inline
    class CanBuildFromArray extends CanBuildFrom[Array[_], A, Array[A]] {
      def apply(from: Array[_]): mutable.Builder[A, Array[A]] =
        new ArrayOps[A]
      def apply(): mutable.Builder[A, Array[A]] =
        new ArrayOps[A]
    }
    new CanBuildFromArray
  }

  implicit def fromFunction0[R](f: scala.Function0[R]): Function0[R] = sys.error("stub")
  implicit def fromFunction1[T1, R](f: scala.Function1[T1, R]): Function1[T1, R] = sys.error("stub")
  implicit def fromFunction2[T1, T2, R](f: scala.Function2[T1, T2, R]): Function2[T1, T2, R] = sys.error("stub")
  implicit def fromFunction3[T1, T2, T3, R](f: scala.Function3[T1, T2, T3, R]): Function3[T1, T2, T3, R] = sys.error("stub")
  implicit def fromFunction4[T1, T2, T3, T4, R](f: scala.Function4[T1, T2, T3, T4, R]): Function4[T1, T2, T3, T4, R] = sys.error("stub")
  implicit def fromFunction5[T1, T2, T3, T4, T5, R](f: scala.Function5[T1, T2, T3, T4, T5, R]): Function5[T1, T2, T3, T4, T5, R] = sys.error("stub")
  implicit def fromFunction6[T1, T2, T3, T4, T5, T6, R](f: scala.Function6[T1, T2, T3, T4, T5, T6, R]): Function6[T1, T2, T3, T4, T5, T6, R] = sys.error("stub")
  implicit def fromFunction7[T1, T2, T3, T4, T5, T6, T7, R](f: scala.Function7[T1, T2, T3, T4, T5, T6, T7, R]): Function7[T1, T2, T3, T4, T5, T6, T7, R] = sys.error("stub")
  implicit def fromFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R](f: scala.Function8[T1, T2, T3, T4, T5, T6, T7, T8, R]): Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] = sys.error("stub")
  implicit def fromFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](f: scala.Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]): Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] = sys.error("stub")
  implicit def fromFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](f: scala.Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]): Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R] = sys.error("stub")
  implicit def fromFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R](f: scala.Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]): Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] = sys.error("stub")
  implicit def fromFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R](f: scala.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]): Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] = sys.error("stub")
  implicit def fromFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R](f: scala.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]): Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R] = sys.error("stub")
  implicit def fromFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R](f: scala.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]): Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R] = sys.error("stub")
  implicit def fromFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R](f: scala.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]): Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R] = sys.error("stub")
  implicit def fromFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R](f: scala.Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]): Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R] = sys.error("stub")
  implicit def fromFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R](f: scala.Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]): Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] = sys.error("stub")
  implicit def fromFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R](f: scala.Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]): Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] = sys.error("stub")
  implicit def fromFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R](f: scala.Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]): Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R] = sys.error("stub")
  implicit def fromFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R](f: scala.Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]): Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R] = sys.error("stub")
  implicit def fromFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R](f: scala.Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]): Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R] = sys.error("stub")
  implicit def fromFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R](f: scala.Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]): Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] = sys.error("stub")

  implicit def toFunction0[R](f: Function0[R]): scala.Function0[R] = () => f()
  implicit def toFunction1[T1, R](f: Function1[T1, R]): scala.Function1[T1, R] = (x1) => f(x1)
  implicit def toFunction2[T1, T2, R](f: Function2[T1, T2, R]): scala.Function2[T1, T2, R] = (x1, x2) => f(x1, x2)
  implicit def toFunction3[T1, T2, T3, R](f: Function3[T1, T2, T3, R]): scala.Function3[T1, T2, T3, R] = (x1, x2, x3) => f(x1, x2, x3)
  implicit def toFunction4[T1, T2, T3, T4, R](f: Function4[T1, T2, T3, T4, R]): scala.Function4[T1, T2, T3, T4, R] = (x1, x2, x3, x4) => f(x1, x2, x3, x4)
  implicit def toFunction5[T1, T2, T3, T4, T5, R](f: Function5[T1, T2, T3, T4, T5, R]): scala.Function5[T1, T2, T3, T4, T5, R] = (x1, x2, x3, x4, x5) => f(x1, x2, x3, x4, x5)
  implicit def toFunction6[T1, T2, T3, T4, T5, T6, R](f: Function6[T1, T2, T3, T4, T5, T6, R]): scala.Function6[T1, T2, T3, T4, T5, T6, R] = (x1, x2, x3, x4, x5, x6) => f(x1, x2, x3, x4, x5, x6)
  implicit def toFunction7[T1, T2, T3, T4, T5, T6, T7, R](f: Function7[T1, T2, T3, T4, T5, T6, T7, R]): scala.Function7[T1, T2, T3, T4, T5, T6, T7, R] = (x1, x2, x3, x4, x5, x6, x7) => f(x1, x2, x3, x4, x5, x6, x7)
  implicit def toFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R](f: Function8[T1, T2, T3, T4, T5, T6, T7, T8, R]): scala.Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] = (x1, x2, x3, x4, x5, x6, x7, x8) => f(x1, x2, x3, x4, x5, x6, x7, x8)
  implicit def toFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](f: Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]): scala.Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9)
  implicit def toFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](f: Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]): scala.Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)
  implicit def toFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R](f: Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]): scala.Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
  implicit def toFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R](f: Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]): scala.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)
  implicit def toFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R](f: Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]): scala.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)
  implicit def toFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R](f: Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]): scala.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)
  implicit def toFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R](f: Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]): scala.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)
  implicit def toFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R](f: Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]): scala.Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)
  implicit def toFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R](f: Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]): scala.Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)
  implicit def toFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R](f: Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]): scala.Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)
  implicit def toFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R](f: Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]): scala.Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)
  implicit def toFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R](f: Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]): scala.Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)
  implicit def toFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R](f: Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]): scala.Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)
  implicit def toFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R](f: Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]): scala.Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)
}

trait LowPrioAnyImplicits {
  @inline implicit def richDouble(num: prim.Number): scala.runtime.RichDouble =
    new scala.runtime.RichDouble(Any.toDouble(num))
  @inline implicit def richBoolean(b: prim.Boolean): scala.runtime.RichBoolean =
    new scala.runtime.RichBoolean(Any.toBoolean(b))

  @inline implicit def stringOps(string: prim.String): immutable.StringOps =
    new immutable.StringOps(Any.toScalaString(string))

  implicit def wrapArray[A](array: Array[A]): WrappedArray[A] =
    new WrappedArray(array)
  implicit def wrapDictionary[A](dict: Dictionary[A]): WrappedDictionary[A] =
    new WrappedDictionary(dict)
}

/** Dynamically typed JavaScript value.
 *
 *  Values of this trait accept all possible JavaScript operations in a
 *  dynamically typed way. You can read and write any field, call any method,
 *  apply any JavaScript operator to values of this type.
 */
sealed trait Dynamic extends Any with scala.Dynamic {
  /** Calls a method of this object. */
  def applyDynamic(name: java.lang.String)(args: Any*): Dynamic = sys.error("stub")

  /** Reads a field of this object. */
  def selectDynamic(name: java.lang.String): Dynamic = sys.error("stub")

  /** Writes a field of this object. */
  def updateDynamic(name: java.lang.String)(value: Any): Unit = sys.error("stub")

  /** Calls this object as a callable. */
  def apply(args: Any*): Dynamic = native

  import prim.Number

  def unary_!(): Boolean = native

  def unary_+(): Number = native
  def unary_-(): Number = native
  def unary_~(): Number = native

  def +(that: Number): Dynamic = native // could be a String if this is a String
  def -(that: Number): Number = native
  def *(that: Number): Number = native
  def /(that: Number): Number = native
  def %(that: Number): Number = native
  def <<(that: Number): Number = native
  def >>(that: Number): Number = native
  def >>>(that: Number): Number = native
  def &(that: Number): Number = native
  def |(that: Number): Number = native
  def ^(that: Number): Number = native

  def +(that: Dynamic): Dynamic = native // could be String if this or that is a String
  def -(that: Dynamic): Number = native
  def *(that: Dynamic): Number = native
  def /(that: Dynamic): Number = native
  def %(that: Dynamic): Number = native
  def <<(that: Dynamic): Number = native
  def >>(that: Dynamic): Number = native
  def >>>(that: Dynamic): Number = native
  def &(that: Dynamic): Number = native
  def |(that: Dynamic): Number = native
  def ^(that: Dynamic): Number = native

  def <(that: Number): Boolean = native
  def >(that: Number): Boolean = native
  def <=(that: Number): Boolean = native
  def >=(that: Number): Boolean = native

  def <(that: String): Boolean = native
  def >(that: String): Boolean = native
  def <=(that: String): Boolean = native
  def >=(that: String): Boolean = native

  def <(that: Dynamic): Boolean = native
  def >(that: Dynamic): Boolean = native
  def <=(that: Dynamic): Boolean = native
  def >=(that: Dynamic): Boolean = native

  /* The result of (dyn && bool) and (dyn || bool) has, in theory, type
   * (Dynamic v Boolean). This type cannot be expressed in Scala, but if it
   * could, the operations one could apply on a (Dynamic v Boolean) would be
   * the *intersection* of the operations one can apply on a Dynamic and on a
   * Boolean. Since any operation can be applied on a Dynamic, this
   * intersection is equal to the set of operations supported by Boolean.
   * Hence the result type is restricted to Boolean.
   */
  def &&(that: Boolean): Boolean = native
  def ||(that: Boolean): Boolean = native

  def &&(that: Dynamic): Dynamic = native
  def ||(that: Dynamic): Dynamic = native

  // Work around the annoying implicits in Predef in Scala 2.10.
  def x: Dynamic = native
  def x_=(value: Any): Unit = native
}

/** Factory for dynamically typed JavaScript values. */
object Dynamic {
  /** Dynamic view of the global scope. */
  @inline def global: Dynamic = scala.scalajs.runtime.environmentInfo.global

  /** Instantiates a new object of a JavaScript class. */
  def newInstance(clazz: Dynamic)(args: Any*): Object with Dynamic = sys.error("stub")

  /** Creates a new object with a literal syntax.
   *
   *  For example,
   *    js.Dynamic.literal(foo = 3, bar = "foobar")
   *  returns the JavaScript object
   *    {foo: 3, bar: "foobar"}
   */
  object literal extends scala.Dynamic {
    /** literal creation like this:
     *  js.Dynamic.literal(name1 = "value", name2 = "value")
     */
    def applyDynamicNamed(name: java.lang.String)(
        fields: (java.lang.String, Any)*): Object with Dynamic = sys.error("stub")

    /** literal creation like this:
     *  js.Dynamic.literal("name1" -> "value", "name2" -> "value")
     *
     *  Note that this could be simply `def apply`, but this would make the
     *  applyDynamicNamed fail, since a call with named arguments would
     *  be routed to the `def apply`, rather than def dynamic version.
     */
    def applyDynamic(name: java.lang.String)(
        fields: (java.lang.String, Any)*): Object with Dynamic = sys.error("stub")

  }
}

/** Base class of all JavaScript objects. */
class Object extends Any {
  def this(value: Any) = this()

  def toLocaleString(): String = native
  def valueOf(): scala.Any = native

  /** Tests whether this object has the specified property as a direct property.
   *
   *  Unlike [[js.Object.hasProperty]], this method does not check down the
   *  object's prototype chain.
   *
   * MDN
   */
  def hasOwnProperty(v: String): Boolean = native

  /** Tests whether this object is in the prototype chain of another object. */
  def isPrototypeOf(v: Object): Boolean = native

  /** Tests whether the specified property in an object can be enumerated by a
   *  call to [[js.Object.properties]], with the exception of properties
   *  inherited through the prototype chain. If the object does not have the
   *  specified property, this method returns false.
   *
   *  MDN
   */
  def propertyIsEnumerable(v: String): Boolean = native
}

/** The top-level `Object` JavaScript object. */
object Object extends Object {
  def apply(): Object = native
  def apply(value: Any): Object = native

  /** Tests whether the object has a property on itself or in its prototype
   *  chain. This method is the equivalent of `p in o` in JavaScript.
   */
  def hasProperty(o: Object, p: String): Boolean = sys.error("stub")

  /**
   * The Object.getPrototypeOf() method returns the prototype (i.e. the
   * internal [[Prototype]]) of the specified object.
   *
   * MDN
   */
  def getPrototypeOf(o: Object): Object = native

  /**
   * The Object.getOwnPropertyDescriptor() method returns a property descriptor
   * for an own property (that is, one directly present on an object, not
   * present by dint of being along an object's prototype chain) of a given object.
   *
   * MDN
   */
  def getOwnPropertyDescriptor(o: Object, p: String): PropertyDescriptor = native

  /**
   * Object.getOwnPropertyNames returns an array whose elements are strings
   * corresponding to the enumerable and non-enumerable properties found
   * directly upon obj. The ordering of the enumerable properties in the array
   * is consistent with the ordering exposed by a for...in loop (or by Object.keys)
   * over the properties of the object. The ordering of the non-enumerable
   * properties in the array, and among the enumerable properties, is not defined.
   *
   * MDN
   */
  def getOwnPropertyNames(o: Object): Array[String] = native

  /**
   * The Object.create() method creates a new object with the specified
   * prototype object and properties.
   *
   * MDN
   */
  def create(o: Object, properties: Any): Object = native
  def create(o: Object): Object = native

  /**
   * The Object.defineProperty() method defines a new property directly on an
   * object, or modifies an existing property on an object, and returns the
   * object.
   *
   * This method allows precise addition to or modification of a property on an
   * object. Normal property addition through assignment creates properties
   * which show up during property enumeration (for...in loop or Object.keys method),
   * whose values may be changed, and which may be deleted. This method allows
   * these extra details to be changed from their defaults.
   *
   * Property descriptors present in objects come in two main flavors: data
   * descriptors and accessor descriptors. A data descriptor is a property
   * that has a value, which may or may not be writable. An accessor descriptor
   * is a property described by a getter-setter pair of functions. A descriptor
   * must be one of these two flavors; it cannot be both.
   *
   * MDN
   */
  def defineProperty(o: Object, p: String, attributes: PropertyDescriptor): o.type = native

  /**
   * The Object.defineProperties() method defines new or modifies existing
   * properties directly on an object, returning the object.
   *
   * MDN
   */
  def defineProperties(o: Object, properties: Any): o.type = native

  /**
   * The Object.seal() method seals an object, preventing new properties from
   * being added to it and marking all existing properties as non-configurable.
   * Values of present properties can still be changed as long as they are
   * writable.
   *
   * MDN
   */
  def seal(o: Object): o.type = native

  /**
   * The Object.freeze() method freezes an object: that is, prevents new properties
   * from being added to it; prevents existing properties from being removed;
   * and prevents existing properties, or their enumerability, configurability,
   * or writability, from being changed. In essence the object is made effectively
   * immutable. The method returns the object being frozen.
   *
   * MDN
   */
  def freeze(o: Object): o.type = native

  /**
   * The Object.preventExtensions() method prevents new properties from ever
   * being added to an object (i.e. prevents future extensions to the object).
   *
   * An object is extensible if new properties can be added to it.  preventExtensions
   * marks an object as no longer extensible, so that it will never have
   * properties beyond the ones it had at the time it was marked as non-extensible.
   * Note that the properties of a non-extensible object, in general, may still be
   * deleted. Attempting to add new properties to a non-extensible object will
   * fail, either silently or by throwing a TypeError (most commonly, but not
   * exclusively, when in strict mode).
   *
   * Object.preventExtensions only prevents addition of own properties. Properties
   * can still be added to the object prototype. However, calling Object.preventExtensions
   * on an object will also prevent extensions on its __proto__ property.
   *
   * MDN
   */
  def preventExtensions(o: Object): o.type = native

  /**
   * Returns true if the object is sealed, otherwise false. An object is sealed
   * if it is not extensible and if all its properties are non-configurable and
   * therefore not removable (but not necessarily non-writable).
   *
   * MDN
   */
  def isSealed(o: Object): Boolean = native

  /**
   * The Object.isFrozen() determines if an object is frozen.
   *
   * An object is frozen if and only if it is not extensible, all its properties
   * are non-configurable, and all its data properties (that is, properties which
   * are not accessor properties with getter or setter components) are non-writable.
   *
   * MDN
   */
  def isFrozen(o: Object): Boolean = native

  /**
   * Determines if extending of an object is allowed
   *
   * Objects are extensible by default: they can have new properties added to
   * them, and (in engines that support __proto__  their __proto__ property)
   * can be modified. An object can be marked as non-extensible using
   * Object.preventExtensions, Object.seal, or Object.freeze
   *
   * MDN
   */
  def isExtensible(o: Object): Boolean = native

  /**
   * The Object.keys() method returns an array of a given object's own enumerable
   * properties, in the same order as that provided by a for...in loop (the
   * difference being that a for-in loop enumerates properties in the prototype
   * chain as well).
   *
   * MDN
   */
  def keys(o: Object): Array[String] = native

  /** Returns the names of all the enumerable properties of this object,
   *  including properties in its prototype chain.
   *
   *  This method returns the same set of names that would be enumerated by
   *  a for-in loop in JavaScript, but not necessarily in the same order.
   *
   *  If the underlying implementation guarantees an order for for-in loops,
   *  then this is guaranteed to be consistent with [[keys]], in the sense
   *  that the list returned by [[keys]] is a sublist of the list returned by
   *  this method (not just a subset).
   */
  def properties(o: Any): Array[String] = sys.error("stub")
}

package prim {

/** Primitive JavaScript number.
 *
 *  In most situations, you should not need this trait, and use
 *  [[scala.Double]] instead (or [[scala.Int]] where appropriate).
 */
sealed trait Number extends Any {
  def unary_+(): Number = native
  def unary_-(): Number = native
  def unary_~(): Number = native

  def +(that: Number): Number = native
  def -(that: Number): Number = native
  def *(that: Number): Number = native
  def /(that: Number): Number = native
  def %(that: Number): Number = native
  def <<(that: Number): Number = native
  def >>(that: Number): Number = native
  def >>>(that: Number): Number = native
  def &(that: Number): Number = native
  def |(that: Number): Number = native
  def ^(that: Number): Number = native

  def +(that: Dynamic): Dynamic = native // could be a String if that is a String
  def -(that: Dynamic): Number = native
  def *(that: Dynamic): Number = native
  def /(that: Dynamic): Number = native
  def %(that: Dynamic): Number = native
  def <<(that: Dynamic): Number = native
  def >>(that: Dynamic): Number = native
  def >>>(that: Dynamic): Number = native
  def &(that: Dynamic): Number = native
  def |(that: Dynamic): Number = native
  def ^(that: Dynamic): Number = native

  def <(that: Number): Boolean = native
  def >(that: Number): Boolean = native
  def <=(that: Number): Boolean = native
  def >=(that: Number): Boolean = native

  def <(that: Dynamic): Boolean = native
  def >(that: Dynamic): Boolean = native
  def <=(that: Dynamic): Boolean = native
  def >=(that: Dynamic): Boolean = native

  def toString(radix: Number): String = native

  /**
   * Returns a string representation of number that does not use exponential
   * notation and has exactly digits digits after the decimal place. The number
   * is rounded if necessary, and the fractional part is padded with zeros if
   * necessary so that it has the specified length. If number is greater than
   * 1e+21, this method simply calls Number.prototype.toString() and returns
   * a string in exponential notation.
   *
   * MDN
   */
  def toFixed(fractionDigits: Number): String = native
  def toFixed(): String = native

  /**
   * Returns a string representing a Number object in exponential notation with one
   * digit before the decimal point, rounded to fractionDigits digits after the
   * decimal point. If the fractionDigits argument is omitted, the number of
   * digits after the decimal point defaults to the number of digits necessary
   * to represent the value uniquely.
   *
   * If a number has more digits that requested by the fractionDigits parameter,
   * the number is rounded to the nearest number represented by fractionDigits
   * digits. See the discussion of rounding in the description of the toFixed()
   * method, which also applies to toExponential().
   *
   * MDN
   */
  def toExponential(fractionDigits: Number): String = native
  def toExponential(): String = native

  /**
   * Returns a string representing a Number object in fixed-point or exponential
   * notation rounded to precision significant digits. See the discussion of
   * rounding in the description of the Number.prototype.toFixed() method, which
   * also applies to toPrecision.
   *
   * If the precision argument is omitted, behaves as Number.prototype.toString().
   * If it is a non-integer value, it is rounded to the nearest integer.
   *
   * MDN
   */
  def toPrecision(precision: Number): String = native
  def toPrecision(): String = native
}

/** The top-level `Number` JavaScript object */
object Number extends Object {
  /**
   * The Number.MAX_VALUE property represents the maximum numeric value
   * representable in JavaScript.
   *
   * The MAX_VALUE property has a value of approximately 1.79E+308. Values
   * larger than MAX_VALUE are represented as "Infinity".
   *
   * MDN
   */
  val MAX_VALUE: Double = native
  /**
   * The Number.MIN_VALUE property represents the smallest positive numeric
   * value representable in JavaScript.
   *
   * The MIN_VALUE property is the number closest to 0, not the most negative
   * number, that JavaScript can represent.
   *
   * MIN_VALUE has a value of approximately 5e-324. Values smaller than MIN_VALUE
   * ("underflow values") are converted to 0.
   *
   * MDN
   */
  val MIN_VALUE: Double = native
  /**
   * The Number.NaN property represents Not-A-Number. Equivalent of NaN.
   *
   * MDN
   */
  val NaN: Double = native

  /**
   * The Number.NEGATIVE_INFINITY property represents the negative Infinity value.
   *
   * MDN
   */
  val NEGATIVE_INFINITY: Double = native
  /**
   * The Number.POSITIVE_INFINITY property represents the positive Infinity value.
   *
   * MDN
   */
  val POSITIVE_INFINITY: Double = native
}

/** Primitive JavaScript boolean.
 *
 *  In most situations, you should not need this trait, and use
 *  [[scala.Boolean]] instead.
 */
sealed trait Boolean extends Any {
  def unary_!(): scala.Boolean = native

  def &&(that: Boolean): Boolean = native
  def ||(that: Boolean): Boolean = native

  // See the comment in `Dynamic` for the rationale of returning Boolean here.
  def &&(that: Dynamic): Boolean = native
  def ||(that: Dynamic): Boolean = native
}

/** The top-level `Boolean` JavaScript object. */
object Boolean extends Object

/** Primitive JavaScript string.
 *
 *  In most situations, you should not need this trait, and use
 *  [[java.lang.String]] instead.
 */
sealed trait String extends Any {
  def +(that: String): String = native
  def +(that: Any): String = native
  def +(that: Dynamic): String = native

  def < (that: String): Boolean = native
  def < (that: Dynamic): Boolean = native

  def > (that: String): Boolean = native
  def > (that: Dynamic): Boolean = native

  def <=(that: String): Boolean = native
  def <=(that: Dynamic): Boolean = native

  def >=(that: String): Boolean = native
  def >=(that: Dynamic): Boolean = native

  /**
   * This property returns the number of code units in the string. UTF-16,
   * the string format used by JavaScript, uses a single 16-bit code unit to
   * represent the most common characters, but needs to use two code units for
   * less commonly-used characters, so it's possible for the value returned by
   * length to not match the actual number of characters in the string.
   *
   * For an empty string, length is 0.
   *
   * MDN
   */
  val length: Number = native

  /**
   * The chartAt() method returns the specified character from a string.
   *
   * Characters in a string are indexed from left to right. The index of the
   * first character is 0, and the index of the last character in a string
   * called stringName is stringName.length - 1. If the index you supply is out
   * of range, JavaScript returns an empty string.
   *
   * MDN
   */
  def charAt(pos: Number): String = native

  /**
   * The charCodeAt() method returns the numeric Unicode value of the character
   * at the given index (except for unicode codepoints > 0x10000).
   *
   * MDN
   */
  def charCodeAt(index: Number): Number = native

  /**
   * concat combines the text from one or more strings and returns a new string.
   * Changes to the text in one string do not affect the other string.
   * MDN
   */
  def concat(strings: String*): String = native

  /**
   * Returns the index within the calling String object of the first occurrence
   * of the specified value, starting the search at fromIndex,
   *
   * returns -1 if the value is not found.
   *
   * MDN
   */
  def indexOf(searchString: String, position: Number): Number = native
  def indexOf(searchString: String): Number = native

  /**
   * Returns the index within the calling String object of the last occurrence
   * of the specified value, or -1 if not found. The calling string is searched
   * backward, starting at fromIndex.
   *
   * MDN
   */
  def lastIndexOf(searchString: String, position: Number): Number = native
  def lastIndexOf(searchString: String): Number = native

  /**
   * Returns a number indicating whether a reference string comes before or
   * after or is the same as the given string in sort order. The new locales
   * and options arguments let applications specify the language whose sort
   * order should be used and customize the behavior of the function. In older
   * implementations, which ignore the locales and options arguments, the locale
   * and sort order used are entirely implementation dependent.
   *
   * MDN
   */
  def localeCompare(that: String): Number = native

  /**
   * Used to retrieve the matches when matching a string against a regular
   * expression.
   *
   * If the regular expression does not include the g flag, returns the same
   * result as regexp.exec(string). The returned Array has an extra input
   * property, which contains the original string that was parsed. In addition,
   * it has an index property, which represents the zero-based index of the
   * match in the string.
   *
   * If the regular expression includes the g flag, the method returns an Array
   * containing all matches. If there were no matches, the method returns null.
   *
   * MDN
   */
  def `match`(regexp: String): Array[String] = native
  def `match`(regexp: RegExp): Array[String] = native

  /**
   * Returns a new string with some or all matches of a pattern replaced by a
   * replacement.  The pattern can be a string or a RegExp, and the replacement
   * can be a string or a function to be called for each match.
   *
   * This method does not change the String object it is called on. It simply
   * returns a new string.
   *
   * To perform a global search and replace, either include the g switch in the
   * regular expression or if the first parameter is a string, include g in the
   * flags parameter.
   *
   * MDN
   */
  def replace(searchValue: String, replaceValue: String): String = native
  def replace(searchValue: String, replaceValue: Any): String = native
  def replace(searchValue: RegExp, replaceValue: String): String = native
  def replace(searchValue: RegExp, replaceValue: Any): String = native

  /**
   * If successful, search returns the index of the regular expression inside
   * the string. Otherwise, it returns -1.
   *
   * When you want to know whether a pattern is found in a string use search
   * (similar to the regular expression test method); for more information
   * (but slower execution) use match (similar to the regular expression exec
   * method).
   *
   * MDN
   */
  def search(regexp: String): Number = native
  def search(regexp: RegExp): Number = native

  /**
   * slice extracts the text from one string and returns a new string. Changes
   * to the text in one string do not affect the other string.
   *
   * slice extracts up to but not including endSlice. string.slice(1,4) extracts
   * the second character through the fourth character (characters indexed 1, 2,
   * and 3).
   *
   * As an example, string.slice(2,-1) extracts the third character through the
   * second to last character in the string.
   *
   * MDN
   */
  def slice(start: Number, end: Number): String = native
  def slice(start: Number): String = native

  /**
   * Splits a String object into an array of strings by separating the string
   * into substrings.
   *
   * When found, separator is removed from the string and the substrings are
   * returned in an array. If separator is omitted, the array contains one
   * element consisting of the entire string. If separator is an empty string,
   * string is converted to an array of characters.
   *
   * If separator is a regular expression that contains capturing parentheses,
   * then each time separator is matched, the results (including any undefined
   * results) of the capturing parentheses are spliced into the output array.
   * However, not all browsers support this capability.
   *
   * Note: When the string is empty, split returns an array containing one
   * empty string, rather than an empty array.
   *
   * MDN
   */
  def split(separator: String, limit: Number): Array[String] = native
  def split(separator: String): Array[String] = native
  def split(separator: RegExp, limit: Number): Array[String] = native
  def split(separator: RegExp): Array[String] = native

  /**
   * Returns a subset of a string between one index and another, or through
   * the end of the string.
   *
   * MDN
   */
  def substring(start: Number, end: Number): String = native
  def substring(start: Number): String = native

  /**
   * Returns the calling string value converted to lowercase.
   *
   * MDN
   */
  def toLowerCase(): String = native

  /**
   * The toLocaleLowerCase method returns the value of the string converted to
   * lower case according to any locale-specific case mappings. toLocaleLowerCase
   * does not affect the value of the string itself. In most cases, this will
   * produce the same result as toLowerCase(), but for some locales, such as
   * Turkish, whose case mappings do not follow the default case mappings in Unicode,
   * there may be a different result.
   *
   * MDN
   */
  def toLocaleLowerCase(): String = native

  /**
   * Returns the calling string value converted to uppercase.
   *
   * MDN
   */
  def toUpperCase(): String = native

  /**
   * The toLocaleUpperCase method returns the value of the string converted to
   * upper case according to any locale-specific case mappings. toLocaleUpperCase
   * does not affect the value of the string itself. In most cases, this will
   * produce the same result as toUpperCase(), but for some locales, such as
   * Turkish, whose case mappings do not follow the default case mappings in Unicode,
   * there may be a different result.
   *
   * MDN
   */
  def toLocaleUpperCase(): String = native

  /**
   * Removes whitespace from both ends of the string.
   *
   * MDN
   */
  def trim(): String = native
}

/** The top-level `String` JavaScript object. */
object String extends Object {
  def fromCharCode(codes: Int*): java.lang.String = native
}

/** Primitive JavaScript undefined value.
 *
 *  In most situations, you should not need this trait, and use
 *  [[scala.Unit]] instead.
 */
sealed trait Undefined extends Any

}