docs: def font(self):
          """Get the GSFont built from the UFOs + designspace."""
          if self._font is not None:
              return self._font
  
          # Sort UFOS in the original order from the Glyphs file
          sorted_sources = self.to_glyphs_ordered_masters()
  
          # Convert all full source UFOs to Glyphs masters. Sources with layer names
          # are assumed to be sparse or "brace" layers and are ignored because Glyphs
          # considers them to be special layers and will handle them itself.
          self._font = self.glyphs_module.GSFont()
          self._sources = OrderedDict()  # Same as in UFOBuilder
          for index, source in enumerate(s for s in sorted_sources if not s.layerName):
              master = self.glyphs_module.GSFontMaster()
  
              # Filter bracket glyphs out of public.glyphOrder.
              if GLYPH_ORDER_KEY in source.font.lib:
                  source.font.lib[GLYPH_ORDER_KEY] = [
                      glyph_name
                      for glyph_name in source.font.lib[GLYPH_ORDER_KEY]
                      if ".BRACKET." not in glyph_name
                  ]
  
              self.to_glyphs_font_attributes(source, master, is_initial=(index == 0))
              self.to_glyphs_master_attributes(source, master)
              self._font.masters.insert(len(self._font.masters), master)
              self._sources[master.id] = source
  
              # First, move free-standing bracket glyphs back to layers to avoid dealing
              # with GSLayer transplantation.
              for bracket_glyph in [g for g in source.font if ".BRACKET." in g.name]:
                  base_glyph, threshold = bracket_glyph.name.split(".BRACKET.")
                  try:
                      int(threshold)
                  except ValueError:
                      raise ValueError(
                          "Glyph '{}' has malformed bracket layer name. Must be '<glyph "
                          "name>.BRACKET.<crossover value>'.".format(bracket_glyph)
                      )
                  layer_name = bracket_glyph.lib.get(
                      GLYPHLIB_PREFIX + "_originalLayerName", "[{}]".format(threshold)
                  )
                  if layer_name not in source.font.layers:
                      ufo_layer = source.font.newLayer(layer_name)
                  else:
                      ufo_layer = source.font.layers[layer_name]
                  bracket_glyph_new = ufo_layer.newGlyph(base_glyph)
                  bracket_glyph_new.copyDataFromGlyph(bracket_glyph)
  
                  # Remove all freestanding bracket layer glyphs from all layers.
                  for layer in source.font.layers:
                      if bracket_glyph.name in layer:
                          del layer[bracket_glyph.name]
  
              for layer in _sorted_backgrounds_last(source.font.layers):
                  self.to_glyphs_layer_lib(layer)
                  for glyph in layer:
                      self.to_glyphs_glyph(glyph, layer, master)
  
          self.to_glyphs_features()
          self.to_glyphs_groups()
          self.to_glyphs_kerning()
  
          # Now that all GSGlyph are built, restore the glyph order
          if self.designspace.sources:
              first_ufo = self.designspace.sources[0].font
              if GLYPH_ORDER_KEY in first_ufo.lib:
                  glyph_order = first_ufo.lib[GLYPH_ORDER_KEY]
                  lookup = {name: i for i, name in enumerate(glyph_order)}
                  self.font.glyphs = sorted(
                      self.font.glyphs, key=lambda glyph: lookup.get(glyph.name, 1 << 63)
                  )
              # FIXME: (jany) We only do that on the first one. Maybe we should
              # merge the various `public.glyphorder` values?
  
              # Restore the layer ordering in each glyph
              for glyph in self._font.glyphs:
                  self.to_glyphs_layer_order(glyph)
  
          self.to_glyphs_family_user_data_from_designspace()
          self.to_glyphs_axes()
          self.to_glyphs_sources()
          self.to_glyphs_instances()
  
          return self._font