Define all apply* and parse* functions in options/parser package as Parser methods

options/parser/apply.go

@@ -14,59 +14,59 @@ import (
 	"github.com/imgproxy/imgproxy/v3/vips/color"
 )
 
-func applyWidthOption(o *options.Options, args []string) error {
-	return parsePositiveInt(o, keys.Width, args...)
+func (p *Parser) applyWidthOption(o *options.Options, args []string) error {
+	return p.parsePositiveInt(o, keys.Width, args...)
 }
 
-func applyHeightOption(o *options.Options, args []string) error {
-	return parsePositiveInt(o, keys.Height, args...)
+func (p *Parser) applyHeightOption(o *options.Options, args []string) error {
+	return p.parsePositiveInt(o, keys.Height, args...)
 }
 
-func applyMinWidthOption(o *options.Options, args []string) error {
-	return parsePositiveInt(o, keys.MinWidth, args...)
+func (p *Parser) applyMinWidthOption(o *options.Options, args []string) error {
+	return p.parsePositiveInt(o, keys.MinWidth, args...)
 }
 
-func applyMinHeightOption(o *options.Options, args []string) error {
-	return parsePositiveInt(o, keys.MinHeight, args...)
+func (p *Parser) applyMinHeightOption(o *options.Options, args []string) error {
+	return p.parsePositiveInt(o, keys.MinHeight, args...)
 }
 
-func applyEnlargeOption(o *options.Options, args []string) error {
-	return parseBool(o, keys.Enlarge, args...)
+func (p *Parser) applyEnlargeOption(o *options.Options, args []string) error {
+	return p.parseBool(o, keys.Enlarge, args...)
 }
 
-func applyExtendOption(o *options.Options, args []string) error {
-	return parseExtend(o, keys.PrefixExtend, args)
+func (p *Parser) applyExtendOption(o *options.Options, args []string) error {
+	return p.parseExtend(o, keys.PrefixExtend, args)
 }
 
-func applyExtendAspectRatioOption(o *options.Options, args []string) error {
-	return parseExtend(o, keys.PrefixExtendAspectRatio, args)
+func (p *Parser) applyExtendAspectRatioOption(o *options.Options, args []string) error {
+	return p.parseExtend(o, keys.PrefixExtendAspectRatio, args)
 }
 
-func applySizeOption(o *options.Options, args []string) (err error) {
-	if err = ensureMaxArgs("size", args, 7); err != nil {
+func (p *Parser) applySizeOption(o *options.Options, args []string) (err error) {
+	if err = p.ensureMaxArgs("size", args, 7); err != nil {
 		return
 	}
 
 	if len(args) >= 1 && len(args[0]) > 0 {
-		if err = applyWidthOption(o, args[0:1]); err != nil {
+		if err = p.applyWidthOption(o, args[0:1]); err != nil {
 			return
 		}
 	}
 
 	if len(args) >= 2 && len(args[1]) > 0 {
-		if err = applyHeightOption(o, args[1:2]); err != nil {
+		if err = p.applyHeightOption(o, args[1:2]); err != nil {
 			return
 		}
 	}
 
 	if len(args) >= 3 && len(args[2]) > 0 {
-		if err = applyEnlargeOption(o, args[2:3]); err != nil {
+		if err = p.applyEnlargeOption(o, args[2:3]); err != nil {
 			return
 		}
 	}
 
 	if len(args) >= 4 && len(args[3]) > 0 {
-		if err = applyExtendOption(o, args[3:]); err != nil {
+		if err = p.applyExtendOption(o, args[3:]); err != nil {
 			return
 		}
 	}
@@ -74,23 +74,23 @@ func applySizeOption(o *options.Options, args []string) (err error) {
 	return nil
 }
 
-func applyResizingTypeOption(o *options.Options, args []string) error {
-	return parseFromMap(o, keys.ResizingType, processing.ResizeTypes, args...)
+func (p *Parser) applyResizingTypeOption(o *options.Options, args []string) error {
+	return parseFromMap(p, o, keys.ResizingType, processing.ResizeTypes, args...)
 }
 
-func applyResizeOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs("resize", args, 8); err != nil {
+func (p *Parser) applyResizeOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs("resize", args, 8); err != nil {
 		return err
 	}
 
 	if len(args[0]) > 0 {
-		if err := applyResizingTypeOption(o, args[0:1]); err != nil {
+		if err := p.applyResizingTypeOption(o, args[0:1]); err != nil {
 			return err
 		}
 	}
 
 	if len(args) > 1 {
-		if err := applySizeOption(o, args[1:]); err != nil {
+		if err := p.applySizeOption(o, args[1:]); err != nil {
 			return err
 		}
 	}
@@ -98,12 +98,12 @@ func applyResizeOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyZoomOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs("zoom", args, 2); err != nil {
+func (p *Parser) applyZoomOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs("zoom", args, 2); err != nil {
 		return err
 	}
 
-	if err := parsePositiveNonZeroFloat(o, keys.ZoomWidth, args[0]); err != nil {
+	if err := p.parsePositiveNonZeroFloat(o, keys.ZoomWidth, args[0]); err != nil {
 		return err
 	}
 
@@ -112,52 +112,52 @@ func applyZoomOption(o *options.Options, args []string) error {
 		return nil
 	}
 
-	if err := parsePositiveNonZeroFloat(o, keys.ZoomHeight, args[1]); err != nil {
+	if err := p.parsePositiveNonZeroFloat(o, keys.ZoomHeight, args[1]); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func applyDprOption(o *options.Options, args []string) error {
-	return parsePositiveNonZeroFloat(o, keys.Dpr, args...)
+func (p *Parser) applyDprOption(o *options.Options, args []string) error {
+	return p.parsePositiveNonZeroFloat(o, keys.Dpr, args...)
 }
 
-func applyGravityOption(o *options.Options, args []string) error {
-	return parseGravity(o, keys.Gravity, processing.CropGravityTypes, args...)
+func (p *Parser) applyGravityOption(o *options.Options, args []string) error {
+	return p.parseGravity(o, keys.Gravity, processing.CropGravityTypes, args...)
 }
 
-func applyCropOption(o *options.Options, args []string) error {
-	if err := parsePositiveFloat(o, keys.CropWidth, args[0]); err != nil {
+func (p *Parser) applyCropOption(o *options.Options, args []string) error {
+	if err := p.parsePositiveFloat(o, keys.CropWidth, args[0]); err != nil {
 		return err
 	}
 
 	if len(args) > 1 {
-		if err := parsePositiveFloat(o, keys.CropHeight, args[1]); err != nil {
+		if err := p.parsePositiveFloat(o, keys.CropHeight, args[1]); err != nil {
 			return err
 		}
 	}
 
 	if len(args) > 2 {
-		return parseGravity(o, keys.CropGravity, processing.CropGravityTypes, args[2:]...)
+		return p.parseGravity(o, keys.CropGravity, processing.CropGravityTypes, args[2:]...)
 	}
 
 	return nil
 }
 
-func applyPaddingOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs("padding", args, 4); err != nil {
+func (p *Parser) applyPaddingOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs("padding", args, 4); err != nil {
 		return err
 	}
 
 	if len(args) > 0 && len(args[0]) > 0 {
-		if err := parsePositiveInt(o, keys.PaddingTop, args[0]); err != nil {
+		if err := p.parsePositiveInt(o, keys.PaddingTop, args[0]); err != nil {
 			return err
 		}
 	}
 
 	if len(args) > 1 && len(args[1]) > 0 {
-		if err := parsePositiveInt(o, keys.PaddingRight, args[1]); err != nil {
+		if err := p.parsePositiveInt(o, keys.PaddingRight, args[1]); err != nil {
 			return err
 		}
 	} else {
@@ -165,7 +165,7 @@ func applyPaddingOption(o *options.Options, args []string) error {
 	}
 
 	if len(args) > 2 && len(args[2]) > 0 {
-		if err := parsePositiveInt(o, keys.PaddingBottom, args[2]); err != nil {
+		if err := p.parsePositiveInt(o, keys.PaddingBottom, args[2]); err != nil {
 			return err
 		}
 	} else {
@@ -173,7 +173,7 @@ func applyPaddingOption(o *options.Options, args []string) error {
 	}
 
 	if len(args) > 3 && len(args[3]) > 0 {
-		if err := parsePositiveInt(o, keys.PaddingLeft, args[3]); err != nil {
+		if err := p.parsePositiveInt(o, keys.PaddingLeft, args[3]); err != nil {
 			return err
 		}
 	} else {
@@ -183,15 +183,15 @@ func applyPaddingOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyTrimOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs("trim", args, 4); err != nil {
+func (p *Parser) applyTrimOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs("trim", args, 4); err != nil {
 		return err
 	}
 
 	nArgs := len(args)
 
 	if len(args[0]) > 0 {
-		if err := parseFloat(o, keys.TrimThreshold, args[0]); err != nil {
+		if err := p.parseFloat(o, keys.TrimThreshold, args[0]); err != nil {
 			return err
 		}
 	} else {
@@ -199,7 +199,7 @@ func applyTrimOption(o *options.Options, args []string) error {
 	}
 
 	if nArgs > 1 && len(args[1]) > 0 {
-		if err := parseHexRGBColor(o, keys.TrimColor, args[1]); err != nil {
+		if err := p.parseHexRGBColor(o, keys.TrimColor, args[1]); err != nil {
 			return err
 		}
 	} else {
@@ -207,13 +207,13 @@ func applyTrimOption(o *options.Options, args []string) error {
 	}
 
 	if nArgs > 2 && len(args[2]) > 0 {
-		if err := parseBool(o, keys.TrimEqualHor, args[2]); err != nil {
+		if err := p.parseBool(o, keys.TrimEqualHor, args[2]); err != nil {
 			return err
 		}
 	}
 
 	if nArgs > 3 && len(args[3]) > 0 {
-		if err := parseBool(o, keys.TrimEqualVer, args[3]); err != nil {
+		if err := p.parseBool(o, keys.TrimEqualVer, args[3]); err != nil {
 			return err
 		}
 	}
@@ -221,8 +221,8 @@ func applyTrimOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyRotateOption(o *options.Options, args []string) error {
-	if err := parseInt(o, keys.Rotate, args...); err != nil {
+func (p *Parser) applyRotateOption(o *options.Options, args []string) error {
+	if err := p.parseInt(o, keys.Rotate, args...); err != nil {
 		return err
 	}
 
@@ -233,11 +233,11 @@ func applyRotateOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyQualityOption(o *options.Options, args []string) error {
-	return parseQualityInt(o, keys.Quality, args...)
+func (p *Parser) applyQualityOption(o *options.Options, args []string) error {
+	return p.parseQualityInt(o, keys.Quality, args...)
 }
 
-func applyFormatQualityOption(o *options.Options, args []string) error {
+func (p *Parser) applyFormatQualityOption(o *options.Options, args []string) error {
 	argsLen := len(args)
 	if len(args)%2 != 0 {
 		return newOptionArgumentError("Missing %s for: %s", keys.PrefixFormatQuality, args[argsLen-1])
@@ -249,7 +249,7 @@ func applyFormatQualityOption(o *options.Options, args []string) error {
 			return newOptionArgumentError("Invalid image format: %s", args[i])
 		}
 
-		if err := parseQualityInt(o, keys.FormatQuality(f), args[i+1]); err != nil {
+		if err := p.parseQualityInt(o, keys.FormatQuality(f), args[i+1]); err != nil {
 			return err
 		}
 	}
@@ -257,11 +257,11 @@ func applyFormatQualityOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyMaxBytesOption(o *options.Options, args []string) error {
-	return parsePositiveInt(o, keys.MaxBytes, args...)
+func (p *Parser) applyMaxBytesOption(o *options.Options, args []string) error {
+	return p.parsePositiveInt(o, keys.MaxBytes, args...)
 }
 
-func applyBackgroundOption(o *options.Options, args []string) error {
+func (p *Parser) applyBackgroundOption(o *options.Options, args []string) error {
 	switch len(args) {
 	case 1:
 		if len(args[0]) == 0 {
@@ -269,7 +269,7 @@ func applyBackgroundOption(o *options.Options, args []string) error {
 			return nil
 		}
 
-		if err := parseHexRGBColor(o, keys.Background, args[0]); err != nil {
+		if err := p.parseHexRGBColor(o, keys.Background, args[0]); err != nil {
 			return err
 		}
 
@@ -303,29 +303,29 @@ func applyBackgroundOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyBlurOption(o *options.Options, args []string) error {
-	return parsePositiveNonZeroFloat(o, keys.Blur, args...)
+func (p *Parser) applyBlurOption(o *options.Options, args []string) error {
+	return p.parsePositiveNonZeroFloat(o, keys.Blur, args...)
 }
 
-func applySharpenOption(o *options.Options, args []string) error {
-	return parsePositiveNonZeroFloat(o, keys.Sharpen, args...)
+func (p *Parser) applySharpenOption(o *options.Options, args []string) error {
+	return p.parsePositiveNonZeroFloat(o, keys.Sharpen, args...)
 }
 
-func applyPixelateOption(o *options.Options, args []string) error {
-	return parsePositiveInt(o, keys.Pixelate, args...)
+func (p *Parser) applyPixelateOption(o *options.Options, args []string) error {
+	return p.parsePositiveInt(o, keys.Pixelate, args...)
 }
 
-func applyWatermarkOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs("watermark", args, 7); err != nil {
+func (p *Parser) applyWatermarkOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs("watermark", args, 7); err != nil {
 		return err
 	}
 
-	if err := parseOpacityFloat(o, keys.WatermarkOpacity, args[0]); err != nil {
+	if err := p.parseOpacityFloat(o, keys.WatermarkOpacity, args[0]); err != nil {
 		return err
 	}
 
 	if len(args) > 1 && len(args[1]) > 0 {
-		if _, err := parseGravityType(
+		if _, err := p.parseGravityType(
 			o, keys.WatermarkPosition, processing.WatermarkGravityTypes, args[1],
 		); err != nil {
 			return err
@@ -333,19 +333,19 @@ func applyWatermarkOption(o *options.Options, args []string) error {
 	}
 
 	if len(args) > 2 && len(args[2]) > 0 {
-		if err := parseFloat(o, keys.WatermarkXOffset, args[2]); err != nil {
+		if err := p.parseFloat(o, keys.WatermarkXOffset, args[2]); err != nil {
 			return err
 		}
 	}
 
 	if len(args) > 3 && len(args[3]) > 0 {
-		if err := parseFloat(o, keys.WatermarkYOffset, args[3]); err != nil {
+		if err := p.parseFloat(o, keys.WatermarkYOffset, args[3]); err != nil {
 			return err
 		}
 	}
 
 	if len(args) > 4 && len(args[4]) > 0 {
-		if err := parsePositiveNonZeroFloat(o, keys.WatermarkScale, args[4]); err == nil {
+		if err := p.parsePositiveNonZeroFloat(o, keys.WatermarkScale, args[4]); err == nil {
 			return err
 		}
 	}
@@ -353,8 +353,8 @@ func applyWatermarkOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyFormatOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs(keys.Format, args, 1); err != nil {
+func (p *Parser) applyFormatOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs(keys.Format, args, 1); err != nil {
 		return err
 	}
 
@@ -367,8 +367,8 @@ func applyFormatOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyCacheBusterOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs(keys.CacheBuster, args, 1); err != nil {
+func (p *Parser) applyCacheBusterOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs(keys.CacheBuster, args, 1); err != nil {
 		return err
 	}
 
@@ -377,7 +377,7 @@ func applyCacheBusterOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applySkipProcessingFormatsOption(o *options.Options, args []string) error {
+func (p *Parser) applySkipProcessingFormatsOption(o *options.Options, args []string) error {
 	for _, format := range args {
 		if f, ok := imagetype.GetTypeByName(format); ok {
 			options.AppendToSlice(o, keys.SkipProcessing, f)
@@ -389,18 +389,18 @@ func applySkipProcessingFormatsOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyRawOption(o *options.Options, args []string) error {
-	return parseBool(o, keys.Raw, args...)
+func (p *Parser) applyRawOption(o *options.Options, args []string) error {
+	return p.parseBool(o, keys.Raw, args...)
 }
 
-func applyFilenameOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs(keys.Filename, args, 2); err != nil {
+func (p *Parser) applyFilenameOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs(keys.Filename, args, 2); err != nil {
 		return err
 	}
 
 	if len(args) > 1 && len(args[1]) > 0 {
 		if encoded, _ := strconv.ParseBool(args[1]); encoded {
-			return parseBase64String(o, keys.Filename, args[0])
+			return p.parseBase64String(o, keys.Filename, args[0])
 		}
 	}
 
@@ -409,8 +409,8 @@ func applyFilenameOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyExpiresOption(o *options.Options, args []string) error {
-	if err := ensureMaxArgs(keys.Expires, args, 1); err != nil {
+func (p *Parser) applyExpiresOption(o *options.Options, args []string) error {
+	if err := p.ensureMaxArgs(keys.Expires, args, 1); err != nil {
 		return err
 	}
 
@@ -428,71 +428,71 @@ func applyExpiresOption(o *options.Options, args []string) error {
 	return nil
 }
 
-func applyStripMetadataOption(o *options.Options, args []string) error {
-	return parseBool(o, keys.StripMetadata, args...)
+func (p *Parser) applyStripMetadataOption(o *options.Options, args []string) error {
+	return p.parseBool(o, keys.StripMetadata, args...)
 }
 
-func applyKeepCopyrightOption(o *options.Options, args []string) error {
-	return parseBool(o, keys.KeepCopyright, args...)
+func (p *Parser) applyKeepCopyrightOption(o *options.Options, args []string) error {
+	return p.parseBool(o, keys.KeepCopyright, args...)
 }
 
-func applyStripColorProfileOption(o *options.Options, args []string) error {
-	return parseBool(o, keys.StripColorProfile, args...)
+func (p *Parser) applyStripColorProfileOption(o *options.Options, args []string) error {
+	return p.parseBool(o, keys.StripColorProfile, args...)
 }
 
-func applyAutoRotateOption(o *options.Options, args []string) error {
-	return parseBool(o, keys.AutoRotate, args...)
+func (p *Parser) applyAutoRotateOption(o *options.Options, args []string) error {
+	return p.parseBool(o, keys.AutoRotate, args...)
 }
 
-func applyEnforceThumbnailOption(o *options.Options, args []string) error {
-	return parseBool(o, keys.EnforceThumbnail, args...)
+func (p *Parser) applyEnforceThumbnailOption(o *options.Options, args []string) error {
+	return p.parseBool(o, keys.EnforceThumbnail, args...)
 }
 
-func applyReturnAttachmentOption(o *options.Options, args []string) error {
-	return parseBool(o, keys.ReturnAttachment, args...)
+func (p *Parser) applyReturnAttachmentOption(o *options.Options, args []string) error {
+	return p.parseBool(o, keys.ReturnAttachment, args...)
 }
 
-func applyMaxSrcResolutionOption(p *Parser, o *options.Options, args []string) error {
+func (p *Parser) applyMaxSrcResolutionOption(o *options.Options, args []string) error {
 	if err := p.IsSecurityOptionsAllowed(); err != nil {
 		return err
 	}
 
-	return parseResolution(o, keys.MaxSrcResolution, args...)
+	return p.parseResolution(o, keys.MaxSrcResolution, args...)
 }
 
-func applyMaxSrcFileSizeOption(p *Parser, o *options.Options, args []string) error {
+func (p *Parser) applyMaxSrcFileSizeOption(o *options.Options, args []string) error {
 	if err := p.IsSecurityOptionsAllowed(); err != nil {
 		return err
 	}
 
-	return parseInt(o, keys.MaxSrcFileSize, args...)
+	return p.parseInt(o, keys.MaxSrcFileSize, args...)
 }
 
-func applyMaxAnimationFramesOption(p *Parser, o *options.Options, args []string) error {
+func (p *Parser) applyMaxAnimationFramesOption(o *options.Options, args []string) error {
 	if err := p.IsSecurityOptionsAllowed(); err != nil {
 		return err
 	}
 
-	return parsePositiveNonZeroInt(o, keys.MaxAnimationFrames, args...)
+	return p.parsePositiveNonZeroInt(o, keys.MaxAnimationFrames, args...)
 }
 
-func applyMaxAnimationFrameResolutionOption(p *Parser, o *options.Options, args []string) error {
+func (p *Parser) applyMaxAnimationFrameResolutionOption(o *options.Options, args []string) error {
 	if err := p.IsSecurityOptionsAllowed(); err != nil {
 		return err
 	}
 
-	return parseResolution(o, keys.MaxAnimationFrameResolution, args...)
+	return p.parseResolution(o, keys.MaxAnimationFrameResolution, args...)
 }
 
-func applyMaxResultDimensionOption(p *Parser, o *options.Options, args []string) error {
+func (p *Parser) applyMaxResultDimensionOption(o *options.Options, args []string) error {
 	if err := p.IsSecurityOptionsAllowed(); err != nil {
 		return err
 	}
 
-	return parseInt(o, keys.MaxResultDimension, args...)
+	return p.parseInt(o, keys.MaxResultDimension, args...)
 }
 
-func applyPresetOption(p *Parser, o *options.Options, args []string, usedPresets ...string) error {
+func (p *Parser) applyPresetOption(o *options.Options, args []string, usedPresets ...string) error {
 	for _, preset := range args {
 		if pr, ok := p.presets[preset]; ok {
 			if slices.Contains(usedPresets, preset) {

options/parser/parse.go

@@ -16,7 +16,7 @@ import (
 )
 
 // ensureMaxArgs checks if the number of arguments is as expected
-func ensureMaxArgs(name string, args []string, max int) error {
+func (p *Parser) ensureMaxArgs(name string, args []string, max int) error {
 	if len(args) > max {
 		return newInvalidArgsError(name, args)
 	}
@@ -24,8 +24,8 @@ func ensureMaxArgs(name string, args []string, max int) error {
 }
 
 // parseBool parses a boolean option value and warns if the value is invalid
-func parseBool(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parseBool(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -41,8 +41,8 @@ func parseBool(o *options.Options, key string, args ...string) error {
 }
 
 // parseFloat parses a float64 option value
-func parseFloat(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parseFloat(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -57,8 +57,8 @@ func parseFloat(o *options.Options, key string, args ...string) error {
 }
 
 // parsePositiveFloat parses a positive float64 option value
-func parsePositiveFloat(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parsePositiveFloat(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -73,8 +73,8 @@ func parsePositiveFloat(o *options.Options, key string, args ...string) error {
 }
 
 // parsePositiveNonZeroFloat parses a positive non-zero float64 option value
-func parsePositiveNonZeroFloat(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parsePositiveNonZeroFloat(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -89,8 +89,8 @@ func parsePositiveNonZeroFloat(o *options.Options, key string, args ...string) e
 }
 
 // parseInt parses a positive integer option value
-func parseInt(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parseInt(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -105,8 +105,8 @@ func parseInt(o *options.Options, key string, args ...string) error {
 }
 
 // parsePositiveNonZeroInt parses a positive non-zero integer option value
-func parsePositiveNonZeroInt(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parsePositiveNonZeroInt(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -121,8 +121,8 @@ func parsePositiveNonZeroInt(o *options.Options, key string, args ...string) err
 }
 
 // parsePositiveInt parses a positive integer option value
-func parsePositiveInt(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parsePositiveInt(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -137,8 +137,8 @@ func parsePositiveInt(o *options.Options, key string, args ...string) error {
 }
 
 // parseQualityInt parses a quality integer option value (1-100)
-func parseQualityInt(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parseQualityInt(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -153,8 +153,8 @@ func parseQualityInt(o *options.Options, key string, args ...string) error {
 }
 
 // parseOpacityFloat parses an opacity float option value (0-1)
-func parseOpacityFloat(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parseOpacityFloat(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -169,8 +169,8 @@ func parseOpacityFloat(o *options.Options, key string, args ...string) error {
 }
 
 // parseResolution parses a resolution option value in megapixels and stores it as pixels
-func parseResolution(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parseResolution(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -186,8 +186,8 @@ func parseResolution(o *options.Options, key string, args ...string) error {
 }
 
 // parseBase64String parses a base64-encoded string option value
-func parseBase64String(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parseBase64String(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -202,8 +202,8 @@ func parseBase64String(o *options.Options, key string, args ...string) error {
 }
 
 // parseHexRGBColor parses a hex-encoded RGB color option value
-func parseHexRGBColor(o *options.Options, key string, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func (p *Parser) parseHexRGBColor(o *options.Options, key string, args ...string) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -218,8 +218,14 @@ func parseHexRGBColor(o *options.Options, key string, args ...string) error {
 }
 
 // parseFromMap parses an option value from a map of allowed values
-func parseFromMap[T comparable](o *options.Options, key string, m map[string]T, args ...string) error {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+func parseFromMap[T comparable](
+	p *Parser,
+	o *options.Options,
+	key string,
+	m map[string]T,
+	args ...string,
+) error {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return err
 	}
 
@@ -233,13 +239,13 @@ func parseFromMap[T comparable](o *options.Options, key string, m map[string]T,
 	return nil
 }
 
-func parseGravityType(
+func (p *Parser) parseGravityType(
 	o *options.Options,
 	key string,
 	allowedTypes []processing.GravityType,
 	args ...string,
 ) (processing.GravityType, error) {
-	if err := ensureMaxArgs(key, args, 1); err != nil {
+	if err := p.ensureMaxArgs(key, args, 1); err != nil {
 		return processing.GravityUnknown, err
 	}
 
@@ -257,11 +263,11 @@ func parseGravityType(
 	return gType, nil
 }
 
-func isGravityOffsetValid(gravity processing.GravityType, offset float64) bool {
+func (p *Parser) isGravityOffsetValid(gravity processing.GravityType, offset float64) bool {
 	return gravity != processing.GravityFocusPoint || (offset >= 0 && offset <= 1)
 }
 
-func parseGravity(
+func (p *Parser) parseGravity(
 	o *options.Options,
 	key string,
 	allowedTypes []processing.GravityType,
@@ -273,7 +279,7 @@ func parseGravity(
 	keyXOffset := key + keys.SuffixXOffset
 	keyYOffset := key + keys.SuffixYOffset
 
-	gType, err := parseGravityType(o, keyType, allowedTypes, args[0])
+	gType, err := p.parseGravityType(o, keyType, allowedTypes, args[0])
 	if err != nil {
 		return err
 	}
@@ -298,7 +304,7 @@ func parseGravity(
 		}
 
 		if nArgs > 1 {
-			if x, err := strconv.ParseFloat(args[1], 64); err == nil && isGravityOffsetValid(gType, x) {
+			if x, err := strconv.ParseFloat(args[1], 64); err == nil && p.isGravityOffsetValid(gType, x) {
 				o.Set(keyXOffset, x)
 			} else {
 				return newInvalidArgumentError(keyXOffset, args[1])
@@ -306,7 +312,7 @@ func parseGravity(
 		}
 
 		if nArgs > 2 {
-			if y, err := strconv.ParseFloat(args[2], 64); err == nil && isGravityOffsetValid(gType, y) {
+			if y, err := strconv.ParseFloat(args[2], 64); err == nil && p.isGravityOffsetValid(gType, y) {
 				o.Set(keyYOffset, y)
 			} else {
 				return newInvalidArgumentError(keyYOffset, args[2])
@@ -317,17 +323,17 @@ func parseGravity(
 	return nil
 }
 
-func parseExtend(o *options.Options, key string, args []string) error {
-	if err := ensureMaxArgs(key, args, 4); err != nil {
+func (p *Parser) parseExtend(o *options.Options, key string, args []string) error {
+	if err := p.ensureMaxArgs(key, args, 4); err != nil {
 		return err
 	}
 
-	if err := parseBool(o, key+keys.SuffixEnabled, args[0]); err != nil {
+	if err := p.parseBool(o, key+keys.SuffixEnabled, args[0]); err != nil {
 		return err
 	}
 
 	if len(args) > 1 {
-		return parseGravity(o, key+keys.SuffixGravity, processing.ExtendGravityTypes, args[1:]...)
+		return p.parseGravity(o, key+keys.SuffixGravity, processing.ExtendGravityTypes, args[1:]...)
 	}
 
 	return nil

options/parser/processing_options.go

@@ -23,95 +23,95 @@ func (p *Parser) applyURLOption(
 ) error {
 	switch name {
 	case "resize", "rs":
-		return applyResizeOption(o, args)
+		return p.applyResizeOption(o, args)
 	case "size", "s":
-		return applySizeOption(o, args)
+		return p.applySizeOption(o, args)
 	case "resizing_type", "rt":
-		return applyResizingTypeOption(o, args)
+		return p.applyResizingTypeOption(o, args)
 	case "width", "w":
-		return applyWidthOption(o, args)
+		return p.applyWidthOption(o, args)
 	case "height", "h":
-		return applyHeightOption(o, args)
+		return p.applyHeightOption(o, args)
 	case "min-width", "mw":
-		return applyMinWidthOption(o, args)
+		return p.applyMinWidthOption(o, args)
 	case "min-height", "mh":
-		return applyMinHeightOption(o, args)
+		return p.applyMinHeightOption(o, args)
 	case "zoom", "z":
-		return applyZoomOption(o, args)
+		return p.applyZoomOption(o, args)
 	case "dpr":
-		return applyDprOption(o, args)
+		return p.applyDprOption(o, args)
 	case "enlarge", "el":
-		return applyEnlargeOption(o, args)
+		return p.applyEnlargeOption(o, args)
 	case "extend", "ex":
-		return applyExtendOption(o, args)
+		return p.applyExtendOption(o, args)
 	case "extend_aspect_ratio", "extend_ar", "exar":
-		return applyExtendAspectRatioOption(o, args)
+		return p.applyExtendAspectRatioOption(o, args)
 	case "gravity", "g":
-		return applyGravityOption(o, args)
+		return p.applyGravityOption(o, args)
 	case "crop", "c":
-		return applyCropOption(o, args)
+		return p.applyCropOption(o, args)
 	case "trim", "t":
-		return applyTrimOption(o, args)
+		return p.applyTrimOption(o, args)
 	case "padding", "pd":
-		return applyPaddingOption(o, args)
+		return p.applyPaddingOption(o, args)
 	case "auto_rotate", "ar":
-		return applyAutoRotateOption(o, args)
+		return p.applyAutoRotateOption(o, args)
 	case "rotate", "rot":
-		return applyRotateOption(o, args)
+		return p.applyRotateOption(o, args)
 	case "background", "bg":
-		return applyBackgroundOption(o, args)
+		return p.applyBackgroundOption(o, args)
 	case "blur", "bl":
-		return applyBlurOption(o, args)
+		return p.applyBlurOption(o, args)
 	case "sharpen", "sh":
-		return applySharpenOption(o, args)
+		return p.applySharpenOption(o, args)
 	case "pixelate", "pix":
-		return applyPixelateOption(o, args)
+		return p.applyPixelateOption(o, args)
 	case "watermark", "wm":
-		return applyWatermarkOption(o, args)
+		return p.applyWatermarkOption(o, args)
 	case "strip_metadata", "sm":
-		return applyStripMetadataOption(o.Main(), args)
+		return p.applyStripMetadataOption(o.Main(), args)
 	case "keep_copyright", "kcr":
-		return applyKeepCopyrightOption(o.Main(), args)
+		return p.applyKeepCopyrightOption(o.Main(), args)
 	case "strip_color_profile", "scp":
-		return applyStripColorProfileOption(o.Main(), args)
+		return p.applyStripColorProfileOption(o.Main(), args)
 	case "enforce_thumbnail", "eth":
-		return applyEnforceThumbnailOption(o.Main(), args)
+		return p.applyEnforceThumbnailOption(o.Main(), args)
 	// Saving options
 	case "quality", "q":
-		return applyQualityOption(o.Main(), args)
+		return p.applyQualityOption(o.Main(), args)
 	case "format_quality", "fq":
-		return applyFormatQualityOption(o.Main(), args)
+		return p.applyFormatQualityOption(o.Main(), args)
 	case "max_bytes", "mb":
-		return applyMaxBytesOption(o.Main(), args)
+		return p.applyMaxBytesOption(o.Main(), args)
 	case "format", "f", "ext":
-		return applyFormatOption(o.Main(), args)
+		return p.applyFormatOption(o.Main(), args)
 	// Handling options
 	case "skip_processing", "skp":
-		return applySkipProcessingFormatsOption(o.Main(), args)
+		return p.applySkipProcessingFormatsOption(o.Main(), args)
 	case "raw":
-		return applyRawOption(o.Main(), args)
+		return p.applyRawOption(o.Main(), args)
 	case "cachebuster", "cb":
-		return applyCacheBusterOption(o.Main(), args)
+		return p.applyCacheBusterOption(o.Main(), args)
 	case "expires", "exp":
-		return applyExpiresOption(o.Main(), args)
+		return p.applyExpiresOption(o.Main(), args)
 	case "filename", "fn":
-		return applyFilenameOption(o.Main(), args)
+		return p.applyFilenameOption(o.Main(), args)
 	case "return_attachment", "att":
-		return applyReturnAttachmentOption(o.Main(), args)
+		return p.applyReturnAttachmentOption(o.Main(), args)
 	// Presets
 	case "preset", "pr":
-		return applyPresetOption(p, o, args, usedPresets...)
+		return p.applyPresetOption(o, args, usedPresets...)
 	// Security
 	case "max_src_resolution", "msr":
-		return applyMaxSrcResolutionOption(p, o.Main(), args)
+		return p.applyMaxSrcResolutionOption(o, args)
 	case "max_src_file_size", "msfs":
-		return applyMaxSrcFileSizeOption(p, o.Main(), args)
+		return p.applyMaxSrcFileSizeOption(o, args)
 	case "max_animation_frames", "maf":
-		return applyMaxAnimationFramesOption(p, o.Main(), args)
+		return p.applyMaxAnimationFramesOption(o.Main(), args)
 	case "max_animation_frame_resolution", "mafr":
-		return applyMaxAnimationFrameResolutionOption(p, o.Main(), args)
+		return p.applyMaxAnimationFrameResolutionOption(o.Main(), args)
 	case "max_result_dimension", "mrd":
-		return applyMaxResultDimensionOption(p, o.Main(), args)
+		return p.applyMaxResultDimensionOption(o.Main(), args)
 	}
 
 	return newUnknownOptionError("processing", name)
@@ -193,7 +193,7 @@ func (p *Parser) defaultProcessingOptions(headers http.Header) (*options.Options
 	}
 
 	if _, ok := p.presets["default"]; ok {
-		if err := applyPresetOption(p, o, []string{"default"}); err != nil {
+		if err := p.applyPresetOption(o, []string{"default"}); err != nil {
 			return o, err
 		}
 	}
@@ -251,7 +251,7 @@ func (p *Parser) parsePathOptions(
 	}
 
 	if !options.Get(o, keys.Raw, false) && len(extension) > 0 {
-		if err = applyFormatOption(o, []string{extension}); err != nil {
+		if err = p.applyFormatOption(o, []string{extension}); err != nil {
 			return nil, "", err
 		}
 	}
@@ -269,7 +269,7 @@ func (p *Parser) parsePathPresets(parts []string, headers http.Header) (*options
 	presets := strings.Split(parts[0], p.config.ArgumentsSeparator)
 	urlParts := parts[1:]
 
-	if err = applyPresetOption(p, o, presets); err != nil {
+	if err = p.applyPresetOption(o, presets); err != nil {
 		return nil, "", err
 	}
 
@@ -279,7 +279,7 @@ func (p *Parser) parsePathPresets(parts []string, headers http.Header) (*options
 	}
 
 	if !options.Get(o, keys.Raw, false) && len(extension) > 0 {
-		if err = applyFormatOption(o, []string{extension}); err != nil {
+		if err = p.applyFormatOption(o, []string{extension}); err != nil {
 			return nil, "", err
 		}
 	}