colorsort-js 1.0.0

package/dist/types/src/auto-sort.d.ts

@@ -0,0 +1 @@
+export declare function auto(colors: string[], DATA: any): any;

package/dist/types/src/auto.d.ts

@@ -0,0 +1,6 @@
+export interface Trained {
+    mid: string;
+    colors: number;
+    fingerprint: number[];
+}
+export declare function getAuto(colors: string[], trained: Trained[]): string;

package/dist/types/src/color.d.ts

@@ -0,0 +1,42 @@
+import { Vector3 } from './vector.ts';
+import { UniColor } from './method-runner.ts';
+export declare function oklch2hex([l, c, h]: Vector3): string;
+export declare function oklab2hex([l, a, b]: Vector3): string;
+export declare function oklch2oklab([l_, c, h]: Vector3): Vector3;
+export declare function oklab2oklch([l_, a, b]: Vector3): Vector3;
+export declare function hexToRgb(hex: string): [number, number, number];
+export declare const gl: (a: any) => any;
+export declare const cmyk: (a: any) => any;
+export declare const oklab: (a: any) => any;
+export declare const okhsl: (a: any) => any;
+export declare const okhsv: (a: any) => any;
+export declare const oklch: (a: any) => any;
+export declare const lch: (a: any) => any;
+export declare const lab: (a: any) => any;
+export declare const hsl: (a: any) => any;
+export declare const hsv: (a: any) => any;
+export declare function nonH(H: number): H is never;
+export declare const luminance: (a: any) => any;
+export declare function compareLumLCH(a: string, b: string): number;
+export declare function flatRgb(hexes: string[]): number[];
+export declare function deltaE(a: string, b: string, x?: number, y?: number, z?: number): number;
+export declare function normalizeLab(a: Vector3): number[];
+export declare function distanceOk2([L1, a1, b1]: Vector3, [L2, a2, b2]: Vector3): number;
+export declare function convertColors(colors: string[], model: ColorType): [UniColor, string][];
+export type ColorType = 'hex' | 'rgb' | 'gl' | 'oklab' | 'oklch' | 'okhsl' | 'okhsv' | 'lab' | 'lab_norm' | 'lab_int' | 'lch' | 'hsv' | 'hsl' | 'cmyk';
+export declare const COLOR_TYPES: {
+    readonly rgb: "rgb";
+    readonly oklab: "oklab";
+    readonly lab: "lab";
+    readonly lab_norm: "lab_norm";
+    readonly lab_int: "lab_int";
+    readonly oklch: "oklch";
+    readonly okhsl: "okhsl";
+    readonly okhsv: "okhsv";
+    readonly hex: "hex";
+    readonly hsv: "hsv";
+    readonly hsl: "hsl";
+    readonly lch: "lch";
+    readonly gl: "gl";
+    readonly cmyk: "cmyk";
+};

package/dist/types/src/fft.d.ts

@@ -0,0 +1,3 @@
+export declare function fft(numbers: number[]): number[];
+export declare function half(spectrum: number[]): number[];
+export declare function magnitude(half: number[]): number[];

package/dist/types/src/genetic-algo.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Simple Genetic Algorithm implementation for permutation problems
+ */
+export interface GAConfig<T, F> {
+    populationSize?: number;
+    generations?: number;
+    maxStagnation?: number;
+    mutationRate?: number;
+    crossoverRate?: number;
+    eliteSize?: number;
+    tournamentSize?: number;
+    random?: () => number;
+    fitness: (genome: T[]) => F;
+    seed: () => T[];
+    compare?: (a: F, b: F) => number;
+    onGeneration?: (stats: GenerationStats<T, F>) => void;
+}
+export interface Individual<T, F> {
+    genome: T[];
+    fitness: F;
+}
+export interface GenerationStats<T, F> {
+    generation: number;
+    bestFitness: F;
+    bestGenome: T[];
+    averageFitness: number;
+}
+export interface GAResult<T, F> {
+    bestGenome: T[];
+    bestFitness: F;
+    finalPopulation: Individual<T, F>[];
+    peakGeneration: number;
+}
+export declare class GeneticAlgorithm<T, F> {
+    private readonly populationSize;
+    private readonly generations;
+    private readonly maxStagnation;
+    private readonly mutationRate;
+    private readonly crossoverRate;
+    private readonly eliteSize;
+    private readonly tournamentSize;
+    private readonly random;
+    private readonly fitnessFunc;
+    private readonly seedFunc;
+    private readonly fitnessCompare;
+    private readonly onGeneration?;
+    private population;
+    private currentGeneration;
+    private bestIndividual;
+    private bestFitness;
+    private peakGeneration;
+    constructor(config: GAConfig<T, F>);
+    private initializePopulation;
+    private sortPopulation;
+    private updateBest;
+    private tournamentSelect;
+    private orderCrossover;
+    private swapMutate;
+    private shiftMutate;
+    private cheatMutate;
+    private evolve;
+    run(): GAResult<T, F>;
+}

package/dist/types/src/index.d.ts

@@ -0,0 +1,23 @@
+import { round3 } from './statistics.ts';
+export { SORTING_METHODS } from './sorting-methods/index.ts';
+export type { SortingMethod } from './sorting-methods/index.ts';
+export { metrics } from './metrics.js';
+export { detectPaletteType } from './type-detect.ts';
+export type { PaletteType } from './type-detect.ts';
+export { metricsEx, getMetricsExRange, metricsExQuality, metricsExQualitySum } from './metrics-extended.ts';
+export type { MetricsEx } from './metrics-extended.ts';
+export { flatRgb, oklab, oklch, gl, lch, lab, normalizeLab, oklch2hex, oklab2hex, oklch2oklab } from './color.ts';
+export { randomizer } from './randomizer.ts';
+export { metricsFftFingerprint } from './metrics-fft.ts';
+export { cosineSimilarity } from './similarity.ts';
+export { featuresLab } from './metrics-spectral.ts';
+export { compareSpectralFeatures } from './metrics-spectral-similarity.ts';
+export type { Fingerprint } from './metrics-fft.ts';
+export type { StatsLabEx, MagnitudesLab } from './metrics-spectral.ts';
+export { applySpectralProcessing } from './spectral-edit.ts';
+export { fingerprintAverage, fingerprintMedian, fingerprintAverageWithoutOutliers } from './similarity.ts';
+export { compareColors } from './vector.ts';
+export { getAuto } from './auto.ts';
+export declare const MASTER_LCH: (a: any) => any;
+export declare const MASTER_ROUND: typeof round3;
+export { auto } from './auto-sort.ts';

package/dist/types/src/method-runner.d.ts

@@ -0,0 +1,21 @@
+import { ColorType } from './color.ts';
+import { Vector3, Vector4 } from './vector.ts';
+export type UniColor = Vector3 | Vector4 | any;
+export type ColorHelper = {
+    toColors(vectors: UniColor[]): string[];
+    toColor(vector: UniColor): string;
+    distance: Distance<UniColor>;
+};
+export type ColorHelperDelta = ColorHelper & {
+    delta: Distance<UniColor>;
+};
+export type Distance<T> = (a: T, b: T, ...args: any[]) => number;
+export type Distance3 = Distance<Vector3>;
+export type Distance4 = Distance<Vector4>;
+export type DistanceU = Distance<UniColor>;
+export type DistanceC = Distance<string>;
+export type DistanceOptions = {
+    fn: Distance<any>;
+    color: boolean;
+};
+export declare function methodRunner<T>(colors: string[], fn: (this: T, vectors: UniColor[]) => UniColor[] | void, model?: ColorType, deltaMethod_?: Distance<any> | DistanceOptions, distanceMethod_?: Distance<any> | DistanceOptions): string[];

package/dist/types/src/metrics-extended.d.ts

@@ -0,0 +1,27 @@
+export type MetricsLch<T> = {
+    L: T;
+    C: T;
+    H: T;
+};
+export type MetricsEx<T> = {
+    totalDistance: T;
+    avgAngleChange: T;
+    maxAngleChange: T;
+    meanDistance: T;
+    devDistance: T;
+    totalCurveDistance: T;
+    meanCurveDistance: T;
+    devCurveDistance: T;
+    lchAvgChange: MetricsLch<T>;
+    lchMaxChange: MetricsLch<T>;
+    lchDeviation: MetricsLch<T>;
+    curveRatio: T;
+    perceptualUniformity: T;
+    curveUniformity: T;
+    harmonicScore: T;
+    harmonicCurveScore: T;
+};
+export declare function metricsEx(colors: string[]): MetricsEx<number>;
+export declare function getMetricsExRange(list: MetricsEx<number>[]): MetricsEx<[number, number]>;
+export declare function metricsExQuality(value: MetricsEx<number>, range: MetricsEx<[number, number]>): MetricsEx<number>;
+export declare function metricsExQualitySum(value: MetricsEx<number>): number;

package/dist/types/src/metrics-fft.d.ts

@@ -0,0 +1,44 @@
+import { Vector3 } from './vector.ts';
+export type Analysis = {
+    type: string;
+    confidence: number;
+    features: {
+        chromaticRatio?: number;
+        achromaticCount?: number;
+        hueSpread?: number;
+        chromaticCount?: number;
+        largeGaps?: number;
+        avgGap?: number;
+        maxGap?: number;
+        chromaVariance?: number;
+        hueHighFreqRatio?: number;
+        chromaHighFreqRatio?: number;
+    };
+    fingerprint?: Fingerprint;
+    spectra?: {
+        hueDeltaMags: number[];
+        chromaMags: number[];
+        lightnessMags: number[];
+        hueDeltaEnergy: number;
+        chromaEnergy: number;
+        lightnessEnergy: number;
+    };
+};
+export type Fingerprint = [number, number, number, number, number, number, number];
+export type SpectrumData = {
+    freq: number;
+    hueDelta: number;
+    chroma: number;
+    lightness: number;
+};
+export declare function metricsFftFingerprint(lchColors: Vector3[]): {
+    analysis: Analysis;
+    spectrumData: SpectrumData[];
+};
+export declare function compareFingerprints(fp1: Fingerprint, fp2: Fingerprint): {
+    cosine: number;
+    euclidean: number;
+    manhattan: number;
+    similarity: number;
+    interpretation: string;
+};

package/dist/types/src/metrics-hilbert.d.ts

@@ -0,0 +1,9 @@
+export declare function metricsHilbert(colors: string[], model?: 'rgb' | 'lab_int'): {
+    totalDistance: number;
+    minIndex: any;
+    maxIndex: any;
+    indexDistance: number;
+    expectedMean: number;
+    meanDistance: number;
+    devDistance: number;
+};

package/dist/types/src/metrics-spectral-similarity.d.ts

@@ -0,0 +1,21 @@
+import { MagnitudesLab, StatsLabEx } from './metrics-spectral.ts';
+interface SimilarityResult {
+    overall: number;
+    structural: number;
+    perceptual: number;
+    breakdown: {
+        smoothnessSimilarity: number;
+        complexitySimilarity: number;
+        energyDistributionSimilarity: number;
+        centroidSimilarity: number;
+        rolloffSimilarity: number;
+        spectrumCorrelation: number;
+    };
+    interpretation: string;
+}
+/**
+ * Compare two palettes using their spectral features
+ * Returns similarity score from 0 (completely different) to 1 (identical)
+ */
+export declare function compareSpectralFeatures(features1: StatsLabEx & MagnitudesLab, features2: StatsLabEx & MagnitudesLab): SimilarityResult;
+export {};

package/dist/types/src/metrics-spectral.d.ts

@@ -0,0 +1,55 @@
+import { Vector3 } from './vector.ts';
+export interface ChromaticLch {
+    chromatic: Vector3[];
+    achromatic: Vector3[];
+}
+export declare function chromaticLch(lchColors: Vector3[], threshold?: number): ChromaticLch;
+export interface MagnitudesLch {
+    lightnessMags: number[];
+    chromaMags: number[];
+    hueDeltaMags: number[];
+    hues: number[];
+    hueDeltas: number[];
+    sortedHues: number[];
+    chromas: number[];
+    lightnesses: number[];
+}
+export declare function fftLch(lchColors: Vector3[]): MagnitudesLch;
+export interface Stats {
+    dominantFrequencies: number[];
+    smoothness: number;
+    totalEnergy: number;
+    probabilities: number[];
+    complexity: number;
+}
+export declare function magnitudesStats(magnitudes: number[]): Stats;
+export declare function featuresLch(lchColors: Vector3[]): MagnitudesLch & Stats;
+export interface MagnitudesLab {
+    lightnessMags: number[];
+    aMags: number[];
+    bMags: number[];
+    chromaMags: number[];
+}
+export declare function magnitudesLab(labColors: Vector3[]): MagnitudesLab;
+export interface StatsLab {
+    lightness: number;
+    a: number;
+    b: number;
+    chroma: number;
+}
+export declare function statsLab({ lightnessMags, aMags, bMags, chromaMags }: MagnitudesLab, calculate: Function): StatsLab;
+export interface StatsLabEx {
+    spectralCentroid: StatsLab;
+    spectralSpread: StatsLab;
+    spectralRolloff: StatsLab;
+    energyRatios: {
+        lowFreq: number;
+        midFreq: number;
+        highFreq: number;
+    };
+    smoothness: number;
+    complexity: number;
+    dominantFrequencies: number[];
+}
+export declare function statsLabsEx(magnitudesLab: MagnitudesLab): StatsLabEx;
+export declare function featuresLab(labColors: Vector3[]): StatsLabEx & MagnitudesLab;

package/dist/types/src/metrics.d.ts

@@ -0,0 +1,8 @@
+import { Vector3 } from './vector.ts';
+export declare function metrics(vectors: Vector3[]): {
+    totalDistance: number;
+    avgAngleChange: number;
+    maxAngleChange: number;
+    meanDistance: number;
+    devDistance: number;
+};

package/dist/types/src/randomizer.d.ts

@@ -0,0 +1 @@
+export declare function randomizer(p?: number): () => number;

package/dist/types/src/resample.d.ts

@@ -0,0 +1,6 @@
+import { Vector3 } from './vector.ts';
+export declare function snapInterpolator(values: number[], samples: number): (sample: number) => number;
+export declare function resamplePaletteSnap(labColors: Vector3[], samples?: number): Vector3[];
+export declare function downsamplePalette(labColors: Vector3[], targetSize: number): Vector3[];
+export declare function resamplePaletteLinear(labColors: Vector3[], samples?: number): Vector3[];
+export declare function resampleLinear(values: number[], samples?: number): number[];

package/dist/types/src/similarity.d.ts

@@ -0,0 +1,8 @@
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function manhattanDistance(fp1: number[], fp2: number[]): number;
+export declare function euclideanDistance(a: number[], b: number[]): number;
+export declare function gaussianSimilarity(a: number, b: number, sigma: number): number;
+export declare function pearsonCorrelation(a: number[], b: number[]): number;
+export declare function fingerprintAverage(fingerprints: number[][]): number[];
+export declare function fingerprintMedian(fingerprints: number[][]): number[];
+export declare function fingerprintAverageWithoutOutliers(fingerprints: number[][]): number[];

package/dist/types/src/sorting-methods/clustering.d.ts

@@ -0,0 +1,34 @@
+import { Vector3 } from '../vector.ts';
+export declare function sortByHierarchicalClustering(colors: Vector3[], linkage?: 'single' | 'complete' | 'average', traversal?: 'depth-first' | 'breadth-first' | 'balanced'): Vector3[];
+/**
+ * K-means clustering followed by ordering clusters and points within clusters
+ */
+export declare function sortByKMeans(colors: Vector3[], k?: number, maxIterations?: number): Vector3[];
+export declare function sortByDBSCAN(colors: Vector3[], eps?: number, minPts?: number): Vector3[];
+export declare function cluster(colors: string[], model?: 'rgb' | 'lab', linkage?: 'single' | 'complete' | 'average', traversal?: 'depth-first' | 'breadth-first' | 'balanced'): string[];
+export declare namespace cluster {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}
+export declare function kMeans(colors: string[], model?: 'rgb' | 'lab', k?: number, iterations?: number): string[];
+export declare namespace kMeans {
+    var params: ({
+        name: string;
+        values: string[];
+    } | {
+        name: string;
+        values: number[];
+    })[];
+}
+export declare function dbScan(colors: string[], model?: 'rgb' | 'lab', eps?: number, pts?: number): string[];
+export declare namespace dbScan {
+    var params: ({
+        name: string;
+        values: string[];
+    } | {
+        name: string;
+        values: number[];
+    })[];
+}

package/dist/types/src/sorting-methods/genetic.d.ts

@@ -0,0 +1,3 @@
+export declare function evolve(colors: string[]): string[];
+export declare function evolveT<T>(colors: string[], fitness: (colors: string[]) => T, compare: (a: T, b: T) => number): string[];
+export declare function evolveMulti(colors: string[]): string[];

package/dist/types/src/sorting-methods/graph.d.ts

@@ -0,0 +1,14 @@
+import { Vector3 } from '../vector.ts';
+import { Distance3 } from '../method-runner.ts';
+export declare function graphDeltaE(colors: Vector3[], delta: Distance3): Vector3[];
+export declare function graph(colors: string[], post?: 'tsp' | 'raw'): string[];
+export declare namespace graph {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}
+export declare function graphWeighted(colors: string[]): string[];
+export declare function graphWeightedPlusPlus(colors: string[]): string[];
+export declare function graphWeightedAdaptive1(colors: string[]): string[];
+export declare function graphWeightedAdaptive2(colors: string[]): string[];

package/dist/types/src/sorting-methods/harmonize.d.ts

@@ -0,0 +1,22 @@
+import { Vector3 } from '../vector.ts';
+interface HarmonizeOptions {
+    selectStart: (colors: Vector3[]) => Vector3;
+    distance: (a: Vector3, b: Vector3) => number;
+    compareColors: (a: Vector3, b: Vector3) => number;
+}
+export declare function harmonize(colors: Vector3[], options: HarmonizeOptions): Vector3[];
+export declare function harmonizeModel(colors: string[], model?: 'hsl' | 'hsv' | 'oklch' | 'oklab' | 'okhsl' | 'okhsv' | 'lch' | 'lab' | 'rgb' | 'cmyk', start?: 'bright' | 'dark', distance?: 'euclidean' | 'delta'): string[];
+export declare namespace harmonizeModel {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}
+export declare function harmonizeDelta(colors: string[], start?: 'bright' | 'dark'): string[];
+export declare namespace harmonizeDelta {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}
+export {};

package/dist/types/src/sorting-methods/hilbert.d.ts

@@ -0,0 +1,14 @@
+import { Vector3 } from '../vector.ts';
+/**
+ * Convert 3D (0 to 255) coordinates to Hilbert curve index
+ * This ensures spatially close points stay close in the sorted order
+ */
+export declare function hilbertIndex([x, y, z]: [number, number, number]): number;
+export declare function sortByHilbertCurve(colors: Vector3[]): Vector3[];
+export declare function hilbert(colors: string[], model?: 'rgb' | 'lab_int'): string[];
+export declare namespace hilbert {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}

package/dist/types/src/sorting-methods/index.d.ts

@@ -0,0 +1,21 @@
+export type SortingFunction = Function & {
+    params?: {
+        name: string;
+        values: any[];
+    }[];
+    valid?: Function;
+};
+export type SortingMethod = {
+    name: string;
+    mid: string;
+    description?: {
+        model?: any | null;
+        method?: any | null;
+        diff?: any | null;
+    };
+    fn: SortingFunction;
+    speed?: number;
+    valid?: Function;
+};
+export declare const SORTING_METHODS_RAW: SortingMethod[];
+export declare const SORTING_METHODS: SortingMethod[];

package/dist/types/src/sorting-methods/momentum.d.ts

@@ -0,0 +1,12 @@
+export declare function momentumClosestOklab(colors: string[]): string[];
+export declare function momentumClosestBestOklab(colors: string[], post?: 'raw' | 'tsp'): string[];
+export declare namespace momentumClosestBestOklab {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}
+export declare function momentumClosestBestDeltaEOklab(colors: string[]): string[];
+export declare function momentumInlinestOklab(colors: string[]): string[];
+export declare function momentumInlinestDeltaEOklab(colors: string[]): string[];
+export declare function momentumInlinestDeltaEPlusOklab(colors: string[]): string[];

package/dist/types/src/sorting-methods/principal.d.ts

@@ -0,0 +1,9 @@
+import { Vector3 } from '../vector.ts';
+export declare function sortByPrincipalComponent(colors: Vector3[]): Vector3[];
+export declare function principal(colors: string[], model: 'gl' | 'lab' | 'oklab', post?: 'raw' | 'tsp' | 'tsp-adapt'): string[];
+export declare namespace principal {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}

package/dist/types/src/sorting-methods/radial.d.ts

@@ -0,0 +1,17 @@
+import { Vector3 } from '../vector.ts';
+export declare function sortByHslSpiral(this: any, colors: Vector3[], model?: 'hsl' | 'hsv' | 'lch' | 'okhsl' | 'okhsv' | 'oklch', mode?: 'outward' | 'inward' | 'bottom-up' | 'top-down'): Vector3[];
+export declare function spiral(colors: string[], model?: 'hsl' | 'hsv' | 'lch' | 'okhsl' | 'okhsv' | 'oklch', mode?: 'outward' | 'inward' | 'bottom-up' | 'top-down'): string[];
+export declare namespace spiral {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}
+export declare function sortByHslCylindrical(colors: Vector3[], model?: 'hsl' | 'hsv' | 'lch' | 'okhsl' | 'okhsv' | 'oklch', direction?: 'ascending' | 'descending'): Vector3[];
+export declare function cylindrical(colors: string[], model?: 'hsl' | 'hsv' | 'lch' | 'okhsl' | 'okhsv' | 'oklch', direction?: 'ascending' | 'descending'): string[];
+export declare namespace cylindrical {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}

package/dist/types/src/sorting-methods/ramp.d.ts

@@ -0,0 +1,77 @@
+import { Vector3 } from '../vector.ts';
+/**
+ * Sort colors into hue-based ramps
+ * Strategy:
+ * 1. Group by hue buckets (e.g., reds, oranges, yellows, etc.)
+ * 2. Within each bucket, sort by chroma (vivid to muted) then lightness
+ * 3. Handle achromatic colors (grays) separately
+ */
+export declare function sortColorsIntoHueRamps(colors: Vector3[], hueBuckets?: number, // Number of hue buckets (default: 12)
+achromaticThreshold?: number): Vector3[];
+/**
+ * Alternative: Sort into a single smooth gradient
+ * This creates one continuous ramp through the entire hue spectrum
+ */
+export declare function sortIntoSmoothGradient(colors: Vector3[]): Vector3[];
+/**
+ * Auto-detect hue clusters using gap detection algorithm
+ */
+export declare function detectHueClusters(colors: Vector3[], minGapDegrees?: number, // Minimum gap to split clusters
+achromaticThreshold?: number): Vector3[][];
+/**
+ * Sort colors using nearest-neighbor traveling salesman approach
+ * This creates smooth visual progressions
+ */
+export declare function sortColorsByNearestNeighbor(colors: Vector3[]): Vector3[];
+/**
+ * Sort colors into perceptual hue-based ramps
+ *
+ * Strategy:
+ * 1. Achromatic colors (very low chroma) sorted by lightness
+ * 2. Chromatic colors sorted by composite key: Hue Zone → Chroma Stratum → Lightness
+ *
+ * This creates natural color ramps that work well for palettes of 60+ colors,
+ * organizing them into manageable visual groups while maintaining smooth gradients.
+ *
+ */
+export declare function sortColorsByHueRamps2(colors: Vector3[], // Oklch, Vector3 is [number, number, number]
+achromaticThreshold?: number, // Chroma below this is considered achromatic (default: 0.03)
+hueZoneSize?: number, // Degrees per hue zone (default: 40)
+hueRotation?: number, // Starting hue angle (default: 270)
+chromaOrder?: 'vivid' | 'muted'): Vector3[];
+export declare function sortMultiRampPalette2(lchColors: Vector3[], numRamps?: number): Vector3[];
+export declare function ramp(colors: string[]): string[];
+export declare function rampa(colors: string[], gap?: number, threshold?: number, strategy?: 'cl' | 'lc'): string[];
+export declare namespace rampa {
+    var params: ({
+        name: string;
+        values: number[];
+    } | {
+        name: string;
+        values: string[];
+    })[];
+}
+export declare function rampb(colors: string[]): string[];
+export declare function rampc(colors: string[]): string[];
+export declare function rampd(colors: string[]): string[];
+export declare function rampe(colors: string[]): string[];
+export declare function rampf(colors: string[]): string[];
+export declare function rampg(colors: string[], threshold: number, zone: number, rotation: number, order: 'vivid' | 'muted'): string[];
+export declare namespace rampg {
+    var params: ({
+        name: string;
+        values: number[];
+    } | {
+        name: string;
+        values: string[];
+    })[];
+}
+export declare function ramph(colors: string[], ramps?: number): string[];
+export declare namespace ramph {
+    var params: {
+        name: string;
+        values: number[];
+    }[];
+    var valid: (colors: Vector3[], ramps: number) => boolean;
+}
+export declare function rampi(colors: string[]): string[];

package/dist/types/src/sorting-methods/raw.d.ts

@@ -0,0 +1,7 @@
+export declare function raw(colors: string[], model?: 'hsl' | 'hsv' | 'oklch' | 'oklab' | 'okhsl' | 'okhsv' | 'lch' | 'lab' | 'rgb' | 'cmyk'): string[];
+export declare namespace raw {
+    var params: {
+        name: string;
+        values: string[];
+    }[];
+}

package/dist/types/src/sorting-methods/spectral.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from '../vector.ts';
+import { MagnitudesLch, Stats } from '../metrics-spectral.ts';
+/**
+ * Strategy 1: Match the spectral smoothness of a reference palette
+ *
+ * Analyzes the reference palette's frequency distribution and sorts
+ * the target colors to create a similar smoothness profile.
+ */
+export declare function sortBySpectralSmoothness(colorsLch: Vector3[], referenceFeatures: MagnitudesLch & Stats, achromaticThreshold?: number): Vector3[];
+/**
+ * Strategy 2: Match the chroma wave pattern of a reference palette
+ *
+ * Uses the chroma FFT pattern to create similar saturation rhythms.
+ */
+export declare function sortByChromaWave(lchColors: Vector3[], referenceFeatures: MagnitudesLch & Stats, achromaticThreshold?: number): Vector3[];
+/**
+ * Strategy 3: Reconstruct spectral template
+ *
+ * Uses the reference palette's dominant frequencies to determine
+ * how many distinct hue groups to create.
+ */
+export declare function sortBySpectralTemplate(lchColors: Vector3[], referenceFeatures: MagnitudesLch & Stats, achromaticThreshold?: number): Vector3[];
+/**
+ * Strategy 4: Hybrid approach - detect palette type and apply best strategy
+ */
+export declare function sortBySpectralGuidance(colors: Vector3[], referenceFeatures: MagnitudesLch & Stats, achromaticThreshold?: number): Vector3[];