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

package/dist/atoms.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineAtomNode = defineAtomNode;
+exports.withAtomsSchema = withAtomsSchema;
+exports.serializeEditorAtoms = serializeEditorAtoms;
+const attributeValidation_1 = require("./attributeValidation");
+const atomConstants_1 = require("./atomConstants");
+const atomPolicy_1 = require("./atomPolicy");
+function isAtomComponent(value) {
+    if (typeof value === 'function')
+        return true;
+    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'));
+}
+function isSafeTag(tag) {
+    return atomPolicy_1.ATOM_HTML_IDENTIFIER.test(tag) && !atomPolicy_1.ATOM_HTML_DENIED_TAGS.has(tag);
+}
+function isSafeAttr(name) {
+    return (atomPolicy_1.ATOM_HTML_IDENTIFIER.test(name) &&
+        !name.startsWith('on') &&
+        !atomPolicy_1.ATOM_HTML_DENIED_ATTRS.has(name));
+}
+function stringRecord(value, label) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry !== 'string') {
+            throw new Error(`${label} '${key}' must be a string`);
+        }
+        result[key] = entry;
+    }
+    return result;
+}
+function kebabCase(value) {
+    return value
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/_/g, '-')
+        .toLowerCase();
+}
+function normalizedHtmlRules(config) {
+    if (config.html == null || typeof config.html !== 'object' || Array.isArray(config.html)) {
+        throw new Error(`atom '${config.name}' requires HTML rules`);
+    }
+    const raw = config.html;
+    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)) {
+        throw new Error(`atom '${config.name}' has an invalid HTML tag '${String(raw.tag)}'`);
+    }
+    const staticAttrs = stringRecord(raw.staticAttrs, `atom '${config.name}' staticAttrs`);
+    if (Object.keys(staticAttrs).length === 0) {
+        throw new Error(`atom '${config.name}' requires a static attribute discriminator`);
+    }
+    for (const name of Object.keys(staticAttrs)) {
+        if (!isSafeAttr(name)) {
+            throw new Error(`atom '${config.name}' has an invalid HTML attribute '${name}'`);
+        }
+    }
+    const attrs = config.attrs ?? {};
+    const attrMap = raw.attrMap == null
+        ? 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)) {
+            throw new Error(`atom '${config.name}' maps undeclared attribute '${name}'`);
+        }
+    }
+    for (const name of Object.keys(attrs)) {
+        if (!Object.prototype.hasOwnProperty.call(attrMap, name)) {
+            throw new Error(`atom '${config.name}' attrMap is missing '${name}'`);
+        }
+    }
+    const targets = new Set();
+    for (const target of Object.values(attrMap)) {
+        if (!isSafeAttr(target)) {
+            throw new Error(`atom '${config.name}' has an invalid HTML attribute '${target}'`);
+        }
+        if (targets.has(target)) {
+            throw new Error(`atom '${config.name}' repeats HTML attribute '${target}'`);
+        }
+        if (Object.prototype.hasOwnProperty.call(staticAttrs, target)) {
+            throw new Error(`atom '${config.name}' collides on HTML attribute '${target}'`);
+        }
+        targets.add(target);
+    }
+    return { tag: raw.tag, staticAttrs, attrMap };
+}
+function defineAtomNode(config) {
+    if (config == null || typeof config !== 'object') {
+        throw new Error('atom config must be an object');
+    }
+    if (typeof config.name !== 'string' || config.name.length === 0) {
+        throw new Error('atom name must be a non-empty string');
+    }
+    if (atomPolicy_1.RESERVED_WIRE_NODE_TYPES.has(config.name)) {
+        throw new Error(`atom name '${config.name}' is reserved`);
+    }
+    if (!isAtomComponent(config.component)) {
+        throw new Error(`atom '${config.name}' requires a component`);
+    }
+    if (config.estimatedHeight != null &&
+        (!Number.isFinite(config.estimatedHeight) || config.estimatedHeight < 0)) {
+        throw new Error(`atom '${config.name}' estimatedHeight must be non-negative`);
+    }
+    if ('allowUndeclaredAttrs' in config) {
+        throw new Error(`atom '${config.name}' cannot allow undeclared attributes`);
+    }
+    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 ?? {}))
+        (0, attributeValidation_1.validateAttributeSpec)(spec, name);
+    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,
+        content: '',
+        group: 'block',
+        role: 'block',
+        isVoid: true,
+        ...(config.attrs == null ? {} : { attrs: config.attrs }),
+        html,
+    };
+    return {
+        name: config.name,
+        ...(config.attrs == null ? {} : { attrs: config.attrs }),
+        html,
+        component: config.component,
+        ...(config.idAttribute === undefined ? {} : { idAttribute: config.idAttribute }),
+        estimatedHeight: config.estimatedHeight ?? atomConstants_1.DEFAULT_ATOM_CHIP_HEIGHT,
+        nodeSpec,
+        buildFragmentJson(attrs, descriptor) {
+            (0, attributeValidation_1.validateAttributes)(attrs ?? {}, config.attrs ?? {});
+            return {
+                type: descriptor?.documentNodeName ?? 'doc',
+                content: [
+                    {
+                        type: config.name,
+                        ...(attrs == null ? {} : { attrs }),
+                    },
+                ],
+            };
+        },
+    };
+}
+function schemaValuesEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left == null || right == null || typeof left !== 'object' || typeof right !== 'object') {
+        return false;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return (Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((value, index) => schemaValuesEqual(value, right[index])));
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).sort();
+    const rightKeys = Object.keys(rightRecord).sort();
+    return (leftKeys.length === rightKeys.length &&
+        leftKeys.every((key, index) => key === rightKeys[index] && schemaValuesEqual(leftRecord[key], rightRecord[key])));
+}
+function assertUnambiguousHtmlRules(nodes) {
+    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)
+                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) &&
+                rightStatic[name] !== value);
+            if (!conflicts) {
+                throw new Error(`ambiguous atom HTML rules for '${left.name}' and '${right.name}'`);
+            }
+        }
+    }
+}
+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);
+        if (existing != null) {
+            if (!schemaValuesEqual(existing, atom.nodeSpec)) {
+                throw new Error(`schema already declares conflicting node '${atom.name}'`);
+            }
+            continue;
+        }
+        nodes.push(atom.nodeSpec);
+        changed = true;
+    }
+    assertUnambiguousHtmlRules(nodes);
+    return changed ? { ...schema, nodes } : schema;
+}
+function serializeEditorAtoms(atoms) {
+    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))
+            continue;
+        serialized.nodeTypes.push(atom.name);
+        serialized.estimatedHeights[atom.name] = atom.estimatedHeight ?? atomConstants_1.DEFAULT_ATOM_CHIP_HEIGHT;
+    }
+    return JSON.stringify(serialized);
+}

package/dist/attributeValidation.d.ts

@@ -0,0 +1,4 @@
+import type { AttrSpec } from './schemas';
+export declare function validateAttribute(value: unknown, spec: AttrSpec, name: string): void;
+export declare function validateAttributeSpec(spec: AttrSpec, name: string): void;
+export declare function validateAttributes(attrs: Record<string, unknown>, specs: Record<string, AttrSpec>): void;

package/dist/attributeValidation.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAttribute = validateAttribute;
+exports.validateAttributeSpec = validateAttributeSpec;
+exports.validateAttributes = validateAttributes;
+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')
+        return;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return;
+    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)
+        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)
+        validateJson(entries[index], ancestors);
+    ancestors.delete(value);
+}
+function equal(left, right) {
+    if (left === right)
+        return true;
+    if (left == null || right == null || typeof left !== 'object' || typeof right !== 'object')
+        return false;
+    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) &&
+            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)))
+        throw new Error(`invalid attribute '${name}': expected ${spec.type ?? 'finite number'}`);
+    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'
+            ? [...value].length
+            : Array.isArray(value)
+                ? value.length
+                : undefined;
+    if ((spec.min != null && (size == null || size < spec.min)) ||
+        (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))
+        throw new Error(`invalid attribute '${name}' declaration`);
+    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))
+        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))
+            throw new Error(`invalid attribute '${name}' bounds`);
+        if (spec.type !== 'number' &&
+            [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)
+            throw new Error(`invalid attribute '${name}' enum`);
+        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)
+            validateAttribute(entry, { ...spec, enum: undefined }, name);
+    }
+    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))
+            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)
+            throw new Error(`required attribute '${name}' missing`);
+        validateAttribute(value, spec, name);
+    }
+}

package/dist/contentExpression.d.ts

@@ -0,0 +1,6 @@
+export declare const CONTENT_EXPRESSION_MAX_DEPTH = 128;
+export declare const DEFAULT_CONTENT_MAX_NODES = 10000;
+/** Return every referenced node/group symbol, or null for an invalid expression. */
+export declare function contentExpressionSymbols(content: string): string[] | null;
+export declare function acceptingContentSymbols(content: string, existingChildTypes?: readonly string[], symbolMatches?: (childType: string, symbol: string) => boolean): string[];
+export declare function minimalContentMatch<T>(content: string, choose: (symbol: string) => T | undefined, consumeWork?: () => boolean): T[] | undefined;

package/dist/contentExpression.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONTENT_MAX_NODES = exports.CONTENT_EXPRESSION_MAX_DEPTH = void 0;
+exports.contentExpressionSymbols = contentExpressionSymbols;
+exports.acceptingContentSymbols = acceptingContentSymbols;
+exports.minimalContentMatch = minimalContentMatch;
+exports.CONTENT_EXPRESSION_MAX_DEPTH = 128;
+exports.DEFAULT_CONTENT_MAX_NODES = 10000;
+const MAX_AUTOMATON_STATES = 10000;
+const MAX_REPETITION_BOUND = 10000;
+function collectExpressionSymbols(expression, symbols) {
+    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);
+    }
+}
+/** Return every referenced node/group symbol, or null for an invalid expression. */
+function contentExpressionSymbols(content) {
+    try {
+        const expression = new ContentExpressionParser(content).parse();
+        const compiler = new ContentExpressionCompiler();
+        compiler.compile(expression);
+        const symbols = new Set();
+        collectExpressionSymbols(expression, symbols);
+        return [...symbols];
+    }
+    catch {
+        return null;
+    }
+}
+class ContentExpressionParser {
+    constructor(source) {
+        this.source = source;
+        this.position = 0;
+        this.depth = 0;
+    }
+    parse() {
+        if (this.source.trim() === '')
+            return { kind: 'empty' };
+        const expression = this.parseAlternation();
+        this.skipWhitespace();
+        if (!this.atEnd())
+            throw new Error(`unexpected '${this.peek()}'`);
+        return expression;
+    }
+    parseAlternation() {
+        const expressions = [this.parseSequence()];
+        while (true) {
+            this.skipWhitespace();
+            if (!this.consume('|'))
+                break;
+            this.skipWhitespace();
+            if (this.atEnd() || this.peek() === ')' || this.peek() === '|') {
+                throw new Error("missing expression after '|'");
+            }
+            expressions.push(this.parseSequence());
+        }
+        return expressions.length === 1 ? expressions[0] : { kind: 'alternation', expressions };
+    }
+    parseSequence() {
+        const expressions = [];
+        while (true) {
+            this.skipWhitespace();
+            if (this.atEnd() || this.peek() === ')' || this.peek() === '|')
+                break;
+            expressions.push(this.parseRepeated());
+        }
+        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('?'))
+            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('+'))
+            expression = { kind: 'repeat', expression: atom, min: 1, max: null };
+        else if (this.consume('{'))
+            expression = this.parseRange(atom);
+        this.skipWhitespace();
+        if (['?', '*', '+', '{'].includes(this.peek() ?? '')) {
+            throw new Error('multiple quantifiers');
+        }
+        return expression;
+    }
+    parseAtom() {
+        this.skipWhitespace();
+        if (this.consume('(')) {
+            if (this.depth >= exports.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');
+                const expression = this.parseAlternation();
+                this.skipWhitespace();
+                if (!this.consume(')'))
+                    throw new Error("missing ')'");
+                return expression;
+            }
+            finally {
+                this.depth -= 1;
+            }
+        }
+        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');
+        return { kind: 'symbol', symbol: this.source.slice(start, this.position) };
+    }
+    parseRange(expression) {
+        const min = this.parseNumber();
+        let max;
+        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 (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 };
+    }
+    parseNumber() {
+        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');
+        const value = Number(this.source.slice(start, this.position));
+        if (!Number.isSafeInteger(value) || value > 4294967295)
+            throw new Error('invalid count');
+        return value;
+    }
+    skipWhitespace() {
+        while (this.peek() != null && /\s/.test(this.peek()))
+            this.position += 1;
+    }
+    peek() {
+        return this.source[this.position];
+    }
+    consume(character) {
+        if (this.peek() !== character)
+            return false;
+        this.position += 1;
+        return true;
+    }
+    atEnd() {
+        return this.position === this.source.length;
+    }
+}
+class ContentExpressionCompiler {
+    constructor() {
+        this.states = [];
+    }
+    compile(expression, depth = 0) {
+        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();
+            this.states[start].epsilon.push(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];
+        }
+        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);
+                this.states[tail].epsilon.push(nestedStart);
+                tail = nestedEnd;
+            }
+            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);
+                this.states[start].epsilon.push(nestedStart);
+                this.states[nestedEnd].epsilon.push(end);
+            }
+            return [start, end];
+        }
+        return this.compileRepeat(expression.expression, expression.min, expression.max, depth + 1);
+    }
+    compileRepeat(expression, min, max, depth) {
+        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);
+            this.states[tail].epsilon.push(itemStart);
+            tail = itemEnd;
+        }
+        if (max == null) {
+            this.states[tail].epsilon.push(end);
+            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);
+                this.states[tail].epsilon.push(itemStart);
+                tail = itemEnd;
+            }
+            this.states[tail].epsilon.push(end);
+        }
+        return [start, end];
+    }
+    state() {
+        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, initial) {
+    const result = new Set();
+    const pending = [...initial];
+    while (pending.length > 0) {
+        const state = pending.pop();
+        if (result.has(state))
+            continue;
+        result.add(state);
+        pending.push(...states[state].epsilon);
+    }
+    return result;
+}
+function acceptingContentSymbols(content, existingChildTypes = [], symbolMatches = (child, symbol) => child === symbol) {
+    try {
+        const expression = new ContentExpressionParser(content).parse();
+        const compiler = new ContentExpressionCompiler();
+        const [start] = compiler.compile(expression);
+        let current = epsilonClosure(compiler.states, [start]);
+        for (const childType of existingChildTypes) {
+            const next = new Set();
+            for (const state of current) {
+                for (const transition of compiler.states[state].transitions) {
+                    if (symbolMatches(childType, transition.symbol))
+                        next.add(transition.target);
+                }
+            }
+            current = epsilonClosure(compiler.states, next);
+        }
+        const symbols = new Set();
+        for (const state of current) {
+            for (const transition of compiler.states[state].transitions) {
+                symbols.add(transition.symbol);
+            }
+        }
+        return [...symbols].sort();
+    }
+    catch {
+        return [];
+    }
+}
+function minimalContentMatch(content, choose, consumeWork = () => true) {
+    try {
+        const expression = new ContentExpressionParser(content).parse();
+        const compiler = new ContentExpressionCompiler();
+        const [start, accept] = compiler.compile(expression);
+        let current = new Map([[start, undefined]]);
+        const visited = new Set();
+        while (current.size > 0) {
+            const closure = new Map();
+            const pending = [...current.entries()];
+            while (pending.length > 0) {
+                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]);
+            }
+            const accepted = closure.get(accept);
+            if (closure.has(accept)) {
+                const result = [];
+                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))
+                    continue;
+                visited.add(state);
+                for (const transition of compiler.states[state].transitions) {
+                    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;
+    }
+}