The image renderer:

func (r *nodeRederFuncs) renderImage(w *Writer, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
	// while this has entering and leaving states, it doesn't appear
	// to be useful except for other markup languages to close the tag
	n := node.(*ast.Image)

	if entering {
		w.LogDebug("Image (entering)", fmt.Sprintf("Destination[%v] Title[%v]", string(n.Destination), string(n.Title)))
		// following changes suggested by @sirnewton01, issue #6
		// does file exist?
		imgPath := string(n.Destination) <--------------------------------------------------
		imgFile, err := w.ImageFS.Open(imgPath)
		if err == nil {
			defer imgFile.Close()

			width, _ := w.Pdf.GetPageSize()
			mleft, _, mright, _ := w.Pdf.GetMargins()
			maxw := width - (mleft * 2) - (mright * 2)

			format := strings.ToUpper(strings.Trim(filepath.Ext(imgPath), ".")) <-------
			w.Pdf.RegisterImage(imgPath, format, imgFile)
			w.Pdf.UseImage(imgPath, (mleft * 2), w.Pdf.GetY(), maxw, 0)
		} else {
			log.Printf("IMAGE ERROR: %v", err)
			w.LogDebug("Image (file error)", err.Error())
		}
	} else {
		w.LogDebug("Image (leaving)", "")
	}

	return ast.WalkContinue, nil
}

relies on path to determine the mime type of the file. But if I use http file directory to embed/render images linked via http and not stored locally, this fails miserably unless the url contains the mime type suffix, which is rarely the case.

Hence, there should be a built-in http file directory the mime should be determined manually by github.com/gabriel-vasile/mimetype or similar library.

My quickly built fs is:

type HttpFs struct{}

func (f *HttpFs) Open(name string) (fs.File, error) {
	res, err := http.Get(name)
	if err != nil {
		return nil, err
	}
	return &HttpFile{r: res}, nil
}

type HttpFile struct {
	r *http.Response
}

func (f *HttpFile) Stat() (fs.FileInfo, error) {
	return &HttpInfo{r: f.r}, nil
}

func (f *HttpFile) Read(p []byte) (int, error) {
	return f.r.Body.Read(p)
}

func (f *HttpFile) Close() error {
	return f.r.Body.Close()
}

type HttpInfo struct {
	r *http.Response
}

func (i *HttpInfo) Name() string {
	fn := strings.TrimPrefix(i.r.Request.URL.Path, "/")
	if fn == "" {
		if _, params, err := mime.ParseMediaType(i.r.Header.Get("Content-Disposition")); err == nil {
			fn = params["filename"]
		}
	}
	if filepath.Ext(fn) == "" {
		mt, _, _ := mime.ParseMediaType(i.r.Header.Get("Content-Type"))
		if spl := strings.Split(mt, "/"); len(spl) > 0 {
			if fn == "" {
				fn = spl[0]
			}
			fn += "." + spl[len(spl)-1]
		}
	}
	return filepath.Base(fn)
}

func (i *HttpInfo) Size() int64 {
	return i.r.ContentLength
}

func (i *HttpInfo) Mode() fs.FileMode {
	return fs.ModeIrregular
}

func (i *HttpInfo) ModTime() time.Time {
	if t, err := time.Parse(time.RFC1123, i.r.Header.Get("Last-Modified")); err == nil {
		return t
	}
	return time.Time{}
}

func (i *HttpInfo) IsDir() bool {
	return false
}

func (i *HttpInfo) Sys() any {
	return i.r
}

If the cell contents are longer than the heading length of the column then the next column will overwrite the last part of the previous column. Column widths are determined based on the values in the header row. Column contents do not wrap (at least not without changing the row height, which I have not tested).

This makes the table functionality not very useful except for the simplest of tables, which is a shame since otherwise the generated PDF looks very good.

When I link big image(say 4MB), it will be embedded into the pdf file as is, making the file size that much larger.

I think there should be an option to convert images above configured size into jpeg and embed those re-coded images instead of the originals. This can save a lot of disk space in case the assets' quality is not of utmost importance(which is usually the case, very few people embed high-resolution images into PDF documents).

With the FS branch with the new file system, there is access to file size via Stat() and mime detection is present as well, which can be used to invoke the code, that will look something like this:

import (
	"errors"
	"github.com/disintegration/imaging"
	"golang.org/x/image/webp"
	"image"
	"image/gif"
	"image/jpeg"
	"image/png"
	"io"
)

func Resize(srcMime string, src io.Reader, dst io.Writer, documentWidth int) error {
	var img image.Image
	var err error

	switch srcMime {
	case "image/jpeg":
		img, err = jpeg.Decode(src)
	case "image/gif":
		img, err = gif.Decode(src)
	case "image/png":
		img, err = png.Decode(src)
	case "image/webp":
		img, err = webp.Decode(src)
	default:
		return errors.New("unsupported input mime type: " + srcMime)
	}

	if err != nil {
		return err
	}

       if img.Bounds().Dx() < documentWidth {
              documentWidth = img.Bounds().Dx()
       }

	filter := imaging.Lanczos // best quality but slow
	img = imaging.Resize(img, documentWidth, 0, filter)
	return jpeg.Encode(dst, img, nil) // jpeg has the best compression with sufficient quality for this purpose
}

Having local navigation, like:

# <a name="top"></a>Markdown Test Page

* [Headings](#Headings)
* [Paragraphs](#Paragraphs)
* [Blockquotes](#Blockquotes)
* [Lists](#Lists)
* [Horizontal rule](#Horizontal)
* [Table](#Table)
* [Code](#Code)
* [Inline elements](#Inline)

***

# <a name="Headings"></a>Headings

# Heading one

Sint sit cillum pariatur eiusmod nulla pariatur ipsum. Sit laborum anim qui mollit tempor pariatur nisi minim dolor. Aliquip et adipisicing sit sit fugiat commodo id sunt. Nostrud enim ad commodo incididunt cupidatat in ullamco ullamco Lorem cupidatat velit enim et Lorem. Ut laborum cillum laboris fugiat culpa sint irure do reprehenderit culpa occaecat. Exercitation esse mollit tempor magna aliqua in occaecat aliquip veniam reprehenderit nisi dolor in laboris dolore velit.

## Heading two

[[Top]](#top)

will render links but they won't work.

When image is not loaded, it's alt text is ignored:

![The San Juan Mountains are beautiful!](san-juan-mountains.jpggg "San Juan Mountains Alt Text")

Image with caption will have it rendered aligned to the left of the document instead of centered, with the image.

For example: ![The San Juan Mountains are beautiful!](/assets/images/san-juan-mountains.jpg "San Juan Mountains")

will end up like:

I have a testing document which contains a small image of 176px*176px dimensions. The problem is that this image will be scaled to the entire width of the document, which does not look good and is most likely not desired because it would not be rendered as such in HTML document, unless specifically configured with CSS.

The code responsible for this behavior is: https://github.com/stephenafamo/goldmark-pdf/blob/master/renderer_funcs.go#L581

I think that if the image is smaller than the width of the document, it should be kept as is and if the image is wider, only then it should be scaled down to fit the document.