How to use the slate.Text.create function in slate

// Set patches patching either string values or span objects
    if (patch.type === 'set') {
      const valueIsString = isString(patch.value)
      const patchSpan = valueIsString ? null : (patch.value as Span)
      const patchText = valueIsString ? patch.value : patchSpan.text
      // If single leaf, we can just replace the text with the current marks
      if (textNode.leaves.size === 1) {
        let marks
        // eslint-disable-next-line max-depth
        if (valueIsString) {
          marks = textNode.leaves.map(leaf => leaf.marks).get(0)
        } else {
          marks = Mark.createSet(patchSpan.marks.map(mark => ({type: mark})))
        }
        editor.replaceNodeByPath(textPath, Text.create({text: patchText, marks}))
        return editor.operations
      }

      // Build the new text
      workTextNode.leaves[leafIndex] = {
        object: 'leaf',
        text: patchText,
        marks: valueIsString
          ? node.leaves.get(leafIndex).marks
          : Mark.createSet(patchSpan.marks.map(mark => ({type: mark})))
      }
      // Replace it
      editor.replaceNodeByPath(textPath, Text.fromJSON(workTextNode))
      return editor.operations
    }

const value = new wrappers[contentType](rawValue);
    const data = { value };
    return node.merge({ data });
  }

  // Handle Links
  if (contentType === 'Link') {
    delete rawValue.content;
    const value = new wrappers[contentType]().with(rawValue);
    const data = { value };
    return node.merge({ data });
  }

  // Cite, Extra, InputRef (or anthing else) just gets
  // stripped out and replaced with a text node
  return Text.create({ text: node.text });
}

validate(node) {
            const { nodes } = node;

            const toRemove = nodes.filterNot(n => n.object === 'text');
            if (!toRemove.isEmpty()) {
                // Remove them, and the rest
                // will be done in the next validation call.
                return { toRemove };
            } else if (nodes.size > 1) {
                // Else, there are only text nodes

                return { toJoin: nodes };
            } else if (nodes.size === 0) {
                return { toAdd: [Text.create()] };
            }

            // There is a single text node -> valid
            return null;
        },

const lines = text.split('\n').map(line =>
    Block.create({
      type: 'code_line',
      nodes: [Text.create(line)],
    })
  );

export function createText(tagName, attributes, children) {
  const { key, marks } = attributes
  const list = createChildren(children)
  let node

  if (list.size > 1) {
    throw new Error(
      `The 

if (isList) {
      transform = transform
        .setBlock(isActive ? defaultNode : type)
        .unwrapBlock('bulleted-list')
        .unwrapBlock('numbered-list');
    } else {
      if (initNode) {
        node = initNode(node, { value, schema, parentKey, index, transform });
      }
      const block = createBlock(node);

      if (defaultNodes && typeof defaultNodes === 'function') {
        defaultNodes = defaultNodes({ value, node, schema, parentKey, index, transform });
      } else if (!defaultNodes && !block.isVoid) {
        defaultNodes = [Text.create(defaultText)];
      }

      if (block && block.kind === 'block') {
        transform = parentKey
          ? transform.insertNodeByKey(parentKey, index, block)
          : transform.insertBlock(block);
      } else if (block) {
        transform = parentKey
          ? transform.insertNodeByKey(parentKey, index, block)
          : transform.insertInline(block);
      }

      if (defaultNodes) {
        defaultNodes.forEach((item, index) => {
          if (typeof item === 'string' && schema.nodes[item]) {
            transform = addBlock(

normalize: (editor, error) => {
          switch (error.code) {
            case "child_min_invalid":
              editor.insertNodeByKey(
                error.node.key,
                0,
                Block.create({
                  type: blocks.list_item_child,
                  nodes: [Text.create()]
                })
              );
              return;
            case "child_type_invalid":
              editor.wrapBlockByKey(error.child.key, {
                type: blocks.list_item_child
              });
              return;
            case "parent_type_invalid":
              editor.wrapBlockByKey(error.node.key, blocks.unordered_list);
              return;
            default:
              return;
          }
        }
      }

const checkListItems = List(el.childNodes).map(line =>
      Block.create({
        type: isCheckList ? BLOCKS.CHECK_LIST_ITEM : BLOCKS.LIST_ITEM,
        nodes: [Text.create(line.innerText)]
      }))

const push = node => {
    const last = nodes.last()
    const isString = typeof node === 'string'

    if (last && last.__string && (isString || node.__string)) {
      const text = isString ? node : node.text
      const { length } = last.text
      const next = preservePoints(last, l => l.insertText(length, text))
      incrementPoints(node, length)
      copyPoints(node, next)
      next.__string = true
      nodes = nodes.pop().push(next)
    } else if (isString) {
      node = Text.create({ text: node })
      node.__string = true
      nodes = nodes.push(node)
    } else {
      nodes = nodes.push(node)
    }
  }

function makeEmptyCell(opts: Options): Block {
    return Block.create({
        type: opts.typeCell,
        nodes: List([Text.create('')])
    });
}