Function linkReferenceDestination

internal/attachments/references.go:650–692

linkReferenceDestination finds the destination in a link reference definition, as the "./f.png" of [ref]: ./f.png "a title", so that rewriting it leaves the label and the title as the author wrote them. It reads the destination out of the source and refuses if that disagrees with what goldmark pars

(src []byte, def *ast.LinkReferenceDefinition)

// with what goldmark parsed, which means the line is shaped in some way this
// does not understand and is safer left alone.
func linkReferenceDestination(src []byte, def *ast.LinkReferenceDefinition) (byteRange, bool) {
	lo, hi, ok := blockRange(def, len(src))
	if !ok {
		return byteRange{}, false
	}

	// Past the label, which ends at the first unescaped "]:".
	colon := -1
	for off, c := range src[lo:hi] {
		i := lo + off
		if c == ']' && i+1 < hi && src[i+1] == ':' && !isEscaped(src, i) {
			colon = i + 1
			break
		}
	}
	if colon < 0 {
		return byteRange{}, false
	}

	start := skipSpace(src, colon+1, hi)
	if start >= hi {
		return byteRange{}, false
	}
	stop := start
	if src[stop] == '<' {
		end, ok := scanAngleDest(src, stop, hi)
		if !ok {
			return byteRange{}, false
		}
		stop = end
	} else {
		stop = scanBareDest(src, stop, hi)
	}

	// A definition continued onto the next line of a blockquote is the case
	// that reaches here: the block range still carries the ">" prefix of the
	// continuation, so the destination read from the source is that marker
	// rather than the path, and rewriting it would eat the blockquote.
	if comparableSource(string(src[start:stop])) != comparableDestination(string(def.Destination)) {
		return byteRange{}, false
	}
	return byteRange{start: start, stop: stop}, true
}

// isEscaped reports whether the byte at i is preceded by an odd number of
// backslashes, which is what makes it a literal rather than markup.