A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://www.scala-lang.org/api/2.13.10/scala/collection/mutable/StringBuilder.html below:

Scala Standard Library 2.13.10 - scala.collection.mutable.StringBuilder

final class StringBuilder extends AbstractSeq[Char] with ReusableBuilder[Char, String] with IndexedSeq[Char] with IndexedSeqOps[Char, IndexedSeq, StringBuilder] with IterableFactoryDefaults[Char, IndexedSeq] with CharSequence with Serializable



Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. StringBuilder
  2. Serializable
  3. CharSequence
  4. IndexedSeq
  5. IndexedSeqOps
  6. IndexedSeq
  7. IndexedSeqOps
  8. ReusableBuilder
  9. Builder
  10. Growable
  11. Clearable
  12. AbstractSeq
  13. Seq
  14. SeqOps
  15. Cloneable
  16. Cloneable
  17. Iterable
  18. AbstractSeq
  19. Seq
  20. Equals
  21. SeqOps
  22. PartialFunction
  23. Function1
  24. AbstractIterable
  25. Iterable
  26. IterableFactoryDefaults
  27. IterableOps
  28. IterableOnceOps
  29. IterableOnce
  30. AnyRef
  31. Any
Implicitly
  1. by iterableOnceExtensionMethods
  2. by any2stringadd
  3. by StringFormat
  4. by Ensuring
  5. by ArrowAssoc
Visibility
  1. Public
  2. Protected
Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##: Int
  3.  def +(other: String): String
  4.  final def ++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
  5.  final def ++:[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]
  6.  def ++=(s: String): StringBuilder.this.type
  7.  final def ++=(xs: IterableOnce[Char]): StringBuilder.this.type
  8.  final def +:[B >: Char](elem: B): IndexedSeq[B]
  9.  final def +=(elem: Char): StringBuilder.this.type
  10.  def ->[B](y: B): (StringBuilder, B)
  11.  final def :+[B >: Char](elem: B): IndexedSeq[B]
  12.  final def :++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
  13.  final def ==(arg0: Any): Boolean
  14.  def addAll(s: String): StringBuilder.this.type
  15.  def addAll(xs: IterableOnce[Char]): StringBuilder.this.type
  16.  def addOne(x: Char): StringBuilder.this.type
  17.  final def addString(b: StringBuilder): b.type
  18.  final def addString(b: StringBuilder, sep: String): b.type
  19.  def addString(b: StringBuilder, start: String, sep: String, end: String): b.type
  20.  def andThen[C](k: PartialFunction[Char, C]): PartialFunction[Int, C]
  21.  def andThen[C](k: (Char) => C): PartialFunction[Int, C]
  22.  def append(x: Char): StringBuilder.this.type
  23.  def append(x: Double): StringBuilder.this.type
  24.  def append(x: Float): StringBuilder.this.type
  25.  def append(x: Long): StringBuilder.this.type
  26.  def append(x: Int): StringBuilder.this.type
  27.  def append(x: Short): StringBuilder.this.type
  28.  def append(x: Byte): StringBuilder.this.type
  29.  def append(x: Boolean): StringBuilder.this.type
  30.  def append(s: StringBuilder): StringBuilder.this.type
  31.  def append(cs: CharSequence): StringBuilder.this.type
  32.  def append(s: String): StringBuilder.this.type
  33.  def append(x: Any): StringBuilder.this.type
  34.  def appendAll(xs: Array[Char], offset: Int, len: Int): StringBuilder.this.type
  35.  def appendAll(xs: Array[Char]): StringBuilder.this.type
  36.  def appendAll(xs: IterableOnce[Char]): StringBuilder.this.type
  37.  def appendAll(xs: String): StringBuilder.this.type
  38.  def appended[B >: Char](elem: B): IndexedSeq[B]
  39.  def appendedAll[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
  40.  def apply(i: Int): Char
  41.  def applyOrElse[A1 <: Int, B1 >: Char](x: A1, default: (A1) => B1): B1
  42.  final def asInstanceOf[T0]: T0
  43.  def canEqual(that: Any): Boolean
  44.  def capacity: Int
  45.  def charAt(index: Int): Char
  46.  def chars(): IntStream
  47.  def className: String
  48.  def clear(): Unit
  49.  def clone(): StringBuilder
  50.  def codePoints(): IntStream
  51.  final def coll: StringBuilder.this.type
  52.  def collect[B](pf: PartialFunction[Char, B]): IndexedSeq[B]
  53.  def collectFirst[B](pf: PartialFunction[Char, B]): Option[B]
  54.  def combinations(n: Int): Iterator[StringBuilder]
  55.  def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, Char]
  56.  def compose[A](g: (A) => Int): (A) => Char
  57.  final def concat[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
  58.  def contains[A1 >: Char](elem: A1): Boolean
  59.  def containsSlice[B >: Char](that: collection.Seq[B]): Boolean
  60.  def copyToArray[B >: Char](xs: Array[B], start: Int, len: Int): Int
  61.  def copyToArray[B >: Char](xs: Array[B], start: Int): Int
  62.  def copyToArray[B >: Char](xs: Array[B]): Int
  63.  def corresponds[B](that: collection.Seq[B])(p: (Char, B) => Boolean): Boolean
  64.  def corresponds[B](that: IterableOnce[B])(p: (Char, B) => Boolean): Boolean
  65.  def count(p: (Char) => Boolean): Int
  66.  def delete(start: Int, end: Int): StringBuilder.this.type
  67.  def deleteCharAt(index: Int): StringBuilder.this.type
  68.  def diff[B >: Char](that: collection.Seq[B]): StringBuilder
  69.  def distinct: StringBuilder
  70.  def distinctBy[B](f: (Char) => B): StringBuilder
  71.  def drop(n: Int): StringBuilder
  72.  def dropRight(n: Int): StringBuilder
  73.  def dropWhile(p: (Char) => Boolean): StringBuilder
  74.  def elementWise: ElementWiseExtractor[Int, Char]
  75.  def empty: StringBuilder
  76.  def endsWith[B >: Char](that: collection.Iterable[B]): Boolean
  77.  def ensureCapacity(newCapacity: Int): Unit
  78.  def ensuring(cond: (StringBuilder) => Boolean, msg: => Any): StringBuilder
  79.  def ensuring(cond: (StringBuilder) => Boolean): StringBuilder
  80.  def ensuring(cond: Boolean, msg: => Any): StringBuilder
  81.  def ensuring(cond: Boolean): StringBuilder
  82.  final def eq(arg0: AnyRef): Boolean
  83.  def equals(o: Any): Boolean
  84.  def exists(p: (Char) => Boolean): Boolean
  85.  def filter(pred: (Char) => Boolean): StringBuilder
  86.  def filterNot(pred: (Char) => Boolean): StringBuilder
  87.  def finalize(): Unit
  88.  def find(p: (Char) => Boolean): Option[Char]
  89.  def findLast(p: (Char) => Boolean): Option[Char]
  90.  def flatMap[B](f: (Char) => IterableOnce[B]): IndexedSeq[B]
  91.  def flatten[B](implicit asIterable: (Char) => IterableOnce[B]): IndexedSeq[B]
  92.  def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1
  93.  def foldLeft[B](z: B)(op: (B, Char) => B): B
  94.  def foldRight[B](z: B)(op: (Char, B) => B): B
  95.  def forall(p: (Char) => Boolean): Boolean
  96.  def foreach[U](f: (Char) => U): Unit
  97.  def fromSpecific(coll: IterableOnce[Char]): StringBuilder
  98.  final def getClass(): Class[_ <: AnyRef]
  99.  def groupBy[K](f: (Char) => K): immutable.Map[K, StringBuilder]
  100.  def groupMap[K, B](key: (Char) => K)(f: (Char) => B): immutable.Map[K, IndexedSeq[B]]
  101.  def groupMapReduce[K, B](key: (Char) => K)(f: (Char) => B)(reduce: (B, B) => B): immutable.Map[K, B]
  102.  def grouped(size: Int): Iterator[StringBuilder]
  103.  def hashCode(): Int
  104.  def head: Char
  105.  def headOption: Option[Char]
  106.  def indexOf(str: String, fromIndex: Int): Int
  107.  def indexOf(str: String): Int
  108.  def indexOf[B >: Char](elem: B): Int
  109.  def indexOf[B >: Char](elem: B, from: Int): Int
  110.  def indexOfSlice[B >: Char](that: collection.Seq[B]): Int
  111.  def indexOfSlice[B >: Char](that: collection.Seq[B], from: Int): Int
  112.  def indexWhere(p: (Char) => Boolean): Int
  113.  def indexWhere(p: (Char) => Boolean, from: Int): Int
  114.  def indices: immutable.Range
  115.  def init: StringBuilder
  116.  def inits: Iterator[StringBuilder]
  117.  def insert(index: Int, x: Char): StringBuilder.this.type
  118.  def insert(index: Int, x: Double): StringBuilder.this.type
  119.  def insert(index: Int, x: Float): StringBuilder.this.type
  120.  def insert(index: Int, x: Long): StringBuilder.this.type
  121.  def insert(index: Int, x: Int): StringBuilder.this.type
  122.  def insert(index: Int, x: Short): StringBuilder.this.type
  123.  def insert(index: Int, x: Byte): StringBuilder.this.type
  124.  def insert(index: Int, x: Boolean): StringBuilder.this.type
  125.  def insert(index: Int, x: String): StringBuilder.this.type
  126.  def insert(index: Int, x: Any): StringBuilder.this.type
  127.  def insertAll(index: Int, xs: Array[Char]): StringBuilder.this.type
  128.  def insertAll(index: Int, xs: IterableOnce[Char]): StringBuilder.this.type
  129.  def insertAll(index: Int, str: Array[Char], offset: Int, len: Int): StringBuilder.this.type
  130.  def intersect[B >: Char](that: collection.Seq[B]): StringBuilder
  131.  def isDefinedAt(idx: Int): Boolean
  132.  def isEmpty: Boolean
  133.  final def isInstanceOf[T0]: Boolean
  134.  def isTraversableAgain: Boolean
  135.  def iterableFactory: SeqFactory[IndexedSeq]
  136.  def iterator: Iterator[Char]
  137.  def knownSize: Int
  138.  def last: Char
  139.  def lastIndexOf(str: String, fromIndex: Int): Int
  140.  def lastIndexOf(str: String): Int
  141.  def lastIndexOf[B >: Char](elem: B, end: Int = length - 1): Int
  142.  def lastIndexOfSlice[B >: Char](that: collection.Seq[B]): Int
  143.  def lastIndexOfSlice[B >: Char](that: collection.Seq[B], end: Int): Int
  144.  def lastIndexWhere(p: (Char) => Boolean): Int
  145.  def lastIndexWhere(p: (Char) => Boolean, end: Int): Int
  146.  def lastOption: Option[Char]
  147.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[Char, B, StringBuilder.this.type]
  148.  def length(): Int
  149.  final def lengthCompare(that: collection.Iterable[_]): Int
  150.  final def lengthCompare(len: Int): Int
  151.  final def lengthIs: SizeCompareOps
  152.  def length_=(n: Int): Unit
  153.  def lift: (Int) => Option[Char]
  154.  def map[B](f: (Char) => B): IndexedSeq[B]
  155.  def mapInPlace(f: (Char) => Char): StringBuilder.this.type
  156.  def mapResult[NewTo](f: (String) => NewTo): Builder[Char, NewTo]
  157.  def max[B >: Char](implicit ord: math.Ordering[B]): Char
  158.  def maxBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
  159.  def maxByOption[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Option[Char]
  160.  def maxOption[B >: Char](implicit ord: math.Ordering[B]): Option[Char]
  161.  def min[B >: Char](implicit ord: math.Ordering[B]): Char
  162.  def minBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
  163.  def minByOption[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Option[Char]
  164.  def minOption[B >: Char](implicit ord: math.Ordering[B]): Option[Char]
  165.  final def mkString: String
  166.  final def mkString(sep: String): String
  167.  final def mkString(start: String, sep: String, end: String): String
  168.  final def ne(arg0: AnyRef): Boolean
  169.  def newSpecificBuilder: Builder[Char, StringBuilder]
  170.  def nonEmpty: Boolean
  171.  final def notify(): Unit
  172.  final def notifyAll(): Unit
  173.  def occCounts[B](sq: collection.Seq[B]): Map[B, Int]
  174.  def orElse[A1 <: Int, B1 >: Char](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
  175.  def padTo[B >: Char](len: Int, elem: B): IndexedSeq[B]
  176.  def partition(p: (Char) => Boolean): (StringBuilder, StringBuilder)
  177.  def partitionMap[A1, A2](f: (Char) => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])
  178.  def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]
  179.  def permutations: Iterator[StringBuilder]
  180.  def prepended[B >: Char](elem: B): IndexedSeq[B]
  181.  def prependedAll[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]
  182.  def product[B >: Char](implicit num: math.Numeric[B]): B
  183.  def reduce[B >: Char](op: (B, B) => B): B
  184.  def reduceLeft[B >: Char](op: (B, Char) => B): B
  185.  def reduceLeftOption[B >: Char](op: (B, Char) => B): Option[B]
  186.  def reduceOption[B >: Char](op: (B, B) => B): Option[B]
  187.  def reduceRight[B >: Char](op: (Char, B) => B): B
  188.  def reduceRightOption[B >: Char](op: (Char, B) => B): Option[B]
  189.  def replace(start: Int, end: Int, str: String): StringBuilder.this.type
  190.  def result(): String
  191.  def reverse: StringBuilder
  192.  def reverseInPlace(): StringBuilder.this.type
  193.  def reverseIterator: Iterator[Char]
  194.  def reversed: collection.Iterable[Char]
  195.  def runWith[U](action: (Char) => U): (Int) => Boolean
  196.  def sameElements[B >: Char](that: IterableOnce[B]): Boolean
  197.  def scan[B >: Char](z: B)(op: (B, B) => B): IndexedSeq[B]
  198.  def scanLeft[B](z: B)(op: (B, Char) => B): IndexedSeq[B]
  199.  def scanRight[B](z: B)(op: (Char, B) => B): IndexedSeq[B]
  200.  def search[B >: Char](elem: B, from: Int, to: Int)(implicit ord: math.Ordering[B]): SearchResult
  201.  def search[B >: Char](elem: B)(implicit ord: math.Ordering[B]): SearchResult
  202.  def segmentLength(p: (Char) => Boolean, from: Int): Int
  203.  final def segmentLength(p: (Char) => Boolean): Int
  204.  def setCharAt(index: Int, ch: Char): StringBuilder.this.type
  205.  def setLength(len: Int): Unit
  206.  final def size: Int
  207.  final def sizeCompare(that: collection.Iterable[_]): Int
  208.  final def sizeCompare(otherSize: Int): Int
  209.  final def sizeHint(coll: IterableOnce[_], delta: Int = 0): Unit
  210.  def sizeHint(size: Int): Unit
  211.  final def sizeHintBounded(size: Int, boundingColl: collection.Iterable[_]): Unit
  212.  final def sizeIs: SizeCompareOps
  213.  def slice(from: Int, until: Int): StringBuilder
  214.  def sliding(size: Int, step: Int): Iterator[StringBuilder]
  215.  def sliding(size: Int): Iterator[StringBuilder]
  216.  def sortBy[B](f: (Char) => B)(implicit ord: Ordering[B]): StringBuilder
  217.  def sortInPlace[B >: Char]()(implicit ord: Ordering[B]): StringBuilder.this.type
  218.  def sortInPlaceBy[B](f: (Char) => B)(implicit ord: Ordering[B]): StringBuilder.this.type
  219.  def sortInPlaceWith(lt: (Char, Char) => Boolean): StringBuilder.this.type
  220.  def sortWith(lt: (Char, Char) => Boolean): StringBuilder
  221.  def sorted[B >: Char](implicit ord: Ordering[B]): StringBuilder
  222.  def span(p: (Char) => Boolean): (StringBuilder, StringBuilder)
  223.  def splitAt(n: Int): (StringBuilder, StringBuilder)
  224.  def startsWith[B >: Char](that: IterableOnce[B], offset: Int = 0): Boolean
  225.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[Char, S]): S with EfficientSplit
  226.  def stringPrefix: String
  227.  def subSequence(start: Int, end: Int): CharSequence
  228.  def substring(start: Int, end: Int): String
  229.  def substring(start: Int): String
  230.  def sum[B >: Char](implicit num: math.Numeric[B]): B
  231.  final def synchronized[T0](arg0: => T0): T0
  232.  def tail: StringBuilder
  233.  def tails: Iterator[StringBuilder]
  234.  def take(n: Int): StringBuilder
  235.  def takeRight(n: Int): StringBuilder
  236.  def takeWhile(p: (Char) => Boolean): StringBuilder
  237.  def tapEach[U](f: (Char) => U): StringBuilder
  238.  def to[C1](factory: Factory[Char, C1]): C1
  239.  def toArray[B >: Char](implicit ct: ClassTag[B]): Array[B]
  240.  final def toBuffer[B >: Char]: Buffer[B]
  241.  def toCharArray: Array[Char]
  242.  def toIndexedSeq: immutable.IndexedSeq[Char]
  243.  def toList: immutable.List[Char]
  244.  def toMap[K, V](implicit ev: <:<[Char, (K, V)]): immutable.Map[K, V]
  245.  def toSeq: immutable.Seq[Char]
  246.  def toSet[B >: Char]: immutable.Set[B]
  247.  def toString(): String
  248.  def toVector: immutable.Vector[Char]
  249.  def transpose[B](implicit asIterable: (Char) => collection.Iterable[B]): IndexedSeq[IndexedSeq[B]]
  250.  def unapply(a: Int): Option[Char]
  251.  val underlying: java.lang.StringBuilder
  252.  def unzip[A1, A2](implicit asPair: (Char) => (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
  253.  def unzip3[A1, A2, A3](implicit asTriple: (Char) => (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
  254.  def update(idx: Int, elem: Char): Unit
  255.  def updated[B >: Char](index: Int, elem: B): IndexedSeq[B]
  256.  def view: IndexedSeqView[Char]
  257.  final def wait(): Unit
  258.  final def wait(arg0: Long, arg1: Int): Unit
  259.  final def wait(arg0: Long): Unit
  260.  def withFilter(p: (Char) => Boolean): WithFilter[Char, [_]IndexedSeq[_]]
  261.  def zip[B](that: IterableOnce[B]): IndexedSeq[(Char, B)]
  262.  def zipAll[A1 >: Char, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): IndexedSeq[(A1, B)]
  263.  def zipWithIndex: IndexedSeq[(Char, Int)]
Deprecated Value Members
  1.  final def +=(elem1: Char, elem2: Char, elems: Char*): StringBuilder.this.type
  2.  def /:[B](z: B)(op: (B, Char) => B): B
  3.  final def /:[B](z: B)(op: (B, Char) => B): B
  4.  def :\[B](z: B)(op: (Char, B) => B): B
  5.  final def :\[B](z: B)(op: (Char, B) => B): B
  6.  def aggregate[B](z: => B)(seqop: (B, Char) => B, combop: (B, B) => B): B
  7.  def collectFirst[B](f: PartialFunction[Char, B]): Option[B]
  8.  def companion: IterableFactory[[_]IndexedSeq[_]]
  9.  def copyToBuffer(dest: Buffer[Char]): Unit
  10.  final def copyToBuffer[B >: Char](dest: Buffer[B]): Unit
  11.  def count(f: (Char) => Boolean): Int
  12.  def exists(f: (Char) => Boolean): Boolean
  13.  def filter(f: (Char) => Boolean): Iterator[Char]
  14.  def find(p: (Char) => Boolean): Option[Char]
  15.  def flatMap[B](f: (Char) => IterableOnce[B]): IterableOnce[B]
  16.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
  17.  def foldLeft[B](z: B)(op: (B, Char) => B): B
  18.  def foldRight[B](z: B)(op: (Char, B) => B): B
  19.  def forall(f: (Char) => Boolean): Boolean
  20.  def foreach[U](f: (Char) => U): Unit
  21.  def formatted(fmtstr: String): String
  22.  def hasDefiniteSize: Boolean
  23.  def isEmpty: Boolean
  24.  def map[B](f: (Char) => B): IterableOnce[B]
  25.  def max(implicit ord: math.Ordering[Char]): Char
  26.  def maxBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
  27.  def min(implicit ord: math.Ordering[Char]): Char
  28.  def minBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
  29.  def mkString: String
  30.  def mkString(sep: String): String
  31.  def mkString(start: String, sep: String, end: String): String
  32.  def nonEmpty: Boolean
  33.  final def prefixLength(p: (Char) => Boolean): Int
  34.  def product(implicit num: math.Numeric[Char]): Char
  35.  def reduce(f: (Char, Char) => Char): Char
  36.  def reduceLeft(f: (Char, Char) => Char): Char
  37.  def reduceLeftOption(f: (Char, Char) => Char): Option[Char]
  38.  def reduceOption(f: (Char, Char) => Char): Option[Char]
  39.  def reduceRight(f: (Char, Char) => Char): Char
  40.  def reduceRightOption(f: (Char, Char) => Char): Option[Char]
  41.  final def repr: StringBuilder
  42.  final def reverseContents(): StringBuilder.this.type
  43.  def reverseMap[B](f: (Char) => B): IndexedSeq[B]
  44.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
  45.  def seq: StringBuilder.this.type
  46.  def size: Int
  47.  def sum(implicit num: math.Numeric[Char]): Char
  48.  def to[C1](factory: Factory[Char, C1]): C1
  49.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
  50.  def toBuffer[B >: A]: Buffer[B]
  51.  def toIndexedSeq: collection.IndexedSeq[Char]
  52.  final def toIterable: collection.Iterable[Char]
  53.  final def toIterable: StringBuilder.this.type
  54.  def toIterator: Iterator[Char]
  55.  final def toIterator: Iterator[Char]
  56.  def toList: immutable.List[Char]
  57.  def toMap[K, V](implicit ev: <:<[Char, (K, V)]): immutable.Map[K, V]
  58.  def toSeq: immutable.Seq[Char]
  59.  def toSet[B >: A]: immutable.Set[B]
  60.  def toStream: immutable.Stream[Char]
  61.  final def toStream: immutable.Stream[Char]
  62.  final def toTraversable: collection.Traversable[Char]
  63.  final def toTraversable: collection.Traversable[Char]
  64.  def toVector: immutable.Vector[Char]
  65.  final def transform(f: (Char) => Char): StringBuilder.this.type
  66.  final def union[B >: Char](that: collection.Seq[B]): IndexedSeq[B]
  67.  def view(from: Int, until: Int): IndexedSeqView[Char]
  68.  def withFilter(f: (Char) => Boolean): Iterator[Char]
  69.  def →[B](y: B): (StringBuilder, B)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4