@dicebear/core 9.4.1 → 10.0.0-rc.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Florian Körner
+Copyright (c) 2026 Florian Körner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -24,3 +24,15 @@ Playground, your next avatar is always just a stone's throw away!
 
 [Playground](https://www.dicebear.com/playground) |
 [Documentation](https://www.dicebear.com/introduction)
+
+## Sponsors
+
+Advertisement: Many thanks to our sponsors who provide us with free or discounted products.
+
+<a href="https://bunny.net/" target="_blank" rel="noopener noreferrer">
+    <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="https://www.dicebear.com/sponsors/bunny-light.svg">
+        <source media="(prefers-color-scheme: light)" srcset="https://www.dicebear.com/sponsors/bunny-dark.svg">
+        <img alt="bunny.net" src="https://www.dicebear.com/sponsors/bunny-dark.svg" height="64">
+    </picture>
+</a>

package/lib/Avatar.d.ts

@@ -0,0 +1,15 @@
+import { Style } from './Style.js';
+import type { StyleOptions } from './StyleOptions.js';
+type UnwrapStyle<D> = D extends Style<infer S> ? S : D;
+interface AvatarJson<D = unknown> {
+    readonly svg: string;
+    readonly options: StyleOptions<UnwrapStyle<D>>;
+}
+export declare class Avatar<D = unknown> {
+    #private;
+    constructor(style: D, options?: StyleOptions<UnwrapStyle<D>>);
+    toString(): string;
+    toJSON(): AvatarJson<D>;
+    toDataUri(): string;
+}
+export {};

package/lib/Avatar.js

@@ -0,0 +1,38 @@
+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 _Avatar_svg, _Avatar_resolvedOptions;
+import { Style } from './Style.js';
+import { Options } from './Options.js';
+import { Renderer } from './Renderer.js';
+export class Avatar {
+    constructor(style, options) {
+        _Avatar_svg.set(this, void 0);
+        _Avatar_resolvedOptions.set(this, void 0);
+        const resolvedStyle = style instanceof Style ? style : new Style(style);
+        const resolvedOptions = new Options(resolvedStyle, options ?? {});
+        __classPrivateFieldSet(this, _Avatar_svg, new Renderer(resolvedStyle, resolvedOptions).render(), "f");
+        __classPrivateFieldSet(this, _Avatar_resolvedOptions, resolvedOptions.resolved(), "f");
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _Avatar_svg, "f");
+    }
+    toJSON() {
+        return {
+            svg: __classPrivateFieldGet(this, _Avatar_svg, "f"),
+            options: structuredClone(__classPrivateFieldGet(this, _Avatar_resolvedOptions, "f")),
+        };
+    }
+    toDataUri() {
+        return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(__classPrivateFieldGet(this, _Avatar_svg, "f"))}`;
+    }
+}
+_Avatar_svg = new WeakMap(), _Avatar_resolvedOptions = new WeakMap();

package/lib/Error/CircularColorReferenceError.d.ts

@@ -0,0 +1,4 @@
+export declare class CircularColorReferenceError extends Error {
+    readonly chain: readonly string[];
+    constructor(chain: readonly string[]);
+}

package/lib/Error/CircularColorReferenceError.js

@@ -0,0 +1,8 @@
+export class CircularColorReferenceError extends Error {
+    constructor(chain) {
+        const path = chain.join(' → ');
+        super(`Circular color reference: ${path}`);
+        this.name = 'CircularColorReferenceError';
+        this.chain = chain;
+    }
+}

package/lib/Error/OptionsValidationError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from './ValidationError.js';
+import type { ValidationErrorDetail } from './ValidationError.js';
+export declare class OptionsValidationError extends ValidationError {
+    constructor(details: readonly ValidationErrorDetail[]);
+}

package/lib/Error/OptionsValidationError.js

@@ -0,0 +1,7 @@
+import { ValidationError } from './ValidationError.js';
+export class OptionsValidationError extends ValidationError {
+    constructor(details) {
+        super('Invalid options', details);
+        this.name = 'OptionsValidationError';
+    }
+}

package/lib/Error/StyleValidationError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from './ValidationError.js';
+import type { ValidationErrorDetail } from './ValidationError.js';
+export declare class StyleValidationError extends ValidationError {
+    constructor(details: readonly ValidationErrorDetail[]);
+}

package/lib/Error/StyleValidationError.js

@@ -0,0 +1,7 @@
+import { ValidationError } from './ValidationError.js';
+export class StyleValidationError extends ValidationError {
+    constructor(details) {
+        super('Invalid style definition', details);
+        this.name = 'StyleValidationError';
+    }
+}

package/lib/Error/ValidationError.d.ts

@@ -0,0 +1,8 @@
+export interface ValidationErrorDetail {
+    readonly message?: string;
+    readonly instancePath?: string;
+}
+export declare class ValidationError extends Error {
+    readonly details: readonly ValidationErrorDetail[];
+    constructor(prefix: string, details: readonly ValidationErrorDetail[]);
+}

package/lib/Error/ValidationError.js

@@ -0,0 +1,18 @@
+export class ValidationError extends Error {
+    constructor(prefix, details) {
+        const parts = [];
+        for (const detail of details) {
+            const segments = [];
+            if (detail.instancePath) {
+                segments.push(detail.instancePath);
+            }
+            if (detail.message) {
+                segments.push(detail.message);
+            }
+            parts.push(segments.join(' '));
+        }
+        super(`${prefix}: ${parts.join(', ')}`);
+        this.name = 'ValidationError';
+        this.details = details;
+    }
+}

package/lib/Options.d.ts

@@ -0,0 +1,23 @@
+import type { Style } from './Style.js';
+import type { StyleOptionsFlipValue, StyleOptionsColorFillValue, StyleOptions } from './StyleOptions.js';
+export declare class Options<D = unknown> {
+    #private;
+    constructor(style: Style<D>, data: StyleOptions<D>);
+    seed(): string;
+    size(): number | undefined;
+    idRandomization(): boolean;
+    title(): string | undefined;
+    flip(): StyleOptionsFlipValue;
+    fontFamily(): string;
+    fontWeight(): number;
+    scale(): number;
+    borderRadius(): number;
+    variant(name: string): string | undefined;
+    color(name: string): readonly string[];
+    colorFill(name: string): StyleOptionsColorFillValue;
+    colorAngle(name: string): number;
+    rotate(name?: string): number;
+    translateX(name?: string): number;
+    translateY(name?: string): number;
+    resolved(): StyleOptions<D>;
+}

package/lib/Options.js

@@ -0,0 +1,217 @@
+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 _Options_instances, _Options_data, _Options_style, _Options_prng, _Options_colorResolving, _Options_result, _Options_numericComponentOption, _Options_probability, _Options_isVisible, _Options_colorFillStops, _Options_resolveColor, _Options_get, _Options_memo, _Options_toArray;
+import { OptionsValidator } from './Validator/OptionsValidator.js';
+import { Prng } from './Prng.js';
+import { Color } from './Utils/Color.js';
+import { CircularColorReferenceError } from './Error/CircularColorReferenceError.js';
+export class Options {
+    constructor(style, data) {
+        _Options_instances.add(this);
+        _Options_data.set(this, void 0);
+        _Options_style.set(this, void 0);
+        _Options_prng.set(this, void 0);
+        _Options_colorResolving.set(this, []);
+        _Options_result.set(this, {});
+        OptionsValidator.validate(data);
+        __classPrivateFieldSet(this, _Options_data, structuredClone(data), "f");
+        __classPrivateFieldSet(this, _Options_style, style, "f");
+        __classPrivateFieldSet(this, _Options_prng, new Prng(this.seed()), "f");
+    }
+    seed() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'seed', () => __classPrivateFieldGet(this, _Options_data, "f").seed ?? '');
+    }
+    size() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'size', () => __classPrivateFieldGet(this, _Options_data, "f").size);
+    }
+    idRandomization() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'idRandomization', () => __classPrivateFieldGet(this, _Options_data, "f").idRandomization ?? false);
+    }
+    title() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'title', () => __classPrivateFieldGet(this, _Options_data, "f").title);
+    }
+    flip() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'flip', () => __classPrivateFieldGet(this, _Options_prng, "f").pick('flip', __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, __classPrivateFieldGet(this, _Options_data, "f").flip)) ?? 'none');
+    }
+    fontFamily() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'fontFamily', () => __classPrivateFieldGet(this, _Options_prng, "f").pick('fontFamily', __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, __classPrivateFieldGet(this, _Options_data, "f").fontFamily)) ??
+            'system-ui');
+    }
+    fontWeight() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'fontWeight', () => __classPrivateFieldGet(this, _Options_prng, "f").pick('fontWeight', __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, __classPrivateFieldGet(this, _Options_data, "f").fontWeight)) ??
+            400);
+    }
+    scale() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'scale', () => __classPrivateFieldGet(this, _Options_prng, "f").float('scale', __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, __classPrivateFieldGet(this, _Options_data, "f").scale)) ?? 1);
+    }
+    borderRadius() {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, 'borderRadius', () => __classPrivateFieldGet(this, _Options_prng, "f").float('borderRadius', __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, __classPrivateFieldGet(this, _Options_data, "f").borderRadius)) ?? 0);
+    }
+    // Selects a variant for the given component. Depending on what was passed
+    // as `${name}Variant` in the input data:
+    // - undefined: PRNG picks from all style variants using their weights
+    // - string or string[]: PRNG picks from the given subset (weight 1 each)
+    // - Record<string, number>: PRNG picks using the provided weights
+    // Only variants that exist in the style definition are considered.
+    variant(name) {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, `${name}Variant`, () => {
+            if (!__classPrivateFieldGet(this, _Options_instances, "m", _Options_isVisible).call(this, name)) {
+                return undefined;
+            }
+            const component = __classPrivateFieldGet(this, _Options_style, "f").components().get(name);
+            if (!component) {
+                return undefined;
+            }
+            const raw = __classPrivateFieldGet(this, _Options_instances, "m", _Options_get).call(this, `${name}Variant`);
+            const variants = component.variants();
+            let entries;
+            if (raw === undefined) {
+                entries = Array.from(variants).map(([v, variant]) => [
+                    v,
+                    variant.weight(),
+                ]);
+            }
+            else if (typeof raw === 'string' || Array.isArray(raw)) {
+                entries = __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, raw)
+                    .filter((v) => variants.has(v))
+                    .map((v) => [v, 1]);
+            }
+            else {
+                entries = Object.entries(raw).filter(([v]) => variants.has(v));
+            }
+            return __classPrivateFieldGet(this, _Options_prng, "f").weightedPick(`${name}Variant`, entries);
+        });
+    }
+    color(name) {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, `${name}Color`, () => __classPrivateFieldGet(this, _Options_instances, "m", _Options_resolveColor).call(this, name));
+    }
+    colorFill(name) {
+        const key = `${name}ColorFill`;
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, key, () => {
+            const raw = __classPrivateFieldGet(this, _Options_instances, "m", _Options_get).call(this, key);
+            return __classPrivateFieldGet(this, _Options_prng, "f").pick(key, __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, raw)) ?? 'solid';
+        });
+    }
+    colorAngle(name) {
+        const key = `${name}ColorAngle`;
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, key, () => {
+            const raw = __classPrivateFieldGet(this, _Options_instances, "m", _Options_get).call(this, key);
+            return __classPrivateFieldGet(this, _Options_prng, "f").float(key, __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, raw)) ?? 0;
+        });
+    }
+    rotate(name) {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_numericComponentOption).call(this, 'rotate', name, (c) => c.rotate());
+    }
+    translateX(name) {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_numericComponentOption).call(this, 'translateX', name, (c) => c.translate().x());
+    }
+    translateY(name) {
+        return __classPrivateFieldGet(this, _Options_instances, "m", _Options_numericComponentOption).call(this, 'translateY', name, (c) => c.translate().y());
+    }
+    resolved() {
+        return structuredClone(__classPrivateFieldGet(this, _Options_result, "f"));
+    }
+}
+_Options_data = new WeakMap(), _Options_style = new WeakMap(), _Options_prng = new WeakMap(), _Options_colorResolving = new WeakMap(), _Options_result = new WeakMap(), _Options_instances = new WeakSet(), _Options_numericComponentOption = function _Options_numericComponentOption(option, name, componentDefault) {
+    const key = name
+        ? `${name}${option.charAt(0).toUpperCase()}${option.slice(1)}`
+        : option;
+    return __classPrivateFieldGet(this, _Options_instances, "m", _Options_memo).call(this, key, () => {
+        const raw = __classPrivateFieldGet(this, _Options_instances, "m", _Options_get).call(this, key);
+        let values;
+        if (raw === undefined && name) {
+            const component = __classPrivateFieldGet(this, _Options_style, "f").components().get(name);
+            values = component ? componentDefault(component) : [];
+        }
+        else {
+            values = __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, raw);
+        }
+        return __classPrivateFieldGet(this, _Options_prng, "f").float(key, values) ?? 0;
+    });
+}, _Options_probability = function _Options_probability(name) {
+    const raw = __classPrivateFieldGet(this, _Options_instances, "m", _Options_get).call(this, `${name}Probability`);
+    if (raw !== undefined) {
+        return raw;
+    }
+    return __classPrivateFieldGet(this, _Options_style, "f").components().get(name)?.probability() ?? 100;
+}, _Options_isVisible = function _Options_isVisible(name) {
+    return __classPrivateFieldGet(this, _Options_prng, "f").bool(`${name}Probability`, __classPrivateFieldGet(this, _Options_instances, "m", _Options_probability).call(this, name));
+}, _Options_colorFillStops = function _Options_colorFillStops(name) {
+    const raw = __classPrivateFieldGet(this, _Options_instances, "m", _Options_get).call(this, `${name}ColorFillStops`);
+    const values = __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, raw);
+    return __classPrivateFieldGet(this, _Options_prng, "f").integer(`${name}ColorFillStops`, values) ?? 2;
+}, _Options_resolveColor = function _Options_resolveColor(name) {
+    const raw = __classPrivateFieldGet(this, _Options_instances, "m", _Options_get).call(this, `${name}Color`);
+    const styleColor = __classPrivateFieldGet(this, _Options_style, "f").colors().get(name);
+    let source;
+    if (raw === undefined) {
+        source = styleColor ? styleColor.values() : [];
+    }
+    else {
+        source = __classPrivateFieldGet(this, _Options_instances, "m", _Options_toArray).call(this, raw);
+    }
+    let candidates = source.map((c) => Color.toHex(c));
+    const fill = this.colorFill(name);
+    const stops = fill === 'solid' ? 1 : __classPrivateFieldGet(this, _Options_instances, "m", _Options_colorFillStops).call(this, name);
+    if (!styleColor) {
+        return __classPrivateFieldGet(this, _Options_prng, "f").shuffle(`${name}Color`, candidates).slice(0, stops);
+    }
+    // Detect circular references (e.g. a.contrastTo = b, b.contrastTo = a)
+    if (__classPrivateFieldGet(this, _Options_colorResolving, "f").includes(name)) {
+        throw new CircularColorReferenceError(__classPrivateFieldGet(this, _Options_colorResolving, "f").concat(name));
+    }
+    __classPrivateFieldGet(this, _Options_colorResolving, "f").push(name);
+    const contrastTo = styleColor.contrastTo();
+    const notEqualTo = styleColor.notEqualTo();
+    try {
+        if (contrastTo) {
+            const refColor = this.color(contrastTo)[0];
+            if (refColor) {
+                candidates = Color.sortByContrast(candidates, refColor);
+            }
+        }
+        if (notEqualTo.length > 0) {
+            const excluded = [];
+            for (const ref of notEqualTo) {
+                for (const color of this.color(ref)) {
+                    excluded.push(color);
+                }
+            }
+            candidates = Color.filterNotEqualTo(candidates, excluded);
+        }
+    }
+    finally {
+        __classPrivateFieldGet(this, _Options_colorResolving, "f").pop();
+    }
+    // Skip shuffle when sorted by contrast to preserve the ordering
+    const ordered = contrastTo
+        ? candidates
+        : __classPrivateFieldGet(this, _Options_prng, "f").shuffle(`${name}Color`, candidates);
+    return ordered.slice(0, stops);
+}, _Options_get = function _Options_get(key) {
+    return __classPrivateFieldGet(this, _Options_data, "f")[key];
+}, _Options_memo = function _Options_memo(key, compute) {
+    if (key in __classPrivateFieldGet(this, _Options_result, "f")) {
+        return __classPrivateFieldGet(this, _Options_result, "f")[key];
+    }
+    const value = compute();
+    __classPrivateFieldGet(this, _Options_result, "f")[key] = value;
+    return value;
+}, _Options_toArray = function _Options_toArray(value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [value];
+};

package/lib/OptionsDescriptor.d.ts

@@ -0,0 +1,37 @@
+import type { Style } from './Style.js';
+interface StringField {
+    readonly type: 'string';
+    readonly list?: true;
+}
+interface NumberField {
+    readonly type: 'number';
+    readonly min?: number;
+    readonly max?: number;
+    readonly list?: true;
+}
+interface BooleanField {
+    readonly type: 'boolean';
+}
+interface EnumField {
+    readonly type: 'enum';
+    readonly values: readonly string[];
+    readonly list?: true;
+    readonly weighted?: true;
+}
+interface ColorField {
+    readonly type: 'color';
+    readonly list?: true;
+}
+interface RangeField {
+    readonly type: 'range';
+    readonly min?: number;
+    readonly max?: number;
+}
+export type FieldDescriptor = StringField | NumberField | BooleanField | EnumField | ColorField | RangeField;
+export type Descriptor = Record<string, FieldDescriptor>;
+export declare class OptionsDescriptor {
+    #private;
+    constructor(style: Style);
+    toJSON(): Descriptor;
+}
+export {};

package/lib/OptionsDescriptor.js

@@ -0,0 +1,70 @@
+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 _OptionsDescriptor_instances, _a, _OptionsDescriptor_rotateRange, _OptionsDescriptor_translateRange, _OptionsDescriptor_descriptor, _OptionsDescriptor_style, _OptionsDescriptor_build;
+export class OptionsDescriptor {
+    constructor(style) {
+        _OptionsDescriptor_instances.add(this);
+        _OptionsDescriptor_descriptor.set(this, void 0);
+        _OptionsDescriptor_style.set(this, void 0);
+        __classPrivateFieldSet(this, _OptionsDescriptor_style, style, "f");
+    }
+    toJSON() {
+        __classPrivateFieldSet(this, _OptionsDescriptor_descriptor, __classPrivateFieldGet(this, _OptionsDescriptor_descriptor, "f") ?? __classPrivateFieldGet(this, _OptionsDescriptor_instances, "m", _OptionsDescriptor_build).call(this), "f");
+        return structuredClone(__classPrivateFieldGet(this, _OptionsDescriptor_descriptor, "f"));
+    }
+}
+_a = OptionsDescriptor, _OptionsDescriptor_descriptor = new WeakMap(), _OptionsDescriptor_style = new WeakMap(), _OptionsDescriptor_instances = new WeakSet(), _OptionsDescriptor_build = function _OptionsDescriptor_build() {
+    const result = {
+        seed: { type: 'string' },
+        size: { type: 'number', min: 1 },
+        idRandomization: { type: 'boolean' },
+        title: { type: 'string' },
+        flip: {
+            type: 'enum',
+            values: ['none', 'horizontal', 'vertical', 'both'],
+            list: true,
+        },
+        fontFamily: { type: 'string', list: true },
+        fontWeight: { type: 'number', min: 1, max: 1000, list: true },
+        scale: { type: 'range', min: 0 },
+        borderRadius: { type: 'range', min: 0, max: 50 },
+        rotate: __classPrivateFieldGet(_a, _a, "f", _OptionsDescriptor_rotateRange),
+        translateX: __classPrivateFieldGet(_a, _a, "f", _OptionsDescriptor_translateRange),
+        translateY: __classPrivateFieldGet(_a, _a, "f", _OptionsDescriptor_translateRange),
+    };
+    for (const [name, component] of __classPrivateFieldGet(this, _OptionsDescriptor_style, "f").components()) {
+        const variants = Array.from(component.variants().keys()).sort();
+        result[`${name}Variant`] = {
+            type: 'enum',
+            values: variants,
+            list: true,
+            weighted: true,
+        };
+        result[`${name}Probability`] = { type: 'number', min: 0, max: 100 };
+        result[`${name}Rotate`] = __classPrivateFieldGet(_a, _a, "f", _OptionsDescriptor_rotateRange);
+        result[`${name}TranslateX`] = __classPrivateFieldGet(_a, _a, "f", _OptionsDescriptor_translateRange);
+        result[`${name}TranslateY`] = __classPrivateFieldGet(_a, _a, "f", _OptionsDescriptor_translateRange);
+    }
+    for (const name of [...__classPrivateFieldGet(this, _OptionsDescriptor_style, "f").colors().keys(), 'background']) {
+        result[`${name}Color`] = { type: 'color', list: true };
+        result[`${name}ColorFill`] = {
+            type: 'enum',
+            values: ['solid', 'linear', 'radial'],
+            list: true,
+        };
+        result[`${name}ColorFillStops`] = { type: 'range', min: 2 };
+        result[`${name}ColorAngle`] = __classPrivateFieldGet(_a, _a, "f", _OptionsDescriptor_rotateRange);
+    }
+    return result;
+};
+_OptionsDescriptor_rotateRange = { value: { type: 'range', min: -360, max: 360 } };
+_OptionsDescriptor_translateRange = { value: { type: 'range', min: -100, max: 100 } };

package/lib/Prng/Fnv1a.d.ts

@@ -0,0 +1,4 @@
+export declare class Fnv1a {
+    static hash(input: string): number;
+    static hex(input: string): string;
+}

package/lib/Prng/Fnv1a.js

@@ -0,0 +1,16 @@
+// FNV-1a 32-bit hash.
+// Offset basis: 0x811c9dc5, prime: 0x01000193.
+// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+export class Fnv1a {
+    static hash(input) {
+        let hash = 0x811c9dc5;
+        for (let i = 0; i < input.length; i++) {
+            hash ^= input.charCodeAt(i);
+            hash = Math.imul(hash, 0x01000193);
+        }
+        return hash >>> 0;
+    }
+    static hex(input) {
+        return Fnv1a.hash(input).toString(16).padStart(8, '0');
+    }
+}

package/lib/Prng/Mulberry32.d.ts

@@ -0,0 +1,7 @@
+export declare class Mulberry32 {
+    #private;
+    constructor(seed: number);
+    next(): number;
+    nextFloat(): number;
+    state(): number;
+}

package/lib/Prng/Mulberry32.js

@@ -0,0 +1,40 @@
+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 _Mulberry32_state;
+// Mulberry32 PRNG — stateful, matching the C reference by Tommy Ettinger.
+// https://gist.github.com/tommyettinger/46a874533244883189143505d203312c
+//
+// C original:
+//   uint32_t z = (x += 0x6D2B79F5UL);
+//   z = (z ^ (z >> 15)) * (z | 1UL);
+//   z ^= z + (z ^ (z >> 7)) * (z | 61UL);
+//   return z ^ (z >> 14);
+const UINT32_MAX_PLUS_1 = 2 ** 32;
+export class Mulberry32 {
+    constructor(seed) {
+        _Mulberry32_state.set(this, void 0);
+        __classPrivateFieldSet(this, _Mulberry32_state, seed, "f");
+    }
+    next() {
+        const z = (__classPrivateFieldSet(this, _Mulberry32_state, (__classPrivateFieldGet(this, _Mulberry32_state, "f") + 0x6d2b79f5) | 0, "f"));
+        let t = Math.imul(z ^ (z >>> 15), z | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0);
+    }
+    nextFloat() {
+        return this.next() / UINT32_MAX_PLUS_1;
+    }
+    state() {
+        return __classPrivateFieldGet(this, _Mulberry32_state, "f");
+    }
+}
+_Mulberry32_state = new WeakMap();

package/lib/Prng.d.ts

@@ -0,0 +1,11 @@
+export declare class Prng {
+    #private;
+    constructor(seed: string);
+    pick<T>(key: string, items: readonly T[]): T | undefined;
+    weightedPick<T>(key: string, entries: readonly (readonly [T, number])[]): T | undefined;
+    bool(key: string, likelihood?: number): boolean;
+    float(key: string, values: readonly number[]): number | undefined;
+    integer(key: string, values: readonly number[]): number | undefined;
+    shuffle<T>(key: string, items: readonly T[]): T[];
+    getValue(key: string): number;
+}