生成可用的WASM包。

src/color_functions/color_module.d.ts

@@ -30,6 +30,44 @@ export function tonal_lighten_series(color: string, expand_amount: number, step:
 export function tonal_darken_series(color: string, expand_amount: number, step: number): (string)[];
 export function color_categories(): any;
 export function search_color_cards(tag: string, category?: string): any;
+export function differ_in_rgb(color: string, other: string): RGBDifference;
+export function differ_in_hsl(color: string, other: string): HSLDifference;
+export function differ_in_hct(color: string, other: string): HctDiffference;
+export function differ_in_oklch(color: string, other: string): OklchDifference;
+export class Differ {
+  private constructor();
+  free(): void;
+  delta: number;
+  percent: number;
+}
+export class HSLDifference {
+  private constructor();
+  free(): void;
+  hue: Differ;
+  saturation: Differ;
+  lightness: Differ;
+}
+export class HctDiffference {
+  private constructor();
+  free(): void;
+  hue: Differ;
+  chroma: Differ;
+  lightness: Differ;
+}
+export class OklchDifference {
+  private constructor();
+  free(): void;
+  hue: Differ;
+  chroma: Differ;
+  lightness: Differ;
+}
+export class RGBDifference {
+  private constructor();
+  free(): void;
+  r: Differ;
+  g: Differ;
+  b: Differ;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
@@ -65,6 +103,43 @@ export interface InitOutput {
   readonly tonal_darken_series: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly color_categories: () => [number, number, number];
   readonly search_color_cards: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly differ_in_rgb: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly differ_in_hsl: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly differ_in_hct: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly differ_in_oklch: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly __wbg_oklchdifference_free: (a: number, b: number) => void;
+  readonly __wbg_get_oklchdifference_hue: (a: number) => number;
+  readonly __wbg_set_oklchdifference_hue: (a: number, b: number) => void;
+  readonly __wbg_get_oklchdifference_chroma: (a: number) => number;
+  readonly __wbg_set_oklchdifference_chroma: (a: number, b: number) => void;
+  readonly __wbg_get_oklchdifference_lightness: (a: number) => number;
+  readonly __wbg_set_oklchdifference_lightness: (a: number, b: number) => void;
+  readonly __wbg_differ_free: (a: number, b: number) => void;
+  readonly __wbg_get_differ_delta: (a: number) => number;
+  readonly __wbg_set_differ_delta: (a: number, b: number) => void;
+  readonly __wbg_get_differ_percent: (a: number) => number;
+  readonly __wbg_set_differ_percent: (a: number, b: number) => void;
+  readonly __wbg_hctdiffference_free: (a: number, b: number) => void;
+  readonly __wbg_get_hctdiffference_hue: (a: number) => number;
+  readonly __wbg_set_hctdiffference_hue: (a: number, b: number) => void;
+  readonly __wbg_get_hctdiffference_chroma: (a: number) => number;
+  readonly __wbg_set_hctdiffference_chroma: (a: number, b: number) => void;
+  readonly __wbg_get_hctdiffference_lightness: (a: number) => number;
+  readonly __wbg_set_hctdiffference_lightness: (a: number, b: number) => void;
+  readonly __wbg_rgbdifference_free: (a: number, b: number) => void;
+  readonly __wbg_get_rgbdifference_r: (a: number) => number;
+  readonly __wbg_set_rgbdifference_r: (a: number, b: number) => void;
+  readonly __wbg_get_rgbdifference_g: (a: number) => number;
+  readonly __wbg_set_rgbdifference_g: (a: number, b: number) => void;
+  readonly __wbg_get_rgbdifference_b: (a: number) => number;
+  readonly __wbg_set_rgbdifference_b: (a: number, b: number) => void;
+  readonly __wbg_hsldifference_free: (a: number, b: number) => void;
+  readonly __wbg_get_hsldifference_hue: (a: number) => number;
+  readonly __wbg_set_hsldifference_hue: (a: number, b: number) => void;
+  readonly __wbg_get_hsldifference_saturation: (a: number) => number;
+  readonly __wbg_set_hsldifference_saturation: (a: number, b: number) => void;
+  readonly __wbg_get_hsldifference_lightness: (a: number) => number;
+  readonly __wbg_set_hsldifference_lightness: (a: number, b: number) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_export_2: WebAssembly.Table;

src/color_functions/color_module.js

@@ -739,6 +739,421 @@ export function search_color_cards(tag, category) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {string} color
+ * @param {string} other
+ * @returns {RGBDifference}
+ */
+export function differ_in_rgb(color, other) {
+    const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(other, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.differ_in_rgb(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RGBDifference.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} color
+ * @param {string} other
+ * @returns {HSLDifference}
+ */
+export function differ_in_hsl(color, other) {
+    const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(other, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.differ_in_hsl(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return HSLDifference.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} color
+ * @param {string} other
+ * @returns {HctDiffference}
+ */
+export function differ_in_hct(color, other) {
+    const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(other, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.differ_in_hct(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return HctDiffference.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} color
+ * @param {string} other
+ * @returns {OklchDifference}
+ */
+export function differ_in_oklch(color, other) {
+    const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(other, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.differ_in_oklch(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return OklchDifference.__wrap(ret[0]);
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+const DifferFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_differ_free(ptr >>> 0, 1));
+
+export class Differ {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Differ.prototype);
+        obj.__wbg_ptr = ptr;
+        DifferFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DifferFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_differ_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get delta() {
+        const ret = wasm.__wbg_get_differ_delta(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set delta(arg0) {
+        wasm.__wbg_set_differ_delta(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get percent() {
+        const ret = wasm.__wbg_get_differ_percent(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set percent(arg0) {
+        wasm.__wbg_set_differ_percent(this.__wbg_ptr, arg0);
+    }
+}
+
+const HSLDifferenceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_hsldifference_free(ptr >>> 0, 1));
+
+export class HSLDifference {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(HSLDifference.prototype);
+        obj.__wbg_ptr = ptr;
+        HSLDifferenceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HSLDifferenceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_hsldifference_free(ptr, 0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get hue() {
+        const ret = wasm.__wbg_get_hsldifference_hue(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set hue(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_hsldifference_hue(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get saturation() {
+        const ret = wasm.__wbg_get_hsldifference_saturation(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set saturation(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_hsldifference_saturation(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get lightness() {
+        const ret = wasm.__wbg_get_hsldifference_lightness(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set lightness(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_hsldifference_lightness(this.__wbg_ptr, ptr0);
+    }
+}
+
+const HctDiffferenceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_hctdiffference_free(ptr >>> 0, 1));
+
+export class HctDiffference {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(HctDiffference.prototype);
+        obj.__wbg_ptr = ptr;
+        HctDiffferenceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HctDiffferenceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_hctdiffference_free(ptr, 0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get hue() {
+        const ret = wasm.__wbg_get_hctdiffference_hue(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set hue(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_hctdiffference_hue(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get chroma() {
+        const ret = wasm.__wbg_get_hctdiffference_chroma(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set chroma(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_hctdiffference_chroma(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get lightness() {
+        const ret = wasm.__wbg_get_hctdiffference_lightness(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set lightness(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_hctdiffference_lightness(this.__wbg_ptr, ptr0);
+    }
+}
+
+const OklchDifferenceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_oklchdifference_free(ptr >>> 0, 1));
+
+export class OklchDifference {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OklchDifference.prototype);
+        obj.__wbg_ptr = ptr;
+        OklchDifferenceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OklchDifferenceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_oklchdifference_free(ptr, 0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get hue() {
+        const ret = wasm.__wbg_get_oklchdifference_hue(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set hue(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_oklchdifference_hue(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get chroma() {
+        const ret = wasm.__wbg_get_oklchdifference_chroma(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set chroma(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_oklchdifference_chroma(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get lightness() {
+        const ret = wasm.__wbg_get_oklchdifference_lightness(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set lightness(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_oklchdifference_lightness(this.__wbg_ptr, ptr0);
+    }
+}
+
+const RGBDifferenceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rgbdifference_free(ptr >>> 0, 1));
+
+export class RGBDifference {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RGBDifference.prototype);
+        obj.__wbg_ptr = ptr;
+        RGBDifferenceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RGBDifferenceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rgbdifference_free(ptr, 0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get r() {
+        const ret = wasm.__wbg_get_rgbdifference_r(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set r(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_rgbdifference_r(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get g() {
+        const ret = wasm.__wbg_get_rgbdifference_g(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set g(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_rgbdifference_g(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Differ}
+     */
+    get b() {
+        const ret = wasm.__wbg_get_rgbdifference_b(this.__wbg_ptr);
+        return Differ.__wrap(ret);
+    }
+    /**
+     * @param {Differ} arg0
+     */
+    set b(arg0) {
+        _assertClass(arg0, Differ);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_rgbdifference_b(this.__wbg_ptr, ptr0);
+    }
+}
+
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {

src/color_functions/color_module_bg.wasm.d.ts

@@ -31,6 +31,43 @@ export const tonal_lighten_series: (a: number, b: number, c: number, d: number)
 export const tonal_darken_series: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const color_categories: () => [number, number, number];
 export const search_color_cards: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const differ_in_rgb: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const differ_in_hsl: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const differ_in_hct: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const differ_in_oklch: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const __wbg_oklchdifference_free: (a: number, b: number) => void;
+export const __wbg_get_oklchdifference_hue: (a: number) => number;
+export const __wbg_set_oklchdifference_hue: (a: number, b: number) => void;
+export const __wbg_get_oklchdifference_chroma: (a: number) => number;
+export const __wbg_set_oklchdifference_chroma: (a: number, b: number) => void;
+export const __wbg_get_oklchdifference_lightness: (a: number) => number;
+export const __wbg_set_oklchdifference_lightness: (a: number, b: number) => void;
+export const __wbg_differ_free: (a: number, b: number) => void;
+export const __wbg_get_differ_delta: (a: number) => number;
+export const __wbg_set_differ_delta: (a: number, b: number) => void;
+export const __wbg_get_differ_percent: (a: number) => number;
+export const __wbg_set_differ_percent: (a: number, b: number) => void;
+export const __wbg_hctdiffference_free: (a: number, b: number) => void;
+export const __wbg_get_hctdiffference_hue: (a: number) => number;
+export const __wbg_set_hctdiffference_hue: (a: number, b: number) => void;
+export const __wbg_get_hctdiffference_chroma: (a: number) => number;
+export const __wbg_set_hctdiffference_chroma: (a: number, b: number) => void;
+export const __wbg_get_hctdiffference_lightness: (a: number) => number;
+export const __wbg_set_hctdiffference_lightness: (a: number, b: number) => void;
+export const __wbg_rgbdifference_free: (a: number, b: number) => void;
+export const __wbg_get_rgbdifference_r: (a: number) => number;
+export const __wbg_set_rgbdifference_r: (a: number, b: number) => void;
+export const __wbg_get_rgbdifference_g: (a: number) => number;
+export const __wbg_set_rgbdifference_g: (a: number, b: number) => void;
+export const __wbg_get_rgbdifference_b: (a: number) => number;
+export const __wbg_set_rgbdifference_b: (a: number, b: number) => void;
+export const __wbg_hsldifference_free: (a: number, b: number) => void;
+export const __wbg_get_hsldifference_hue: (a: number) => number;
+export const __wbg_set_hsldifference_hue: (a: number, b: number) => void;
+export const __wbg_get_hsldifference_saturation: (a: number) => number;
+export const __wbg_set_hsldifference_saturation: (a: number, b: number) => void;
+export const __wbg_get_hsldifference_lightness: (a: number) => number;
+export const __wbg_set_hsldifference_lightness: (a: number, b: number) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export_2: WebAssembly.Table;