@SuppressWarnings("unchecked")
	public Node graphicOf(@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_GRAPHIC;
		}
		if (resource == null) {
			logger.error("Path node missing resource section: {}", item);
			return UNKNOWN_GRAPHIC;
		}

		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_GRAPHIC;
			}

			ClassInfo info = classPath.getValue();
			if (info.isJvmClass()) {
				return iconService.getJvmClassInfoIconProvider(workspace, resource,
						(JvmClassBundle) bundle, info.asJvmClass()).makeIcon();
			} else if (info.isAndroidClass()) {
				return iconService.getAndroidClassInfoIconProvider(workspace, resource,
						(AndroidClassBundle) bundle, info.asAndroidClass()).makeIcon();
			}
		} 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_GRAPHIC;
			}

			FileInfo info = filePath.getValue();
			return iconService.getFileInfoIconProvider(workspace, resource, bundle, info).makeIcon();
		} 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();
			return iconService.getClassMemberIconProvider(workspace, resource, bundle, classInfo, member).makeIcon();
		} 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_GRAPHIC;
			}

			if (bundle instanceof FileBundle fileBundle) {
				return iconService.getDirectoryIconProvider(workspace, resource, fileBundle, directoryPath.getValue()).makeIcon();
			} else if (bundle instanceof ClassBundle<?> classBundle) {
				return iconService.getPackageIconProvider(workspace, resource, classBundle, directoryPath.getValue()).makeIcon();
			}
		} 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_GRAPHIC;
			}

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

			InnerClassInfo innerClass = innerClassPath.getValue();
			return iconService.getInnerClassInfoIconProvider(workspace, resource,
					bundle, outerClass.asJvmClass(), innerClass).makeIcon();
		} 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_GRAPHIC;
			}

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

			AnnotationInfo annotation = annotationPath.getValue();
			return iconService.getAnnotationIconProvider(workspace, resource, bundle, annotated, annotation).makeIcon();
		} else if (item instanceof BundlePathNode bundlePath) {
			return iconService.getBundleIconProvider(workspace, resource, bundlePath.getValue()).makeIcon();
		} else if (item instanceof ResourcePathNode) {
			return iconService.getResourceIconProvider(workspace, resource).makeIcon();
		} else if (item instanceof InstructionPathNode insnPath) {
			ClassBundle<?> bundle = insnPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Instruction path node missing bundle section: {}", item);
				return null;
			}

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

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

			AbstractInsnNode insn = insnPath.getValue();
			return iconService.getInstructionIconProvider(workspace, resource, bundle, classInfo, method, insn).makeIcon();
		} else if (item instanceof LocalVariablePathNode varPath) {
			ClassBundle<?> bundle = varPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Local var path node missing bundle section: {}", item);
				return null;
			}

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

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

			LocalVariable local = varPath.getValue();
			return iconService.getVariableIconProvider(workspace, resource, bundle, classInfo, method, local).makeIcon();
		} else if (item instanceof ThrowsPathNode throwsPath) {
			ClassBundle<?> bundle = throwsPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Throws path node missing bundle section: {}", item);
				return null;
			}

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

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

			String thrown = throwsPath.getValue();
			return iconService.getThrowsIconProvider(workspace, resource, bundle, classInfo, method, thrown).makeIcon();
		} else if (item instanceof CatchPathNode catchPath) {
			ClassBundle<?> bundle = catchPath.getValueOfType(ClassBundle.class);
			if (bundle == null) {
				logger.error("Catch path node missing bundle section: {}", item);
				return null;
			}

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

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

			String caught = catchPath.getValue();
			return iconService.getCatchIconProvider(workspace, resource, bundle, classInfo, method, caught).makeIcon();
		} else if (item instanceof EmbeddedResourceContainerPathNode) {
			return new FontIconView(CarbonIcons.CATEGORIES);
		}

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

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