SvgTags

implicit abstract def SeqFrag[A](xs: Seq[A])(implicit ev: (A) ⇒ generic.Frag[Element, Node]): generic.Frag[Element, Node]

Renders an Seq of FragT into a single FragT

implicit abstract def UnitFrag(u: Unit): generic.Frag[Element, Node]

Lets you put Unit into a scalatags tree, as a no-op.

abstract def makeAbstractTypedTag[T <: Element](tag: String, void: Boolean, namespaceConfig: Namespace): ConcreteHtmlTag[T]

implicit abstract def stringAttrX: AttrValue[Element, String]

implicit abstract def stringPixelStyleX: PixelStyleValue[Element, String]

implicit abstract def stringStyleX: StyleValue[Element, String]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

implicit def ArrayFrag[A](xs: Array[A])(implicit ev: (A) ⇒ generic.Frag[Element, Node]): generic.Frag[Element, Node]

Renders an Seq of FragT into a single FragT

implicit def ArrayNode[A](xs: Array[A])(implicit ev: (A) ⇒ Modifier[Element]): SeqNode[A]

Allows you to modify a ConcreteHtmlTag by adding an Array containing other nest-able objects to its list of children.

implicit def OptionFrag[A](xs: Option[A])(implicit ev: (A) ⇒ generic.Frag[Element, Node]): generic.Frag[Element, Node]

Renders an Option of FragT into a single FragT

implicit def OptionNode[A](xs: Option[A])(implicit ev: (A) ⇒ Modifier[Element]): SeqNode[A]

Allows you to modify a ConcreteHtmlTag by adding an Option containing other nest-able objects to its list of children.

lazy val altGlyph: ConcreteHtmlTag[Element]

lazy val altGlyphDef: ConcreteHtmlTag[Element]

lazy val altGlyphItem: ConcreteHtmlTag[Element]

lazy val animate: ConcreteHtmlTag[Element]

lazy val animateMotion: ConcreteHtmlTag[Element]

lazy val animateTransform: ConcreteHtmlTag[Element]

final def asInstanceOf[T0]: T0

def attr(s: String, ns: Namespace = null, raw: Boolean = false): Attr

Constructs an Attr attribute object from a string; can be used inline:

div(
attr("hello-world-special-attr") := "foo
)

val hello = attr("hello-world-special-attr")
div(
  hello := "foo
)

lazy val circle: ConcreteHtmlTag[Circle]

lazy val clipPath: ConcreteHtmlTag[ClipPath]

def clone(): AnyRef

lazy val color-profile: ConcreteHtmlTag[Element]

def css(s: String): Style

Constructs a CSS Style from a string, can be used inline

div(
css("-moz-special-style") := "foo"
)

val mozSpecial := css("-moz-special-style")
div(
  mozSpecial := "foo"
)

lazy val cursor: ConcreteHtmlTag[Element]

lazy val defs: ConcreteHtmlTag[Defs]

lazy val desc: ConcreteHtmlTag[Desc]

lazy val ellipse: ConcreteHtmlTag[Ellipse]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

lazy val feBlend: ConcreteHtmlTag[FEBlend]

lazy val feColorMatrix: ConcreteHtmlTag[FEColorMatrix]

lazy val feComponentTransfer: ConcreteHtmlTag[ComponentTransferFunction]

lazy val feComposite: ConcreteHtmlTag[FEComposite]

lazy val feConvolveMatrix: ConcreteHtmlTag[FEConvolveMatrix]

lazy val feDiffuseLighting: ConcreteHtmlTag[FEDiffuseLighting]

lazy val feDisplacementMap: ConcreteHtmlTag[FEDisplacementMap]

lazy val feDistantLighting: ConcreteHtmlTag[FEDistantLight]

lazy val feFlood: ConcreteHtmlTag[FEFlood]

lazy val feFuncA: ConcreteHtmlTag[FEFuncA]

lazy val feFuncB: ConcreteHtmlTag[FEFuncB]

lazy val feFuncG: ConcreteHtmlTag[FEFuncG]

lazy val feFuncR: ConcreteHtmlTag[FEFuncR]

lazy val feGaussianBlur: ConcreteHtmlTag[FEGaussianBlur]

lazy val feImage: ConcreteHtmlTag[FEImage]

lazy val feMerge: ConcreteHtmlTag[FEMerge]

lazy val feMergeNode: ConcreteHtmlTag[FEMergeNode]

lazy val feMorphology: ConcreteHtmlTag[FEMorphology]

lazy val feOffset: ConcreteHtmlTag[FEOffset]

lazy val fePointLight: ConcreteHtmlTag[FEPointLight]

lazy val feSpecularLighting: ConcreteHtmlTag[FESpecularLighting]

lazy val feSpotlight: ConcreteHtmlTag[FESpotLight]

lazy val feTile: ConcreteHtmlTag[FETile]

lazy val feTurbulance: ConcreteHtmlTag[FETurbulence]

lazy val filter: ConcreteHtmlTag[Filter]

def finalize(): Unit

lazy val font: ConcreteHtmlTag[Element]

lazy val font-face: ConcreteHtmlTag[Element]

lazy val font-face-format: ConcreteHtmlTag[Element]

lazy val font-face-name: ConcreteHtmlTag[Element]

lazy val font-face-src: ConcreteHtmlTag[Element]

lazy val font-face-uri: ConcreteHtmlTag[Element]

lazy val foreignObject: ConcreteHtmlTag[Element]

def frag(frags: generic.Frag[Element, Node]*): generic.Frag[Element, Node]

lazy val g: ConcreteHtmlTag[G]

final def getClass(): Class[_]

lazy val glyph: ConcreteHtmlTag[Element]

lazy val glyphRef: ConcreteHtmlTag[Element]

def hashCode(): Int

lazy val hkern: ConcreteHtmlTag[Element]

lazy val image: ConcreteHtmlTag[Image]

final def isInstanceOf[T0]: Boolean

lazy val line: ConcreteHtmlTag[Line]

lazy val linearGradient: ConcreteHtmlTag[LinearGradient]

lazy val marker: ConcreteHtmlTag[Marker]

lazy val mask: ConcreteHtmlTag[Mask]

lazy val metadata: ConcreteHtmlTag[Metadata]

lazy val missing-glyph: ConcreteHtmlTag[Element]

def modifier(mods: Modifier[Element]*): Modifier[Element]

lazy val mpath: ConcreteHtmlTag[Element]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val path: ConcreteHtmlTag[Path]

lazy val pattern: ConcreteHtmlTag[Pattern]

lazy val polygon: ConcreteHtmlTag[Polygon]

lazy val polyline: ConcreteHtmlTag[Polyline]

lazy val radialGradient: ConcreteHtmlTag[RadialGradient]

lazy val rect: ConcreteHtmlTag[RectElement]

lazy val set: ConcreteHtmlTag[Element]

lazy val stop: ConcreteHtmlTag[Stop]

lazy val svg: ConcreteHtmlTag[SVG]

implicit lazy val svgNamespaceConfig: Namespace

lazy val switch: ConcreteHtmlTag[Switch]

lazy val symbol: ConcreteHtmlTag[Symbol]

final def synchronized[T0](arg0: ⇒ T0): T0

def tag(s: String, void: Boolean = false): ConcreteHtmlTag[Element]

lazy val text: ConcreteHtmlTag[Text]

lazy val textPath: ConcreteHtmlTag[TextPath]

def toString(): String

lazy val tref: ConcreteHtmlTag[Element]

lazy val tspan: ConcreteHtmlTag[TSpan]

def typedTag[T <: Element](s: String, void: Boolean = false)(implicit ns: Namespace): ConcreteHtmlTag[T]

lazy val use: ConcreteHtmlTag[Use]

lazy val view: ConcreteHtmlTag[View]

lazy val vkern: ConcreteHtmlTag[Element]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit