@dicebear/core 9.4.1 → 10.0.0-rc.1

package/lib/Prng.js

@@ -0,0 +1,101 @@
+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 _Prng_instances, _Prng_seed, _Prng_compareByCodePoint;
+import { Fnv1a } from './Prng/Fnv1a.js';
+import { Mulberry32 } from './Prng/Mulberry32.js';
+// Key-based pseudorandom number generator.
+//
+// Each method takes a key that, combined with the seed, produces a
+// deterministic value. The same seed + key always yields the same result,
+// regardless of call order.
+export class Prng {
+    constructor(seed) {
+        _Prng_instances.add(this);
+        _Prng_seed.set(this, void 0);
+        __classPrivateFieldSet(this, _Prng_seed, seed, "f");
+    }
+    pick(key, items) {
+        if (items.length === 0) {
+            return undefined;
+        }
+        if (items.length === 1) {
+            return items[0];
+        }
+        const sorted = Array.from(items).sort(__classPrivateFieldGet(this, _Prng_instances, "m", _Prng_compareByCodePoint));
+        const index = Math.floor(this.getValue(key) * sorted.length);
+        return sorted[index];
+    }
+    weightedPick(key, entries) {
+        if (entries.length === 0) {
+            return undefined;
+        }
+        const sorted = Array.from(entries).sort((a, b) => __classPrivateFieldGet(this, _Prng_instances, "m", _Prng_compareByCodePoint).call(this, a[0], b[0]));
+        const totalWeight = sorted.reduce((sum, e) => sum + e[1], 0);
+        if (totalWeight === 0) {
+            return this.pick(key, sorted.map((e) => e[0]));
+        }
+        const threshold = this.getValue(key) * totalWeight;
+        let cumulative = 0;
+        for (const [item, weight] of sorted) {
+            cumulative += weight;
+            if (threshold < cumulative) {
+                return item;
+            }
+        }
+        return sorted[sorted.length - 1][0];
+    }
+    bool(key, likelihood = 50) {
+        return this.getValue(key) * 100 < likelihood;
+    }
+    float(key, values) {
+        if (values.length === 0) {
+            return undefined;
+        }
+        const min = Math.min(...values);
+        const max = Math.max(...values);
+        return Math.round((min + this.getValue(key) * (max - min)) * 10000) / 10000;
+    }
+    integer(key, values) {
+        if (values.length === 0) {
+            return undefined;
+        }
+        const min = Math.min(...values);
+        const max = Math.max(...values);
+        return Math.floor(this.getValue(key) * (max - min + 1)) + min;
+    }
+    // Fisher-Yates shuffle with chained Mulberry32 state.
+    shuffle(key, items) {
+        const result = Array.from(items).sort(__classPrivateFieldGet(this, _Prng_instances, "m", _Prng_compareByCodePoint));
+        const prng = new Mulberry32(Fnv1a.hash(__classPrivateFieldGet(this, _Prng_seed, "f") + ':' + key));
+        for (let i = result.length - 1; i > 0; i--) {
+            const j = Math.floor(prng.nextFloat() * (i + 1));
+            const temp = result[i];
+            result[i] = result[j];
+            result[j] = temp;
+        }
+        return result;
+    }
+    getValue(key) {
+        return new Mulberry32(Fnv1a.hash(__classPrivateFieldGet(this, _Prng_seed, "f") + ':' + key)).nextFloat();
+    }
+}
+_Prng_seed = new WeakMap(), _Prng_instances = new WeakSet(), _Prng_compareByCodePoint = function _Prng_compareByCodePoint(a, b) {
+    const sa = String(a);
+    const sb = String(b);
+    if (sa < sb) {
+        return -1;
+    }
+    if (sa > sb) {
+        return 1;
+    }
+    return 0;
+};

package/lib/Renderer.d.ts

@@ -0,0 +1,7 @@
+import type { Style } from './Style.js';
+import type { Options } from './Options.js';
+export declare class Renderer {
+    #private;
+    constructor(style: Style, options: Options);
+    render(): string;
+}

package/lib/Renderer.js

@@ -0,0 +1,293 @@
+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 _Renderer_instances, _Renderer_style, _Renderer_options, _Renderer_defs, _Renderer_cachedSeedHash, _Renderer_cachedInitials, _Renderer_applyFlip, _Renderer_applyScale, _Renderer_applyBorderRadius, _Renderer_applyRotate, _Renderer_applyTranslate, _Renderer_renderBackground, _Renderer_randomizeIds, _Renderer_renderElements, _Renderer_renderElement, _Renderer_renderSvgElement, _Renderer_renderTextElement, _Renderer_renderComponentElement, _Renderer_buildTransforms, _Renderer_renderAttributes, _Renderer_resolveAttributeValue, _Renderer_resolveColorReference, _Renderer_buildGradientDef, _Renderer_resolveValue, _Renderer_resolveVariable, _Renderer_initials, _Renderer_hashSeed;
+import { Fnv1a } from './Prng/Fnv1a.js';
+import { Initials } from './Utils/Initials.js';
+import { License } from './Utils/License.js';
+import { Xml } from './Utils/Xml.js';
+export class Renderer {
+    constructor(style, options) {
+        _Renderer_instances.add(this);
+        _Renderer_style.set(this, void 0);
+        _Renderer_options.set(this, void 0);
+        _Renderer_defs.set(this, new Map());
+        _Renderer_cachedSeedHash.set(this, void 0);
+        _Renderer_cachedInitials.set(this, void 0);
+        __classPrivateFieldSet(this, _Renderer_style, style, "f");
+        __classPrivateFieldSet(this, _Renderer_options, options, "f");
+    }
+    render() {
+        const canvas = __classPrivateFieldGet(this, _Renderer_style, "f").canvas();
+        const background = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderBackground).call(this, canvas);
+        let body = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderElements).call(this, canvas.elements());
+        // Order matters: scale and flip around center, then rotate, translate,
+        // and finally clip with border radius (outermost wrapper).
+        body = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_applyScale).call(this, body, canvas);
+        body = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_applyFlip).call(this, body, canvas);
+        body = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_applyRotate).call(this, body, canvas);
+        body = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_applyTranslate).call(this, body, canvas);
+        body = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_applyBorderRadius).call(this, `${background}${body}`, canvas);
+        const metadata = License.xml(__classPrivateFieldGet(this, _Renderer_style, "f").meta());
+        const defs = __classPrivateFieldGet(this, _Renderer_defs, "f").size > 0
+            ? `<defs>${Array.from(__classPrivateFieldGet(this, _Renderer_defs, "f").values()).join('')}</defs>`
+            : '';
+        const size = __classPrivateFieldGet(this, _Renderer_options, "f").size();
+        const title = __classPrivateFieldGet(this, _Renderer_options, "f").title();
+        const escapedTitle = title !== undefined ? Xml.escape(title) : undefined;
+        const attrs = [
+            'xmlns="http://www.w3.org/2000/svg"',
+            `viewBox="0 0 ${canvas.width()} ${canvas.height()}"`,
+        ];
+        const rootAttributes = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderAttributes).call(this, __classPrivateFieldGet(this, _Renderer_style, "f").attributes());
+        if (rootAttributes) {
+            attrs.push(rootAttributes.trimStart());
+        }
+        if (escapedTitle !== undefined) {
+            attrs.push('role="img"', `aria-label="${escapedTitle}"`);
+        }
+        else {
+            attrs.push('aria-hidden="true"');
+        }
+        if (size !== undefined) {
+            attrs.push(`width="${size}"`, `height="${size}"`);
+        }
+        const titleElement = escapedTitle !== undefined ? `<title>${escapedTitle}</title>` : '';
+        let svg = `<svg ${attrs.join(' ')}>${metadata}${defs}${titleElement}${body}</svg>`;
+        if (__classPrivateFieldGet(this, _Renderer_options, "f").idRandomization()) {
+            svg = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_randomizeIds).call(this, svg);
+        }
+        return svg;
+    }
+}
+_Renderer_style = new WeakMap(), _Renderer_options = new WeakMap(), _Renderer_defs = new WeakMap(), _Renderer_cachedSeedHash = new WeakMap(), _Renderer_cachedInitials = new WeakMap(), _Renderer_instances = new WeakSet(), _Renderer_applyFlip = function _Renderer_applyFlip(body, canvas) {
+    const flip = __classPrivateFieldGet(this, _Renderer_options, "f").flip();
+    if (flip === 'none') {
+        return body;
+    }
+    const w = canvas.width();
+    const h = canvas.height();
+    let transform;
+    switch (flip) {
+        case 'horizontal':
+            transform = `translate(${w}, 0) scale(-1, 1)`;
+            break;
+        case 'vertical':
+            transform = `translate(0, ${h}) scale(1, -1)`;
+            break;
+        case 'both':
+            transform = `translate(${w}, ${h}) scale(-1, -1)`;
+            break;
+    }
+    return `<g transform="${transform}">${body}</g>`;
+}, _Renderer_applyScale = function _Renderer_applyScale(body, canvas) {
+    const scale = __classPrivateFieldGet(this, _Renderer_options, "f").scale();
+    if (scale === 1) {
+        return body;
+    }
+    const cx = canvas.width() / 2;
+    const cy = canvas.height() / 2;
+    return `<g transform="translate(${cx}, ${cy}) scale(${scale}) translate(${-cx}, ${-cy})">${body}</g>`;
+}, _Renderer_applyBorderRadius = function _Renderer_applyBorderRadius(body, canvas) {
+    const radius = __classPrivateFieldGet(this, _Renderer_options, "f").borderRadius();
+    if (radius === 0) {
+        return body;
+    }
+    const id = `clip-${__classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_hashSeed).call(this)}`;
+    const rx = (radius / 100) * canvas.width();
+    const ry = (radius / 100) * canvas.height();
+    __classPrivateFieldGet(this, _Renderer_defs, "f").set(id, `<clipPath id="${id}"><rect width="${canvas.width()}" height="${canvas.height()}" rx="${rx}" ry="${ry}"/></clipPath>`);
+    return `<g clip-path="url(#${id})">${body}</g>`;
+}, _Renderer_applyRotate = function _Renderer_applyRotate(body, canvas) {
+    const rotate = __classPrivateFieldGet(this, _Renderer_options, "f").rotate();
+    if (rotate === 0) {
+        return body;
+    }
+    const cx = canvas.width() / 2;
+    const cy = canvas.height() / 2;
+    return `<g transform="rotate(${rotate}, ${cx}, ${cy})">${body}</g>`;
+}, _Renderer_applyTranslate = function _Renderer_applyTranslate(body, canvas) {
+    const tx = __classPrivateFieldGet(this, _Renderer_options, "f").translateX();
+    const ty = __classPrivateFieldGet(this, _Renderer_options, "f").translateY();
+    if (tx === 0 && ty === 0) {
+        return body;
+    }
+    const x = (tx / 100) * canvas.width();
+    const y = (ty / 100) * canvas.height();
+    return `<g transform="translate(${x}, ${y})">${body}</g>`;
+}, _Renderer_renderBackground = function _Renderer_renderBackground(canvas) {
+    const colors = __classPrivateFieldGet(this, _Renderer_options, "f").color('background');
+    if (colors.length === 0) {
+        return '';
+    }
+    return `<rect width="${canvas.width()}" height="${canvas.height()}" fill="${Xml.escape(__classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_resolveColorReference).call(this, 'background'))}"/>`;
+}, _Renderer_randomizeIds = function _Renderer_randomizeIds(svg) {
+    // Uses Math.random() intentionally — a PRNG-based suffix would
+    // produce the same ID for the same seed, preventing two identical
+    // avatars from coexisting in the same document.
+    const suffix = Math.floor(Math.random() * 0xffffff)
+        .toString(16)
+        .padStart(6, '0');
+    const ids = new Set();
+    for (const match of svg.matchAll(/\bid="([^"]+)"/g)) {
+        ids.add(match[1]);
+    }
+    if (ids.size === 0) {
+        return svg;
+    }
+    const escaped = Array.from(ids, (id) => id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const pattern = new RegExp(`(id="|url\\(#|href="#)(${escaped.join('|')})("|\\))`, 'g');
+    return svg.replace(pattern, (_, prefix, id, end) => `${prefix}${id}-${suffix}${end}`);
+}, _Renderer_renderElements = function _Renderer_renderElements(elements) {
+    return elements.map((el) => __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderElement).call(this, el)).join('');
+}, _Renderer_renderElement = function _Renderer_renderElement(element) {
+    switch (element.type()) {
+        case 'element':
+            return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderSvgElement).call(this, element);
+        case 'text':
+            return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderTextElement).call(this, element);
+        case 'component':
+            return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderComponentElement).call(this, element);
+    }
+}, _Renderer_renderSvgElement = function _Renderer_renderSvgElement(element) {
+    const name = element.name();
+    if (!name) {
+        return '';
+    }
+    if (name === 'defs') {
+        for (const child of element.children()) {
+            const rendered = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderElement).call(this, child);
+            if (rendered.length > 0) {
+                const id = child.attributes()?.id;
+                const key = typeof id === 'string' ? id : `_${__classPrivateFieldGet(this, _Renderer_defs, "f").size}`;
+                __classPrivateFieldGet(this, _Renderer_defs, "f").set(key, rendered);
+            }
+        }
+        return '';
+    }
+    const attrs = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderAttributes).call(this, element.attributes());
+    const children = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderElements).call(this, element.children());
+    if (children.length === 0) {
+        return `<${name}${attrs}/>`;
+    }
+    return `<${name}${attrs}>${children}</${name}>`;
+}, _Renderer_renderTextElement = function _Renderer_renderTextElement(element) {
+    const value = element.value();
+    return value !== undefined ? Xml.escape(__classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_resolveValue).call(this, value)) : '';
+}, _Renderer_renderComponentElement = function _Renderer_renderComponentElement(element) {
+    const value = element.value();
+    if (typeof value !== 'string') {
+        return '';
+    }
+    const variantName = __classPrivateFieldGet(this, _Renderer_options, "f").variant(value);
+    if (!variantName) {
+        return '';
+    }
+    const component = __classPrivateFieldGet(this, _Renderer_style, "f").components().get(value);
+    if (!component) {
+        return '';
+    }
+    const variant = component.variants().get(variantName);
+    if (!variant) {
+        return '';
+    }
+    const body = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_renderElements).call(this, variant.elements());
+    const transforms = __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_buildTransforms).call(this, value);
+    if (transforms.length === 0) {
+        return body;
+    }
+    return `<g transform="${transforms.join(' ')}">${body}</g>`;
+}, _Renderer_buildTransforms = function _Renderer_buildTransforms(componentName) {
+    const transforms = [];
+    const translateX = __classPrivateFieldGet(this, _Renderer_options, "f").translateX(componentName);
+    const translateY = __classPrivateFieldGet(this, _Renderer_options, "f").translateY(componentName);
+    const rotate = __classPrivateFieldGet(this, _Renderer_options, "f").rotate(componentName);
+    if (translateX !== 0 || translateY !== 0) {
+        transforms.push(`translate(${translateX}, ${translateY})`);
+    }
+    if (rotate !== 0) {
+        const component = __classPrivateFieldGet(this, _Renderer_style, "f").components().get(componentName);
+        if (!component) {
+            return transforms;
+        }
+        const cx = component.width() / 2;
+        const cy = component.height() / 2;
+        transforms.push(`rotate(${rotate}, ${cx}, ${cy})`);
+    }
+    return transforms;
+}, _Renderer_renderAttributes = function _Renderer_renderAttributes(attributes) {
+    if (!attributes) {
+        return '';
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(attributes)) {
+        if (value === undefined) {
+            continue;
+        }
+        parts.push(`${key}="${Xml.escape(__classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_resolveAttributeValue).call(this, value))}"`);
+    }
+    if (parts.length === 0) {
+        return '';
+    }
+    return ` ${parts.join(' ')}`;
+}, _Renderer_resolveAttributeValue = function _Renderer_resolveAttributeValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value.type === 'color') {
+        return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_resolveColorReference).call(this, value.value);
+    }
+    return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_resolveVariable).call(this, value.value);
+}, _Renderer_resolveColorReference = function _Renderer_resolveColorReference(name) {
+    const colors = __classPrivateFieldGet(this, _Renderer_options, "f").color(name);
+    const fill = __classPrivateFieldGet(this, _Renderer_options, "f").colorFill(name);
+    if (fill === 'solid' || colors.length <= 1) {
+        return colors[0] ?? 'none';
+    }
+    return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_buildGradientDef).call(this, name, colors);
+}, _Renderer_buildGradientDef = function _Renderer_buildGradientDef(name, colors) {
+    const fill = __classPrivateFieldGet(this, _Renderer_options, "f").colorFill(name);
+    const rotation = __classPrivateFieldGet(this, _Renderer_options, "f").colorAngle(name);
+    const id = `${name}-color-${__classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_hashSeed).call(this)}`;
+    const tag = fill === 'linear' ? 'linearGradient' : 'radialGradient';
+    const rotateAttr = rotation !== 0
+        ? ` gradientTransform="rotate(${rotation}, 0.5, 0.5)"`
+        : '';
+    const stops = colors.map((color, i) => {
+        const offset = Math.round((i / (colors.length - 1)) * 100);
+        return `<stop offset="${offset}%" stop-color="${Xml.escape(color)}"/>`;
+    });
+    __classPrivateFieldGet(this, _Renderer_defs, "f").set(id, `<${tag} id="${id}"${rotateAttr}>${stops.join('')}</${tag}>`);
+    return `url(#${id})`;
+}, _Renderer_resolveValue = function _Renderer_resolveValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value.type === 'variable') {
+        return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_resolveVariable).call(this, value.value);
+    }
+    return '';
+}, _Renderer_resolveVariable = function _Renderer_resolveVariable(name) {
+    switch (name) {
+        case 'initial':
+            return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_initials).call(this).charAt(0);
+        case 'initials':
+            return __classPrivateFieldGet(this, _Renderer_instances, "m", _Renderer_initials).call(this);
+        case 'fontWeight':
+            return String(__classPrivateFieldGet(this, _Renderer_options, "f").fontWeight());
+        case 'fontFamily':
+            return __classPrivateFieldGet(this, _Renderer_options, "f").fontFamily();
+    }
+}, _Renderer_initials = function _Renderer_initials() {
+    return (__classPrivateFieldSet(this, _Renderer_cachedInitials, __classPrivateFieldGet(this, _Renderer_cachedInitials, "f") ?? Initials.fromSeed(__classPrivateFieldGet(this, _Renderer_options, "f").seed()), "f"));
+}, _Renderer_hashSeed = function _Renderer_hashSeed() {
+    return (__classPrivateFieldSet(this, _Renderer_cachedSeedHash, __classPrivateFieldGet(this, _Renderer_cachedSeedHash, "f") ?? Fnv1a.hex(__classPrivateFieldGet(this, _Renderer_options, "f").seed()), "f"));
+};

package/lib/Style/Canvas.d.ts

@@ -0,0 +1,9 @@
+import type { StyleDefinitionCanvas } from '../StyleDefinition.js';
+import { Element } from './Element.js';
+export declare class Canvas {
+    #private;
+    constructor(data: StyleDefinitionCanvas);
+    width(): number;
+    height(): number;
+    elements(): readonly Element[];
+}

package/lib/Style/Canvas.js

@@ -0,0 +1,31 @@
+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 _Canvas_data, _Canvas_elements;
+import { Element } from './Element.js';
+export class Canvas {
+    constructor(data) {
+        _Canvas_data.set(this, void 0);
+        _Canvas_elements.set(this, void 0);
+        __classPrivateFieldSet(this, _Canvas_data, data, "f");
+    }
+    width() {
+        return __classPrivateFieldGet(this, _Canvas_data, "f").width;
+    }
+    height() {
+        return __classPrivateFieldGet(this, _Canvas_data, "f").height;
+    }
+    elements() {
+        __classPrivateFieldSet(this, _Canvas_elements, __classPrivateFieldGet(this, _Canvas_elements, "f") ?? __classPrivateFieldGet(this, _Canvas_data, "f").elements.map((el) => new Element(el)), "f");
+        return __classPrivateFieldGet(this, _Canvas_elements, "f");
+    }
+}
+_Canvas_data = new WeakMap(), _Canvas_elements = new WeakMap();

package/lib/Style/Color.d.ts

@@ -0,0 +1,8 @@
+import type { StyleDefinitionColor } from '../StyleDefinition.js';
+export declare class Color {
+    #private;
+    constructor(data: StyleDefinitionColor);
+    values(): readonly string[];
+    notEqualTo(): readonly string[];
+    contrastTo(): string | undefined;
+}

package/lib/Style/Color.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 _Color_data;
+export class Color {
+    constructor(data) {
+        _Color_data.set(this, void 0);
+        __classPrivateFieldSet(this, _Color_data, data, "f");
+    }
+    values() {
+        return __classPrivateFieldGet(this, _Color_data, "f").values;
+    }
+    notEqualTo() {
+        return __classPrivateFieldGet(this, _Color_data, "f").notEqualTo ?? [];
+    }
+    contrastTo() {
+        return __classPrivateFieldGet(this, _Color_data, "f").contrastTo;
+    }
+}
+_Color_data = new WeakMap();

package/lib/Style/Component.d.ts

@@ -0,0 +1,13 @@
+import type { StyleDefinitionComponent } from '../StyleDefinition.js';
+import { ComponentTranslate } from './ComponentTranslate.js';
+import { ComponentVariant } from './ComponentVariant.js';
+export declare class Component {
+    #private;
+    constructor(data: StyleDefinitionComponent);
+    width(): number;
+    height(): number;
+    probability(): number;
+    rotate(): readonly number[];
+    translate(): ComponentTranslate;
+    variants(): ReadonlyMap<string, ComponentVariant>;
+}

package/lib/Style/Component.js

@@ -0,0 +1,46 @@
+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 _Component_data, _Component_translate, _Component_variants;
+import { ComponentTranslate } from './ComponentTranslate.js';
+import { ComponentVariant } from './ComponentVariant.js';
+export class Component {
+    constructor(data) {
+        _Component_data.set(this, void 0);
+        _Component_translate.set(this, void 0);
+        _Component_variants.set(this, void 0);
+        __classPrivateFieldSet(this, _Component_data, data, "f");
+    }
+    width() {
+        return __classPrivateFieldGet(this, _Component_data, "f").width;
+    }
+    height() {
+        return __classPrivateFieldGet(this, _Component_data, "f").height;
+    }
+    probability() {
+        return __classPrivateFieldGet(this, _Component_data, "f").probability ?? 100;
+    }
+    rotate() {
+        return __classPrivateFieldGet(this, _Component_data, "f").rotate ?? [];
+    }
+    translate() {
+        __classPrivateFieldSet(this, _Component_translate, __classPrivateFieldGet(this, _Component_translate, "f") ?? new ComponentTranslate(__classPrivateFieldGet(this, _Component_data, "f").translate ?? {}), "f");
+        return __classPrivateFieldGet(this, _Component_translate, "f");
+    }
+    variants() {
+        __classPrivateFieldSet(this, _Component_variants, __classPrivateFieldGet(this, _Component_variants, "f") ?? new Map(Object.entries(__classPrivateFieldGet(this, _Component_data, "f").variants).map(([name, data]) => [
+            name,
+            new ComponentVariant(data),
+        ])), "f");
+        return __classPrivateFieldGet(this, _Component_variants, "f");
+    }
+}
+_Component_data = new WeakMap(), _Component_translate = new WeakMap(), _Component_variants = new WeakMap();

package/lib/Style/ComponentTranslate.d.ts

@@ -0,0 +1,7 @@
+import type { StyleDefinitionComponentTranslate } from '../StyleDefinition.js';
+export declare class ComponentTranslate {
+    #private;
+    constructor(data: StyleDefinitionComponentTranslate);
+    x(): readonly number[];
+    y(): readonly number[];
+}

package/lib/Style/ComponentTranslate.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 _ComponentTranslate_data;
+export class ComponentTranslate {
+    constructor(data) {
+        _ComponentTranslate_data.set(this, void 0);
+        __classPrivateFieldSet(this, _ComponentTranslate_data, data, "f");
+    }
+    x() {
+        return __classPrivateFieldGet(this, _ComponentTranslate_data, "f").x ?? [];
+    }
+    y() {
+        return __classPrivateFieldGet(this, _ComponentTranslate_data, "f").y ?? [];
+    }
+}
+_ComponentTranslate_data = new WeakMap();

package/lib/Style/ComponentVariant.d.ts

@@ -0,0 +1,8 @@
+import type { StyleDefinitionComponentVariant } from '../StyleDefinition.js';
+import { Element } from './Element.js';
+export declare class ComponentVariant {
+    #private;
+    constructor(data: StyleDefinitionComponentVariant);
+    elements(): readonly Element[];
+    weight(): number;
+}

package/lib/Style/ComponentVariant.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 _ComponentVariant_data, _ComponentVariant_elements;
+import { Element } from './Element.js';
+export class ComponentVariant {
+    constructor(data) {
+        _ComponentVariant_data.set(this, void 0);
+        _ComponentVariant_elements.set(this, void 0);
+        __classPrivateFieldSet(this, _ComponentVariant_data, data, "f");
+    }
+    elements() {
+        __classPrivateFieldSet(this, _ComponentVariant_elements, __classPrivateFieldGet(this, _ComponentVariant_elements, "f") ?? __classPrivateFieldGet(this, _ComponentVariant_data, "f").elements.map((el) => new Element(el)), "f");
+        return __classPrivateFieldGet(this, _ComponentVariant_elements, "f");
+    }
+    weight() {
+        return __classPrivateFieldGet(this, _ComponentVariant_data, "f").weight ?? 1;
+    }
+}
+_ComponentVariant_data = new WeakMap(), _ComponentVariant_elements = new WeakMap();

package/lib/Style/Element.d.ts

@@ -0,0 +1,10 @@
+import type { StyleDefinitionElement, StyleDefinitionElementValue, StyleDefinitionElementType, StyleDefinitionAttributes } from '../StyleDefinition.js';
+export declare class Element {
+    #private;
+    constructor(data: StyleDefinitionElement);
+    type(): StyleDefinitionElementType;
+    name(): string | undefined;
+    value(): StyleDefinitionElementValue | undefined;
+    attributes(): StyleDefinitionAttributes | undefined;
+    children(): readonly Element[];
+}