@portabletext/editor 6.6.3 → 7.0.0

package/lib/_chunks-es/util.slice-blocks.js

@@ -1,12 +1,114 @@
-import { isTextBlock, isSpan } from "@portabletext/schema";
-function isTypedObject(object) {
-  return isRecord(object) && typeof object._type == "string";
+import { isTextBlock, isSpan, getSubSchema } from "@portabletext/schema";
+import { getAncestor, getNode, isKeyedSegment, isTypedObject, isRecord } from "./get-ancestor.js";
+function getAncestorTextBlock(snapshot, path) {
+  const result = getAncestor(snapshot, path, (node) => isTextBlock({
+    schema: snapshot.context.schema
+  }, node));
+  if (result && isTextBlock({
+    schema: snapshot.context.schema
+  }, result.node))
+    return {
+      node: result.node,
+      path: result.path
+    };
+}
+function blockOffsetToSpanSelectionPoint({
+  snapshot,
+  blockOffset,
+  direction
+}) {
+  const blockEntry = getNode(snapshot, blockOffset.path);
+  if (!blockEntry || !isTextBlock(snapshot.context, blockEntry.node))
+    return;
+  const block = blockEntry.node, blockPath = blockEntry.path;
+  let offsetLeft = blockOffset.offset, selectionPoint, skippedInlineObject = !1;
+  for (const child of block.children) {
+    if (direction === "forward") {
+      if (!isSpan(snapshot.context, child))
+        continue;
+      if (offsetLeft <= child.text.length) {
+        selectionPoint = {
+          path: [...blockPath, "children", {
+            _key: child._key
+          }],
+          offset: offsetLeft
+        };
+        break;
+      }
+      offsetLeft -= child.text.length;
+      continue;
+    }
+    if (!isSpan(snapshot.context, child)) {
+      skippedInlineObject = !0;
+      continue;
+    }
+    if (offsetLeft === 0 && selectionPoint && !skippedInlineObject) {
+      skippedInlineObject && (selectionPoint = {
+        path: [...blockPath, "children", {
+          _key: child._key
+        }],
+        offset: 0
+      });
+      break;
+    }
+    if (offsetLeft > child.text.length) {
+      offsetLeft -= child.text.length;
+      continue;
+    }
+    if (offsetLeft <= child.text.length && (selectionPoint = {
+      path: [...blockPath, "children", {
+        _key: child._key
+      }],
+      offset: offsetLeft
+    }, offsetLeft -= child.text.length, offsetLeft !== 0))
+      break;
+  }
+  return selectionPoint;
+}
+function spanSelectionPointToBlockOffset({
+  snapshot,
+  selectionPoint
+}) {
+  const spanSegment = selectionPoint.path.at(-1);
+  if (!isKeyedSegment(spanSegment))
+    return;
+  const textBlock = getAncestorTextBlock(snapshot, selectionPoint.path);
+  if (!textBlock)
+    return;
+  let offset = 0;
+  for (const child of textBlock.node.children)
+    if (isSpan(snapshot.context, child)) {
+      if (child._key === spanSegment._key)
+        return {
+          path: textBlock.path,
+          offset: offset + selectionPoint.offset
+        };
+      offset += child.text.length;
+    }
+}
+function isEqualPathSegments(segA, segB) {
+  return segA === segB ? !0 : segA === void 0 || segB === void 0 ? !1 : (typeof segA == "string" || typeof segA == "number") && (typeof segB == "string" || typeof segB == "number") ? segA === segB : isKeyedSegment(segA) && isKeyedSegment(segB) ? segA._key === segB._key : Array.isArray(segA) && Array.isArray(segB) ? segA[0] === segB[0] && segA[1] === segB[1] : !1;
+}
+function isEqualPaths(a, b) {
+  if (a.length !== b.length)
+    return !1;
+  for (let i = 0; i < a.length; i++)
+    if (!isEqualPathSegments(a[i], b[i]))
+      return !1;
+  return !0;
+}
+function isEqualSelectionPoints(a, b) {
+  return a.offset === b.offset && isEqualPaths(a.path, b.path);
 }
-function isRecord(value) {
-  return !!value && (typeof value == "object" || typeof value == "function");
+function getBlockKeyFromSelectionPoint(point) {
+  const blockPathSegment = point.path.at(0);
+  if (isKeyedSegment(blockPathSegment))
+    return blockPathSegment._key;
 }
-function isKeyedSegment(segment) {
-  return typeof segment == "object" && segment !== null && "_key" in segment;
+function getChildKeyFromSelectionPoint(point) {
+  const childPathSegment = point.path.at(2);
+  if (isKeyedSegment(childPathSegment))
+    return childPathSegment._key;
 }
 function getBlockEndPoint({
   context,
@@ -45,38 +147,25 @@ function getBlockStartPoint({
     offset: 0
   };
 }
-function isEqualPathSegments(segA, segB) {
-  return segA === segB ? !0 : segA === void 0 || segB === void 0 ? !1 : (typeof segA == "string" || typeof segA == "number") && (typeof segB == "string" || typeof segB == "number") ? segA === segB : isKeyedSegment(segA) && isKeyedSegment(segB) ? segA._key === segB._key : Array.isArray(segA) && Array.isArray(segB) ? segA[0] === segB[0] && segA[1] === segB[1] : !1;
-}
-function isEqualPaths(a, b) {
-  if (a.length !== b.length)
-    return !1;
-  for (let i = 0; i < a.length; i++)
-    if (!isEqualPathSegments(a[i], b[i]))
-      return !1;
-  return !0;
-}
 function isSelectionCollapsed(selection) {
   return selection ? isEqualPaths(selection.anchor.path, selection.focus.path) && selection.anchor.offset === selection.focus.offset : !1;
 }
-function getBlockKeyFromSelectionPoint(point) {
-  const blockPathSegment = point.path.at(0);
-  if (isKeyedSegment(blockPathSegment))
-    return blockPathSegment._key;
+function getSelectionEndPoint(selection) {
+  return selection ? selection.backward ? selection.anchor : selection.focus : null;
 }
-function getChildKeyFromSelectionPoint(point) {
-  const childPathSegment = point.path.at(2);
-  if (isKeyedSegment(childPathSegment))
-    return childPathSegment._key;
+function getSelectionStartPoint(selection) {
+  return selection ? selection.backward ? selection.focus : selection.anchor : null;
 }
 function parseBlocks({
-  context,
+  schema,
+  keyGenerator,
   blocks,
   options
 }) {
   return Array.isArray(blocks) ? blocks.flatMap((block) => {
-    const parsedBlock = parseBlock({
-      context,
+    const parsedBlock = parseBlockInternal({
+      schema,
+      keyGenerator,
       block,
       options
     });
@@ -84,37 +173,94 @@ function parseBlocks({
   }) : [];
 }
 function parseBlock({
-  context,
+  schema,
+  keyGenerator,
+  block,
+  options
+}) {
+  return parseBlockInternal({
+    schema,
+    keyGenerator,
+    block,
+    options
+  });
+}
+function parseSpan({
+  span,
+  schema,
+  keyGenerator,
+  markDefKeyMap,
+  options
+}) {
+  return parseSpanInternal({
+    span,
+    schema,
+    keyGenerator,
+    markDefKeyMap,
+    options
+  });
+}
+function parseInlineObject({
+  inlineObject,
+  schema,
+  keyGenerator,
+  options
+}) {
+  return parseInlineObjectInternal({
+    inlineObject,
+    schema,
+    keyGenerator,
+    options
+  });
+}
+function parseMarkDefs({
+  schema,
+  keyGenerator,
+  markDefs,
+  options
+}) {
+  return parseMarkDefsInternal({
+    schema,
+    keyGenerator,
+    markDefs,
+    options
+  });
+}
+function parseBlockInternal({
+  schema,
+  keyGenerator,
   block,
   options
 }) {
   return parseTextBlock({
     block,
-    context,
+    schema,
+    keyGenerator,
     options
   }) ?? parseBlockObject({
     blockObject: block,
-    context,
+    schema,
+    keyGenerator,
     options
   });
 }
 function parseBlockObject({
   blockObject,
-  context,
+  schema,
+  keyGenerator,
   options
 }) {
   if (!isTypedObject(blockObject))
     return;
-  const schemaType = context.schema.blockObjects.find(({
+  const schemaType = schema.blockObjects.find(({
     name
   }) => name === blockObject._type);
   if (schemaType)
     return parseObject({
       object: blockObject,
-      context: {
-        keyGenerator: context.keyGenerator,
-        schemaType
-      },
+      schema,
+      keyGenerator,
+      schemaType,
       options
     });
 }
@@ -123,61 +269,67 @@ function isListBlock(context, block) {
 }
 function parseTextBlock({
   block,
-  context,
+  schema,
+  keyGenerator,
   options
 }) {
-  if (!isTypedObject(block))
+  if (!isTypedObject(block) || block._type !== schema.block.name)
     return;
   const customFields = {};
   for (const key of Object.keys(block))
-    key === "_type" || key === "_key" || key === "children" || key === "markDefs" || key === "style" || key === "listItem" || key === "level" || (options.validateFields ? context.schema.block.fields?.some((field) => field.name === key) && (customFields[key] = block[key]) : customFields[key] = block[key]);
-  if (block._type !== context.schema.block.name)
-    return;
-  const _key = typeof block._key == "string" ? block._key : context.keyGenerator(), {
+    key === "_type" || key === "_key" || key === "children" || key === "markDefs" || key === "style" || key === "listItem" || key === "level" || (options.validateFields ? (schema.block.fields ?? []).some((f) => f.name === key) && (customFields[key] = block[key]) : customFields[key] = block[key]);
+  const _key = typeof block._key == "string" ? block._key : keyGenerator(), {
     markDefs,
     markDefKeyMap
-  } = parseMarkDefs({
-    context,
+  } = parseMarkDefsInternal({
+    schema,
+    keyGenerator,
     markDefs: block.markDefs,
     options
-  }), parsedChildren = (Array.isArray(block.children) ? block.children : []).map((child) => parseChild({
+  }), parsedChildren = (Array.isArray(block.children) ? block.children : []).map((child) => parseChildInternal({
     child,
-    context,
+    schema,
+    keyGenerator,
     markDefKeyMap,
     options
   })).filter((child) => child !== void 0), marks = parsedChildren.flatMap((child) => child.marks ?? []), children = parsedChildren.length > 0 ? parsedChildren : [{
-    _key: context.keyGenerator(),
-    _type: context.schema.span.name,
+    _key: keyGenerator(),
+    _type: schema.span.name,
     text: "",
     marks: []
   }], normalizedChildren = options.normalize ? (
     // Ensure that inline objects re surrounded by spans
     children.reduce((normalizedChildren2, child, index) => {
-      if (isSpan(context, child))
+      if (isSpan({
+        schema
+      }, child))
         return [...normalizedChildren2, child];
       const previousChild = normalizedChildren2.at(-1);
-      return !previousChild || !isSpan(context, previousChild) ? [...normalizedChildren2, {
-        _key: context.keyGenerator(),
-        _type: context.schema.span.name,
+      return !previousChild || !isSpan({
+        schema
+      }, previousChild) ? [...normalizedChildren2, {
+        _key: keyGenerator(),
+        _type: schema.span.name,
         text: "",
         marks: []
       }, child, ...index === children.length - 1 ? [{
-        _key: context.keyGenerator(),
-        _type: context.schema.span.name,
+        _key: keyGenerator(),
+        _type: schema.span.name,
         text: "",
         marks: []
       }] : []] : [...normalizedChildren2, child];
     }, [])
   ) : children, parsedBlock = {
-    _type: context.schema.block.name,
+    _type: schema.block.name,
     _key,
     children: normalizedChildren,
     ...customFields
   };
-  return typeof block.markDefs == "object" && block.markDefs !== null && (parsedBlock.markDefs = options.removeUnusedMarkDefs ? markDefs.filter((markDef) => marks.includes(markDef._key)) : markDefs), typeof block.style == "string" && context.schema.styles.find((style) => style.name === block.style) && (parsedBlock.style = block.style), typeof block.listItem == "string" && context.schema.lists.find((list) => list.name === block.listItem) && (parsedBlock.listItem = block.listItem), typeof block.level == "number" && (parsedBlock.level = block.level), parsedBlock;
+  return typeof block.markDefs == "object" && block.markDefs !== null && (parsedBlock.markDefs = options.removeUnusedMarkDefs ? markDefs.filter((markDef) => marks.includes(markDef._key)) : markDefs), typeof block.style == "string" && schema.styles.find((style) => style.name === block.style) && (parsedBlock.style = block.style), typeof block.listItem == "string" && schema.lists.find((list) => list.name === block.listItem) && (parsedBlock.listItem = block.listItem), typeof block.level == "number" && (parsedBlock.level = block.level), parsedBlock;
 }
-function parseMarkDefs({
-  context,
+function parseMarkDefsInternal({
+  schema,
+  keyGenerator,
   markDefs,
   options
 }) {
@@ -186,7 +338,7 @@ function parseMarkDefs({
     markDefs: unparsedMarkDefs.flatMap((markDef) => {
       if (!isTypedObject(markDef))
         return [];
-      const schemaType = context.schema.annotations.find(({
+      const schemaType = schema.annotations.find(({
         name
       }) => name === markDef._type);
       if (!schemaType)
@@ -195,10 +347,9 @@ function parseMarkDefs({
         return [];
       const parsedAnnotation = parseObject({
         object: markDef,
-        context: {
-          schemaType,
-          keyGenerator: context.keyGenerator
-        },
+        schema,
+        keyGenerator,
+        schemaType,
         options
       });
       return parsedAnnotation ? (markDefKeyMap.set(markDef._key, parsedAnnotation._key), [parsedAnnotation]) : [];
@@ -206,26 +357,30 @@ function parseMarkDefs({
     markDefKeyMap
   };
 }
-function parseChild({
+function parseChildInternal({
   child,
-  context,
+  schema,
+  keyGenerator,
   markDefKeyMap,
   options
 }) {
-  return parseSpan({
+  return parseSpanInternal({
     span: child,
-    context,
+    schema,
+    keyGenerator,
     markDefKeyMap,
     options
-  }) ?? parseInlineObject({
+  }) ?? parseInlineObjectInternal({
     inlineObject: child,
-    context,
+    schema,
+    keyGenerator,
     options
   });
 }
-function parseSpan({
+function parseSpanInternal({
   span,
-  context,
+  schema,
+  keyGenerator,
   markDefKeyMap,
   options
 }) {
@@ -238,164 +393,166 @@ function parseSpan({
     if (typeof mark != "string")
       return [];
     const markDefKey = markDefKeyMap.get(mark);
-    return markDefKey !== void 0 ? [markDefKey] : context.schema.decorators.some((decorator) => decorator.name === mark) ? [mark] : [];
+    return markDefKey !== void 0 ? [markDefKey] : schema.decorators.some((decorator) => decorator.name === mark) ? [mark] : [];
   });
-  if (!(typeof span._type == "string" && span._type !== context.schema.span.name))
+  if (!(typeof span._type == "string" && span._type !== schema.span.name))
     return typeof span._type != "string" ? typeof span.text == "string" ? {
-      _type: context.schema.span.name,
-      _key: typeof span._key == "string" ? span._key : context.keyGenerator(),
+      _type: schema.span.name,
+      _key: typeof span._key == "string" ? span._key : keyGenerator(),
       text: span.text,
       marks,
       ...options.validateFields ? {} : customFields
     } : void 0 : {
-      _type: context.schema.span.name,
-      _key: typeof span._key == "string" ? span._key : context.keyGenerator(),
+      _type: schema.span.name,
+      _key: typeof span._key == "string" ? span._key : keyGenerator(),
       text: typeof span.text == "string" ? span.text : "",
       marks,
       ...options.validateFields ? {} : customFields
     };
 }
-function parseInlineObject({
+function parseInlineObjectInternal({
   inlineObject,
-  context,
+  schema,
+  keyGenerator,
   options
 }) {
   if (!isTypedObject(inlineObject))
     return;
-  const schemaType = context.schema.inlineObjects.find(({
+  const schemaType = schema.inlineObjects.find(({
     name
   }) => name === inlineObject._type);
   if (schemaType)
     return parseObject({
       object: inlineObject,
-      context: {
-        keyGenerator: context.keyGenerator,
-        schemaType
-      },
+      schema,
+      keyGenerator,
+      schemaType,
       options
     });
 }
 function parseAnnotation({
   annotation,
-  context,
+  schema,
+  keyGenerator,
   options
 }) {
   if (!isTypedObject(annotation))
     return;
-  const schemaType = context.schema.annotations.find(({
+  const schemaType = schema.annotations.find(({
     name
   }) => name === annotation._type);
   if (schemaType)
     return parseObject({
       object: annotation,
-      context: {
-        keyGenerator: context.keyGenerator,
-        schemaType
-      },
+      schema,
+      keyGenerator,
+      schemaType,
       options
     });
 }
+function resolveOfMember(of, typeName, schema, ancestorFields) {
+  for (const member of of)
+    if (member.type !== "block") {
+      if (member.type === "object" && "name" in member && member.name) {
+        if (member.name === typeName && "fields" in member && member.fields)
+          return {
+            name: member.name,
+            fields: member.fields
+          };
+        continue;
+      }
+      if (member.type === typeName) {
+        const ancestorMatch = ancestorFields.get(typeName);
+        if (ancestorMatch)
+          return {
+            name: typeName,
+            fields: ancestorMatch
+          };
+        const rootMatch = schema.blockObjects.find((blockObject) => blockObject.name === typeName);
+        return rootMatch && "fields" in rootMatch && rootMatch.fields ? {
+          name: rootMatch.name,
+          fields: rootMatch.fields
+        } : void 0;
+      }
+    }
+}
 function parseObject({
   object,
-  context,
+  schema,
+  keyGenerator,
+  schemaType,
+  ancestorFields,
   options
 }) {
   const {
-    _type,
     _key,
     ...customFields
-  } = object, values = options.validateFields ? context.schemaType.fields.reduce((fieldValues, field) => {
-    const fieldValue = object[field.name];
-    return fieldValue !== void 0 && (fieldValues[field.name] = fieldValue), fieldValues;
-  }, {}) : customFields;
+  } = object, fieldsByName = new Map(schemaType.fields.map((field) => [field.name, field])), nextAncestors = new Map(ancestorFields ?? []);
+  nextAncestors.set(schemaType.name, schemaType.fields);
+  const values = {};
+  for (const [key, value] of Object.entries(customFields)) {
+    if (key === "_type" || value === void 0)
+      continue;
+    const field = fieldsByName.get(key);
+    if (!(options.validateFields && !field)) {
+      if (field && field.type === "array" && field.of && Array.isArray(value)) {
+        values[key] = parseContainerFieldValue({
+          schema,
+          keyGenerator,
+          of: field.of,
+          value,
+          ancestorFields: nextAncestors,
+          options
+        });
+        continue;
+      }
+      values[key] = value;
+    }
+  }
   return {
-    _type: context.schemaType.name,
-    _key: typeof object._key == "string" ? object._key : context.keyGenerator(),
+    _type: schemaType.name,
+    _key: typeof _key == "string" ? _key : keyGenerator(),
     ...values
   };
 }
-function blockOffsetToSpanSelectionPoint({
-  context,
-  blockOffset,
-  direction
+function parseContainerFieldValue({
+  schema,
+  keyGenerator,
+  of,
+  value,
+  ancestorFields,
+  options
 }) {
-  let offsetLeft = blockOffset.offset, selectionPoint, skippedInlineObject = !1;
-  for (const block of context.value)
-    if (block._key === blockOffset.path[0]._key && isTextBlock(context, block))
-      for (const child of block.children) {
-        if (direction === "forward") {
-          if (!isSpan(context, child))
-            continue;
-          if (offsetLeft <= child.text.length) {
-            selectionPoint = {
-              path: [...blockOffset.path, "children", {
-                _key: child._key
-              }],
-              offset: offsetLeft
-            };
-            break;
-          }
-          offsetLeft -= child.text.length;
-          continue;
-        }
-        if (!isSpan(context, child)) {
-          skippedInlineObject = !0;
-          continue;
-        }
-        if (offsetLeft === 0 && selectionPoint && !skippedInlineObject) {
-          skippedInlineObject && (selectionPoint = {
-            path: [...blockOffset.path, "children", {
-              _key: child._key
-            }],
-            offset: 0
-          });
-          break;
+  const childBlockSubSchema = of.some((member) => member.type === "block") ? getSubSchema(schema, of) : void 0;
+  return value.flatMap((item) => {
+    if (!isTypedObject(item))
+      return [item];
+    if (childBlockSubSchema && item._type === childBlockSubSchema.block.name) {
+      const parsed = parseTextBlock({
+        block: item,
+        schema: childBlockSubSchema,
+        keyGenerator,
+        options: {
+          normalize: !1,
+          removeUnusedMarkDefs: !1,
+          validateFields: options.validateFields
         }
-        if (offsetLeft > child.text.length) {
-          offsetLeft -= child.text.length;
-          continue;
-        }
-        if (offsetLeft <= child.text.length && (selectionPoint = {
-          path: [...blockOffset.path, "children", {
-            _key: child._key
-          }],
-          offset: offsetLeft
-        }, offsetLeft -= child.text.length, offsetLeft !== 0))
-          break;
-      }
-  return selectionPoint;
-}
-function spanSelectionPointToBlockOffset({
-  context,
-  selectionPoint
-}) {
-  let offset = 0;
-  const blockKey = getBlockKeyFromSelectionPoint(selectionPoint), spanKey = getChildKeyFromSelectionPoint(selectionPoint);
-  if (!(!blockKey || !spanKey)) {
-    for (const block of context.value)
-      if (block._key === blockKey && isTextBlock(context, block)) {
-        for (const child of block.children)
-          if (isSpan(context, child)) {
-            if (child._key === spanKey)
-              return {
-                path: [{
-                  _key: block._key
-                }],
-                offset: offset + selectionPoint.offset
-              };
-            offset += child.text.length;
-          }
-      }
-  }
-}
-function getSelectionEndPoint(selection) {
-  return selection ? selection.backward ? selection.anchor : selection.focus : null;
-}
-function getSelectionStartPoint(selection) {
-  return selection ? selection.backward ? selection.focus : selection.anchor : null;
-}
-function isEqualSelectionPoints(a, b) {
-  return a.offset === b.offset && isEqualPaths(a.path, b.path);
+      });
+      return parsed ? [parsed] : [];
+    }
+    const schemaType = resolveOfMember(of, item._type, schema, ancestorFields);
+    return schemaType ? [parseObject({
+      object: item,
+      schema,
+      keyGenerator,
+      schemaType: {
+        name: schemaType.name,
+        fields: schemaType.fields
+      },
+      ancestorFields,
+      options
+    })] : [item];
+  });
 }
 const defaultKeyGenerator = () => randomKey(12), getByteHexTable = /* @__PURE__ */ (() => {
   let table;
@@ -501,59 +658,51 @@ function sliceBlocks({
       break;
     }
     startBlock && middleBlocks.push(parseBlock({
-      context: {
-        schema: context.schema,
-        keyGenerator: context.keyGenerator ?? defaultKeyGenerator
-      },
+      keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
       block,
       options: {
         normalize: !1,
         removeUnusedMarkDefs: !0,
         validateFields: !1
-      }
+      },
+      schema: context.schema
     }) ?? block);
   }
   const parsedStartBlock = startBlock ? parseBlock({
-    context: {
-      schema: context.schema,
-      keyGenerator: context.keyGenerator ?? defaultKeyGenerator
-    },
+    keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
     block: startBlock,
     options: {
       normalize: !1,
       removeUnusedMarkDefs: !0,
       validateFields: !1
-    }
-  }) : void 0, parsedEndBlock = endBlock ? parseBlock({
-    context: {
-      schema: context.schema,
-      keyGenerator: context.keyGenerator ?? defaultKeyGenerator
     },
+    schema: context.schema
+  }) : void 0, parsedEndBlock = endBlock ? parseBlock({
+    keyGenerator: context.keyGenerator ?? defaultKeyGenerator,
     block: endBlock,
     options: {
       normalize: !1,
       removeUnusedMarkDefs: !0,
       validateFields: !1
-    }
+    },
+    schema: context.schema
   }) : void 0;
   return [...parsedStartBlock ? [parsedStartBlock] : [], ...middleBlocks, ...parsedEndBlock ? [parsedEndBlock] : []];
 }
 export {
   blockOffsetToSpanSelectionPoint,
   defaultKeyGenerator,
+  getAncestorTextBlock,
   getBlockEndPoint,
   getBlockKeyFromSelectionPoint,
   getBlockStartPoint,
-  getChildKeyFromSelectionPoint,
   getSelectionEndPoint,
   getSelectionStartPoint,
   isEqualPathSegments,
   isEqualPaths,
   isEqualSelectionPoints,
-  isKeyedSegment,
   isListBlock,
   isSelectionCollapsed,
-  isTypedObject,
   parseAnnotation,
   parseBlock,
   parseBlocks,