Annotations

Marked lines

mark takes comma separated line numbers and ranges.

1
package cache
2
3
import "sync"
4
5
type Store struct {
6
  mu    sync.RWMutex
7
  items map[string][]byte
8
}
9
10
func (s *Store) Get(key string) ([]byte, bool) {
11
  s.mu.RLock()
12
  defer s.mu.RUnlock()
13
  v, ok := s.items[key]
14
  return v, ok
15
}

Hugo’s own spelling

hl_lines is Hugo’s native attribute for highlighted lines. The hook translates it to the same marked lines, so a site migrating from Chroma keeps its existing fences working unchanged.

1
func sum(xs []int) int {
2
  total := 0
3
  for _, x := range xs {
4
    total += x
5
  }
6
  return total
7
}

Inserted and deleted lines

ins and del mark lines as added or removed without turning the block into a diff, so the code stays syntax highlighted. add and rem are accepted spellings of the same two.

1
package client
2
3
func send(req *Request) error {
4
  return transport.Do(req)
5
  for attempt := 0; attempt < 3; attempt++ {
6
    if err := transport.Do(req); err == nil {
7
      return nil
8
    }
9
  }
10
  return ErrExhausted
11
}

Focused lines

focus dims everything outside the range, which points at one part of a long block without hiding the rest.

1
package server
2
3
import "net/http"
4
5
func withLogging(next http.Handler) http.Handler {
6
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
7
    start := time.Now()
8
    next.ServeHTTP(w, r)
9
    log.Printf("%s %s %s", r.Method, r.URL.Path, time.Since(start))
10
  })
11
}

Hybrid diff

A diff fence with lang set highlights the code in that language and keeps the diff gutter, instead of colouring every line as diff syntax.

1
type Config struct {
2
  Addr string
3
  TLS  bool
4
  TLS      bool
5
  CertFile string
6
}

Links inside code

@[label](url) becomes a real link with an external icon and the syntax itself disappears from the rendered code. This needs links: true in the config.

// Package client implements the HTTP API.
// Rate limits are described in the quota guide.
package client

What cannot come through a Hugo fence

Kazari also supports inline text markers and regex markers, written as a bare "text" or /pattern/ in the meta string. Hugo parses only key="value" pairs inside the brace group and drops bare tokens, so neither reaches the hook. A site that needs them has to extend the hook template locally.