@tempots/std 0.9.0

package/dist/colors/hsl.d.ts

@@ -0,0 +1,24 @@
+export declare class HSL {
+    static fromString(s: string): HSL;
+    static ofChannels([hue, saturation, lightness]: [
+        hue: number,
+        saturation: number,
+        lightness: number
+    ]): HSL;
+    readonly hue: number;
+    readonly saturation: number;
+    readonly lightness: number;
+    /**
+     *
+     * @param hue Angle in degrees (0-360)
+     * @param saturation Percentage (0-100)
+     * @param lightness Percentage (0-100)
+     */
+    constructor(hue: number, saturation?: number, lightness?: number);
+    withHue(hue: number): HSL;
+    withSaturation(saturation: number): HSL;
+    withLightness(lightness: number): HSL;
+    toChannels(): [number, number, number];
+    toString(): string;
+    equals(other: HSL, tollerance?: number): boolean;
+}

package/dist/colors/hsl.js

@@ -0,0 +1,56 @@
+import { clamp, nearEquals } from '../numbers';
+const TOLLERANCE = 0.0001;
+export class HSL {
+    static fromString(s) {
+        const m = s.match(/^hsl\((\d+)(deg)?, ?(\d+(?:\.\d+)?)%?, ?(\d+(?:\.\d+)?)%?\)$/);
+        if (m != null) {
+            const [, h, , s, l] = m;
+            return new HSL(parseFloat(h), parseFloat(s), parseFloat(l));
+        }
+        else {
+            throw new Error(`Invalid HSL string: ${s}`);
+        }
+    }
+    static ofChannels([hue, saturation, lightness]) {
+        return new HSL(hue, saturation * 100, lightness * 100);
+    }
+    hue;
+    saturation;
+    lightness;
+    /**
+     *
+     * @param hue Angle in degrees (0-360)
+     * @param saturation Percentage (0-100)
+     * @param lightness Percentage (0-100)
+     */
+    constructor(hue, saturation = 50, lightness = 50) {
+        this.hue = hue % 360.0;
+        this.saturation = clamp(saturation, 0, 100);
+        this.lightness = clamp(lightness, 0, 100);
+    }
+    withHue(hue) {
+        return new HSL(hue, this.saturation, this.lightness);
+    }
+    withSaturation(saturation) {
+        return new HSL(this.hue, saturation, this.lightness);
+    }
+    withLightness(lightness) {
+        return new HSL(this.hue, this.saturation, lightness);
+    }
+    toChannels() {
+        return [this.hue, this.saturation / 100, this.lightness / 100];
+    }
+    toString() {
+        return `hsl(${this.hue}deg, ${this.saturation}%, ${this.lightness}%)`;
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        if ((nearEquals(this.lightness, other.lightness, tollerance) &&
+            nearEquals(this.saturation, 0, tollerance)) ||
+            nearEquals(this.saturation, 100, tollerance)) {
+            return true;
+        }
+        return (nearEquals(this.hue, other.hue, tollerance) &&
+            nearEquals(this.saturation, other.saturation, tollerance) &&
+            nearEquals(this.lightness, other.lightness, tollerance));
+    }
+}

package/dist/colors/hsla.d.ts

@@ -0,0 +1,18 @@
+import { HSL } from './hsl';
+export declare class HSLA extends HSL {
+    readonly alpha: number;
+    /**
+     *
+     * @param hue Angle in degrees (0-360)
+     * @param saturation Percentage (0-100)
+     * @param lightness Percentage (0-100)
+     * @param alpha Percentage (0-100)
+     */
+    constructor(hue: number, saturation?: number, lightness?: number, alpha?: number);
+    withHue(hue: number): HSLA;
+    withSaturation(saturation: number): HSLA;
+    withLightness(lightness: number): HSLA;
+    withAlpha(alpha: number): HSLA;
+    toString(): string;
+    equals(other: HSLA, tollerance?: number): boolean;
+}

package/dist/colors/hsla.js

@@ -0,0 +1,35 @@
+import { clamp, nearEquals } from '../numbers';
+import { HSL } from './hsl';
+const TOLLERANCE = 0.0001;
+export class HSLA extends HSL {
+    alpha;
+    /**
+     *
+     * @param hue Angle in degrees (0-360)
+     * @param saturation Percentage (0-100)
+     * @param lightness Percentage (0-100)
+     * @param alpha Percentage (0-100)
+     */
+    constructor(hue, saturation = 50, lightness = 50, alpha = 100) {
+        super(hue, saturation, lightness);
+        this.alpha = clamp(0, 1, alpha);
+    }
+    withHue(hue) {
+        return new HSLA(hue, this.saturation, this.lightness, this.alpha);
+    }
+    withSaturation(saturation) {
+        return new HSLA(this.hue, saturation, this.lightness, this.alpha);
+    }
+    withLightness(lightness) {
+        return new HSLA(this.hue, this.saturation, lightness, this.alpha);
+    }
+    withAlpha(alpha) {
+        return new HSLA(this.hue, this.saturation, this.lightness, alpha);
+    }
+    toString() {
+        return `hsla(${this.hue}deg, ${this.saturation}%, ${this.lightness}%, ${this.alpha / 100})`;
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        return super.equals(other, tollerance) && nearEquals(this.alpha, other.alpha, tollerance);
+    }
+}

package/dist/colors/hsluv.d.ts

@@ -0,0 +1,24 @@
+export declare class HSLuv {
+    static fromString(s: string): HSLuv;
+    static ofChannels([hue, saturation, lightness]: [
+        hue: number,
+        saturation: number,
+        lightness: number
+    ]): HSLuv;
+    readonly hue: number;
+    readonly saturation: number;
+    readonly lightness: number;
+    /**
+     *
+     * @param hue Angle in degrees (0-360)
+     * @param saturation
+     * @param lightness
+     */
+    constructor(hue: number, saturation: number, lightness: number);
+    withHue(hue: number): HSLuv;
+    withSaturation(saturation: number): HSLuv;
+    withLightness(lightness: number): HSLuv;
+    toChannels(): [number, number, number];
+    toString(): string;
+    equals(other: HSLuv, tollerance?: number): boolean;
+}

package/dist/colors/hsluv.js

@@ -0,0 +1,56 @@
+import { nearEquals } from '../numbers';
+const TOLLERANCE = 0.0001;
+export class HSLuv {
+    static fromString(s) {
+        const m = s.match(/^hsluv\((\d+)(deg)?, ?(\d+(?:\.\d+)?)%?, ?(\d+(?:\.\d+)?)%?\)$/);
+        if (m != null) {
+            const [, h, , s, l] = m;
+            return new HSLuv(parseFloat(h), parseFloat(s), parseFloat(l));
+        }
+        else {
+            throw new Error(`Invalid HSLuv string: ${s}`);
+        }
+    }
+    static ofChannels([hue, saturation, lightness]) {
+        return new HSLuv(hue, saturation, lightness);
+    }
+    hue;
+    saturation;
+    lightness;
+    /**
+     *
+     * @param hue Angle in degrees (0-360)
+     * @param saturation
+     * @param lightness
+     */
+    constructor(hue, saturation, lightness) {
+        this.hue = hue % 360.0;
+        this.saturation = saturation;
+        this.lightness = lightness;
+    }
+    withHue(hue) {
+        return new HSLuv(hue, this.saturation, this.lightness);
+    }
+    withSaturation(saturation) {
+        return new HSLuv(this.hue, saturation, this.lightness);
+    }
+    withLightness(lightness) {
+        return new HSLuv(this.hue, this.saturation, lightness);
+    }
+    toChannels() {
+        return [this.hue, this.saturation, this.lightness];
+    }
+    toString() {
+        return `hsluv(${this.hue}deg, ${this.saturation}%, ${this.lightness}%)`;
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        if ((nearEquals(this.lightness, other.lightness, tollerance) &&
+            nearEquals(this.saturation, 0, tollerance)) ||
+            nearEquals(this.saturation, 100, tollerance)) {
+            return true;
+        }
+        return (nearEquals(this.hue, other.hue, tollerance) &&
+            nearEquals(this.saturation, other.saturation, tollerance) &&
+            nearEquals(this.lightness, other.lightness, tollerance));
+    }
+}

package/dist/colors/hsv.d.ts

@@ -0,0 +1,24 @@
+export declare class HSV {
+    static fromString(s: string): HSV;
+    static ofChannels([hue, saturation, value]: [
+        hue: number,
+        saturation: number,
+        value: number
+    ]): HSV;
+    readonly hue: number;
+    readonly saturation: number;
+    readonly value: number;
+    /**
+     *
+     * @param hue Angle in degrees (0-360)
+     * @param saturation Percentage (0-100)
+     * @param value Percentage (0-100)
+     */
+    constructor(hue: number, saturation: number, value: number);
+    withHue(h: number): HSV;
+    withSaturation(s: number): HSV;
+    withValue(v: number): HSV;
+    toChannels(): [number, number, number];
+    toString(): string;
+    equals(other: HSV, tollerance?: number): boolean;
+}

package/dist/colors/hsv.js

@@ -0,0 +1,54 @@
+import { clamp, nearEquals } from '../numbers';
+const TOLLERANCE = 0.0001;
+export class HSV {
+    static fromString(s) {
+        const m = s.match(/^hsv\((\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%\)$/i);
+        if (m != null) {
+            const [, h, s, v] = m;
+            return new HSV(parseFloat(h), parseFloat(s), parseFloat(v));
+        }
+        else {
+            throw new Error(`Invalid HSV string: ${s}`);
+        }
+    }
+    static ofChannels([hue, saturation, value]) {
+        return new HSV(hue % 360.0, clamp(saturation * 100, 0, 100), clamp(value * 100, 0, 100));
+    }
+    hue;
+    saturation;
+    value;
+    /**
+     *
+     * @param hue Angle in degrees (0-360)
+     * @param saturation Percentage (0-100)
+     * @param value Percentage (0-100)
+     */
+    constructor(hue, saturation, value) {
+        this.hue = hue;
+        this.saturation = saturation;
+        this.value = value;
+    }
+    withHue(h) {
+        return new HSV(h, this.saturation, this.value);
+    }
+    withSaturation(s) {
+        return new HSV(this.hue, s, this.value);
+    }
+    withValue(v) {
+        return new HSV(this.hue, this.saturation, v);
+    }
+    toChannels() {
+        return [this.hue, this.saturation / 100, this.value / 100];
+    }
+    toString() {
+        return `hsv(${this.hue}, ${this.saturation}, ${this.value})`;
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        if (nearEquals(this.value, other.value, tollerance) && (nearEquals(this.saturation, 0, tollerance) || nearEquals(this.saturation, 100, tollerance))) {
+            return true;
+        }
+        return (nearEquals(this.hue, other.hue, tollerance) &&
+            nearEquals(this.saturation, other.saturation, tollerance) &&
+            nearEquals(this.value, other.value, tollerance));
+    }
+}

package/dist/colors/lab.d.ts

@@ -0,0 +1,24 @@
+export declare class LAB {
+    static fromString(s: string): LAB;
+    static ofChannels([lightness, a, b]: [
+        lightness: number,
+        a: number,
+        b: number
+    ]): LAB;
+    readonly lightness: number;
+    readonly a: number;
+    readonly b: number;
+    /**
+     *
+     * @param lightness Lightness in range (0, 100)
+     * @param a usually in the range (~-150, ~+150) - not clamped
+     * @param b usually in the range (~-150, ~+150) - not clamped
+     */
+    constructor(lightness: number, a: number, b: number);
+    withL(l: number): LAB;
+    withA(a: number): LAB;
+    withB(b: number): LAB;
+    toChannels(): [number, number, number];
+    toString(): string;
+    equals(other: LAB, tollerance?: number): boolean;
+}

package/dist/colors/lab.js

@@ -0,0 +1,54 @@
+import { clamp, nearEquals } from '../numbers';
+const TOLLERANCE = 0.0001;
+export class LAB {
+    static fromString(s) {
+        const m = s.match(/^lab\((\d+(?:\.\d+)?)°, ?(\d+(?:\.\d+)?)°, ?(\d+(?:\.\d+)?)°\)$/);
+        if (m != null) {
+            const [, lightness, a, b] = m;
+            return new LAB(parseFloat(lightness), parseFloat(a), parseFloat(b));
+        }
+        else {
+            throw new Error(`Invalid LAB string: ${s}`);
+        }
+    }
+    static ofChannels([lightness, a, b]) {
+        return new LAB(lightness, a, b);
+    }
+    lightness;
+    a;
+    b;
+    /**
+     *
+     * @param lightness Lightness in range (0, 100)
+     * @param a usually in the range (~-150, ~+150) - not clamped
+     * @param b usually in the range (~-150, ~+150) - not clamped
+     */
+    constructor(lightness, a, b) {
+        this.lightness = clamp(lightness, 0, 100);
+        this.a = a;
+        this.b = b;
+    }
+    withL(l) {
+        return new LAB(l, this.a, this.b);
+    }
+    withA(a) {
+        return new LAB(this.lightness, a, this.b);
+    }
+    withB(b) {
+        return new LAB(this.lightness, this.a, b);
+    }
+    toChannels() {
+        return [this.lightness, this.a, this.b];
+    }
+    toString() {
+        return `lab(${this.lightness}, ${this.a}, ${this.b})`;
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        if (nearEquals(this.lightness, other.lightness, tollerance) && ((nearEquals(this.lightness, 100, tollerance)) || nearEquals(this.lightness, 0, tollerance))) {
+            return true;
+        }
+        return (nearEquals(this.lightness, other.lightness, tollerance) &&
+            nearEquals(this.a, other.a, tollerance) &&
+            nearEquals(this.b, other.b, tollerance));
+    }
+}

package/dist/colors/lch.d.ts

@@ -0,0 +1,19 @@
+export declare class LCH {
+    static ofChannels([l, c, h]: [l: number, c: number, h: number]): LCH;
+    readonly luminance: number;
+    readonly chroma: number;
+    readonly hue: number;
+    /**
+     *
+     * @param luminance Luminance in cd/m^2
+     * @param chroma
+     * @param hue Angle in degrees (0-360)
+     */
+    constructor(luminance: number, chroma: number, hue: number);
+    withLightness(l: number): LCH;
+    withChroma(c: number): LCH;
+    withHue(h: number): LCH;
+    toChannels(): [number, number, number];
+    toString(): string;
+    equals(other: LCH, tollerance?: number): boolean;
+}

package/dist/colors/lch.js

@@ -0,0 +1,44 @@
+import { nearEquals } from '../numbers';
+const TOLLERANCE = 0.0001;
+export class LCH {
+    static ofChannels([l, c, h]) {
+        return new LCH(l, c, h);
+    }
+    luminance;
+    chroma;
+    hue;
+    /**
+     *
+     * @param luminance Luminance in cd/m^2
+     * @param chroma
+     * @param hue Angle in degrees (0-360)
+     */
+    constructor(luminance, chroma, hue) {
+        this.luminance = luminance < 0 ? 0 : luminance;
+        this.chroma = chroma;
+        this.hue = hue % 360;
+    }
+    withLightness(l) {
+        return new LCH(l, this.chroma, this.hue);
+    }
+    withChroma(c) {
+        return new LCH(this.luminance, c, this.hue);
+    }
+    withHue(h) {
+        return new LCH(this.luminance, this.chroma, h);
+    }
+    toChannels() {
+        return [this.luminance, this.chroma, this.hue];
+    }
+    toString() {
+        return `lch(${this.luminance}, ${this.chroma}, ${this.hue})`;
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        if (nearEquals(this.luminance, other.luminance, tollerance) && ((nearEquals(this.luminance, 100, tollerance)) || nearEquals(this.luminance, 0, tollerance))) {
+            return true;
+        }
+        return (nearEquals(this.luminance, other.luminance, tollerance) &&
+            nearEquals(this.chroma, other.chroma, tollerance) &&
+            nearEquals(this.hue, other.hue, tollerance));
+    }
+}

package/dist/colors/luv.d.ts

@@ -0,0 +1,19 @@
+export declare class LUV {
+    static ofChannels([l, u, v]: [l: number, u: number, v: number]): LUV;
+    readonly l: number;
+    readonly u: number;
+    readonly v: number;
+    /**
+     *
+     * @param l
+     * @param u range (0, 1)
+     * @param v range (0, 1)
+     */
+    constructor(l: number, u: number, v: number);
+    withL(l: number): LUV;
+    withU(u: number): LUV;
+    withV(v: number): LUV;
+    toChannels(): [number, number, number];
+    toString(): string;
+    equals(other: LUV, tollerance?: number): boolean;
+}

package/dist/colors/luv.js

@@ -0,0 +1,45 @@
+import { nearEquals } from '../numbers';
+const TOLLERANCE = 0.0001;
+export class LUV {
+    static ofChannels([l, u, v]) {
+        return new LUV(l, u, v);
+    }
+    l;
+    u;
+    v;
+    /**
+     *
+     * @param l
+     * @param u range (0, 1)
+     * @param v range (0, 1)
+     */
+    constructor(l, u, v) {
+        this.l = l;
+        this.u = u;
+        this.v = v;
+    }
+    withL(l) {
+        return new LUV(l, this.u, this.v);
+    }
+    withU(u) {
+        return new LUV(this.l, u, this.v);
+    }
+    withV(v) {
+        return new LUV(this.l, this.u, v);
+    }
+    toChannels() {
+        return [this.l, this.u, this.v];
+    }
+    toString() {
+        return `luv(${this.l}, ${this.u}, ${this.v})`;
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        if ((nearEquals(this.l, other.l, tollerance) && nearEquals(this.l, 1, tollerance)) ||
+            nearEquals(this.l, 0, tollerance)) {
+            return true;
+        }
+        return (nearEquals(this.l, other.l, tollerance) &&
+            nearEquals(this.u, other.u, tollerance) &&
+            nearEquals(this.v, other.v, tollerance));
+    }
+}

package/dist/colors/rgb.d.ts

@@ -0,0 +1,13 @@
+export declare class RGB {
+    readonly value: number;
+    static fromString(s: string): RGB;
+    static fromRGB(r: number, g: number, b: number): RGB;
+    static ofChannels([r, g, b]: [r: number, g: number, b: number]): RGB;
+    constructor(value: number);
+    get red(): number;
+    get green(): number;
+    get blue(): number;
+    toChannels(): [number, number, number];
+    toString(): string;
+    equals(other: RGB): boolean;
+}

package/dist/colors/rgb.js

@@ -0,0 +1,47 @@
+import { clampInt } from '../numbers';
+export class RGB {
+    value;
+    static fromString(s) {
+        const m = s.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+        if (m != null) {
+            const r = parseInt(m[1], 16);
+            const g = parseInt(m[2], 16);
+            const b = parseInt(m[3], 16);
+            return RGB.fromRGB(r, g, b);
+        }
+        else {
+            throw new Error(`Invalid RGB string: ${s}`);
+        }
+    }
+    static fromRGB(r, g, b) {
+        return new RGB((clampInt(Math.round(r), 0, 255) << 16) |
+            (clampInt(Math.round(g), 0, 255) << 8) |
+            clampInt(Math.round(b), 0, 255));
+    }
+    static ofChannels([r, g, b]) {
+        return RGB.fromRGB(r * 255, g * 255, b * 255);
+    }
+    constructor(value) {
+        this.value = value;
+    }
+    get red() {
+        return (this.value >> 16) & 0xff;
+    }
+    get green() {
+        return (this.value >> 8) & 0xff;
+    }
+    get blue() {
+        return this.value & 0xff;
+    }
+    toChannels() {
+        return [this.red / 255, this.green / 255, this.blue / 255];
+    }
+    toString() {
+        return `#${this.red.toString(16).padStart(2, '0')}${this.green
+            .toString(16)
+            .padStart(2, '0')}${this.blue.toString(16).padStart(2, '0')}`;
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+}

package/dist/colors/rgba.d.ts

@@ -0,0 +1,12 @@
+export declare class RGBA {
+    readonly value: number;
+    static fromString(s: string): RGBA;
+    static fromRGBA(r: number, g: number, b: number, a: number): RGBA;
+    constructor(value: number);
+    get red(): number;
+    get green(): number;
+    get blue(): number;
+    get alpha(): number;
+    toString(): string;
+    equals(other: RGBA): boolean;
+}

package/dist/colors/rgba.js

@@ -0,0 +1,44 @@
+import { clampInt } from '../numbers';
+export class RGBA {
+    value;
+    static fromString(s) {
+        const m = s.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+        if (m != null) {
+            const r = parseInt(m[1], 16);
+            const g = parseInt(m[2], 16);
+            const b = parseInt(m[3], 16);
+            const a = parseInt(m[4], 16);
+            return RGBA.fromRGBA(r, g, b, a);
+        }
+        else {
+            throw new Error(`Invalid RGBA string: ${s}`);
+        }
+    }
+    static fromRGBA(r, g, b, a) {
+        return new RGBA((clampInt(r, 0, 255) << 24) |
+            (clampInt(g, 0, 255) << 16) |
+            (clampInt(b, 0, 255) << 8) |
+            clampInt(a, 0, 255));
+    }
+    constructor(value) {
+        this.value = value;
+    }
+    get red() {
+        return (this.value >> 24) & 0xff;
+    }
+    get green() {
+        return (this.value >> 16) & 0xff;
+    }
+    get blue() {
+        return (this.value >> 8) & 0xff;
+    }
+    get alpha() {
+        return this.value & 0xff;
+    }
+    toString() {
+        return `rgba(${this.red}, ${this.green}, ${this.blue}, ${this.alpha / 256})`;
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+}

package/dist/colors/srgb.d.ts

@@ -0,0 +1,24 @@
+export declare class SRGB {
+    static fromString(s: string): SRGB;
+    static ofChannels([red, blue, green]: [
+        red: number,
+        blue: number,
+        green: number
+    ]): SRGB;
+    readonly red: number;
+    readonly blue: number;
+    readonly green: number;
+    /**
+     *
+     * @param red Percentage (0-100)
+     * @param blue Percentage (0-100)
+     * @param green Percentage (0-100)
+     */
+    constructor(red: number, blue: number, green: number);
+    withRed(red: number): SRGB;
+    withBlue(blue: number): SRGB;
+    withGreen(green: number): SRGB;
+    toString(): string;
+    toChannels(): [number, number, number];
+    equals(other: SRGB, tollerance?: number): boolean;
+}