@apollohg/react-native-rich-text-editor 2.0.0 → 2.0.1

package/dist/atoms.js

@@ -7,10 +7,12 @@ const attributeValidation_1 = require("./attributeValidation");
 const atomConstants_1 = require("./atomConstants");
 const atomPolicy_1 = require("./atomPolicy");
 function isAtomComponent(value) {
-    if (typeof value === 'function')
+    if (typeof value === 'function') {
         return true;
-    if (value == null || typeof value !== 'object' || !('$$typeof' in value))
+    }
+    if (value == null || typeof value !== 'object' || !('$$typeof' in value)) {
         return false;
+    }
     return (value.$$typeof === Symbol.for('react.memo') ||
         value.$$typeof === Symbol.for('react.forward_ref') ||
         value.$$typeof === Symbol.for('react.lazy'));
@@ -48,7 +50,7 @@ function normalizedHtmlRules(config) {
         throw new Error(`atom '${config.name}' requires HTML rules`);
     }
     const raw = config.html;
-    if (Object.keys(raw).some((key) => !['tag', 'staticAttrs', 'attrMap'].includes(key))) {
+    if (Object.keys(raw).some(key => !['tag', 'staticAttrs', 'attrMap'].includes(key))) {
         throw new Error(`atom '${config.name}' has an unknown HTML rule field`);
     }
     if (typeof raw.tag !== 'string' || !isSafeTag(raw.tag)) {
@@ -65,7 +67,7 @@ function normalizedHtmlRules(config) {
     }
     const attrs = config.attrs ?? {};
     const attrMap = raw.attrMap == null
-        ? Object.fromEntries(Object.keys(attrs).map((name) => [name, `data-${kebabCase(name)}`]))
+        ? Object.fromEntries(Object.keys(attrs).map(name => [name, `data-${kebabCase(name)}`]))
         : stringRecord(raw.attrMap, `atom '${config.name}' attrMap`);
     for (const name of Object.keys(attrMap)) {
         if (!Object.prototype.hasOwnProperty.call(attrs, name)) {
@@ -115,10 +117,12 @@ function defineAtomNode(config) {
     if (config.attrs != null && (typeof config.attrs !== 'object' || Array.isArray(config.attrs))) {
         throw new Error(`atom '${config.name}' attrs must be an object`);
     }
-    for (const [name, spec] of Object.entries(config.attrs ?? {}))
+    for (const [name, spec] of Object.entries(config.attrs ?? {})) {
         (0, attributeValidation_1.validateAttributeSpec)(spec, name);
-    if (config.idAttribute !== undefined && config.attrs?.[config.idAttribute]?.type !== 'string')
+    }
+    if (config.idAttribute !== undefined && config.attrs?.[config.idAttribute]?.type !== 'string') {
         throw new Error(`atom '${config.name}' identifier attribute must declare type string`);
+    }
     const html = normalizedHtmlRules(config);
     const nodeSpec = {
         name: config.name,
@@ -152,8 +156,9 @@ function defineAtomNode(config) {
     };
 }
 function schemaValuesEqual(left, right) {
-    if (Object.is(left, right))
+    if (Object.is(left, right)) {
         return true;
+    }
     if (left == null || right == null || typeof left !== 'object' || typeof right !== 'object') {
         return false;
     }
@@ -171,13 +176,14 @@ function schemaValuesEqual(left, right) {
         leftKeys.every((key, index) => key === rightKeys[index] && schemaValuesEqual(leftRecord[key], rightRecord[key])));
 }
 function assertUnambiguousHtmlRules(nodes) {
-    const ruled = nodes.filter((node) => node.html != null);
+    const ruled = nodes.filter(node => node.html != null);
     for (let rightIndex = 1; rightIndex < ruled.length; rightIndex += 1) {
         const right = ruled[rightIndex];
         for (let leftIndex = 0; leftIndex < rightIndex; leftIndex += 1) {
             const left = ruled[leftIndex];
-            if (left.html?.tag !== right.html?.tag)
+            if (left.html?.tag !== right.html?.tag) {
                 continue;
+            }
             const leftStatic = left.html?.staticAttrs ?? {};
             const rightStatic = right.html?.staticAttrs ?? {};
             const conflicts = Object.entries(leftStatic).some(([name, value]) => Object.prototype.hasOwnProperty.call(rightStatic, name) &&
@@ -192,7 +198,7 @@ function withAtomsSchema(schema, atoms) {
     const nodes = [...schema.nodes];
     let changed = false;
     for (const atom of atoms) {
-        const existing = nodes.find((node) => node.name === atom.name);
+        const existing = nodes.find(node => node.name === atom.name);
         if (existing != null) {
             if (!schemaValuesEqual(existing, atom.nodeSpec)) {
                 throw new Error(`schema already declares conflicting node '${atom.name}'`);
@@ -206,15 +212,17 @@ function withAtomsSchema(schema, atoms) {
     return changed ? { ...schema, nodes } : schema;
 }
 function serializeEditorAtoms(atoms) {
-    if (atoms == null || atoms.length === 0)
+    if (atoms == null || atoms.length === 0) {
         return undefined;
+    }
     const serialized = {
         nodeTypes: [],
         estimatedHeights: {},
     };
     for (const atom of atoms) {
-        if (Object.prototype.hasOwnProperty.call(serialized.estimatedHeights, atom.name))
+        if (Object.prototype.hasOwnProperty.call(serialized.estimatedHeights, atom.name)) {
             continue;
+        }
         serialized.nodeTypes.push(atom.name);
         serialized.estimatedHeights[atom.name] = atom.estimatedHeight ?? atomConstants_1.DEFAULT_ATOM_CHIP_HEIGHT;
     }

package/dist/attributeValidation.js

@@ -7,41 +7,51 @@ function jsonType(value) {
     return Array.isArray(value) ? 'array' : value === null ? 'null' : typeof value;
 }
 function validateJson(value, ancestors = new Set()) {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
         return;
-    if (typeof value === 'number' && Number.isFinite(value))
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
         return;
-    if (typeof value !== 'object' || ancestors.has(value) || ancestors.size > 128)
+    }
+    if (typeof value !== 'object' || ancestors.has(value) || ancestors.size > 128) {
         throw new Error('Attribute values must be finite, acyclic JSON.');
+    }
     if (!Array.isArray(value) &&
         Object.getPrototypeOf(value) !== Object.prototype &&
-        Object.getPrototypeOf(value) !== null)
+        Object.getPrototypeOf(value) !== null) {
         throw new Error('Attribute values must be plain JSON objects.');
+    }
     ancestors.add(value);
     const entries = Array.isArray(value) ? value : Object.values(value);
-    for (let index = 0; index < entries.length; index += 1)
+    for (let index = 0; index < entries.length; index += 1) {
         validateJson(entries[index], ancestors);
+    }
     ancestors.delete(value);
 }
 function equal(left, right) {
-    if (left === right)
+    if (left === right) {
         return true;
-    if (left == null || right == null || typeof left !== 'object' || typeof right !== 'object')
+    }
+    if (left == null || right == null || typeof left !== 'object' || typeof right !== 'object') {
         return false;
-    if (Array.isArray(left) !== Array.isArray(right))
+    }
+    if (Array.isArray(left) !== Array.isArray(right)) {
         return false;
+    }
     const a = Object.keys(left), b = Object.keys(right);
     return (a.length === b.length &&
-        a.every((key) => Object.prototype.hasOwnProperty.call(right, key) &&
+        a.every(key => Object.prototype.hasOwnProperty.call(right, key) &&
             equal(left[key], right[key])));
 }
 function validateAttribute(value, spec, name) {
     validateJson(value);
     const type = jsonType(value);
-    if ((spec.type != null && type !== spec.type) || (type === 'number' && !Number.isFinite(value)))
+    if ((spec.type != null && type !== spec.type) || (type === 'number' && !Number.isFinite(value))) {
         throw new Error(`invalid attribute '${name}': expected ${spec.type ?? 'finite number'}`);
-    if (spec.enum != null && !spec.enum.some((entry) => equal(entry, value)))
+    }
+    if (spec.enum != null && !spec.enum.some(entry => equal(entry, value))) {
         throw new Error(`invalid attribute '${name}': outside enum`);
+    }
     const size = typeof value === 'number'
         ? value
         : typeof value === 'string'
@@ -50,48 +60,69 @@ function validateAttribute(value, spec, name) {
                 ? value.length
                 : undefined;
     if ((spec.min != null && (size == null || size < spec.min)) ||
-        (spec.max != null && (size == null || size > spec.max)))
+        (spec.max != null && (size == null || size > spec.max))) {
         throw new Error(`invalid attribute '${name}': outside bounds`);
+    }
 }
 function validateAttributeSpec(spec, name) {
-    if (spec == null || typeof spec !== 'object' || Array.isArray(spec))
+    if (spec == null || typeof spec !== 'object' || Array.isArray(spec)) {
         throw new Error(`invalid attribute '${name}' declaration`);
-    if (Object.keys(spec).some((key) => !['default', 'type', 'enum', 'min', 'max'].includes(key)))
+    }
+    if (Object.keys(spec).some(key => !['default',
+        'type',
+        'enum',
+        'min',
+        'max'].includes(key))) {
         throw new Error(`invalid attribute '${name}' declaration field`);
+    }
     if (spec.type !== undefined &&
-        !['string', 'number', 'boolean', 'object', 'array'].includes(spec.type))
+        !['string',
+            'number',
+            'boolean',
+            'object',
+            'array'].includes(spec.type)) {
         throw new Error(`invalid attribute '${name}' type`);
+    }
     if (spec.min !== undefined || spec.max !== undefined) {
         if (!['number', 'string', 'array'].includes(spec.type ?? '') ||
             (spec.min !== undefined && !Number.isFinite(spec.min)) ||
             (spec.max !== undefined && !Number.isFinite(spec.max)) ||
-            (spec.min !== undefined && spec.max !== undefined && spec.min > spec.max))
+            (spec.min !== undefined && spec.max !== undefined && spec.min > spec.max)) {
             throw new Error(`invalid attribute '${name}' bounds`);
+        }
         if (spec.type !== 'number' &&
-            [spec.min, spec.max].some((bound) => bound !== undefined && (!Number.isInteger(bound) || bound < 0)))
+            [spec.min, spec.max].some(bound => bound !== undefined && (!Number.isInteger(bound) || bound < 0))) {
             throw new Error(`invalid attribute '${name}' length bounds`);
+        }
     }
     if (spec.enum !== undefined) {
-        if (!Array.isArray(spec.enum) || spec.enum.length === 0)
+        if (!Array.isArray(spec.enum) || spec.enum.length === 0) {
             throw new Error(`invalid attribute '${name}' enum`);
-        if (new Set(spec.enum.map(jsonType)).size !== 1)
+        }
+        if (new Set(spec.enum.map(jsonType)).size !== 1) {
             throw new Error(`invalid attribute '${name}': enum values must share one JSON type`);
-        for (const entry of spec.enum)
+        }
+        for (const entry of spec.enum) {
             validateAttribute(entry, { ...spec, enum: undefined }, name);
+        }
     }
-    if (spec.default !== undefined)
+    if (spec.default !== undefined) {
         validateAttribute(spec.default, spec, name);
+    }
 }
 function validateAttributes(attrs, specs) {
-    for (const name of Object.keys(attrs))
-        if (!Object.prototype.hasOwnProperty.call(specs, name))
+    for (const name of Object.keys(attrs)) {
+        if (!Object.prototype.hasOwnProperty.call(specs, name)) {
             throw new Error(`undeclared attribute '${name}'`);
+        }
+    }
     for (const [name, spec] of Object.entries(specs)) {
         const value = Object.prototype.hasOwnProperty.call(attrs, name)
             ? attrs[name]
             : spec.default;
-        if (value === undefined)
+        if (value === undefined) {
             throw new Error(`required attribute '${name}' missing`);
+        }
         validateAttribute(value, spec, name);
     }
 }

package/dist/contentExpression.js

@@ -13,11 +13,14 @@ function collectExpressionSymbols(expression, symbols) {
         symbols.add(expression.symbol);
     }
     else if (expression.kind !== 'empty') {
-        if (expression.kind === 'repeat')
+        if (expression.kind === 'repeat') {
             collectExpressionSymbols(expression.expression, symbols);
-        else
-            for (const nested of expression.expressions)
+        }
+        else {
+            for (const nested of expression.expressions) {
                 collectExpressionSymbols(nested, symbols);
+            }
+        }
     }
 }
 /** Return every referenced node/group symbol, or null for an invalid expression. */
@@ -41,23 +44,26 @@ class ContentExpressionParser {
         this.depth = 0;
     }
     parse() {
-        if (this.source.trim() === '')
+        if (this.source.trim() === '') {
             return { kind: 'empty' };
+        }
         const expression = this.parseAlternation();
         this.skipWhitespace();
-        if (!this.atEnd())
+        if (!this.atEnd()) {
             throw new Error(`unexpected '${this.peek()}'`);
+        }
         return expression;
     }
     parseAlternation() {
         const expressions = [this.parseSequence()];
         while (true) {
             this.skipWhitespace();
-            if (!this.consume('|'))
+            if (!this.consume('|')) {
                 break;
+            }
             this.skipWhitespace();
             if (this.atEnd() || this.peek() === ')' || this.peek() === '|') {
-                throw new Error("missing expression after '|'");
+                throw new Error('missing expression after \'|\'');
             }
             expressions.push(this.parseSequence());
         }
@@ -67,26 +73,32 @@ class ContentExpressionParser {
         const expressions = [];
         while (true) {
             this.skipWhitespace();
-            if (this.atEnd() || this.peek() === ')' || this.peek() === '|')
+            if (this.atEnd() || this.peek() === ')' || this.peek() === '|') {
                 break;
+            }
             expressions.push(this.parseRepeated());
         }
-        if (expressions.length === 0)
+        if (expressions.length === 0) {
             throw new Error('expected expression');
+        }
         return expressions.length === 1 ? expressions[0] : { kind: 'sequence', expressions };
     }
     parseRepeated() {
         const atom = this.parseAtom();
         this.skipWhitespace();
         let expression = atom;
-        if (this.consume('?'))
+        if (this.consume('?')) {
             expression = { kind: 'repeat', expression: atom, min: 0, max: 1 };
-        else if (this.consume('*'))
+        }
+        else if (this.consume('*')) {
             expression = { kind: 'repeat', expression: atom, min: 0, max: null };
-        else if (this.consume('+'))
+        }
+        else if (this.consume('+')) {
             expression = { kind: 'repeat', expression: atom, min: 1, max: null };
-        else if (this.consume('{'))
+        }
+        else if (this.consume('{')) {
             expression = this.parseRange(atom);
+        }
         this.skipWhitespace();
         if (['?', '*', '+', '{'].includes(this.peek() ?? '')) {
             throw new Error('multiple quantifiers');
@@ -96,17 +108,20 @@ class ContentExpressionParser {
     parseAtom() {
         this.skipWhitespace();
         if (this.consume('(')) {
-            if (this.depth >= exports.CONTENT_EXPRESSION_MAX_DEPTH)
+            if (this.depth >= exports.CONTENT_EXPRESSION_MAX_DEPTH) {
                 throw new Error('expression nesting too deep');
+            }
             this.depth += 1;
             try {
                 this.skipWhitespace();
-                if (this.peek() === ')')
+                if (this.peek() === ')') {
                     throw new Error('empty group');
+                }
                 const expression = this.parseAlternation();
                 this.skipWhitespace();
-                if (!this.consume(')'))
-                    throw new Error("missing ')'");
+                if (!this.consume(')')) {
+                    throw new Error('missing \')\'');
+                }
                 return expression;
             }
             finally {
@@ -114,55 +129,68 @@ class ContentExpressionParser {
             }
         }
         const start = this.position;
-        while (this.peek() != null && /[A-Za-z0-9_-]/.test(this.peek()))
+        while (this.peek() != null && /[A-Za-z0-9_-]/.test(this.peek())) {
             this.position += 1;
-        if (start === this.position)
+        }
+        if (start === this.position) {
             throw new Error('expected node or group name');
+        }
         return { kind: 'symbol', symbol: this.source.slice(start, this.position) };
     }
     parseRange(expression) {
         const min = this.parseNumber();
         let max;
-        if (this.consume('}'))
+        if (this.consume('}')) {
             max = min;
+        }
         else {
-            if (!this.consume(','))
-                throw new Error("expected ',' or '}'");
-            if (this.consume('}'))
+            if (!this.consume(',')) {
+                throw new Error('expected \',\' or \'}\'');
+            }
+            if (this.consume('}')) {
                 max = null;
+            }
             else {
                 max = this.parseNumber();
-                if (!this.consume('}'))
-                    throw new Error("expected '}'");
+                if (!this.consume('}')) {
+                    throw new Error('expected \'}\'');
+                }
             }
         }
-        if (max != null && max < min)
+        if (max != null && max < min) {
             throw new Error('range maximum is smaller than minimum');
-        if ((max ?? min) > MAX_REPETITION_BOUND)
+        }
+        if ((max ?? min) > MAX_REPETITION_BOUND) {
             throw new Error('repetition bound too large');
+        }
         return { kind: 'repeat', expression, min, max };
     }
     parseNumber() {
         const start = this.position;
-        while (this.peek() != null && /[0-9]/.test(this.peek()))
+        while (this.peek() != null && /[0-9]/.test(this.peek())) {
             this.position += 1;
-        if (start === this.position)
+        }
+        if (start === this.position) {
             throw new Error('expected number');
+        }
         const value = Number(this.source.slice(start, this.position));
-        if (!Number.isSafeInteger(value) || value > 4294967295)
+        if (!Number.isSafeInteger(value) || value > 4294967295) {
             throw new Error('invalid count');
+        }
         return value;
     }
     skipWhitespace() {
-        while (this.peek() != null && /\s/.test(this.peek()))
+        while (this.peek() != null && /\s/.test(this.peek())) {
             this.position += 1;
+        }
     }
     peek() {
         return this.source[this.position];
     }
     consume(character) {
-        if (this.peek() !== character)
+        if (this.peek() !== character) {
             return false;
+        }
         this.position += 1;
         return true;
     }
@@ -175,8 +203,9 @@ class ContentExpressionCompiler {
         this.states = [];
     }
     compile(expression, depth = 0) {
-        if (depth > exports.CONTENT_EXPRESSION_MAX_DEPTH)
+        if (depth > exports.CONTENT_EXPRESSION_MAX_DEPTH) {
             throw new Error('expression nesting too deep');
+        }
         if (expression.kind === 'empty') {
             const start = this.state();
             const end = this.state();
@@ -238,8 +267,9 @@ class ContentExpressionCompiler {
         return [start, end];
     }
     state() {
-        if (this.states.length >= MAX_AUTOMATON_STATES)
+        if (this.states.length >= MAX_AUTOMATON_STATES) {
             throw new Error('too many automaton states');
+        }
         this.states.push({ epsilon: [], transitions: [] });
         return this.states.length - 1;
     }
@@ -249,8 +279,9 @@ function epsilonClosure(states, initial) {
     const pending = [...initial];
     while (pending.length > 0) {
         const state = pending.pop();
-        if (result.has(state))
+        if (result.has(state)) {
             continue;
+        }
         result.add(state);
         pending.push(...states[state].epsilon);
     }
@@ -266,8 +297,9 @@ function acceptingContentSymbols(content, existingChildTypes = [], symbolMatches
             const next = new Set();
             for (const state of current) {
                 for (const transition of compiler.states[state].transitions) {
-                    if (symbolMatches(childType, transition.symbol))
+                    if (symbolMatches(childType, transition.symbol)) {
                         next.add(transition.target);
+                    }
                 }
             }
             current = epsilonClosure(compiler.states, next);
@@ -295,30 +327,36 @@ function minimalContentMatch(content, choose, consumeWork = () => true) {
             const closure = new Map();
             const pending = [...current.entries()];
             while (pending.length > 0) {
-                if (!consumeWork())
+                if (!consumeWork()) {
                     return undefined;
+                }
                 const [state, path] = pending.pop();
-                if (closure.has(state))
+                if (closure.has(state)) {
                     continue;
+                }
                 closure.set(state, path);
-                for (const target of compiler.states[state].epsilon)
+                for (const target of compiler.states[state].epsilon) {
                     pending.push([target, path]);
+                }
             }
             const accepted = closure.get(accept);
             if (closure.has(accept)) {
                 const result = [];
-                for (let path = accepted; path; path = path.previous)
+                for (let path = accepted; path; path = path.previous) {
                     result.push(path.value);
+                }
                 return result.reverse();
             }
             const next = new Map();
             for (const [state, path] of closure) {
-                if (visited.has(state))
+                if (visited.has(state)) {
                     continue;
+                }
                 visited.add(state);
                 for (const transition of compiler.states[state].transitions) {
-                    if (!consumeWork())
+                    if (!consumeWork()) {
                         return undefined;
+                    }
                     const value = choose(transition.symbol);
                     if (value !== undefined && !next.has(transition.target)) {
                         next.set(transition.target, { value, previous: path });

package/dist/listMarkers.d.ts

@@ -3,7 +3,7 @@
  *
  * CROSS-LAYER CONTRACT: these values must match the Rust core
  * (rust/editor-core/src/render/mod.rs: task_list_marker_string /
- * list_marker_string — pinned by marker_strings_are_the_cross_layer_contract
+ * list_marker_string : pinned by marker_strings_are_the_cross_layer_contract
  * in render_test.rs), Android (LayoutConstants.TASK_LIST_MARKER_* /
  * UNORDERED_LIST_BULLET), and iOS (RenderBridge.listMarkerString). The
  * marker's scalar length feeds position mapping; a mismatch corrupts

package/dist/listMarkers.js

@@ -7,7 +7,7 @@ exports.orderedListMarker = orderedListMarker;
  *
  * CROSS-LAYER CONTRACT: these values must match the Rust core
  * (rust/editor-core/src/render/mod.rs: task_list_marker_string /
- * list_marker_string — pinned by marker_strings_are_the_cross_layer_contract
+ * list_marker_string : pinned by marker_strings_are_the_cross_layer_contract
  * in render_test.rs), Android (LayoutConstants.TASK_LIST_MARKER_* /
  * UNORDERED_LIST_BULLET), and iOS (RenderBridge.listMarkerString). The
  * marker's scalar length feeds position mapping; a mismatch corrupts

package/dist/schemaDefinition.d.ts

@@ -63,7 +63,7 @@ export interface NodeSpec {
      * `insert_content_json`) admits attrs on this node that are not declared
      * in `attrs`, instead of filtering them out. Default `false`. Intended
      * for node types with an intentional pass-through-metadata contract
-     * (e.g. the mention node — see `mentionNodeSpec()` in addons.ts).
+     * (e.g. the mention node : see `mentionNodeSpec()` in addons.ts).
      */
     allowUndeclaredAttrs?: boolean;
     /** Public JSON representation when it differs from the native node name. */

package/dist/schemaDefinition.js

@@ -27,35 +27,42 @@ function outputTag(spec) {
 }
 function appendGroup(group, name) {
     const groups = group?.split(/\s+/).filter(Boolean) ?? [];
-    if (!groups.includes(name))
+    if (!groups.includes(name)) {
         groups.push(name);
+    }
     return groups.join(' ');
 }
 function schemaNodeRole(name, node) {
-    if (node.role != null)
+    if (node.role != null) {
         return node.role === 'heading' ? 'textBlock' : node.role;
-    if (name === 'doc')
+    }
+    if (name === 'doc') {
         return 'doc';
-    if (name === 'text')
+    }
+    if (name === 'text') {
         return 'text';
+    }
     if (node.content === 'inline*' && node.group?.split(/\s+/).includes('block')) {
         return 'textBlock';
     }
-    if (node.group?.split(/\s+/).includes('inline'))
+    if (node.group?.split(/\s+/).includes('inline')) {
         return 'inline';
+    }
     return 'block';
 }
 function caseAttributeValue(key, attribute, tag, parseDOM, defaultValue) {
-    const rule = parseDOM?.find((candidate) => candidate.tag === tag &&
+    const rule = parseDOM?.find(candidate => candidate.tag === tag &&
         candidate.attrs != null &&
         String(candidate.attrs[attribute]) === key);
     if (rule?.attrs && Object.prototype.hasOwnProperty.call(rule.attrs, attribute)) {
         return rule.attrs[attribute];
     }
-    if (typeof defaultValue === 'number')
+    if (typeof defaultValue === 'number') {
         return Number(key);
-    if (typeof defaultValue === 'boolean')
+    }
+    if (typeof defaultValue === 'boolean') {
         return key === 'true';
+    }
     return key;
 }
 function validateAttributeDOMRules(name, switched, parseDOM, defaultValue) {
@@ -66,7 +73,7 @@ function validateAttributeDOMRules(name, switched, parseDOM, defaultValue) {
         ? typeof defaultValue
         : undefined;
     if (discriminatorType == null && parseDOM != null) {
-        const parsedTypes = parseDOM.map((rule) => {
+        const parsedTypes = parseDOM.map(rule => {
             const value = rule.attrs?.[switched.switchOn];
             return typeof value === 'string' ||
                 typeof value === 'number' ||
@@ -75,7 +82,7 @@ function validateAttributeDOMRules(name, switched, parseDOM, defaultValue) {
                 : undefined;
         });
         const firstType = parsedTypes[0];
-        if (firstType != null && parsedTypes.every((type) => type === firstType)) {
+        if (firstType != null && parsedTypes.every(type => type === firstType)) {
             discriminatorType = firstType;
         }
     }
@@ -94,7 +101,7 @@ function validateAttributeDOMRules(name, switched, parseDOM, defaultValue) {
         }
         return;
     }
-    const matchesCase = ([caseKey, output]) => parseDOM.filter((rule) => rule.tag === outputTag(output) &&
+    const matchesCase = ([caseKey, output]) => parseDOM.filter(rule => rule.tag === outputTag(output) &&
         rule.attrs != null &&
         Object.prototype.hasOwnProperty.call(rule.attrs, switched.switchOn) &&
         String(rule.attrs[switched.switchOn]) === caseKey).length === 1;
@@ -102,7 +109,7 @@ function validateAttributeDOMRules(name, switched, parseDOM, defaultValue) {
         throw new Error(`node '${name}' DOM parse rules must map one-to-one with '${switched.switchOn}' output cases`);
     }
     if (discriminatorType != null &&
-        parseDOM.some((rule) => rule.attrs != null && typeof rule.attrs[switched.switchOn] !== discriminatorType)) {
+        parseDOM.some(rule => rule.attrs != null && typeof rule.attrs[switched.switchOn] !== discriminatorType)) {
         throw new Error(`node '${name}' DOM discriminator '${switched.switchOn}' must use ${discriminatorType} values`);
     }
 }
@@ -153,8 +160,9 @@ function defineSchema(spec) {
             const { attrs: _attrs, ...variantCommon } = common;
             for (const [caseKey, output] of Object.entries(switched.cases)) {
                 const tag = outputTag(output);
-                if (names.has(tag))
+                if (names.has(tag)) {
                     throw new Error(`schema produces duplicate native node '${tag}'`);
+                }
                 names.add(tag);
                 const { [switched.switchOn]: _discriminator, ...variantAttrs } = node.attrs ?? {};
                 nodes.push({
@@ -173,8 +181,9 @@ function defineSchema(spec) {
             }
             continue;
         }
-        if (names.has(name))
+        if (names.has(name)) {
             throw new Error(`schema produces duplicate native node '${name}'`);
+        }
         names.add(name);
         const tag = staticDOMTag('node', name, node.parseDOM, node.toDOM);
         nodes.push({