@dicebear/core 9.4.2 → 10.0.0-rc.1

package/lib/Style/Element.js

@@ -0,0 +1,36 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Element_data, _Element_children;
+export class Element {
+    constructor(data) {
+        _Element_data.set(this, void 0);
+        _Element_children.set(this, void 0);
+        __classPrivateFieldSet(this, _Element_data, data, "f");
+    }
+    type() {
+        return __classPrivateFieldGet(this, _Element_data, "f").type;
+    }
+    name() {
+        return __classPrivateFieldGet(this, _Element_data, "f").name;
+    }
+    value() {
+        return __classPrivateFieldGet(this, _Element_data, "f").value;
+    }
+    attributes() {
+        return __classPrivateFieldGet(this, _Element_data, "f").attributes;
+    }
+    children() {
+        __classPrivateFieldSet(this, _Element_children, __classPrivateFieldGet(this, _Element_children, "f") ?? (__classPrivateFieldGet(this, _Element_data, "f").children ?? []).map((child) => new Element(child)), "f");
+        return __classPrivateFieldGet(this, _Element_children, "f");
+    }
+}
+_Element_data = new WeakMap(), _Element_children = new WeakMap();

package/lib/Style/Meta.d.ts

@@ -0,0 +1,11 @@
+import type { StyleDefinitionMeta } from '../StyleDefinition.js';
+import { MetaLicense } from './MetaLicense.js';
+import { MetaCreator } from './MetaCreator.js';
+import { MetaSource } from './MetaSource.js';
+export declare class Meta {
+    #private;
+    constructor(data: StyleDefinitionMeta);
+    license(): MetaLicense;
+    creator(): MetaCreator;
+    source(): MetaSource;
+}

package/lib/Style/Meta.js

@@ -0,0 +1,37 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Meta_data, _Meta_license, _Meta_creator, _Meta_source;
+import { MetaLicense } from './MetaLicense.js';
+import { MetaCreator } from './MetaCreator.js';
+import { MetaSource } from './MetaSource.js';
+export class Meta {
+    constructor(data) {
+        _Meta_data.set(this, void 0);
+        _Meta_license.set(this, void 0);
+        _Meta_creator.set(this, void 0);
+        _Meta_source.set(this, void 0);
+        __classPrivateFieldSet(this, _Meta_data, data, "f");
+    }
+    license() {
+        __classPrivateFieldSet(this, _Meta_license, __classPrivateFieldGet(this, _Meta_license, "f") ?? new MetaLicense(__classPrivateFieldGet(this, _Meta_data, "f").license ?? {}), "f");
+        return __classPrivateFieldGet(this, _Meta_license, "f");
+    }
+    creator() {
+        __classPrivateFieldSet(this, _Meta_creator, __classPrivateFieldGet(this, _Meta_creator, "f") ?? new MetaCreator(__classPrivateFieldGet(this, _Meta_data, "f").creator ?? {}), "f");
+        return __classPrivateFieldGet(this, _Meta_creator, "f");
+    }
+    source() {
+        __classPrivateFieldSet(this, _Meta_source, __classPrivateFieldGet(this, _Meta_source, "f") ?? new MetaSource(__classPrivateFieldGet(this, _Meta_data, "f").source ?? {}), "f");
+        return __classPrivateFieldGet(this, _Meta_source, "f");
+    }
+}
+_Meta_data = new WeakMap(), _Meta_license = new WeakMap(), _Meta_creator = new WeakMap(), _Meta_source = new WeakMap();

package/lib/Style/MetaCreator.d.ts

@@ -0,0 +1,7 @@
+import type { StyleDefinitionMetaCreator } from '../StyleDefinition.js';
+export declare class MetaCreator {
+    #private;
+    constructor(data: StyleDefinitionMetaCreator);
+    name(): string | undefined;
+    url(): string | undefined;
+}

package/lib/Style/MetaCreator.js

@@ -0,0 +1,25 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MetaCreator_data;
+export class MetaCreator {
+    constructor(data) {
+        _MetaCreator_data.set(this, void 0);
+        __classPrivateFieldSet(this, _MetaCreator_data, data, "f");
+    }
+    name() {
+        return __classPrivateFieldGet(this, _MetaCreator_data, "f").name;
+    }
+    url() {
+        return __classPrivateFieldGet(this, _MetaCreator_data, "f").url;
+    }
+}
+_MetaCreator_data = new WeakMap();

package/lib/Style/MetaLicense.d.ts

@@ -0,0 +1,8 @@
+import type { StyleDefinitionMetaLicense } from '../StyleDefinition.js';
+export declare class MetaLicense {
+    #private;
+    constructor(data: StyleDefinitionMetaLicense);
+    name(): string | undefined;
+    url(): string | undefined;
+    text(): string | undefined;
+}

package/lib/Style/MetaLicense.js

@@ -0,0 +1,28 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MetaLicense_data;
+export class MetaLicense {
+    constructor(data) {
+        _MetaLicense_data.set(this, void 0);
+        __classPrivateFieldSet(this, _MetaLicense_data, data, "f");
+    }
+    name() {
+        return __classPrivateFieldGet(this, _MetaLicense_data, "f").name;
+    }
+    url() {
+        return __classPrivateFieldGet(this, _MetaLicense_data, "f").url;
+    }
+    text() {
+        return __classPrivateFieldGet(this, _MetaLicense_data, "f").text;
+    }
+}
+_MetaLicense_data = new WeakMap();

package/lib/Style/MetaSource.d.ts

@@ -0,0 +1,7 @@
+import type { StyleDefinitionMetaSource } from '../StyleDefinition.js';
+export declare class MetaSource {
+    #private;
+    constructor(data: StyleDefinitionMetaSource);
+    name(): string | undefined;
+    url(): string | undefined;
+}

package/lib/Style/MetaSource.js

@@ -0,0 +1,25 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MetaSource_data;
+export class MetaSource {
+    constructor(data) {
+        _MetaSource_data.set(this, void 0);
+        __classPrivateFieldSet(this, _MetaSource_data, data, "f");
+    }
+    name() {
+        return __classPrivateFieldGet(this, _MetaSource_data, "f").name;
+    }
+    url() {
+        return __classPrivateFieldGet(this, _MetaSource_data, "f").url;
+    }
+}
+_MetaSource_data = new WeakMap();

package/lib/Style.d.ts

@@ -0,0 +1,18 @@
+import type { StyleDefinitionAttributes } from './StyleDefinition.js';
+import { Meta } from './Style/Meta.js';
+import { Canvas } from './Style/Canvas.js';
+import { Component } from './Style/Component.js';
+import { Color } from './Style/Color.js';
+export type { StyleDefinition } from './StyleDefinition.js';
+export declare class Style<D = unknown> {
+    #private;
+    constructor(data: D);
+    id(): string | undefined;
+    schema(): string | undefined;
+    comment(): string | undefined;
+    meta(): Meta;
+    attributes(): StyleDefinitionAttributes;
+    canvas(): Canvas;
+    components(): ReadonlyMap<string, Component>;
+    colors(): ReadonlyMap<string, Color>;
+}

package/lib/Style.js

@@ -0,0 +1,63 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Style_data, _Style_meta, _Style_canvas, _Style_components, _Style_colors;
+import { StyleValidator } from './Validator/StyleValidator.js';
+import { Meta } from './Style/Meta.js';
+import { Canvas } from './Style/Canvas.js';
+import { Component } from './Style/Component.js';
+import { Color } from './Style/Color.js';
+export class Style {
+    constructor(data) {
+        _Style_data.set(this, void 0);
+        _Style_meta.set(this, void 0);
+        _Style_canvas.set(this, void 0);
+        _Style_components.set(this, void 0);
+        _Style_colors.set(this, void 0);
+        StyleValidator.validate(data);
+        __classPrivateFieldSet(this, _Style_data, structuredClone(data), "f");
+    }
+    id() {
+        return __classPrivateFieldGet(this, _Style_data, "f").$id;
+    }
+    schema() {
+        return __classPrivateFieldGet(this, _Style_data, "f").$schema;
+    }
+    comment() {
+        return __classPrivateFieldGet(this, _Style_data, "f").$comment;
+    }
+    meta() {
+        __classPrivateFieldSet(this, _Style_meta, __classPrivateFieldGet(this, _Style_meta, "f") ?? new Meta(__classPrivateFieldGet(this, _Style_data, "f").meta ?? {}), "f");
+        return __classPrivateFieldGet(this, _Style_meta, "f");
+    }
+    attributes() {
+        return structuredClone(__classPrivateFieldGet(this, _Style_data, "f").attributes ?? {});
+    }
+    canvas() {
+        __classPrivateFieldSet(this, _Style_canvas, __classPrivateFieldGet(this, _Style_canvas, "f") ?? new Canvas(__classPrivateFieldGet(this, _Style_data, "f").canvas), "f");
+        return __classPrivateFieldGet(this, _Style_canvas, "f");
+    }
+    components() {
+        __classPrivateFieldSet(this, _Style_components, __classPrivateFieldGet(this, _Style_components, "f") ?? new Map(Object.entries(__classPrivateFieldGet(this, _Style_data, "f").components ?? {}).map(([name, data]) => [
+            name,
+            new Component(data),
+        ])), "f");
+        return __classPrivateFieldGet(this, _Style_components, "f");
+    }
+    colors() {
+        __classPrivateFieldSet(this, _Style_colors, __classPrivateFieldGet(this, _Style_colors, "f") ?? new Map(Object.entries(__classPrivateFieldGet(this, _Style_data, "f").colors ?? {}).map(([name, data]) => [
+            name,
+            new Color(data),
+        ])), "f");
+        return __classPrivateFieldGet(this, _Style_colors, "f");
+    }
+}
+_Style_data = new WeakMap(), _Style_meta = new WeakMap(), _Style_canvas = new WeakMap(), _Style_components = new WeakMap(), _Style_colors = new WeakMap();

package/lib/StyleDefinition.d.ts

@@ -0,0 +1,83 @@
+export interface StyleDefinitionMetaLicense {
+    readonly name?: string;
+    readonly url?: string;
+    readonly text?: string;
+}
+export interface StyleDefinitionMetaCreator {
+    readonly name?: string;
+    readonly url?: string;
+}
+export interface StyleDefinitionMetaSource {
+    readonly name?: string;
+    readonly url?: string;
+}
+export interface StyleDefinitionMeta {
+    readonly license?: StyleDefinitionMetaLicense;
+    readonly creator?: StyleDefinitionMetaCreator;
+    readonly source?: StyleDefinitionMetaSource;
+}
+export interface StyleDefinitionVariableReference {
+    readonly type: 'variable';
+    readonly value: 'initial' | 'initials' | 'fontWeight' | 'fontFamily';
+}
+export interface StyleDefinitionColorReference {
+    readonly type: 'color';
+    readonly value: string;
+}
+export type StyleDefinitionColorAttributeValue = string | StyleDefinitionColorReference;
+export type StyleDefinitionElementValue = string | StyleDefinitionVariableReference;
+export type StyleDefinitionElementType = 'element' | 'text' | 'component';
+export interface StyleDefinitionAttributes {
+    readonly color?: StyleDefinitionColorAttributeValue;
+    readonly 'flood-color'?: StyleDefinitionColorAttributeValue;
+    readonly 'lighting-color'?: StyleDefinitionColorAttributeValue;
+    readonly 'stop-color'?: StyleDefinitionColorAttributeValue;
+    readonly fill?: StyleDefinitionColorAttributeValue;
+    readonly stroke?: StyleDefinitionColorAttributeValue;
+    readonly 'font-family'?: string | StyleDefinitionVariableReference;
+    readonly 'font-weight'?: string | StyleDefinitionVariableReference;
+    readonly [key: string]: string | StyleDefinitionColorReference | StyleDefinitionVariableReference | undefined;
+}
+export interface StyleDefinitionElement {
+    readonly type: StyleDefinitionElementType;
+    readonly name?: string;
+    readonly value?: StyleDefinitionElementValue;
+    readonly attributes?: StyleDefinitionAttributes;
+    readonly children?: readonly StyleDefinitionElement[];
+}
+export interface StyleDefinitionCanvas {
+    readonly width: number;
+    readonly height: number;
+    readonly elements: readonly StyleDefinitionElement[];
+}
+export interface StyleDefinitionColor {
+    readonly values: readonly string[];
+    readonly notEqualTo?: readonly string[];
+    readonly contrastTo?: string;
+}
+export interface StyleDefinitionComponentTranslate {
+    readonly x?: readonly number[];
+    readonly y?: readonly number[];
+}
+export interface StyleDefinitionComponentVariant {
+    readonly elements: readonly StyleDefinitionElement[];
+    readonly weight?: number;
+}
+export interface StyleDefinitionComponent {
+    readonly width: number;
+    readonly height: number;
+    readonly probability?: number;
+    readonly rotate?: readonly number[];
+    readonly translate?: StyleDefinitionComponentTranslate;
+    readonly variants: Readonly<Record<string, StyleDefinitionComponentVariant>>;
+}
+export interface StyleDefinition {
+    readonly $id?: string;
+    readonly $schema?: string;
+    readonly $comment?: string;
+    readonly meta?: StyleDefinitionMeta;
+    readonly attributes?: StyleDefinitionAttributes;
+    readonly canvas: StyleDefinitionCanvas;
+    readonly components?: Readonly<Record<string, StyleDefinitionComponent>>;
+    readonly colors?: Readonly<Record<string, StyleDefinitionColor>>;
+}

package/lib/StyleOptions.d.ts

@@ -0,0 +1,54 @@
+export type StyleOptionsFlipValue = 'none' | 'horizontal' | 'vertical' | 'both';
+export type StyleOptionsColorFillValue = 'solid' | 'linear' | 'radial';
+type ComponentNames<D> = D extends {
+    components: Record<infer K extends string, unknown>;
+} ? string extends K ? never : K : never;
+type ColorNames<D> = D extends {
+    colors: Record<infer K extends string, unknown>;
+} ? string extends K ? never : K : never;
+type AllColorNames<D> = ColorNames<D> | 'background';
+type VariantNames<D, C extends string> = D extends {
+    components: Record<string, unknown>;
+} ? C extends keyof D['components'] ? D['components'][C] extends {
+    variants: Record<infer V extends string, unknown>;
+} ? string extends V ? string : V : string : string : string;
+type HasSpecificKeys<D> = [ComponentNames<D>] extends [never] ? [ColorNames<D>] extends [never] ? false : true : true;
+export interface StyleOptionsBase {
+    readonly seed?: string;
+    readonly size?: number;
+    readonly idRandomization?: boolean;
+    readonly title?: string;
+    readonly flip?: StyleOptionsFlipValue | readonly StyleOptionsFlipValue[];
+    readonly fontFamily?: string | readonly string[];
+    readonly fontWeight?: number | readonly number[];
+    readonly scale?: number | readonly [number, number];
+    readonly borderRadius?: number | readonly [number, number];
+    readonly rotate?: number | readonly [number, number];
+    readonly translateX?: number | readonly [number, number];
+    readonly translateY?: number | readonly [number, number];
+}
+type ComponentVariantOption<D, K extends string> = VariantNames<D, K> | readonly VariantNames<D, K>[] | Readonly<Partial<Record<VariantNames<D, K>, number>>>;
+type ComponentOptions<D, C extends string> = [C] extends [never] ? unknown : {
+    readonly [K in C as `${K}Variant`]?: ComponentVariantOption<D, K>;
+} & {
+    readonly [K in C as `${K}Probability`]?: number;
+} & {
+    readonly [K in C as `${K}Rotate`]?: number | readonly [number, number];
+} & {
+    readonly [K in C as `${K}TranslateX`]?: number | readonly [number, number];
+} & {
+    readonly [K in C as `${K}TranslateY`]?: number | readonly [number, number];
+};
+type ColorOptions<C extends string> = [C] extends [never] ? unknown : {
+    readonly [K in C as `${K}Color`]?: string | readonly string[];
+} & {
+    readonly [K in C as `${K}ColorFill`]?: StyleOptionsColorFillValue | readonly StyleOptionsColorFillValue[];
+} & {
+    readonly [K in C as `${K}ColorFillStops`]?: number | readonly [number, number];
+} & {
+    readonly [K in C as `${K}ColorAngle`]?: number | readonly [number, number];
+};
+export type StyleOptions<D = unknown> = StyleOptionsBase & ComponentOptions<D, ComponentNames<D>> & ColorOptions<AllColorNames<D>> & (HasSpecificKeys<D> extends true ? unknown : {
+    readonly [key: string]: unknown;
+});
+export {};

package/lib/StyleOptions.js

@@ -0,0 +1 @@
+export {};

package/lib/Utils/Color.d.ts

@@ -0,0 +1,9 @@
+export declare class Color {
+    #private;
+    static toHex(hex: string): string;
+    static toRgbHex(hex: string): string;
+    static parseHex(hex: string): [number, number, number];
+    static luminance(hex: string): number;
+    static sortByContrast(candidates: readonly string[], refColor: string): string[];
+    static filterNotEqualTo(candidates: readonly string[], excluded: readonly string[]): string[];
+}

package/lib/Utils/Color.js

@@ -0,0 +1,67 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _Color_linearize;
+export class Color {
+    // Normalizes any hex format to 6- or 8-digit lowercase with '#' prefix.
+    static toHex(hex) {
+        const h = hex.replace(/^#/, '').toLowerCase();
+        if (h.length === 3) {
+            return '#' + h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+        }
+        if (h.length === 4) {
+            return '#' + h[0] + h[0] + h[1] + h[1] + h[2] + h[2] + h[3] + h[3];
+        }
+        return '#' + h;
+    }
+    // Like toHex, but strips the alpha channel to always return 6-digit hex.
+    static toRgbHex(hex) {
+        const h = this.toHex(hex);
+        return h.length > 7 ? h.slice(0, 7) : h;
+    }
+    static parseHex(hex) {
+        const h = this.toHex(hex).slice(1);
+        return [
+            parseInt(h.slice(0, 2), 16),
+            parseInt(h.slice(2, 4), 16),
+            parseInt(h.slice(4, 6), 16),
+        ];
+    }
+    // WCAG 2.1 relative luminance with sRGB linearization.
+    // https://www.w3.org/WAI/GL/wiki/Relative_luminance
+    static luminance(hex) {
+        const rgb = this.parseHex(hex);
+        const linearR = __classPrivateFieldGet(this, _a, "m", _Color_linearize).call(this, rgb[0]);
+        const linearG = __classPrivateFieldGet(this, _a, "m", _Color_linearize).call(this, rgb[1]);
+        const linearB = __classPrivateFieldGet(this, _a, "m", _Color_linearize).call(this, rgb[2]);
+        return 0.2126 * linearR + 0.7152 * linearG + 0.0722 * linearB;
+    }
+    // Returns a new array sorted by descending contrast against the reference color.
+    // https://www.w3.org/WAI/GL/wiki/Contrast_ratio
+    static sortByContrast(candidates, refColor) {
+        const refLum = this.luminance(refColor);
+        const withRatio = candidates.map((c) => {
+            const lum = this.luminance(c);
+            const ratio = (Math.max(lum, refLum) + 0.05) / (Math.min(lum, refLum) + 0.05);
+            return { color: c, ratio };
+        });
+        withRatio.sort((a, b) => b.ratio - a.ratio);
+        return withRatio.map((e) => e.color);
+    }
+    // Returns a new array with excluded colors removed.
+    // Returns the original candidates if filtering would empty the list.
+    static filterNotEqualTo(candidates, excluded) {
+        const normalized = new Set(excluded.map((c) => this.toRgbHex(c)));
+        const filtered = candidates.filter((c) => !normalized.has(this.toRgbHex(c)));
+        return filtered.length > 0 ? filtered : Array.from(candidates);
+    }
+}
+_a = Color, _Color_linearize = function _Color_linearize(channel) {
+    const s = channel / 255;
+    if (s <= 0.04045) {
+        return s / 12.92;
+    }
+    return ((s + 0.055) / 1.055) ** 2.4;
+};

package/lib/Utils/Initials.d.ts

@@ -0,0 +1,3 @@
+export declare class Initials {
+    static fromSeed(seed: string, discardAtSymbol?: boolean): string;
+}

package/lib/Utils/Initials.js

@@ -0,0 +1,26 @@
+// @see https://www.regular-expressions.info/unicode.html
+export class Initials {
+    // Strips '@...' so email addresses yield a single initial instead
+    // of being treated as two words.
+    static fromSeed(seed, discardAtSymbol = true) {
+        let input = seed;
+        if (discardAtSymbol) {
+            input = seed.replace(/@.*/, '');
+        }
+        input = input.replace(/[`´'ʼ]/g, '');
+        const matches = input.match(/(\p{L}[\p{L}\p{M}]*)/gu);
+        if (!matches) {
+            return discardAtSymbol ? this.fromSeed(seed, false) : '';
+        }
+        if (matches.length === 1) {
+            const match = matches[0].match(/^(?:\p{L}\p{M}*){1,2}/u);
+            return match ? match[0].toUpperCase() : '';
+        }
+        const first = matches[0].match(/^(?:\p{L}\p{M}*)/u);
+        const last = matches[matches.length - 1].match(/^(?:\p{L}\p{M}*)/u);
+        if (!first || !last) {
+            return '';
+        }
+        return (first[0] + last[0]).toUpperCase();
+    }
+}

package/lib/Utils/License.d.ts

@@ -0,0 +1,5 @@
+import type { Meta } from '../Style/Meta.js';
+export declare class License {
+    static text(meta: Meta): string;
+    static xml(meta: Meta): string;
+}

package/lib/Utils/License.js

@@ -0,0 +1,64 @@
+import { Xml } from './Xml.js';
+export class License {
+    static text(meta) {
+        const sourceName = meta.source().name();
+        const sourceUrl = meta.source().url();
+        const creatorName = meta.creator().name();
+        const licenseName = meta.license().name();
+        const licenseUrl = meta.license().url();
+        if (!sourceName && !creatorName && !licenseName) {
+            return '';
+        }
+        let title = sourceName ? `“${sourceName}”` : 'Design';
+        if (sourceUrl) {
+            title += ` (${sourceUrl})`;
+        }
+        const creator = `“${creatorName ?? 'Unknown'}”`;
+        let result = '';
+        // Skip "Remix of" prefix for MIT-licensed or DiceBear-original styles.
+        if (licenseName !== 'MIT' && creatorName !== 'DiceBear' && sourceName) {
+            result += 'Remix of ';
+        }
+        result += `${title} by ${creator}`;
+        if (licenseName) {
+            result += `, licensed under “${licenseName}”`;
+            if (licenseUrl) {
+                result += ` (${licenseUrl})`;
+            }
+        }
+        return result;
+    }
+    static xml(meta) {
+        const title = meta.source().name();
+        const creatorName = meta.creator().name();
+        const sourceUrl = meta.source().url();
+        const licenseUrl = meta.license().url();
+        const rights = this.text(meta);
+        if (!title && !creatorName && !sourceUrl && !licenseUrl && !rights) {
+            return '';
+        }
+        const fields = [];
+        if (title) {
+            fields.push(`<dc:title>${Xml.escape(title)}</dc:title>`);
+        }
+        if (creatorName) {
+            fields.push(`<dc:creator>${Xml.escape(creatorName)}</dc:creator>`);
+        }
+        if (sourceUrl) {
+            fields.push(`<dc:source xsi:type="dcterms:URI">${Xml.escape(sourceUrl)}</dc:source>`);
+        }
+        if (licenseUrl) {
+            fields.push(`<dcterms:license xsi:type="dcterms:URI">${Xml.escape(licenseUrl)}</dcterms:license>`);
+        }
+        if (rights) {
+            fields.push(`<dc:rights>${Xml.escape(rights)}</dc:rights>`);
+        }
+        return ('<metadata' +
+            ' xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"' +
+            ' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
+            ' xmlns:dc="http://purl.org/dc/elements/1.1/"' +
+            ' xmlns:dcterms="http://purl.org/dc/terms/">' +
+            `<rdf:RDF><rdf:Description>${fields.join('')}</rdf:Description></rdf:RDF>` +
+            '</metadata>');
+    }
+}

package/lib/Utils/Xml.d.ts

@@ -0,0 +1,4 @@
+export declare class Xml {
+    #private;
+    static escape(value: string): string;
+}

package/lib/Utils/Xml.js

@@ -0,0 +1,20 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _Xml_entities, _Xml_pattern;
+export class Xml {
+    static escape(value) {
+        return value.replace(__classPrivateFieldGet(_a, _a, "f", _Xml_pattern), (ch) => __classPrivateFieldGet(_a, _a, "f", _Xml_entities)[ch]);
+    }
+}
+_a = Xml;
+_Xml_entities = { value: {
+        '&': '&',
+        "'": ''',
+        '"': '"',
+        '<': '&lt;',
+        '>': '&gt;',
+    } };
+_Xml_pattern = { value: new RegExp(`[${Object.keys(__classPrivateFieldGet(_a, _a, "f", _Xml_entities)).join('')}]`, 'g') };

package/lib/Validator/OptionsValidator.d.ts

@@ -0,0 +1,3 @@
+export class OptionsValidator {
+    static validate(data: any): void;
+}