print(cases.Upper(language.Make("el")).String(text))

        nDst, nSrc, err = t.Transform(dst[pDst:], src[:n], pSrc+n == len(s))

func (t *undUpperCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
    c := context{dst: dst, src: src, atEOF: atEOF}
    for c.next() {
        upper(&c)
    }
    // Standard upper case does not need any lookahead so we can safely not use
    // the checkpointing mechanism. pDst and pSrc will always point to the
    // furthest possible position.
    return c.pDst, c.pSrc, c.err
}

func (c *context) next() bool {
    c.pSrc += c.sz
    if c.pSrc == len(c.src) || c.err != nil {
        c.info, c.sz = 0, 0
        return false
    }
    v, sz := trie.lookup(c.src[c.pSrc:])
    c.info, c.sz = info(v), sz
    if c.sz == 0 {
        if c.atEOF {
            // A zero size means we have an incomplete rune. If we are atEOF,
            // this means it is an illegal rune, which we will consume one
            // byte at a time.
            c.sz = 1
        } else {
            c.err = transform.ErrShortSrc
            return false
        }
    }
    return true
}

    if pDst+nDst < initialBufSize {

func (c *context) next() bool {
    if len(c.dst) == 0 {
        c.err = transform.ErrShortDst
        return false
    }
    c.pSrc += c.sz
    if c.pSrc == len(c.src) || c.err != nil {
        c.info, c.sz = 0, 0
        return false
    }
    v, sz := trie.lookup(c.src[c.pSrc:])
    c.info, c.sz = info(v), sz
    if c.sz == 0 {
        if c.atEOF {
            // A zero size means we have an incomplete rune. If we are atEOF,
            // this means it is an illegal rune, which we will consume one
            // byte at a time.
            c.sz = 1
        } else {
            c.err = transform.ErrShortSrc
            return false
        }
    }
    return true
}