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

package/dist/schemaDocument.js

@@ -43,7 +43,7 @@ function defaultEmptyDocument(schema = schemaPresets_1.defaultSchema, limits) {
 function resolveDocumentDescriptor(schema, limits) {
     const resolvedLimits = (0, schemaResolution_1.resolveDescriptorLimits)(limits);
     const resolvedSchema = (0, schemaResolution_1.resolveDocumentSchema)(schema, resolvedLimits);
-    const documentNode = resolvedSchema.nodes.find((node) => node.role === 'doc');
+    const documentNode = resolvedSchema.nodes.find(node => node.role === 'doc');
     if (!documentNode) {
         throw new NativeEditorBoundaryError_1.NativeEditorBoundaryError('SCHEMA_INVALID', 'schema has no document-role node');
     }

package/dist/schemaDocumentConstruction.js

@@ -4,9 +4,10 @@ exports.constructDefaultEmptyDocument = constructDefaultEmptyDocument;
 const contentExpression_1 = require("./contentExpression");
 const schemaNormalization_1 = require("./schemaNormalization");
 function constructDefaultEmptyDocument(schema, resolvedLimits, admittedCollections) {
-    const docNode = schema.nodes.find((node) => node.role === 'doc');
-    if (!docNode)
+    const docNode = schema.nodes.find(node => node.role === 'doc');
+    if (!docNode) {
         throw new Error('schema cannot construct a default document: missing doc role');
+    }
     const budget = { nodes: 0, work: 0, exhausted: false };
     const workLimit = Math.min(contentExpression_1.DEFAULT_CONTENT_MAX_NODES, resolvedLimits.maxSchemaNodes * 64 + resolvedLimits.maxSchemaExpressionBytes * 32);
     const consumeWork = () => {
@@ -27,13 +28,16 @@ function constructDefaultEmptyDocument(schema, resolvedLimits, admittedCollectio
     const candidatesBySymbol = new Map();
     let candidateIndexAdmitted = true;
     const addCandidate = (symbol, candidate) => {
-        if (!consumeWork())
+        if (!consumeWork()) {
             return false;
+        }
         const candidates = candidatesBySymbol.get(symbol);
-        if (candidates)
+        if (candidates) {
             candidates.push(candidate);
-        else
+        }
+        else {
             candidatesBySymbol.set(symbol, [candidate]);
+        }
         return true;
     };
     for (const candidate of schema.nodes) {
@@ -47,8 +51,9 @@ function constructDefaultEmptyDocument(schema, resolvedLimits, admittedCollectio
                 break;
             }
         }
-        if (!candidateIndexAdmitted)
+        if (!candidateIndexAdmitted) {
             break;
+        }
     }
     for (const candidates of candidatesBySymbol.values()) {
         const sortingWork = Math.max(candidates.length, Math.ceil(candidates.length * Math.log2(Math.max(2, candidates.length))));
@@ -58,8 +63,9 @@ function constructDefaultEmptyDocument(schema, resolvedLimits, admittedCollectio
                 break;
             }
         }
-        if (!candidateIndexAdmitted)
+        if (!candidateIndexAdmitted) {
             break;
+        }
         candidates.sort((left, right) => candidatePriority(left) - candidatePriority(right) ||
             left.name.localeCompare(right.name));
     }
@@ -71,10 +77,11 @@ function constructDefaultEmptyDocument(schema, resolvedLimits, admittedCollectio
             !consumeWork()) {
             return undefined;
         }
-        if (node.role === 'text' || visiting.has(node.name))
+        if (node.role === 'text' || visiting.has(node.name)) {
             return undefined;
+        }
         const attrs = admittedCollections.attrsByNode.get(node) ?? [];
-        for (const _attr of attrs) {
+        for (let index = 0; index < attrs.length; index += 1) {
             if (!consumeWork()) {
                 budget.exhausted = true;
                 return undefined;
@@ -84,27 +91,31 @@ function constructDefaultEmptyDocument(schema, resolvedLimits, admittedCollectio
             return undefined;
         }
         visiting.add(node.name);
-        const children = (0, contentExpression_1.minimalContentMatch)(node.content ?? '', (symbol) => {
+        const children = (0, contentExpression_1.minimalContentMatch)(node.content ?? '', symbol => {
             for (const candidate of candidatesBySymbol.get(symbol) ?? []) {
-                if (!consumeWork())
+                if (!consumeWork()) {
                     return undefined;
+                }
                 const constructed = constructNode(candidate, visiting, depth + 1);
-                if (constructed)
+                if (constructed) {
                     return constructed;
+                }
             }
             return undefined;
         }, consumeWork);
         visiting.delete(node.name);
-        if (!children)
+        if (!children) {
             return undefined;
+        }
         if (budget.nodes >= resolvedLimits.maxDocumentNodes) {
             budget.exhausted = true;
             return undefined;
         }
         budget.nodes += 1;
         const result = { type: node.json?.type ?? node.name };
-        if (children.length > 0)
+        if (children.length > 0) {
             result.content = children;
+        }
         const projectedAttrs = Object.entries(node.json?.attrs ?? {});
         if (attrs.length > 0 || projectedAttrs.length > 0) {
             result.attrs = Object.fromEntries([

package/dist/schemaNormalization.js

@@ -30,22 +30,26 @@ function utf8ByteLengthUpTo(value, maximum) {
     for (const char of value) {
         const codePoint = char.codePointAt(0) ?? 0;
         bytes += codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
-        if (bytes > maximum)
+        if (bytes > maximum) {
             return bytes;
+        }
     }
     return bytes;
 }
 function forEachGroupToken(group, visit, consumeCharacter, consumeToken) {
     let tokenStart = -1;
     for (let index = 0; index <= group.length; index += 1) {
-        if (index < group.length && consumeCharacter && !consumeCharacter())
+        if (index < group.length && consumeCharacter && !consumeCharacter()) {
             return false;
+        }
         const isBoundary = index === group.length || /\s/.test(group[index]);
-        if (!isBoundary && tokenStart < 0)
+        if (!isBoundary && tokenStart < 0) {
             tokenStart = index;
+        }
         if (isBoundary && tokenStart >= 0) {
-            if (consumeToken && !consumeToken())
+            if (consumeToken && !consumeToken()) {
                 return false;
+            }
             visit(group.slice(tokenStart, index));
             tokenStart = -1;
         }
@@ -67,21 +71,25 @@ function consumeSchemaStringWork(budget, value) {
     return consumeSchemaWorkAmount(budget, utf8ByteLengthUpTo(value, budget.limit) + 1);
 }
 function collectOwnAttrs(value, budget) {
-    if (value == null || typeof value !== 'object' || Array.isArray(value))
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         return [];
+    }
     const attrs = [];
     for (const name in value) {
-        if (!Object.prototype.hasOwnProperty.call(value, name))
+        if (!Object.prototype.hasOwnProperty.call(value, name)) {
             continue;
-        if (!consumeSchemaWork(budget))
+        }
+        if (!consumeSchemaWork(budget)) {
             return attrs;
+        }
         attrs.push([name, value[name]]);
     }
     return attrs;
 }
 function isSafeHtmlTag(tag) {
-    if (tag.length === 0 || tag[0] < 'a' || tag[0] > 'z')
+    if (tag.length === 0 || tag[0] < 'a' || tag[0] > 'z') {
         return false;
+    }
     for (let index = 1; index < tag.length; index += 1) {
         const char = tag[index];
         if (!((char >= 'a' && char <= 'z') || (char >= '0' && char <= '9') || char === '-')) {
@@ -91,11 +99,13 @@ function isSafeHtmlTag(tag) {
     return true;
 }
 function isSafeHtmlAttr(name) {
-    if (name.length === 0)
+    if (name.length === 0) {
         return false;
+    }
     const isAlpha = (char) => (char >= 'A' && char <= 'Z') || (char >= 'a' && char <= 'z');
-    if (!(isAlpha(name[0]) || name[0] === '_' || name[0] === ':'))
+    if (!(isAlpha(name[0]) || name[0] === '_' || name[0] === ':')) {
         return false;
+    }
     for (let index = 1; index < name.length; index += 1) {
         const char = name[index];
         if (!(isAlpha(char) ||
@@ -110,8 +120,9 @@ function isSafeHtmlAttr(name) {
     return true;
 }
 function normalizeAttrs(value) {
-    if (value == null || typeof value !== 'object' || Array.isArray(value))
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         return {};
+    }
     return Object.fromEntries(Object.entries(value).map(([name, rawSpec]) => {
         if (rawSpec == null || typeof rawSpec !== 'object' || Array.isArray(rawSpec)) {
             return [name, {}];
@@ -124,21 +135,27 @@ function normalizeAttrs(value) {
     }));
 }
 function normalizeNodeJSONProjection(value) {
-    if (value === undefined)
+    if (value === undefined) {
         return undefined;
-    if (value == null || typeof value !== 'object' || Array.isArray(value))
+    }
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         return null;
+    }
     const raw = value;
-    if (typeof raw.type !== 'string' || raw.type.length === 0)
+    if (typeof raw.type !== 'string' || raw.type.length === 0) {
         return null;
-    if (raw.attrs === undefined)
+    }
+    if (raw.attrs === undefined) {
         return { type: raw.type };
-    if (raw.attrs == null || typeof raw.attrs !== 'object' || Array.isArray(raw.attrs))
+    }
+    if (raw.attrs == null || typeof raw.attrs !== 'object' || Array.isArray(raw.attrs)) {
         return null;
+    }
     const attrs = {};
     for (const [name, attrValue] of Object.entries(raw.attrs)) {
-        if (!isSafeHtmlAttr(name))
+        if (!isSafeHtmlAttr(name)) {
             return null;
+        }
         if (attrValue !== null &&
             typeof attrValue !== 'string' &&
             typeof attrValue !== 'boolean' &&
@@ -158,26 +175,30 @@ function isSafeAtomHtmlAttr(name) {
         !atomPolicy_1.ATOM_HTML_DENIED_ATTRS.has(name));
 }
 function normalizeNodeHtmlRules(value) {
-    if (value === undefined)
+    if (value === undefined) {
         return undefined;
-    if (value == null || typeof value !== 'object' || Array.isArray(value))
+    }
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         return null;
+    }
     const raw = value;
-    if (Object.keys(raw).some((key) => key !== 'tag' && key !== 'staticAttrs' && key !== 'attrMap') ||
+    if (Object.keys(raw).some(key => key !== 'tag' && key !== 'staticAttrs' && key !== 'attrMap') ||
         typeof raw.tag !== 'string' ||
         !isSafeAtomHtmlTag(raw.tag)) {
         return null;
     }
     const normalizeMap = (candidate, validateName) => {
-        if (candidate === undefined)
+        if (candidate === undefined) {
             return undefined;
+        }
         if (candidate == null || typeof candidate !== 'object' || Array.isArray(candidate)) {
             return null;
         }
         const normalized = {};
         for (const [name, mapped] of Object.entries(candidate)) {
-            if (!validateName(name) || typeof mapped !== 'string')
+            if (!validateName(name) || typeof mapped !== 'string') {
                 return null;
+            }
             normalized[name] = mapped;
         }
         return normalized;
@@ -186,7 +207,7 @@ function normalizeNodeHtmlRules(value) {
     const attrMap = normalizeMap(raw.attrMap, isSafeHtmlAttr);
     if (staticAttrs === null ||
         attrMap === null ||
-        (attrMap != null && Object.values(attrMap).some((name) => !isSafeAtomHtmlAttr(name)))) {
+        (attrMap != null && Object.values(attrMap).some(name => !isSafeAtomHtmlAttr(name)))) {
         return null;
     }
     return {
@@ -199,8 +220,9 @@ function projectionAttrsOverlap(left, right) {
     return Object.entries(left).every(([name, value]) => !Object.prototype.hasOwnProperty.call(right, name) || right[name] === value);
 }
 function legacyHeadingProjectionName(projection) {
-    if (projection.type !== 'heading')
+    if (projection.type !== 'heading') {
         return undefined;
+    }
     const value = projection.attrs?.level;
     let level;
     if (typeof value === 'number' && Number.isInteger(value)) {
@@ -240,7 +262,7 @@ function normalizeSchemaDefinition(schema, budget) {
         if ((htmlTag != null && !isSafeHtmlTag(htmlTag)) ||
             html === null ||
             json === null ||
-            Object.keys(attrs).some((name) => !isSafeHtmlAttr(name))) {
+            Object.keys(attrs).some(name => !isSafeHtmlAttr(name))) {
             return null;
         }
         nodes.push({
@@ -261,8 +283,8 @@ function normalizeSchemaDefinition(schema, budget) {
                 : {}),
         });
     }
-    const nativeNodeNames = new Set(nodes.map((node) => node.name));
-    const projectedNodes = nodes.filter((node) => node.json != null);
+    const nativeNodeNames = new Set(nodes.map(node => node.name));
+    const projectedNodes = nodes.filter(node => node.json != null);
     for (let index = 0; index < projectedNodes.length; index += 1) {
         const node = projectedNodes[index];
         const projection = node.json;
@@ -272,7 +294,7 @@ function normalizeSchemaDefinition(schema, budget) {
             (legacyHeadingName != null &&
                 legacyHeadingName !== node.name &&
                 nativeNodeNames.has(legacyHeadingName)) ||
-            Object.keys(projection.attrs ?? {}).some((name) => Object.prototype.hasOwnProperty.call(node.attrs ?? {}, name))) {
+            Object.keys(projection.attrs ?? {}).some(name => Object.prototype.hasOwnProperty.call(node.attrs ?? {}, name))) {
             return null;
         }
         for (let previousIndex = 0; previousIndex < index; previousIndex += 1) {
@@ -296,7 +318,7 @@ function normalizeSchemaDefinition(schema, budget) {
         const htmlTag = typeof raw.htmlTag === 'string' ? raw.htmlTag.toLowerCase() : undefined;
         const attrs = normalizeAttrs(raw.attrs);
         if ((htmlTag != null && !schemaDefinition_1.ALLOWED_MARK_HTML_TAGS.has(htmlTag)) ||
-            Object.keys(attrs).some((name) => !isSafeHtmlAttr(name))) {
+            Object.keys(attrs).some(name => !isSafeHtmlAttr(name))) {
             return null;
         }
         marks.push({

package/dist/schemaPresets.d.ts

@@ -16,7 +16,7 @@ export interface ImageNodeAttributes {
 export interface ResolvedDocumentSchema {
     /** The schema itself, defaulted to {@link defaultSchema} when none was supplied. */
     schema: SchemaDefinition;
-    /** Name of the node with `role: 'doc'` — the `type` of a document's root. */
+    /** Name of the node with `role: 'doc'` : the `type` of a document's root. */
     documentNodeName: string;
     /** The smallest document this schema admits. Used by `clearContent()`. */
     emptyDocument: DocumentJSON;

package/dist/schemaPresets.js

@@ -9,7 +9,12 @@ exports.buildImageFragmentJson = buildImageFragmentJson;
 const schemaDefinition_1 = require("./schemaDefinition");
 /** Node name the built-in image node is stored under. */
 exports.IMAGE_NODE_NAME = 'image';
-exports.HEADING_LEVELS = [1, 2, 3, 4, 5, 6];
+exports.HEADING_LEVELS = [1,
+    2,
+    3,
+    4,
+    5,
+    6];
 /**
  * The built-in image node spec: a void block node carrying
  * {@link ImageNodeAttributes}. Add it through {@link withImagesSchema}.
@@ -41,7 +46,7 @@ function imageNodeSpec(name = exports.IMAGE_NODE_NAME) {
  * already declares one. {@link tiptapCompatibleSchema} already includes it.
  */
 function withImagesSchema(schema) {
-    const hasImageNode = schema.nodes.some((node) => node.name === exports.IMAGE_NODE_NAME);
+    const hasImageNode = schema.nodes.some(node => node.name === exports.IMAGE_NODE_NAME);
     if (hasImageNode) {
         return schema;
     }
@@ -93,13 +98,13 @@ exports.tiptapCompatibleSchemaSpec = {
             group: 'block',
             role: 'heading',
             attrs: { level: { default: 1 } },
-            parseDOM: exports.HEADING_LEVELS.map((level) => ({
+            parseDOM: exports.HEADING_LEVELS.map(level => ({
                 tag: `h${level}`,
                 attrs: { level },
             })),
             toDOM: {
                 switchOn: 'level',
-                cases: Object.fromEntries(exports.HEADING_LEVELS.map((level) => [level, [`h${level}`, 0]])),
+                cases: Object.fromEntries(exports.HEADING_LEVELS.map(level => [level, [`h${level}`, 0]])),
             },
         },
         blockquote: {

package/dist/schemaResolution.js

@@ -25,20 +25,23 @@ function admitSchemaCollections(schema, budget) {
     const attrsByNode = new Map();
     for (let nodeIndex = 0; nodeIndex < schema.nodes.length; nodeIndex += 1) {
         const node = schema.nodes[nodeIndex];
-        if (node == null || typeof node !== 'object')
+        if (node == null || typeof node !== 'object') {
             return null;
+        }
         const groups = [];
         if (typeof node.group === 'string') {
-            if (!(0, schemaNormalization_1.forEachGroupToken)(node.group, (group) => groups.push(group), () => (0, schemaNormalization_1.consumeSchemaWork)(budget), () => (0, schemaNormalization_1.consumeSchemaWork)(budget))) {
+            if (!(0, schemaNormalization_1.forEachGroupToken)(node.group, group => groups.push(group), () => (0, schemaNormalization_1.consumeSchemaWork)(budget), () => (0, schemaNormalization_1.consumeSchemaWork)(budget))) {
                 throw (0, schemaNormalization_1.schemaBoundaryError)(budget.limit, budget.limit + 1);
             }
         }
         const attrs = (0, schemaNormalization_1.collectOwnAttrs)(node.attrs, budget);
-        if (attrs == null)
+        if (attrs == null) {
             return null;
+        }
         const projectionAttrs = (0, schemaNormalization_1.collectOwnAttrs)(node.json?.attrs, budget);
-        if (projectionAttrs == null)
+        if (projectionAttrs == null) {
             return null;
+        }
         if (node.json != null &&
             ((typeof node.json.type === 'string' &&
                 !(0, schemaNormalization_1.consumeSchemaStringWork)(budget, node.json.type)) ||
@@ -62,11 +65,13 @@ function admitSchemaCollections(schema, budget) {
         if (!(0, schemaNormalization_1.consumeSchemaWork)(budget)) {
             throw (0, schemaNormalization_1.schemaBoundaryError)(budget.limit, budget.limit + 1);
         }
-        if (mark == null || typeof mark !== 'object')
+        if (mark == null || typeof mark !== 'object') {
             return null;
+        }
         const attrs = (0, schemaNormalization_1.collectOwnAttrs)(mark.attrs, budget);
-        if (attrs == null)
+        if (attrs == null) {
             return null;
+        }
         if (budget.exhausted) {
             throw (0, schemaNormalization_1.schemaBoundaryError)(budget.limit, budget.limit + 1);
         }
@@ -75,10 +80,12 @@ function admitSchemaCollections(schema, budget) {
 }
 /** Mirror native's invalid-schema fallback after bounded admission succeeds. */
 function resolveDocumentSchema(schema, limits) {
-    if (schema == null)
+    if (schema == null) {
         return schemaPresets_1.defaultSchema;
-    if (!Array.isArray(schema.nodes))
+    }
+    if (!Array.isArray(schema.nodes)) {
         return schemaPresets_1.defaultSchema;
+    }
     if (!Array.isArray(schema.marks)) {
         schema = { ...schema, marks: [] };
     }
@@ -97,19 +104,22 @@ function resolveDocumentSchema(schema, limits) {
         }
     }
     const schemaBudget = createSchemaWorkBudget(resolvedLimits);
-    if (admitSchemaCollections(schema, schemaBudget) == null)
+    if (admitSchemaCollections(schema, schemaBudget) == null) {
         return schemaPresets_1.defaultSchema;
+    }
     const normalizedSchema = (0, schemaNormalization_1.normalizeSchemaDefinition)(schema, schemaBudget);
-    if (normalizedSchema == null)
+    if (normalizedSchema == null) {
         return schemaPresets_1.defaultSchema;
+    }
     schema = normalizedSchema;
     const admittedCollections = admitSchemaCollections(schema, {
         limit: Number.MAX_SAFE_INTEGER,
         work: 0,
         exhausted: false,
     });
-    if (admittedCollections == null)
+    if (admittedCollections == null) {
         return schemaPresets_1.defaultSchema;
+    }
     const nodeNames = new Set();
     const markNames = new Set();
     let docRoles = 0;
@@ -124,10 +134,12 @@ function resolveDocumentSchema(schema, limits) {
             return schemaPresets_1.defaultSchema;
         }
         nodeNames.add(node.name);
-        if (node.role === 'doc')
+        if (node.role === 'doc') {
             docRoles += 1;
-        if (node.role === 'text')
+        }
+        if (node.role === 'text') {
             textRoles += 1;
+        }
     }
     for (const mark of schema.marks) {
         if (mark == null ||
@@ -138,16 +150,19 @@ function resolveDocumentSchema(schema, limits) {
         }
         markNames.add(mark.name);
     }
-    if (docRoles !== 1 || textRoles !== 1)
+    if (docRoles !== 1 || textRoles !== 1) {
         return schemaPresets_1.defaultSchema;
+    }
     const groups = new Set();
     const nodesBySymbol = new Map();
     const addCandidate = (symbol, node) => {
         const candidates = nodesBySymbol.get(symbol);
-        if (candidates)
+        if (candidates) {
             candidates.push(node);
-        else
+        }
+        else {
             nodesBySymbol.set(symbol, [node]);
+        }
     };
     for (const node of schema.nodes) {
         addCandidate(node.name, node);
@@ -159,22 +174,25 @@ function resolveDocumentSchema(schema, limits) {
     for (const node of schema.nodes) {
         const symbols = (0, contentExpression_1.contentExpressionSymbols)(node.content);
         if (symbols == null ||
-            symbols.some((symbol) => !nodeNames.has(symbol) && !groups.has(symbol))) {
+            symbols.some(symbol => !nodeNames.has(symbol) && !groups.has(symbol))) {
             return schemaPresets_1.defaultSchema;
         }
     }
     const generatable = new Set();
     const consumeWork = () => (0, schemaNormalization_1.consumeSchemaWork)(schemaBudget);
     const contentIsConstructible = (node) => {
-        if (!consumeWork())
+        if (!consumeWork()) {
             return false;
-        return ((0, contentExpression_1.minimalContentMatch)(node.content, (symbol) => {
+        }
+        return ((0, contentExpression_1.minimalContentMatch)(node.content, symbol => {
             const candidates = nodesBySymbol.get(symbol) ?? [];
             for (const candidate of candidates) {
-                if (!consumeWork())
+                if (!consumeWork()) {
                     return undefined;
-                if (generatable.has(candidate.name))
+                }
+                if (generatable.has(candidate.name)) {
                     return { type: candidate.name };
+                }
             }
             return undefined;
         }, consumeWork) != null);
@@ -187,25 +205,28 @@ function resolveDocumentSchema(schema, limits) {
                 generatable.add(node.name);
             }
         }
-        if (generatable.size === before)
+        if (generatable.size === before) {
             break;
+        }
     }
     if (schemaBudget.exhausted) {
         throw (0, schemaNormalization_1.schemaBoundaryError)(schemaBudget.limit, schemaBudget.limit + 1);
     }
-    const hasUnconstructibleNode = schema.nodes.some((node) => !contentIsConstructible(node));
+    const hasUnconstructibleNode = schema.nodes.some(node => !contentIsConstructible(node));
     if (schemaBudget.exhausted) {
         throw (0, schemaNormalization_1.schemaBoundaryError)(schemaBudget.limit, schemaBudget.limit + 1);
     }
-    if (hasUnconstructibleNode)
+    if (hasUnconstructibleNode) {
         return schemaPresets_1.defaultSchema;
+    }
     try {
         (0, schemaDocumentConstruction_1.constructDefaultEmptyDocument)(schema, resolvedLimits, admittedCollections);
         return schema;
     }
     catch (error) {
-        if (error instanceof NativeEditorBoundaryError_1.NativeEditorBoundaryError)
+        if (error instanceof NativeEditorBoundaryError_1.NativeEditorBoundaryError) {
             throw error;
+        }
         return schemaPresets_1.defaultSchema;
     }
 }

package/dist/specs/PreparedProseViewerNativeComponent.d.ts

@@ -15,6 +15,10 @@ export interface NativeProps extends ViewProps {
         href: string;
         text: string;
     }>;
+    /**
+     * React Native numbers are IEEE-754 doubles, which exactly represent every
+     * UInt32 document position. Int32 would corrupt positions above 2^31 - 1.
+     */
     onPressMention?: DirectEventHandler<{
         docPos: Double;
         label: string;

package/dist/useEditorToolbarInteractions.d.ts

@@ -1,5 +1,5 @@
-import { useEditorToolbarState } from './useEditorToolbarState';
-import { useEditorToolbarItems } from './useEditorToolbarItems';
+import { type useEditorToolbarState } from './useEditorToolbarState';
+import { type useEditorToolbarItems } from './useEditorToolbarItems';
 import { type ToolbarButton, type ToolbarGroupButton } from './EditorToolbarTypes';
 export declare function useEditorToolbarInteractions(context: Pick<ReturnType<typeof useEditorToolbarState>, 'showTopBorder' | 'theme' | 'registrationIdRef' | 'rootRef' | 'publishesFocusFrames' | 'frameOwnerId' | 'framePublisherMountedRef' | 'publishesFocusFramesRef' | 'frameOwnerIdRef' | 'menuRegistrationIdRef' | 'menuCardRef' | 'menuState' | 'menuStateRef' | 'framePublishAnimationFramesRef' | 'framePublishTimeoutsRef' | 'expandedGroupKey' | 'windowHeight' | 'windowWidth' | 'toolbarInteractionActiveRef' | 'setExpandedGroupKey' | 'setMenuState' | 'shouldRenderMentionSuggestions' | 'preserveEditorFocus' | 'groupButtonRefs'> & Pick<ReturnType<typeof useEditorToolbarItems>, 'startItems' | 'scrollItems' | 'endItems' | 'groupsByKey'>): {
     handleToolbarPressIn: () => void;