@SuppressWarnings("unchecked")
	public String textOf(@Nonnull PathNode<?> item) {
		Workspace workspace = item.getValueOfType(Workspace.class);
		WorkspaceResource resource = item.getValueOfType(WorkspaceResource.class);

		if (workspace == null) {
			logger.error("Path node missing workspace section: {}", item);
			return UNKNOWN_TEXT;
		}
		if (resource == null) {
			logger.error("Path node missing resource section: {}", item);
			return UNKNOWN_TEXT;
		}

		if (item instanceof ClassPathNode classPath) {
			ClassBundle<?> bundle = classPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Class path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			ClassInfo info = classPath.getValue();
			if (info.isJvmClass()) {
				return textService.getJvmClassInfoTextProvider(workspace, resource,
						(JvmClassBundle) bundle, info.asJvmClass()).makeText();
			} else if (info.isAndroidClass()) {
				return textService.getAndroidClassInfoTextProvider(workspace, resource,
						(AndroidClassBundle) bundle, info.asAndroidClass()).makeText();
			}
		} else if (item instanceof FilePathNode filePath) {
			FileBundle bundle = filePath.getValueOfType(FileBundle.class);
			if (bundle == null) {
				logger.error("File path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			FileInfo info = filePath.getValue();
			return textService.getFileInfoTextProvider(workspace, resource, bundle, info).makeText();
		} else if (item instanceof ClassMemberPathNode memberNode) {
			ClassBundle<?> bundle = memberNode.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Member path node missing bundle section: {}", item);
				return null;
			}

			ClassInfo classInfo = memberNode.getValueOfType(ClassInfo.class);
			if (classInfo == null) {
				logger.error("Member path node missing class section: {}", item);
				return null;
			}

			ClassMember member = memberNode.getValue();
			if (member instanceof FieldMember fieldMember) {
				return textService.getFieldMemberTextProvider(workspace, resource, bundle, classInfo, fieldMember).makeText();
			} else if (member instanceof MethodMember methodMember) {
				return textService.getMethodMemberTextProvider(workspace, resource, bundle, classInfo, methodMember).makeText();
			}
		} else if (item instanceof DirectoryPathNode directoryPath) {
			Bundle<?> bundle = directoryPath.getValueOfType(Bundle.class);
			if (bundle == null) {
				logger.error("Directory/package path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			if (bundle instanceof FileBundle fileBundle) {
				return textService.getDirectoryTextProvider(workspace, resource, fileBundle, directoryPath.getValue()).makeText();
			} else if (bundle instanceof ClassBundle<?> classBundle) {
				return textService.getPackageTextProvider(workspace, resource, classBundle, directoryPath.getValue()).makeText();
			}
		} else if (item instanceof InnerClassPathNode innerClassPath) {
			ClassBundle<? extends ClassInfo> bundle = innerClassPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Inner class path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			ClassInfo outerClass = innerClassPath.getValueOfType(ClassInfo.class);
			if (outerClass == null) {
				logger.error("Inner class path node missing outer class section: {}", item);
				return UNKNOWN_TEXT;
			}

			InnerClassInfo innerClass = innerClassPath.getValue();
			return textService.getInnerClassInfoTextProvider(workspace, resource,
					bundle, outerClass.asJvmClass(), innerClass).makeText();
		} else if (item instanceof AnnotationPathNode annotationPath) {
			ClassBundle<? extends ClassInfo> bundle = annotationPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Annotation path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			Annotated annotated = annotationPath.getValueOfType(Annotated.class);
			if (annotated == null) {
				logger.error("Annotation path node missing annotated element section: {}", item);
				return UNKNOWN_TEXT;
			}

			AnnotationInfo annotation = annotationPath.getValue();
			return textService.getAnnotationTextProvider(workspace, resource, bundle, annotated, annotation).makeText();
		} else if (item instanceof BundlePathNode bundlePath) {
			return textService.getBundleTextProvider(workspace, resource, bundlePath.getValue()).makeText();
		} else if (item instanceof ResourcePathNode) {
			return textService.getResourceTextProvider(workspace, resource).makeText();
		} else if (item instanceof InstructionPathNode instructionPath) {
			ClassBundle<? extends ClassInfo> bundle = instructionPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Instruction path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			ClassInfo declaringClass = instructionPath.getValueOfType(ClassInfo.class);
			if (declaringClass == null) {
				logger.error("Instruction path node missing class section: {}", item);
				return UNKNOWN_TEXT;
			}

			MethodMember declaringMethod = instructionPath.getValueOfType(MethodMember.class);
			if (declaringMethod == null) {
				logger.error("Instruction path node missing method section: {}", item);
				return UNKNOWN_TEXT;
			}

			return textService.getInstructionTextProvider(workspace, resource, bundle,
					declaringClass, declaringMethod, instructionPath.getValue()).makeText();
		} else if (item instanceof LineNumberPathNode lineNumberPath) {
			FileBundle bundle = lineNumberPath.getValueOfType(FileBundle.class);
			if (bundle == null) {
				logger.error("Line number path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			FileInfo declaringTextFile = lineNumberPath.getValueOfType(FileInfo.class);
			if (declaringTextFile == null) {
				logger.error("Line number path node missing file section: {}", item);
				return UNKNOWN_TEXT;
			}

			int line = lineNumberPath.getValue();
			return textService.getLineNumberTextProvider(workspace, resource, bundle, declaringTextFile, line).makeText();
		} else if (item instanceof LocalVariablePathNode localVariablePath) {
			ClassBundle<? extends ClassInfo> bundle = localVariablePath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Local var path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			ClassInfo declaringClass = localVariablePath.getValueOfType(ClassInfo.class);
			if (declaringClass == null) {
				logger.error("Local var path node missing class section: {}", item);
				return UNKNOWN_TEXT;
			}

			MethodMember declaringMethod = localVariablePath.getValueOfType(MethodMember.class);
			if (declaringMethod == null) {
				logger.error("Local var path node missing method section: {}", item);
				return UNKNOWN_TEXT;
			}

			return textService.getVariableTextProvider(workspace, resource, bundle,
					declaringClass, declaringMethod, localVariablePath.getValue()).makeText();
		} else if (item instanceof ThrowsPathNode throwsPath) {
			ClassBundle<? extends ClassInfo> bundle = throwsPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Throws path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			ClassInfo declaringClass = throwsPath.getValueOfType(ClassInfo.class);
			if (declaringClass == null) {
				logger.error("Throws path node missing class section: {}", item);
				return UNKNOWN_TEXT;
			}

			MethodMember declaringMethod = throwsPath.getValueOfType(MethodMember.class);
			if (declaringMethod == null) {
				logger.error("Throws path node missing method section: {}", item);
				return UNKNOWN_TEXT;
			}

			return textService.getThrowsTextProvider(workspace, resource, bundle,
					declaringClass, declaringMethod, throwsPath.getValue()).makeText();
		} else if (item instanceof CatchPathNode catchPath) {
			ClassBundle<? extends ClassInfo> bundle = catchPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Catch path node missing bundle section: {}", item);
				return UNKNOWN_TEXT;
			}

			ClassInfo declaringClass = catchPath.getValueOfType(ClassInfo.class);
			if (declaringClass == null) {
				logger.error("Catch path node missing class section: {}", item);
				return UNKNOWN_TEXT;
			}

			MethodMember declaringMethod = catchPath.getValueOfType(MethodMember.class);
			if (declaringMethod == null) {
				logger.error("Catch path node missing method section: {}", item);
				return UNKNOWN_TEXT;
			}

			return textService.getCatchTextProvider(workspace, resource, bundle,
					declaringClass, declaringMethod, catchPath.getValue()).makeText();
		} else if (item instanceof EmbeddedResourceContainerPathNode) {
			return Lang.get("tree.embedded-resources");
		}

		// No text
		return null;
	}
@param item
		Item to create text for.

@return Text for the item represented by the path.
recaf-ui/src/main/java/software/coley/recaf/services/cell/CellConfigurationService.java