// Minify minifies SVG data, it reads from r and writes to w. func Minify(m minify.Minifier, _ string, w io.Writer, r io.Reader) error { var tag svg.Hash attrMinifyBuffer := buffer.NewWriter(make([]byte, 0, 64)) attrByteBuffer := make([]byte, 0, 64) l := xml.NewLexer(r) tb := xml.NewTokenBuffer(l) for { t := *tb.Shift() if t.TokenType == xml.CDATAToken { var useCDATA bool if t.Data, useCDATA = xml.EscapeCDATAVal(&attrByteBuffer, t.Data); !useCDATA { t.TokenType = xml.TextToken } } SWITCH: switch t.TokenType { case xml.ErrorToken: if l.Err() == io.EOF { return nil } return l.Err() case xml.TextToken: t.Data = parse.ReplaceMultiple(parse.Trim(t.Data, parse.IsWhitespace), parse.IsWhitespace, ' ') if tag == svg.Style && len(t.Data) > 0 { if err := m.Minify("text/css", w, buffer.NewReader(t.Data)); err != nil { if err == minify.ErrNotExist { // no minifier, write the original if _, err := w.Write(t.Data); err != nil { return err } } else { return err } } } else if _, err := w.Write(t.Data); err != nil { return err } case xml.CDATAToken: if _, err := w.Write(cdataStartBytes); err != nil { return err } t.Data = parse.ReplaceMultiple(parse.Trim(t.Data, parse.IsWhitespace), parse.IsWhitespace, ' ') if tag == svg.Style && len(t.Data) > 0 { if err := m.Minify("text/css", w, buffer.NewReader(t.Data)); err != nil { if err == minify.ErrNotExist { // no minifier, write the original if _, err := w.Write(t.Data); err != nil { return err } } else { return err } } } else if _, err := w.Write(t.Data); err != nil { return err } if _, err := w.Write(cdataEndBytes); err != nil { return err } case xml.StartTagPIToken: for { if t := *tb.Shift(); t.TokenType == xml.StartTagClosePIToken || t.TokenType == xml.ErrorToken { break } } case xml.StartTagToken: tag = svg.ToHash(t.Data) if containerTagMap[tag] { // skip empty containers i := 0 for { next := tb.Peek(i) i++ if next.TokenType == xml.EndTagToken && svg.ToHash(next.Data) == tag || next.TokenType == xml.StartTagCloseVoidToken || next.TokenType == xml.ErrorToken { for j := 0; j < i; j++ { tb.Shift() } break SWITCH } else if next.TokenType != xml.AttributeToken && next.TokenType != xml.StartTagCloseToken { break } } } else if tag == svg.Metadata { for { if t := *tb.Shift(); t.TokenType == xml.EndTagToken && svg.ToHash(t.Data) == tag || t.TokenType == xml.StartTagCloseVoidToken || t.TokenType == xml.ErrorToken { break } } break } else if tag == svg.Line || tag == svg.Rect { // TODO: shape2path also for polygon and polyline // x1, y1, x2, y2 float64 := 0, 0, 0, 0 // valid := true // i := 0 // for { // next := tb.Peek(i) // i++ // if next.TokenType != xml.AttributeToken { // break // } // v *int // attr := svg.ToHash(next.Data) // if tag == svg.Line { // if attr == svg.X1 { // v = &x1 // } else if attr == svg.Y1 { // v = &y1 // } else if attr == svg.X2 { // v = &x2 // } else if attr == svg.Y2 { // v = &Y2 // } else { // continue // } // } else if attr == svg.X { // rect // v = &x1 // } else if attr == svg.Y { // v = &y1 // } else if attr == svg.Width { // v = &x2 // } else if attr == svg.Height { // v = &Y2 // } else if attr == svg.Rx || attr == svg.Ry { // valid = false // break // } else { // continue // } // } // if valid { // t.Data = pathBytes // } } if _, err := w.Write(ltBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } case xml.AttributeToken: if len(t.AttrVal) < 2 { continue } attr := svg.ToHash(t.Data) val := parse.ReplaceMultiple(parse.Trim(t.AttrVal[1:len(t.AttrVal)-1], parse.IsWhitespace), parse.IsWhitespace, ' ') if tag == svg.Svg && attr == svg.Version { continue } if _, err := w.Write(spaceBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } if _, err := w.Write(isBytes); err != nil { return err } if attr == svg.Style { attrMinifyBuffer.Reset() if m.Minify("text/css;inline=1", attrMinifyBuffer, buffer.NewReader(val)) == nil { val = attrMinifyBuffer.Bytes() } } else if attr == svg.D { val = shortenPathData(val) } else if attr == svg.ViewBox { j := 0 newVal := val[:0] for i := 0; i < 4; i++ { if i != 0 { if j >= len(val) || val[j] != ' ' && val[j] != ',' { newVal = append(newVal, val[j:]...) break } newVal = append(newVal, ' ') j++ } if dim, n := shortenDimension(val[j:]); n > 0 { newVal = append(newVal, dim...) j += n } else { newVal = append(newVal, val[j:]...) break } } val = newVal } else if colorAttrMap[attr] && len(val) > 0 { parse.ToLower(val) if val[0] == '#' { if name, ok := minifyCSS.ShortenColorHex[string(val)]; ok { val = name } else if len(val) == 7 && val[1] == val[2] && val[3] == val[4] && val[5] == val[6] { val[2] = val[3] val[3] = val[5] val = val[:4] } } else if hex, ok := minifyCSS.ShortenColorName[css.ToHash(val)]; ok { val = hex } else if len(val) > 5 && parse.Equal(val[:4], []byte("rgb(")) && val[len(val)-1] == ')' { // TODO: handle rgb(x, y, z) and hsl(x, y, z) } } else if dim, n := shortenDimension(val); n == len(val) { val = dim } // prefer single or double quotes depending on what occurs more often in value val = xml.EscapeAttrVal(&attrByteBuffer, val) if _, err := w.Write(val); err != nil { return err } case xml.StartTagCloseToken: next := tb.Peek(0) skipExtra := false if next.TokenType == xml.TextToken && parse.IsAllWhitespace(next.Data) { next = tb.Peek(1) skipExtra = true } if next.TokenType == xml.EndTagToken { // collapse empty tags to single void tag tb.Shift() if skipExtra { tb.Shift() } if _, err := w.Write(voidBytes); err != nil { return err } } else { if _, err := w.Write(gtBytes); err != nil { return err } } case xml.StartTagCloseVoidToken: if _, err := w.Write(voidBytes); err != nil { return err } case xml.EndTagToken: if _, err := w.Write(endBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } if _, err := w.Write(gtBytes); err != nil { return err } } } }
// Minify minifies XML data, it reads from r and writes to w. func Minify(m minify.Minifier, _ string, w io.Writer, r io.Reader) error { precededBySpace := true // on true the next text token must not start with a space attrByteBuffer := make([]byte, 0, 64) l := xml.NewLexer(r) tb := xml.NewTokenBuffer(l) for { t := *tb.Shift() if t.TokenType == xml.CDATAToken { var useCDATA bool if t.Data, useCDATA = xml.EscapeCDATAVal(&attrByteBuffer, t.Data); !useCDATA { t.TokenType = xml.TextToken } } switch t.TokenType { case xml.ErrorToken: if l.Err() == io.EOF { return nil } return l.Err() case xml.DOCTYPEToken: if _, err := w.Write(doctypeBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } if _, err := w.Write(gtBytes); err != nil { return err } case xml.CDATAToken: if _, err := w.Write(cdataStartBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } if _, err := w.Write(cdataEndBytes); err != nil { return err } case xml.TextToken: if t.Data = parse.ReplaceMultiple(t.Data, parse.IsWhitespace, ' '); len(t.Data) > 0 { // whitespace removal; trim left if t.Data[0] == ' ' && precededBySpace { t.Data = t.Data[1:] } // whitespace removal; trim right precededBySpace = false if len(t.Data) == 0 { precededBySpace = true } else if t.Data[len(t.Data)-1] == ' ' { precededBySpace = true i := 0 for { next := tb.Peek(i) // trim if EOF, text token with whitespace begin or block token if next.TokenType == xml.StartTagToken || next.TokenType == xml.EndTagToken || next.TokenType == xml.ErrorToken { t.Data = t.Data[:len(t.Data)-1] precededBySpace = false break } else if next.TokenType == xml.TextToken { // remove if the text token starts with a whitespace if len(next.Data) > 0 && parse.IsWhitespace(next.Data[0]) { t.Data = t.Data[:len(t.Data)-1] precededBySpace = false } break } i++ } } if _, err := w.Write(t.Data); err != nil { return err } } case xml.StartTagToken: if _, err := w.Write(ltBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } case xml.StartTagPIToken: if _, err := w.Write(ltPIBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } case xml.AttributeToken: if _, err := w.Write(spaceBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } if _, err := w.Write(isBytes); err != nil { return err } if len(t.AttrVal) < 2 { if _, err := w.Write(t.AttrVal); err != nil { return err } } else { // prefer single or double quotes depending on what occurs more often in value val := xml.EscapeAttrVal(&attrByteBuffer, t.AttrVal[1:len(t.AttrVal)-1]) if _, err := w.Write(val); err != nil { return err } } case xml.StartTagCloseToken: next := tb.Peek(0) skipExtra := false if next.TokenType == xml.TextToken && parse.IsAllWhitespace(next.Data) { next = tb.Peek(1) skipExtra = true } if next.TokenType == xml.EndTagToken { // collapse empty tags to single void tag tb.Shift() if skipExtra { tb.Shift() } if _, err := w.Write(voidBytes); err != nil { return err } } else { if _, err := w.Write(gtBytes); err != nil { return err } } case xml.StartTagCloseVoidToken: if _, err := w.Write(voidBytes); err != nil { return err } case xml.StartTagClosePIToken: if _, err := w.Write(gtPIBytes); err != nil { return err } case xml.EndTagToken: if _, err := w.Write(endBytes); err != nil { return err } if _, err := w.Write(t.Data); err != nil { return err } if _, err := w.Write(gtBytes); err != nil { return err } } } }