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

package/src/contentExpression.ts

@@ -19,8 +19,13 @@ function collectExpressionSymbols(expression: Expression, symbols: Set<string>):
     if (expression.kind === 'symbol') {
         symbols.add(expression.symbol);
     } else if (expression.kind !== 'empty') {
-        if (expression.kind === 'repeat') collectExpressionSymbols(expression.expression, symbols);
-        else for (const nested of expression.expressions) collectExpressionSymbols(nested, symbols);
+        if (expression.kind === 'repeat') {
+            collectExpressionSymbols(expression.expression, symbols);
+        } else {
+            for (const nested of expression.expressions) {
+                collectExpressionSymbols(nested, symbols);
+            }
+        }
     }
 }
 
@@ -32,7 +37,8 @@ export function contentExpressionSymbols(content: string): string[] | null {
         compiler.compile(expression);
         const symbols = new Set<string>();
         collectExpressionSymbols(expression, symbols);
-        return [...symbols];
+
+        return [ ...symbols ];
     } catch {
         return null;
     }
@@ -40,40 +46,66 @@ export function contentExpressionSymbols(content: string): string[] | null {
 
 class ContentExpressionParser {
     private position = 0;
+
     private depth = 0;
 
-    constructor(private readonly source: string) {}
+    constructor(private readonly source: string) {
+    }
 
     parse(): Expression {
-        if (this.source.trim() === '') return { kind: 'empty' };
+        if (this.source.trim() === '') {
+            return { kind: 'empty' };
+        }
+
         const expression = this.parseAlternation();
         this.skipWhitespace();
-        if (!this.atEnd()) throw new Error(`unexpected '${this.peek()}'`);
+
+        if (!this.atEnd()) {
+            throw new Error(`unexpected '${this.peek()}'`);
+        }
+
         return expression;
     }
 
     private parseAlternation(): Expression {
-        const expressions = [this.parseSequence()];
+        const expressions = [ this.parseSequence() ];
+
         while (true) {
             this.skipWhitespace();
-            if (!this.consume('|')) break;
+
+            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());
         }
+
         return expressions.length === 1 ? expressions[0] : { kind: 'alternation', expressions };
     }
 
     private parseSequence(): Expression {
         const expressions: Expression[] = [];
+
         while (true) {
             this.skipWhitespace();
-            if (this.atEnd() || this.peek() === ')' || this.peek() === '|') break;
+
+            if (this.atEnd() || this.peek() === ')' || this.peek() === '|') {
+                break;
+            }
+
             expressions.push(this.parseRepeated());
         }
-        if (expressions.length === 0) throw new Error('expected expression');
+
+        if (expressions.length === 0) {
+            throw new Error('expected expression');
+        }
+
         return expressions.length === 1 ? expressions[0] : { kind: 'sequence', expressions };
     }
 
@@ -81,31 +113,50 @@ class ContentExpressionParser {
         const atom = this.parseAtom();
         this.skipWhitespace();
         let expression = atom;
-        if (this.consume('?')) expression = { kind: 'repeat', expression: atom, min: 0, max: 1 };
-        else if (this.consume('*'))
+
+        if (this.consume('?')) {
+            expression = { kind: 'repeat', expression: atom, min: 0, max: 1 };
+        } 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('{')) expression = this.parseRange(atom);
+        } else if (this.consume('{')) {
+            expression = this.parseRange(atom);
+        }
+
         this.skipWhitespace();
-        if (['?', '*', '+', '{'].includes(this.peek() ?? '')) {
+
+        if ([ '?', '*', '+', '{' ].includes(this.peek() ?? '')) {
             throw new Error('multiple quantifiers');
         }
+
         return expression;
     }
 
     private parseAtom(): Expression {
         this.skipWhitespace();
+
         if (this.consume('(')) {
-            if (this.depth >= CONTENT_EXPRESSION_MAX_DEPTH)
+            if (this.depth >= CONTENT_EXPRESSION_MAX_DEPTH) {
                 throw new Error('expression nesting too deep');
+            }
+
             this.depth += 1;
+
             try {
                 this.skipWhitespace();
-                if (this.peek() === ')') throw new Error('empty group');
+
+                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 {
                 this.depth -= 1;
@@ -113,39 +164,75 @@ class ContentExpressionParser {
         }
 
         const start = this.position;
-        while (this.peek() != null && /[A-Za-z0-9_-]/.test(this.peek()!)) this.position += 1;
-        if (start === this.position) throw new Error('expected node or group name');
+
+        while (this.peek() != null && /[A-Za-z0-9_-]/.test(this.peek()!)) {
+            this.position += 1;
+        }
+
+        if (start === this.position) {
+            throw new Error('expected node or group name');
+        }
+
         return { kind: 'symbol', symbol: this.source.slice(start, this.position) };
     }
 
     private parseRange(expression: Expression): Expression {
         const min = this.parseNumber();
         let max: number | null;
-        if (this.consume('}')) max = min;
-        else {
-            if (!this.consume(',')) throw new Error("expected ',' or '}'");
-            if (this.consume('}')) max = null;
-            else {
+
+        if (this.consume('}')) {
+            max = min;
+        } else {
+            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) throw new Error('range maximum is smaller than minimum');
-        if ((max ?? min) > MAX_REPETITION_BOUND) throw new Error('repetition bound too large');
+
+        if (max != null && max < min) {
+            throw new Error('range maximum is smaller than minimum');
+        }
+
+        if ((max ?? min) > MAX_REPETITION_BOUND) {
+            throw new Error('repetition bound too large');
+        }
+
         return { kind: 'repeat', expression, min, max };
     }
 
     private parseNumber(): number {
         const start = this.position;
-        while (this.peek() != null && /[0-9]/.test(this.peek()!)) this.position += 1;
-        if (start === this.position) throw new Error('expected number');
+
+        while (this.peek() != null && /[0-9]/.test(this.peek()!)) {
+            this.position += 1;
+        }
+
+        if (start === this.position) {
+            throw new Error('expected number');
+        }
+
         const value = Number(this.source.slice(start, this.position));
-        if (!Number.isSafeInteger(value) || value > 0xffff_ffff) throw new Error('invalid count');
+
+        if (!Number.isSafeInteger(value) || value > 0xffff_ffff) {
+            throw new Error('invalid count');
+        }
+
         return value;
     }
 
     private skipWhitespace(): void {
-        while (this.peek() != null && /\s/.test(this.peek()!)) this.position += 1;
+        while (this.peek() != null && /\s/.test(this.peek()!)) {
+            this.position += 1;
+        }
     }
 
     private peek(): string | undefined {
@@ -153,8 +240,12 @@ class ContentExpressionParser {
     }
 
     private consume(character: string): boolean {
-        if (this.peek() !== character) return false;
+        if (this.peek() !== character) {
+            return false;
+        }
+
         this.position += 1;
+
         return true;
     }
 
@@ -167,39 +258,52 @@ class ContentExpressionCompiler {
     readonly states: State[] = [];
 
     compile(expression: Expression, depth = 0): [number, number] {
-        if (depth > CONTENT_EXPRESSION_MAX_DEPTH) throw new Error('expression nesting too deep');
+        if (depth > CONTENT_EXPRESSION_MAX_DEPTH) {
+            throw new Error('expression nesting too deep');
+        }
+
         if (expression.kind === 'empty') {
             const start = this.state();
             const end = this.state();
             this.states[start].epsilon.push(end);
-            return [start, end];
+
+            return [ start, end ];
         }
+
         if (expression.kind === 'symbol') {
             const start = this.state();
             const end = this.state();
             this.states[start].transitions.push({ symbol: expression.symbol, target: end });
-            return [start, end];
+
+            return [ start, end ];
         }
+
         if (expression.kind === 'sequence') {
             const start = this.state();
             let tail = start;
+
             for (const nested of expression.expressions) {
-                const [nestedStart, nestedEnd] = this.compile(nested, depth + 1);
+                const [ nestedStart, nestedEnd ] = this.compile(nested, depth + 1);
                 this.states[tail].epsilon.push(nestedStart);
                 tail = nestedEnd;
             }
-            return [start, tail];
+
+            return [ start, tail ];
         }
+
         if (expression.kind === 'alternation') {
             const start = this.state();
             const end = this.state();
+
             for (const nested of expression.expressions) {
-                const [nestedStart, nestedEnd] = this.compile(nested, depth + 1);
+                const [ nestedStart, nestedEnd ] = this.compile(nested, depth + 1);
                 this.states[start].epsilon.push(nestedStart);
                 this.states[nestedEnd].epsilon.push(end);
             }
-            return [start, end];
+
+            return [ start, end ];
         }
+
         return this.compileRepeat(expression.expression, expression.min, expression.max, depth + 1);
     }
 
@@ -212,45 +316,58 @@ class ContentExpressionCompiler {
         const start = this.state();
         const end = this.state();
         let tail = start;
+
         for (let count = 0; count < min; count += 1) {
-            const [itemStart, itemEnd] = this.compile(expression, depth);
+            const [ itemStart, itemEnd ] = this.compile(expression, depth);
             this.states[tail].epsilon.push(itemStart);
             tail = itemEnd;
         }
+
         if (max == null) {
             this.states[tail].epsilon.push(end);
-            const [itemStart, itemEnd] = this.compile(expression, depth);
+            const [ itemStart, itemEnd ] = this.compile(expression, depth);
             this.states[tail].epsilon.push(itemStart);
             this.states[itemEnd].epsilon.push(tail);
         } else {
             for (let count = min; count < max; count += 1) {
                 this.states[tail].epsilon.push(end);
-                const [itemStart, itemEnd] = this.compile(expression, depth);
+                const [ itemStart, itemEnd ] = this.compile(expression, depth);
                 this.states[tail].epsilon.push(itemStart);
                 tail = itemEnd;
             }
+
             this.states[tail].epsilon.push(end);
         }
-        return [start, end];
+
+        return [ start, end ];
     }
 
     private state(): number {
-        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;
     }
 }
 
 function epsilonClosure(states: State[], initial: Iterable<number>): Set<number> {
     const result = new Set<number>();
-    const pending = [...initial];
+    const pending = [ ...initial ];
+
     while (pending.length > 0) {
         const state = pending.pop()!;
-        if (result.has(state)) continue;
+
+        if (result.has(state)) {
+            continue;
+        }
+
         result.add(state);
         pending.push(...states[state].epsilon);
     }
+
     return result;
 }
 
@@ -263,24 +380,32 @@ export function acceptingContentSymbols(
     try {
         const expression = new ContentExpressionParser(content).parse();
         const compiler = new ContentExpressionCompiler();
-        const [start] = compiler.compile(expression);
-        let current = epsilonClosure(compiler.states, [start]);
+        const [ start ] = compiler.compile(expression);
+        let current = epsilonClosure(compiler.states, [ start ]);
+
         for (const childType of existingChildTypes) {
             const next = new Set<number>();
+
             for (const state of current) {
                 for (const transition of compiler.states[state].transitions) {
-                    if (symbolMatches(childType, transition.symbol)) next.add(transition.target);
+                    if (symbolMatches(childType, transition.symbol)) {
+                        next.add(transition.target);
+                    }
                 }
             }
+
             current = epsilonClosure(compiler.states, next);
         }
+
         const symbols = new Set<string>();
+
         for (const state of current) {
             for (const transition of compiler.states[state].transitions) {
                 symbols.add(transition.symbol);
             }
         }
-        return [...symbols].sort();
+
+        return [ ...symbols ].sort();
     } catch {
         return [];
     }
@@ -294,43 +419,73 @@ export function minimalContentMatch<T>(
     try {
         const expression = new ContentExpressionParser(content).parse();
         const compiler = new ContentExpressionCompiler();
-        const [start, accept] = compiler.compile(expression);
+        const [ start, accept ] = compiler.compile(expression);
         interface Path {
             value: T;
             previous?: Path;
         }
-        let current = new Map<number, Path | undefined>([[start, undefined]]);
+        let current = new Map<number, Path | undefined>([ [ start, undefined ] ]);
         const visited = new Set<number>();
+
         while (current.size > 0) {
             const closure = new Map<number, Path | undefined>();
-            const pending = [...current.entries()];
+            const pending = [ ...current.entries() ];
+
             while (pending.length > 0) {
-                if (!consumeWork()) return undefined;
-                const [state, path] = pending.pop()!;
-                if (closure.has(state)) continue;
+                if (!consumeWork()) {
+                    return undefined;
+                }
+
+                const [ state, path ] = pending.pop()!;
+
+                if (closure.has(state)) {
+                    continue;
+                }
+
                 closure.set(state, path);
-                for (const target of compiler.states[state].epsilon) pending.push([target, path]);
+
+                for (const target of compiler.states[state].epsilon) {
+                    pending.push([ target, path ]);
+                }
             }
+
             const accepted = closure.get(accept);
+
             if (closure.has(accept)) {
                 const result: T[] = [];
-                for (let path = accepted; path; path = path.previous) result.push(path.value);
+
+                for (let path = accepted; path; path = path.previous) {
+                    result.push(path.value);
+                }
+
                 return result.reverse();
             }
+
             const next = new Map<number, Path | undefined>();
-            for (const [state, path] of closure) {
-                if (visited.has(state)) continue;
+
+            for (const [ state, path ] of closure) {
+                if (visited.has(state)) {
+                    continue;
+                }
+
                 visited.add(state);
+
                 for (const transition of compiler.states[state].transitions) {
-                    if (!consumeWork()) return undefined;
+                    if (!consumeWork()) {
+                        return undefined;
+                    }
+
                     const value = choose(transition.symbol);
+
                     if (value !== undefined && !next.has(transition.target)) {
                         next.set(transition.target, { value, previous: path });
                     }
                 }
             }
+
             current = next;
         }
+
         return undefined;
     } catch {
         return undefined;

package/src/listMarkers.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