u2ui 1.5.3 → 1.5.4

package/js/rte/src/mark/dom-adapter.js

@@ -0,0 +1,100 @@
+import {Mark, MarkType} from './mark.js';
+
+const TRUE = () => true;
+
+export class MarkAdapter {
+    #type;
+    #selector;
+    #read;
+    #render;
+    #write;
+    #clear;
+    #reuse;
+
+    constructor(type, {selector, tag, read = TRUE, write, clear, reuse = false, render} = {}) {
+        if (!(type instanceof MarkType)) throw new TypeError('A mark adapter requires a mark type');
+        if (typeof selector !== 'string' || !selector.trim()) {
+            throw new TypeError('A mark adapter requires a non-empty selector');
+        }
+        if (typeof read !== 'function') throw new TypeError('A mark reader must be a function');
+        if (write !== undefined && typeof write !== 'function') throw new TypeError('A mark writer must be a function');
+        if (clear !== undefined && typeof clear !== 'function') throw new TypeError('A mark clearer must be a function');
+        if (typeof reuse !== 'boolean' && typeof reuse !== 'function') {
+            throw new TypeError('Mark reuse must be a boolean or function');
+        }
+        if (reuse && !write) throw new TypeError('A reusable mark adapter requires write');
+        if (render !== undefined && typeof render !== 'function') throw new TypeError('A mark renderer must be a function');
+        if (render && tag !== undefined) throw new TypeError('A custom mark renderer cannot be combined with tag');
+        if (!render && (typeof tag !== 'string' || !/^[a-z][a-z0-9-]*$/.test(tag))) {
+            throw new TypeError('A mark adapter requires a lowercase HTML tag');
+        }
+        this.#type = type;
+        this.#selector = selector.trim();
+        this.#read = read;
+        this.#write = write;
+        this.#clear = clear;
+        this.#reuse = reuse;
+        this.#render = render || ((document, value) => {
+            const element = document.createElement(tag);
+            write?.(element, value);
+            return element;
+        });
+    }
+
+    get type() { return this.#type; }
+    get selector() { return this.#selector; }
+    get reusable() { return !!this.#reuse; }
+    get removable() { return !!this.#clear; }
+
+    parse(element) {
+        assertElement(element);
+        if (!element.matches(this.#selector)) return null;
+        const value = this.#read(element);
+        return value === undefined ? null : this.#type.create(value);
+    }
+
+    canReuse(element) {
+        assertElement(element);
+        return this.#reuse === true || !!this.#reuse && !!this.#reuse(element);
+    }
+
+    apply(element, mark) {
+        this.#assertMark(mark);
+        assertElement(element);
+        if (!this.#write) throw new TypeError('This mark adapter cannot decorate an existing element');
+        this.#write(element, mark.value);
+        return element;
+    }
+
+    clear(element, mark) {
+        this.#assertMark(mark);
+        assertElement(element);
+        if (!this.#clear) throw new TypeError('This mark adapter cannot remove its formatting');
+        const unwrap = this.#clear(element, mark.value) === true;
+        for (const name of ['class', 'style']) {
+            if (!element.getAttribute(name)?.trim()) element.removeAttribute(name);
+        }
+        return unwrap || element.localName === 'span' && !element.attributes.length;
+    }
+
+    render(mark, document) {
+        this.#assertMark(mark);
+        if (document?.nodeType !== Node.DOCUMENT_NODE) throw new TypeError('Mark rendering requires a document');
+        const element = this.#render(document, mark.value);
+        assertElement(element);
+        if (element.ownerDocument !== document || element.parentNode || element.childNodes.length) {
+            throw new TypeError('A rendered mark must be an empty detached element from the requested document');
+        }
+        return element;
+    }
+
+    #assertMark(mark) {
+        if (!(mark instanceof Mark) || mark.type !== this.#type) {
+            throw new TypeError('A mark adapter can only use its own mark type');
+        }
+    }
+}
+
+function assertElement(element) {
+    if (element?.nodeType !== Node.ELEMENT_NODE) throw new TypeError('A mark adapter requires an element');
+}

package/js/rte/src/mark/mark.js

@@ -0,0 +1,133 @@
+const DEFAULT = Symbol('default mark value');
+const EMPTY = Object.freeze([]);
+
+export function markSet(marks) {
+    assertSet(marks);
+    let set = EMPTY;
+    for (const mark of marks) set = mark.add(set);
+    return set;
+}
+
+export class MarkType {
+    #name;
+    #rank;
+    #excludes;
+
+    constructor(name, {rank = 50, excludes = [name]} = {}) {
+        this.#name = nameOf(name, 'A mark type');
+        if (!Number.isFinite(rank)) throw new TypeError('A mark rank must be a finite number');
+        this.#rank = rank;
+        this.#excludes = names(excludes);
+    }
+
+    get name() { return this.#name; }
+    get rank() { return this.#rank; }
+    get exclusions() { return this.#excludes; }
+
+    create(...values) {
+        return new Mark(this, values.length ? values[0] : DEFAULT);
+    }
+
+    excludes(type) {
+        if (!(type instanceof MarkType)) throw new TypeError('A mark type can only exclude another mark type');
+        return this.#excludes.includes('*') || this.#excludes.includes(type.name);
+    }
+
+    remove(marks) {
+        assertSet(marks);
+        const kept = marks.filter(mark => mark.type !== this);
+        return kept.length === marks.length ? marks : Object.freeze(kept);
+    }
+}
+
+export class Mark {
+    #type;
+    #value;
+    #key;
+
+    constructor(type, ...values) {
+        if (!(type instanceof MarkType)) throw new TypeError('A mark requires a mark type');
+        this.#type = type;
+        const value = values.length ? values[0] : DEFAULT;
+        this.#value = data(value === DEFAULT ? true : value);
+        this.#key = JSON.stringify(this.#value);
+        Object.freeze(this);
+    }
+
+    get type() { return this.#type; }
+    get value() { return this.#value; }
+
+    equals(mark) {
+        return mark instanceof Mark && this.#type === mark.type && this.#key === mark.#key;
+    }
+
+    conflicts(mark) {
+        assertMark(mark);
+        return this.#type.excludes(mark.type) || mark.type.excludes(this.#type);
+    }
+
+    add(marks) {
+        assertSet(marks);
+        if (marks.some(mark => this.equals(mark))) return marks;
+        if (marks.some(mark => !this.#type.excludes(mark.type) && mark.type.excludes(this.#type))) return marks;
+        const added = marks.filter(mark => !this.#type.excludes(mark.type));
+        const at = added.findIndex(mark => {
+            const order = this.#type.rank - mark.type.rank
+                || compare(this.#type.name, mark.type.name)
+                || compare(this.#key, mark.#key);
+            return order < 0;
+        });
+        at < 0 ? added.push(this) : added.splice(at, 0, this);
+        return Object.freeze(added);
+    }
+
+    remove(marks) {
+        assertSet(marks);
+        const kept = marks.filter(mark => !this.equals(mark));
+        return kept.length === marks.length ? marks : Object.freeze(kept);
+    }
+}
+
+function data(value, parents = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    if (typeof value !== 'object' || !plain(value)) throw new TypeError('A mark value must be serializable data');
+    if (parents.has(value)) throw new TypeError('A mark value cannot be cyclic');
+    parents.add(value);
+    if (Object.getOwnPropertySymbols(value).length) throw new TypeError('A mark value cannot have symbol keys');
+    const copy = Array.isArray(value)
+        ? Array.from(value, item => data(item, parents))
+        : Object.fromEntries(Object.keys(value).sort().map(key => [key, data(value[key], parents)]));
+    parents.delete(value);
+    return Object.freeze(copy);
+}
+
+function plain(value) {
+    if (Array.isArray(value)) return true;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype?.constructor?.name === 'Object';
+}
+
+function compare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function names(value) {
+    if (!Array.isArray(value)) throw new TypeError('Mark exclusions must be an array of names');
+    return Object.freeze([...new Set(value.map(name => name === '*' ? name : nameOf(name, 'A mark exclusion')))]);
+}
+
+function nameOf(value, subject) {
+    if (typeof value !== 'string' || !value.trim()) throw new TypeError(`${subject} must have a non-empty name`);
+    return value.trim();
+}
+
+function assertSet(marks) {
+    if (!Array.isArray(marks) || marks.some(mark => !(mark instanceof Mark))) {
+        throw new TypeError('A mark set must be an array of marks');
+    }
+}
+
+function assertMark(mark) {
+    if (!(mark instanceof Mark)) throw new TypeError('A mark is required');
+}

package/js/rte/src/mark/standard.js

@@ -0,0 +1,76 @@
+import {MarkAdapter} from './dom-adapter.js';
+import {MarkType} from './mark.js';
+
+const LINK_ATTRIBUTES = ['href', 'target', 'rel', 'title'];
+
+export const bold = new MarkType('bold');
+export const italic = new MarkType('italic');
+export const underline = new MarkType('underline');
+export const strike = new MarkType('strike');
+export const code = new MarkType('code');
+export const link = new MarkType('link');
+
+export const boldHtml = element(bold, 'strong, b', 'strong');
+export const italicHtml = element(italic, 'em, i', 'em');
+export const underlineHtml = element(underline, 'u', 'u');
+export const strikeHtml = element(strike, 's, strike', 's');
+export const codeHtml = element(code, 'code', 'code');
+export const linkHtml = new MarkAdapter(link, {
+    selector: 'a[href]',
+    tag: 'a',
+    read: readLink,
+    write: writeLink,
+    clear: clearLink,
+});
+
+// One closed group of content classes as a single mark. Its value is the class
+// name, so a value command drives it and the group stays mutually exclusive; an
+// application that needs independent axes builds a second adapter.
+export function classMark(names, {type = new MarkType('class'), tag = 'span'} = {}) {
+    const known = [...new Set(names)];
+    if (!known.length || known.some(name => typeof name !== 'string' || !name.trim())) {
+        throw new TypeError('A class mark requires class names');
+    }
+    return new MarkAdapter(type, {
+        selector: known.map(name => `.${CSS.escape(name)}`).join(','),
+        tag,
+        reuse: true,
+        read: element => known.find(name => element.classList.contains(name)),
+        write: (element, value) => {
+            if (!known.includes(value)) throw new RangeError(`Unknown class mark: ${value}`);
+            for (const name of known) element.classList.remove(name);
+            element.classList.add(value);
+        },
+        clear(element) {
+            for (const name of known) element.classList.remove(name);
+            if (!element.classList.length) element.removeAttribute('class');
+            return true;
+        },
+    });
+}
+
+function element(type, selector, tag) {
+    return new MarkAdapter(type, {selector, tag, clear: () => true});
+}
+
+function readLink(element) {
+    const value = {};
+    for (const name of LINK_ATTRIBUTES) {
+        if (element.hasAttribute(name)) value[name] = element.getAttribute(name);
+    }
+    return value;
+}
+
+function writeLink(element, value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)
+        || typeof value.href !== 'string'
+        || Object.keys(value).some(name => !LINK_ATTRIBUTES.includes(name) || typeof value[name] !== 'string')) {
+        throw new TypeError('A link mark requires href and optional target, rel, and title strings');
+    }
+    for (const name of LINK_ATTRIBUTES) if (value[name] !== undefined) element.setAttribute(name, value[name]);
+}
+
+function clearLink(element) {
+    for (const name of LINK_ATTRIBUTES) element.removeAttribute(name);
+    return true;
+}

package/js/rte/src/model/README.md

@@ -0,0 +1,71 @@
+# Content model engine
+
+A content model is the editor's rulebook for valid document structure. For
+example, it can say that a `ul` contains `li` elements and that a paragraph may
+contain text but not another block.
+
+`content-model.js` stores and evaluates these rules. It only answers whether a
+node is allowed directly inside another node; it never changes the DOM itself.
+The generic engine does not hardcode HTML rules.
+
+## Rule shape
+
+- `groups`: categories the node belongs to, such as `flow` or `phrasing`.
+- `children`: accepted tag names, `#text`, `*`, or category tokens prefixed by
+  `@`.
+- `exclude`: child tags or categories forbidden below this element, including
+  through transparent descendants.
+- `block`, `atomic`, and `void`: editor semantics used by traversal and repair.
+- `textBlock`: a paragraph-like block that Enter may split, such as a heading;
+  it implies `block`.
+- `mergeable`: a block whose content Backspace may join into a compatible
+  preceding sibling. It defaults to `true` for text blocks and remains an
+  explicit policy for structural blocks such as list items.
+- `defaultChild`: structural wrapper used when direct content needs repair.
+- `transparent`: inherit the nearest concrete ancestor's child model.
+- `allow(parent, child, model)`: an optional dynamic decision. Returning
+  `undefined` falls back to `children`.
+- `elements`: an optional final allowlist for output element names. Parent
+  rules remain available as context even when the editing host itself is not
+  output content.
+
+## Contract
+
+- Rules, lists, and models are immutable after construction.
+- Names, categories, and category tokens are ASCII-case-insensitive.
+- Text, unknown elements, and non-content DOM nodes have separate fallback
+  rules.
+- Transparent rules require a real DOM context; a detached tag name alone is
+  intentionally insufficient.
+- `extend()` creates an isolated model, shallowly merging named rule overrides
+  and allowing a rule to be removed with `null`.
+- `allowed(node)` answers the element allowlist independently of its current
+  parent; text is still decided by the parent's `children` rule.
+- `withElements(names)` returns and reuses an immutable narrowed model. This is
+  the inexpensive bridge from a surface's CSS element policy to cleanup and
+  commands.
+- The model describes validity only. It never mutates DOM, chooses a repair,
+  crosses editing hosts, or reads browser-computed styles.
+- Element validity is not HTML sanitizing. Attributes, URL schemes, and hostile
+  input require a sanitizer policy before insertion.
+
+`defaultChild(node)` names the element a container fills itself with — `li` for
+a list, `tr` for a table section. Structural commands use it instead of naming
+tags, so the same command serves any configured list-like structure.
+
+## Cost
+
+`allows()` is the engine's hottest question — normalization asks it for every
+child of every element — so the model avoids work rather than caching answers.
+Rules are looked up by `localName`, which is already lowercase, so no lookup
+allocates a string. Ancestor exclusion is the one rule that has to walk upwards,
+and the model knows which tokens any rule excludes at all: a child nothing could
+exclude skips that walk entirely, and the answer is remembered per element name.
+
+## TODO
+
+- Add contextual constraints that depend on sibling order and required child
+  sequences.
+- Expose diagnostic reasons without complicating the hot `allows()` path.
+- Add namespaced SVG and MathML integration points.
+- Compile large policies only if profiling shows rule lookup is significant.

package/js/rte/src/model/content-model.js

@@ -0,0 +1,213 @@
+const EMPTY = rule({});
+
+export class ContentModel {
+    #rules;
+    #fallback;
+    #text;
+    #elements;
+    #elementNames;
+    #elementModels = new Map();
+    #exclusions;
+    #excludable = new Map();
+
+    constructor({rules = {}, fallback = {}, text = {groups: ['flow', 'phrasing']}, elements = null} = {}) {
+        this.#rules = new Map();
+        for (const [name, value] of Object.entries(rules)) this.#rules.set(tag(name), rule(value));
+        this.#fallback = rule(fallback);
+        this.#text = rule(text);
+        this.#elementNames = elements === null ? null : tags(elements);
+        this.#elements = this.#elementNames && new Set(this.#elementNames);
+        // Every token any rule excludes. Ancestor exclusion is the one rule that
+        // has to walk, so a child no rule could ever exclude skips the walk.
+        const exclusions = new Set();
+        for (const item of [...this.#rules.values(), this.#fallback, this.#text]) {
+            for (const token of item.exclude) exclusions.add(token);
+        }
+        this.#exclusions = Object.freeze([...exclusions]);
+        Object.freeze(this);
+    }
+
+    get elements() { return this.#elementNames; }
+
+    // `localName` is already the lowercase name for HTML elements, so the hot
+    // path does no string work at all.
+    rule(node) {
+        if (typeof node === 'string') return this.#rules.get(tag(node)) || this.#fallback;
+        if (node?.nodeType === Node.TEXT_NODE) return this.#text;
+        if (node?.nodeType !== Node.ELEMENT_NODE) return EMPTY;
+        return this.#rules.get(node.localName) || this.#fallback;
+    }
+
+    groups(node) {
+        return this.rule(node).groups;
+    }
+
+    is(node, group) {
+        if (typeof group !== 'string' || !group.trim()) throw new TypeError('A group name must be a non-empty string');
+        return this.rule(node).groups.includes(group.toLowerCase());
+    }
+
+    // Whether any rule could exclude this kind of child. It depends only on the
+    // node's name, so the answer is remembered per name and the ancestor walk in
+    // `allows()` is skipped for everything nothing excludes.
+    excludable(child) {
+        if (!this.#exclusions.length) return false;
+        const key = child?.nodeType === Node.ELEMENT_NODE ? child.localName
+            : child?.nodeType === Node.TEXT_NODE ? '#text' : null;
+        if (key === null) return false;
+        let found = this.#excludable.get(key);
+        if (found === undefined) {
+            found = this.#exclusions.some(token => matches(this, token, child));
+            this.#excludable.set(key, found);
+        }
+        return found;
+    }
+
+    block(node) {
+        return this.rule(node).block;
+    }
+
+    textBlock(node) {
+        return this.rule(node).textBlock;
+    }
+
+    // The element a container fills itself with: `li` for a list, `tr` for a
+    // table section. Structural commands use it instead of naming tags.
+    defaultChild(node) {
+        return this.rule(node).defaultChild;
+    }
+
+    mergeable(node) {
+        const current = this.rule(node);
+        return current.mergeable ?? current.textBlock;
+    }
+
+    atomic(node) {
+        const current = this.rule(node);
+        return current.atomic || current.void;
+    }
+
+    transparent(node) {
+        return this.rule(node).transparent;
+    }
+
+    allowed(node) {
+        if (typeof node === 'string') return !this.#elements || this.#elements.has(tag(node));
+        if (node?.nodeType === Node.TEXT_NODE) return true;
+        return node?.nodeType === Node.ELEMENT_NODE && (!this.#elements || this.#elements.has(node.localName));
+    }
+
+    allows(parent, child) {
+        if (!this.allowed(child)) return false;
+        const context = transparentParent(this, parent);
+        if (!context) return false;
+        if (excluded(this, parent, child)) return false;
+        const parentRule = this.rule(context);
+        if (parentRule.allow) {
+            const allowed = parentRule.allow(context, child, this);
+            if (allowed !== undefined) return !!allowed;
+        }
+        return parentRule.children.some(token => matches(this, token, child));
+    }
+
+    withElements(elements) {
+        if (elements === null && this.#elementNames === null) return this;
+        const names = elements === null ? null : tags(elements);
+        if (same(names, this.#elementNames)) return this;
+        const key = names === null ? '*' : names.join('\u0000');
+        let model = this.#elementModels.get(key);
+        if (!model) {
+            model = this.extend({elements: names});
+            this.#elementModels.set(key, model);
+        }
+        return model;
+    }
+
+    extend({rules = {}, fallback, text, elements} = {}) {
+        const merged = Object.fromEntries(this.#rules);
+        for (const [name, value] of Object.entries(rules)) {
+            const key = tag(name);
+            if (value === null) delete merged[key];
+            else merged[key] = {...(merged[key] || {}), ...value};
+        }
+        return new ContentModel({
+            rules: merged,
+            fallback: fallback ? {...this.#fallback, ...fallback} : this.#fallback,
+            text: text ? {...this.#text, ...text} : this.#text,
+            elements: elements === undefined ? this.#elementNames : elements,
+        });
+    }
+}
+
+function rule(value) {
+    if (!value || typeof value !== 'object') throw new TypeError('A content rule must be an object');
+    const textBlock = !!value.textBlock;
+    return Object.freeze({
+        groups: list(value.groups),
+        children: list(value.children),
+        exclude: list(value.exclude),
+        block: !!value.block || textBlock,
+        textBlock,
+        mergeable: value.mergeable == null ? null : !!value.mergeable,
+        atomic: !!value.atomic,
+        void: !!value.void,
+        transparent: !!value.transparent,
+        defaultChild: value.defaultChild == null ? null : tag(value.defaultChild),
+        allow: callback(value.allow),
+    });
+}
+
+function callback(value) {
+    if (value == null) return null;
+    if (typeof value !== 'function') throw new TypeError('A dynamic content rule must be a function');
+    return value;
+}
+
+function list(value) {
+    if (value === undefined) return Object.freeze([]);
+    if (!Array.isArray(value) || value.some(item => typeof item !== 'string')) {
+        throw new TypeError('Content rule lists must contain strings');
+    }
+    return Object.freeze([...new Set(value.map(item => item.startsWith('@') ? `@${item.slice(1).toLowerCase()}` : tag(item)))]);
+}
+
+function tags(value) {
+    if (!Array.isArray(value) || value.some(name => typeof name !== 'string' || !name.trim())) {
+        throw new TypeError('Allowed elements must be an array of tag names');
+    }
+    return Object.freeze([...new Set(value.map(tag))]);
+}
+
+function same(left, right) {
+    return left === right || !!left && !!right
+        && left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function transparentParent(model, parent) {
+    let context = parent;
+    while (context && model.transparent(context)) {
+        if (typeof context === 'string') return null;
+        context = context.parentElement;
+    }
+    return context;
+}
+
+function excluded(model, parent, child) {
+    if (typeof parent === 'string' || !model.excludable(child)) return false;
+    for (let element = parent; element; element = element.parentElement) {
+        if (model.rule(element).exclude.some(token => matches(model, token, child))) return true;
+    }
+    return false;
+}
+
+function matches(model, token, child) {
+    if (token.charCodeAt(0) === 64) return model.rule(child).groups.includes(token.slice(1));
+    if (token === '*') return child?.nodeType === Node.ELEMENT_NODE || child?.nodeType === Node.TEXT_NODE;
+    if (token === '#text') return child?.nodeType === Node.TEXT_NODE;
+    return child?.nodeType === Node.ELEMENT_NODE && child.localName === token;
+}
+
+function tag(name) {
+    if (typeof name !== 'string' || !name.trim()) throw new TypeError('A content rule name must be a non-empty string');
+    return name.toLowerCase();
+}

package/js/rte/src/model/html/README.md

@@ -0,0 +1,51 @@
+# Default HTML content model
+
+The default HTML content model is RTE's ready-to-use rulebook for ordinary
+HTML. It knows structures such as paragraphs, headings, lists, links, tables,
+media, and form controls, so an application does not have to describe them all.
+
+`html-model.js` supplies these defaults as data for `ContentModel`. Applications
+may extend or replace them; commands and normalizers do not hardcode the rules.
+
+## Defaults
+
+- Flow containers accept flow content; paragraph and heading-like blocks accept
+  phrasing content.
+- Paragraphs, headings, and preformatted blocks are marked as splittable text
+  blocks. Structural blocks such as lists, items, tables, and layout `div`s are
+  not.
+- Text blocks and list items are mergeable at their leading boundary. Layout
+  containers and table structure are not mergeable by default.
+- Lists accept list items, definition lists accept their term/description
+  structures, and table sections accept their native structural children.
+  Structural children are not misclassified as general flow content.
+- Lists, table sections, and rows declare their default repair child explicitly.
+- Transparent elements such as `a`, `ins`, `del`, and `map` inherit their real
+  DOM parent's content restrictions.
+- Interactive descendants are excluded from links and buttons. Nested links
+  are rejected through transparent wrappers.
+- Replaced controls, media, line breaks, images, and horizontal rules are
+  editor-atomic. HTML void elements are also marked `void`.
+- Script, style, and template nodes are not flow content. Security sanitizing
+  remains a separate mandatory stage for untrusted HTML.
+- Unknown/custom elements are transparent flow/phrasing wrappers by default,
+  so their permitted children follow the context where they are used.
+
+`createHtmlModel(overrides)` returns an isolated extended policy when overrides
+are supplied. Shipped rules are defaults and may be narrowed or replaced by an
+application.
+
+## Limits
+
+This first policy describes direct parent/child validity and inherited
+transparent content. It does not yet enforce sibling order, required children,
+attribute-dependent categories, or every uncommon HTML element. Those become
+additional constraints without changing the generic model API.
+
+## TODO
+
+- Cover ruby, media fallback, picture/source order, details/summary order, and
+  definition-list grouping precisely.
+- Add attribute-dependent interactive and embedded-content categories.
+- Add SVG and MathML integration rules.
+- Track relevant HTML Standard changes with focused conformance fixtures.