public GuiParser() {
        objectMap = new HashMap<>();
        importMap = new HashMap<>();
        starImports = new ArrayList<>();
        converterManager = new ConverterManager();
        converterManager.register(Border.class, new AsObjectOnly<Border>() {
            @Override
            protected Border asObjectInternal(String literalValue) {
                try {
                    return (Border) cssBorderConstructor.newInstance(
                            styleSheet.getDeclaration("border:" + literalValue));
                } catch (ReflectiveOperationException ex) {
                    throw new RuntimeException(ex);
                }
            }
        });
        converterManager.register(Color.class, new AsObjectOnly<Color>() {
            @Override
            protected Color asObjectInternal(String literalValue) {
                return styleSheet.stringToColor(literalValue);
            }
        });
        converterManager.register(Cursor.class, new AsObjectOnly<Cursor>() {
            @Override
            protected Cursor asObjectInternal(String literalValue) {
                try {
                    return Cursor.getPredefinedCursor(Integer.parseInt(literalValue));
                } catch (IllegalArgumentException iae) {
                    try {
                        return Cursor.getSystemCustomCursor(literalValue);
                    } catch (AWTException awte) {
                        IllegalArgumentException ex = new IllegalArgumentException(awte);
                        ex.addSuppressed(iae);
                        throw ex;
                    }
                }
            }
        });
        converterManager.register(Dimension.class, new AsObjectOnly<Dimension>() {
            @Override
            protected Dimension asObjectInternal(String literalValue) {
                List<String> dimensions = StringUtils.split(literalValue, ",", true, 1);
                return new Dimension(Integer.parseInt(dimensions.get(0)),
                        Integer.parseInt(dimensions.get(1)));
            }
        });
        converterManager.register(Font.class, new AsObjectOnly<Font>() {
            @Override
            protected Font asObjectInternal(String literalValue) {
                return styleSheet.getFont(
                        styleSheet.getDeclaration("font:" + literalValue));
            }
        });
        converterManager.register(Icon.class, new AsObjectOnly<Icon>() {
            @Override
            protected Icon asObjectInternal(String literalValue) {
                URL url = controllerClass.getResource(literalValue);
                if (url == null) {
                    url = controllerLoader.getResource(literalValue);
                    if (url == null) {
                        url = ClassLoader.getSystemResource(literalValue);
                    }
                }
                return url == null ? new ImageIcon(literalValue) : new ImageIcon(url);
            }
        });
        converterManager.register(Insets.class, new AsObjectOnly<Insets>() {
            @Override
            protected Insets asObjectInternal(String literalValue) {
                List<String> parameters = StringUtils.split(literalValue, ",", true, 3);
                return new Insets(Integer.parseInt(parameters.get(0)),
                        Integer.parseInt(parameters.get(1)),
                        Integer.parseInt(parameters.get(2)),
                        Integer.parseInt(parameters.get(3)));
            }
        });
        converterManager.register(Rectangle.class, new AsObjectOnly<Rectangle>() {
            @Override
            protected Rectangle asObjectInternal(String literalValue) {
                List<String> parameters = StringUtils.split(literalValue, ",", true, 3);
                return new Rectangle(Integer.parseInt(parameters.get(0)),
                        Integer.parseInt(parameters.get(1)),
                        Integer.parseInt(parameters.get(2)),
                        Integer.parseInt(parameters.get(3)));
            }
        });
        converterManager.register(KeyStroke.class, new AsObjectOnly<KeyStroke>() {
            @Override
            protected KeyStroke asObjectInternal(String literalValue) {
                return KeyStroke.getKeyStroke(literalValue);
            }
        });
    }