How to use the image-q.palette function in image-q

var targetColors = parseInt( opts.colors || 0 );
		
		if (!targetColors || isNaN(targetColors) || (targetColors < 2) || (targetColors > 256)) {
			return this.doError('quantize', "Invalid palette size: " + targetColors);
		}
		
		// create pointContainer and fill it with image
		var pointContainer = iq.utils.PointContainer.fromImageData( imgData );
		
		// create chosen distance calculator (see classes inherited from `iq.distance.AbstractDistanceCalculator`)
		var distanceCalculator = opts.alpha ? 
			(new iq.distance.EuclideanRgbQuantWithAlpha()) : 
			(new iq.distance.EuclideanRgbQuantWOAlpha());
		
		// create chosen palette quantizer (see classes implementing `iq.palette.IPaletteQuantizer`) 
		var paletteQuantizer = new iq.palette[opts.quantizer](distanceCalculator, targetColors);
		
		// feed out pointContainer filled with image to paletteQuantizer
		paletteQuantizer.sample(pointContainer);

		// generate palette
		var palette = paletteQuantizer.quantize();

		// get color array
		var iq_colors = palette.getPointContainer().getPointArray();
		
		// create image quantizer (see classes implementing `iq.image.IImageDitherer`)
		var imageDitherer = opts.dither ? 
			(new iq.image.ErrorDiffusionArray(distanceCalculator, iq.image.ErrorDiffusionArrayKernel[opts.ditherType])) : 
			(new iq.image.NearestColor(distanceCalculator));
		
		// apply palette to image

if (ditherAlgs.indexOf(dither.ditherAlgorithm) < 0) {
            throw new Error(`Invalid ditherAlgorithm '${dither.ditherAlgorithm}'`);
        }
        if (dither.serpentine === undefined) {
            dither.serpentine = true;
        }
        if (dither.minimumColorDistanceToDither === undefined) {
            dither.minimumColorDistanceToDither = 0;
        }
        if (dither.calculateErrorLikeGIMP === undefined) {
            dither.calculateErrorLikeGIMP = false;
        }
    }

    const distCalculator = new ImageQ.distance.Euclidean();
    const quantizer = new ImageQ.palette[method](distCalculator, maxColorIndexes, modifier);
    let imageMaker;
    if (dither) {
        imageMaker = new ImageQ.image.ErrorDiffusionArray(
            distCalculator,
            ImageQ.image.ErrorDiffusionArrayKernel[dither.ditherAlgorithm],
            dither.serpentine,
            dither.minimumColorDistanceToDither,
            dither.calculateErrorLikeGIMP
        );
    }
    else {
        imageMaker = new ImageQ.image.NearestColor(distCalculator);
    }

    const inputContainers = [];
    images.forEach(image => {