@xprite/pixelate 0.0.0-stage → 0.1.1

package/dist/settings.d.ts

@@ -0,0 +1,36 @@
+import type { PixelBuffer } from "./base.ts";
+import { PixelationMethod, type PixelGridAnalysis, type PixelationSettings, type PixelateOptions } from "./types.ts";
+export declare const MAX_PIXELATION_SIZE = 512;
+export declare const PIXELATION_SIZES: readonly [16, 32, 64, 128, 256, 512];
+export declare const PIXELATION_METHOD_OPTIONS: readonly [{
+    readonly value: PixelationMethod.Structure;
+    readonly label: "Preserve edges";
+}, {
+    readonly value: PixelationMethod.Dominant;
+    readonly label: "Dominant colors";
+}, {
+    readonly value: PixelationMethod.MostFrequent;
+    readonly label: "Most frequent color";
+}, {
+    readonly value: PixelationMethod.Box;
+    readonly label: "Box average";
+}, {
+    readonly value: PixelationMethod.Nearest;
+    readonly label: "Nearest-neighbor";
+}];
+export declare function defaultPixelationSettings(image: Pick<PixelBuffer, "width" | "height">, grid?: PixelGridAnalysis): PixelationSettings;
+export declare function updatePixelationSettings(settings: PixelationSettings, patch: Partial<PixelationSettings>, image: Pick<PixelBuffer, "width" | "height">): PixelationSettings;
+export declare function pixelationSettingsOptions(settings: PixelationSettings, image?: Pick<PixelBuffer, "width" | "height">, detected?: PixelGridAnalysis): PixelateOptions;
+/**
+ * What a detected grid means for the settings: a reliable one recovers it, anything else falls back
+ * to the plain convert (resize). Shared by the import dialog and the tool pages.
+ */
+export declare function applyPixelationGrid(settings: PixelationSettings, grid: PixelGridAnalysis, image: Pick<PixelBuffer, "width" | "height">): PixelationSettings;
+/**
+ * The output size for typing one dimension: the other follows the image's aspect ratio. Null when the
+ * text is not a usable size.
+ */
+export declare function pixelationSizeFromAxis(axis: "width" | "height", value: string, image: Pick<PixelBuffer, "width" | "height">): {
+    width: number;
+    height: number;
+} | null;

package/dist/settings.js

@@ -0,0 +1,181 @@
+import { manualPixelGrid, MAX_GRID_CELL_SIZE } from "./grid.js";
+import { DEFAULT_LINE_GUIDE, DEFAULT_OUTLINE_PREPASS, readOutlinePrepass, } from "./outline-prepass.js";
+import { CellColorPicker, LineGuideMode, OutlinePrepass, PaletteColorMode, PixelationDither, PixelationMethod, PixelationMode, } from "./types.js";
+export const MAX_PIXELATION_SIZE = 512;
+export const PIXELATION_SIZES = [16, 32, 64, 128, 256, MAX_PIXELATION_SIZE];
+export const PIXELATION_METHOD_OPTIONS = [
+    { value: PixelationMethod.Structure, label: "Preserve edges" },
+    { value: PixelationMethod.Dominant, label: "Dominant colors" },
+    { value: PixelationMethod.MostFrequent, label: "Most frequent color" },
+    { value: PixelationMethod.Box, label: "Box average" },
+    { value: PixelationMethod.Nearest, label: "Nearest-neighbor" },
+];
+const DEFAULT_PIXELATION_SIZE = 64;
+const DEFAULT_COLORS = 16;
+const MAX_COLORS = 256;
+export function defaultPixelationSettings(image, grid) {
+    const scale = Math.min(1, DEFAULT_PIXELATION_SIZE / Math.max(image.width, image.height));
+    const mode = grid?.reliable ? PixelationMode.RecoverGrid : PixelationMode.Convert;
+    // Recover Grid opens on PixelOE + lines with TwoStage and Limit colors (16). Convert opens on
+    // PixelOE + lines with Contrast and no color limit. Both use PixelOE's outline pre-pass.
+    return {
+        mode,
+        reduceColors: mode === PixelationMode.RecoverGrid,
+        outlineStrength: 0,
+        prepass: DEFAULT_OUTLINE_PREPASS,
+        lineGuide: DEFAULT_LINE_GUIDE,
+        colorPicker: mode === PixelationMode.RecoverGrid ? CellColorPicker.TwoStage : CellColorPicker.Contrast,
+        autoGrid: true,
+        gridCellWidth: grid?.reliable ? grid.cellWidth : 8,
+        gridCellHeight: grid?.reliable ? grid.cellHeight : 8,
+        targetWidth: Math.max(1, Math.round(image.width * scale)),
+        targetHeight: Math.max(1, Math.round(image.height * scale)),
+        maxColors: DEFAULT_COLORS,
+        method: PixelationMethod.Structure,
+        blockPicker: false,
+        preserveDimensions: false,
+        removeNoise: false,
+        lockAspectRatio: true,
+        dither: PixelationDither.None,
+        paletteColorMode: PaletteColorMode.Fixed,
+        palette: null,
+        paletteName: "",
+    };
+}
+export function updatePixelationSettings(settings, patch, image) {
+    const next = { ...settings, ...patch };
+    // Settings saved before the pre-pass dropdown carry the old checkbox instead.
+    next.prepass = readOutlinePrepass(patch) ?? readOutlinePrepass(settings) ?? OutlinePrepass.None;
+    delete next.pixeloePrepass;
+    // Settings saved before Limit colors and Snap palette became one control: either one on means
+    // Limit colors, counting Limit colors' own count if it was on, else Snap palette's.
+    const legacy = { ...settings, ...patch };
+    if (legacy.snapPalette !== undefined || legacy.snapColors !== undefined) {
+        if (legacy.snapPalette === true && !next.reduceColors) {
+            next.reduceColors = true;
+            if (typeof legacy.snapColors === "number")
+                next.maxColors = legacy.snapColors;
+        }
+        delete next.snapPalette;
+        delete next.snapColors;
+    }
+    if (!Object.values(PaletteColorMode).includes(next.paletteColorMode))
+        next.paletteColorMode = PaletteColorMode.Fixed;
+    if (!Object.values(LineGuideMode).includes(next.lineGuide))
+        next.lineGuide = DEFAULT_LINE_GUIDE;
+    if (!Object.values(PixelationDither).includes(next.dither))
+        next.dither = PixelationDither.None;
+    // Turning a PixelOE pre-pass on starts from Contrast, PixelOE's own colour rule.
+    if (settings.prepass === OutlinePrepass.None &&
+        next.prepass !== OutlinePrepass.None &&
+        patch.colorPicker === undefined)
+        next.colorPicker = CellColorPicker.Contrast;
+    if (patch.palette !== undefined) {
+        if (patch.palette && (!patch.palette.length || patch.palette.length > MAX_COLORS))
+            throw new RangeError("Choose a palette with 1 to 256 colors.");
+        next.palette = patch.palette ? patch.palette.map((color) => [...color]) : null;
+        if (patch.palette === null)
+            next.paletteName = "";
+    }
+    // Mode-switch defaults: Recover uses Median and limits colours; plain Convert limits only without a pre-pass.
+    if (patch.mode !== undefined && patch.mode !== settings.mode) {
+        if (patch.reduceColors === undefined) {
+            if (patch.mode === PixelationMode.RecoverGrid) {
+                next.reduceColors = true;
+            }
+            else {
+                next.reduceColors = next.prepass === OutlinePrepass.None;
+            }
+        }
+        if (patch.colorPicker === undefined && patch.mode === PixelationMode.RecoverGrid) {
+            next.colorPicker = CellColorPicker.TwoStage;
+        }
+    }
+    const cellSize = (value) => Number.isFinite(value) ? Math.max(1, Math.min(MAX_GRID_CELL_SIZE, value)) : 8;
+    next.gridCellWidth = cellSize(next.gridCellWidth);
+    next.gridCellHeight = cellSize(next.gridCellHeight);
+    next.outlineStrength = Number.isFinite(next.outlineStrength)
+        ? Math.max(0, Math.min(100, Math.round(next.outlineStrength)))
+        : 0;
+    const dimension = (value) => Number.isFinite(value) ? Math.max(1, Math.min(MAX_PIXELATION_SIZE, Math.round(value))) : 1;
+    next.targetWidth = dimension(next.targetWidth);
+    next.targetHeight = dimension(next.targetHeight);
+    if (next.lockAspectRatio) {
+        const fromHeight = patch.targetHeight !== undefined && patch.targetWidth === undefined;
+        const width = fromHeight ? (next.targetHeight * image.width) / image.height : next.targetWidth;
+        const height = fromHeight ? next.targetHeight : (next.targetWidth * image.height) / image.width;
+        const scale = Math.min(1, MAX_PIXELATION_SIZE / Math.max(width, height));
+        next.targetWidth = dimension(width * scale);
+        next.targetHeight = dimension(height * scale);
+    }
+    next.maxColors = Number.isFinite(next.maxColors)
+        ? Math.max(2, Math.min(MAX_COLORS, Math.round(next.maxColors)))
+        : DEFAULT_COLORS;
+    return next;
+}
+export function pixelationSettingsOptions(settings, image, detected) {
+    let grid;
+    if (settings.mode === PixelationMode.RecoverGrid) {
+        if (settings.autoGrid) {
+            if (!detected?.reliable)
+                throw new Error("No consistent pixel grid was detected. Turn off Automatic grid and choose cell sizes.");
+            grid = detected;
+        }
+        else {
+            if (!image)
+                throw new Error("Open an image before choosing grid cells.");
+            grid = manualPixelGrid(image, settings.gridCellWidth, settings.gridCellHeight);
+        }
+    }
+    return {
+        mode: settings.mode,
+        grid,
+        colorPicker: settings.colorPicker,
+        outlineStrength: settings.mode === PixelationMode.Convert ? settings.outlineStrength : 0,
+        prepass: settings.prepass,
+        lineGuide: settings.lineGuide,
+        targetWidth: settings.targetWidth,
+        targetHeight: settings.targetHeight,
+        // Limit colors: k-means to the colour count, adaptive estimation, or the loaded palette.
+        paletteSnap: settings.reduceColors
+            ? settings.palette
+                ? { palette: settings.palette, dither: settings.dither }
+                : settings.paletteColorMode === PaletteColorMode.Adaptive
+                    ? { adaptive: true, dither: settings.dither }
+                    : { colors: settings.maxColors, dither: settings.dither }
+            : undefined,
+        method: settings.method,
+        // A pre-pass hands its result to the colour rule, so the picker (not `method`) fills each block.
+        blockPicker: settings.blockPicker || settings.prepass !== OutlinePrepass.None,
+        preserveDimensions: settings.preserveDimensions,
+        removeNoise: settings.removeNoise,
+        alphaMode: "premultiplied",
+    };
+}
+/**
+ * What a detected grid means for the settings: a reliable one recovers it, anything else falls back
+ * to the plain convert (resize). Shared by the import dialog and the tool pages.
+ */
+export function applyPixelationGrid(settings, grid, image) {
+    return updatePixelationSettings(settings, grid.reliable
+        ? {
+            mode: PixelationMode.RecoverGrid,
+            autoGrid: true,
+            gridCellWidth: grid.cellWidth,
+            gridCellHeight: grid.cellHeight,
+        }
+        : { mode: PixelationMode.Convert }, image);
+}
+/**
+ * The output size for typing one dimension: the other follows the image's aspect ratio. Null when the
+ * text is not a usable size.
+ */
+export function pixelationSizeFromAxis(axis, value, image) {
+    const typed = Number.parseInt(value, 10);
+    if (!Number.isFinite(typed) || typed < 1)
+        return null;
+    const { width, height } = image;
+    return axis === "width"
+        ? { width: typed, height: Math.max(1, Math.round((typed * height) / width)) }
+        : { width: Math.max(1, Math.round((typed * width) / height)), height: typed };
+}

package/dist/types.d.ts

@@ -0,0 +1,255 @@
+import type { Rgba } from "./base.ts";
+/** The intentionally conservative result of the image import heuristic. */
+export declare enum PixelArtClassification {
+    LikelyPixelArt = "likely-pixel-art",
+    LikelyPhoto = "likely-photo",
+    Uncertain = "uncertain"
+}
+export interface PixelArtMetrics {
+    width: number;
+    height: number;
+    sampledPixels: number;
+    uniqueColors: number;
+    uniqueColorsCapped: boolean;
+    uniqueColorRatio: number;
+    exactNeighborRatio: number;
+    nearNeighborRatio: number;
+    edgeDensity: number;
+    colorEntropy: number;
+    transparentRatio: number;
+    opaqueRatio: number;
+}
+export interface PixelArtAnalysisOptions {
+    /** Apply the user's choice after the heuristic has run. */
+    userOverride?: PixelArtClassification | null;
+    /** Bound work for very large photographs while retaining deterministic sampling. */
+    maxSamplePixels?: number;
+    /** Grid detection algorithm; Auto when omitted. */
+    algorithm?: PixelationAlgorithm;
+    /** Output size for entries that take one (Custom size); ignored by the others. */
+    size?: PixelationSize;
+}
+export interface PixelArtAnalysis {
+    /** The choice a caller should use, including an explicit user override. */
+    classification: PixelArtClassification;
+    /** The heuristic's choice before applying a user override. */
+    suggestedClassification: PixelArtClassification;
+    /** A 0..1 indication of how far the heuristic was from its decision boundary. */
+    confidence: number;
+    /** Signed score: positive favors pixel art, negative favors a photo. */
+    score: number;
+    /** Human-readable, deliberately non-authoritative reasons for the suggestion. */
+    evidence: readonly string[];
+    metrics: PixelArtMetrics;
+    userOverride: PixelArtClassification | null;
+    overrideApplied: boolean;
+    /** This is a heuristic and must never silently replace a user's choice. */
+    isHeuristic: true;
+    grid: PixelGridAnalysis;
+}
+export declare enum PixelationMethod {
+    Nearest = "nearest",
+    Box = "box",
+    MostFrequent = "most-frequent",
+    Dominant = "dominant",
+    Structure = "structure",
+    TwoStage = "two-stage"
+}
+export declare enum PixelationMode {
+    Convert = "convert",
+    RecoverGrid = "recover-grid"
+}
+export declare enum PixelationAlgorithm {
+    Auto = "auto",
+    EdgeGrid = "edge-grid",
+    UniformGrid = "uniform-grid",
+    /** Auto's single proposers, each on its own; see the registry for which detector each runs. */
+    FrameLattice = "frame-lattice",
+    PitchLattice = "pitch-lattice",
+    ColorPeriod = "color-period",
+    BorderRuns = "border-runs",
+    EdgeSpacing = "edge-spacing",
+    /** The user names the output size; the image is split into that many even blocks. */
+    CustomSize = "custom-size",
+    Resize = "resize"
+}
+/**
+ * The outline pre-pass ahead of the colour rule. PixelOE runs outline expansion + colour match;
+ * PixelOE + lines also guides the expansion weight with an XDoG line drawing of the source.
+ */
+export declare enum OutlinePrepass {
+    None = "none",
+    Pixeloe = "pixeloe",
+    PixeloeLines = "pixeloe-lines"
+}
+/** Dithering when Limit colors snaps the result to a smaller palette. Off leaves nearest-colour. */
+export declare enum PixelationDither {
+    None = "none",
+    Ordered = "ordered",
+    FloydSteinberg = "floyd-steinberg"
+}
+/** How the max color count is determined when Limit colors is on. */
+export declare enum PaletteColorMode {
+    /** User-specified fixed count (e.g. 16). */
+    Fixed = "fixed",
+    /** One colour per group of near-duplicate shades (Lab ΔE) in the recovered image. */
+    Adaptive = "adaptive"
+}
+/** How a line drawing changes PixelOE's outline weight (1 = spread dark, 0 = spread bright). */
+export declare enum LineGuideMode {
+    /** max(weight, lines): PixelOE's own weight, plus dark spreading along every line. */
+    Union = "union",
+    /** weight = lines: dark spreads only along lines, bright everywhere else. */
+    Replace = "replace"
+}
+/** How one colour is chosen for each grid cell, independent of how the grid was found. */
+export declare enum CellColorPicker {
+    MostCommon = "most-common",
+    Average = "average",
+    Median = "median",
+    KMeans = "k-means",
+    Contrast = "contrast",
+    Nearest = "nearest",
+    Structure = "structure",
+    TwoStage = "two-stage",
+    DualRtTwoStage = "dual-rt-two-stage"
+}
+export interface PixelGridGeometry {
+    width: number;
+    height: number;
+    cellWidth: number;
+    cellHeight: number;
+    offsetX: number;
+    offsetY: number;
+    /** Explicit cell boundaries (pixel indices, first 0, last = image size) for irregular grids. */
+    cutsX?: readonly number[];
+    cutsY?: readonly number[];
+}
+export declare enum PixelGridSamplingAxis {
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}
+/** A piecewise constant inverse displacement: one shift per band and across-axis interval. */
+export interface PixelGridSamplingStage {
+    axis: PixelGridSamplingAxis;
+    /** Boundaries along the displaced axis, first 0 and last its length. */
+    bands: readonly number[];
+    /** Boundaries on the other axis, first 0 and last its length. */
+    across: readonly number[];
+    /** [band][across interval], in whole source pixels. */
+    shifts: readonly (readonly number[] | Int32Array)[];
+}
+export interface PixelGridAnalysis extends PixelGridGeometry {
+    confidence: number;
+    reliable: boolean;
+    /** Registry entry that produced this analysis. */
+    algorithm?: PixelationAlgorithm;
+    /**
+     * Degrees the source was rotated to straighten a tilted grid before it was detected. The cuts
+     * are measured in that straightened image, so recovery applies the same rotation first.
+     */
+    rotation?: number;
+    /** Local inverse sampling steps in the straightened source, in application order. */
+    sampling?: readonly PixelGridSamplingStage[];
+    /**
+     * The cuts already follow the image's edges one by one (grid-edge-path), so arbitration reads
+     * them as placed, without strip shifts or a phase field.
+     */
+    placed?: boolean;
+}
+export interface PixelationSize {
+    width: number;
+    height: number;
+}
+/** Limit colors, applied to the pixelated image (see palette-snap.ts). */
+export interface PaletteSnapOptions {
+    /** Number of colours to cluster into (k-means); ignored when `palette` or `adaptive` is given. */
+    colors?: number;
+    /** Estimate color count from the image instead of using a fixed count. */
+    adaptive?: boolean;
+    /** Snap every visible pixel to its nearest entry (CIE Lab) instead of clustering. */
+    palette?: readonly Rgba[];
+    /** Ordered / Floyd–Steinberg while snapping; None (nearest) when omitted. */
+    dither?: PixelationDither;
+}
+export interface PixelateOptions {
+    mode?: PixelationMode;
+    algorithm?: PixelationAlgorithm;
+    /** Per-cell colour rule when a grid is recovered; MostCommon when omitted. */
+    colorPicker?: CellColorPicker;
+    grid?: PixelGridGeometry;
+    outlineStrength?: number;
+    /**
+     * Outline pre-pass; None when omitted. With the Contrast picker and no grid recovered from the
+     * source (a plain convert or Custom size), a PixelOE pre-pass runs stock PixelOE end to end
+     * (contrast downscale + colour match at the output size); otherwise it is an image -> image step
+     * before the picker or sampler.
+     */
+    prepass?: OutlinePrepass;
+    /** How the line drawing guides PixelOE + lines; Union when omitted. */
+    lineGuide?: LineGuideMode;
+    /** Sampling rule used to choose one representative color per output cell. */
+    method?: PixelationMethod;
+    /** Split the image into even blocks of the target size and let `colorPicker` choose each colour (instead of `method`). */
+    blockPicker?: boolean;
+    /** The low-resolution dimensions to generate. */
+    targetWidth?: number;
+    targetHeight?: number;
+    targetSize?: PixelationSize;
+    /** Choose low-resolution dimensions by grouping this many source pixels. */
+    blockSize?: number | PixelationSize;
+    /** Nearest-neighbor upscale to the source dimensions after pixelation. */
+    preserveDimensions?: boolean;
+    /**
+     * Limit colors: Lab k-means to a colour count that keeps rare colours, or snapping to a given
+     * palette. Alpha stays per pixel. Off when omitted.
+     */
+    paletteSnap?: PaletteSnapOptions;
+    /** Light smoothing of similar neighboring colors on the working grid. */
+    removeNoise?: boolean;
+    /** Box mode defaults to straight channel means; premultiplied is useful for compositing. */
+    alphaMode?: "straight" | "premultiplied";
+}
+export interface PaletteEntry {
+    color: Rgba;
+    count: number;
+    coverage: number;
+}
+export interface ExtractPaletteOptions {
+    /** Number of entries to return. Values above 256 are capped. */
+    maxColors?: number;
+    ignoreTransparent?: boolean;
+}
+/** Shared conversion draft used by import and standalone tools. */
+export interface PixelationSettings {
+    mode: PixelationMode;
+    /**
+     * Limit colors: snap the result to `maxColors` colours (k-means keeping rare colours) or, when
+     * one is loaded, to `palette`.
+     */
+    reduceColors: boolean;
+    outlineStrength: number;
+    /** Outline pre-pass ahead of the colour rule (see `PixelateOptions.prepass`). */
+    prepass: OutlinePrepass;
+    /** Line guide of the PixelOE + lines pre-pass. */
+    lineGuide: LineGuideMode;
+    colorPicker: CellColorPicker;
+    autoGrid: boolean;
+    gridCellWidth: number;
+    gridCellHeight: number;
+    targetWidth: number;
+    targetHeight: number;
+    maxColors: number;
+    method: PixelationMethod;
+    /** Colour each target-size block with `colorPicker` rather than resampling with `method`. */
+    blockPicker: boolean;
+    preserveDimensions: boolean;
+    removeNoise: boolean;
+    lockAspectRatio: boolean;
+    /** Dithering for Limit colors; ignored when Limit colors is off. */
+    dither: PixelationDither;
+    /** How the color count is chosen when Limit colors is on and no palette is loaded. */
+    paletteColorMode: PaletteColorMode;
+    palette: readonly Rgba[] | null;
+    paletteName: string;
+}

package/dist/types.js

@@ -0,0 +1,87 @@
+/** The intentionally conservative result of the image import heuristic. */
+export var PixelArtClassification;
+(function (PixelArtClassification) {
+    PixelArtClassification["LikelyPixelArt"] = "likely-pixel-art";
+    PixelArtClassification["LikelyPhoto"] = "likely-photo";
+    PixelArtClassification["Uncertain"] = "uncertain";
+})(PixelArtClassification || (PixelArtClassification = {}));
+export var PixelationMethod;
+(function (PixelationMethod) {
+    PixelationMethod["Nearest"] = "nearest";
+    PixelationMethod["Box"] = "box";
+    PixelationMethod["MostFrequent"] = "most-frequent";
+    PixelationMethod["Dominant"] = "dominant";
+    PixelationMethod["Structure"] = "structure";
+    PixelationMethod["TwoStage"] = "two-stage";
+})(PixelationMethod || (PixelationMethod = {}));
+export var PixelationMode;
+(function (PixelationMode) {
+    PixelationMode["Convert"] = "convert";
+    PixelationMode["RecoverGrid"] = "recover-grid";
+})(PixelationMode || (PixelationMode = {}));
+export var PixelationAlgorithm;
+(function (PixelationAlgorithm) {
+    PixelationAlgorithm["Auto"] = "auto";
+    PixelationAlgorithm["EdgeGrid"] = "edge-grid";
+    PixelationAlgorithm["UniformGrid"] = "uniform-grid";
+    /** Auto's single proposers, each on its own; see the registry for which detector each runs. */
+    PixelationAlgorithm["FrameLattice"] = "frame-lattice";
+    PixelationAlgorithm["PitchLattice"] = "pitch-lattice";
+    PixelationAlgorithm["ColorPeriod"] = "color-period";
+    PixelationAlgorithm["BorderRuns"] = "border-runs";
+    PixelationAlgorithm["EdgeSpacing"] = "edge-spacing";
+    /** The user names the output size; the image is split into that many even blocks. */
+    PixelationAlgorithm["CustomSize"] = "custom-size";
+    PixelationAlgorithm["Resize"] = "resize";
+})(PixelationAlgorithm || (PixelationAlgorithm = {}));
+/**
+ * The outline pre-pass ahead of the colour rule. PixelOE runs outline expansion + colour match;
+ * PixelOE + lines also guides the expansion weight with an XDoG line drawing of the source.
+ */
+export var OutlinePrepass;
+(function (OutlinePrepass) {
+    OutlinePrepass["None"] = "none";
+    OutlinePrepass["Pixeloe"] = "pixeloe";
+    OutlinePrepass["PixeloeLines"] = "pixeloe-lines";
+})(OutlinePrepass || (OutlinePrepass = {}));
+/** Dithering when Limit colors snaps the result to a smaller palette. Off leaves nearest-colour. */
+export var PixelationDither;
+(function (PixelationDither) {
+    PixelationDither["None"] = "none";
+    PixelationDither["Ordered"] = "ordered";
+    PixelationDither["FloydSteinberg"] = "floyd-steinberg";
+})(PixelationDither || (PixelationDither = {}));
+/** How the max color count is determined when Limit colors is on. */
+export var PaletteColorMode;
+(function (PaletteColorMode) {
+    /** User-specified fixed count (e.g. 16). */
+    PaletteColorMode["Fixed"] = "fixed";
+    /** One colour per group of near-duplicate shades (Lab ΔE) in the recovered image. */
+    PaletteColorMode["Adaptive"] = "adaptive";
+})(PaletteColorMode || (PaletteColorMode = {}));
+/** How a line drawing changes PixelOE's outline weight (1 = spread dark, 0 = spread bright). */
+export var LineGuideMode;
+(function (LineGuideMode) {
+    /** max(weight, lines): PixelOE's own weight, plus dark spreading along every line. */
+    LineGuideMode["Union"] = "union";
+    /** weight = lines: dark spreads only along lines, bright everywhere else. */
+    LineGuideMode["Replace"] = "replace";
+})(LineGuideMode || (LineGuideMode = {}));
+/** How one colour is chosen for each grid cell, independent of how the grid was found. */
+export var CellColorPicker;
+(function (CellColorPicker) {
+    CellColorPicker["MostCommon"] = "most-common";
+    CellColorPicker["Average"] = "average";
+    CellColorPicker["Median"] = "median";
+    CellColorPicker["KMeans"] = "k-means";
+    CellColorPicker["Contrast"] = "contrast";
+    CellColorPicker["Nearest"] = "nearest";
+    CellColorPicker["Structure"] = "structure";
+    CellColorPicker["TwoStage"] = "two-stage";
+    CellColorPicker["DualRtTwoStage"] = "dual-rt-two-stage";
+})(CellColorPicker || (CellColorPicker = {}));
+export var PixelGridSamplingAxis;
+(function (PixelGridSamplingAxis) {
+    PixelGridSamplingAxis["Horizontal"] = "horizontal";
+    PixelGridSamplingAxis["Vertical"] = "vertical";
+})(PixelGridSamplingAxis || (PixelGridSamplingAxis = {}));