pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/astm.rb

@@ -1,38 +1,50 @@
 # frozen_string_literal: true
 
-require "parslet"
-require "lutaml/model"
-require_relative "identifier"
-require_relative "astm/identifier"
-require_relative "astm/components/code"
-require_relative "astm/single_identifier"
-require_relative "astm/parser"
-require_relative "astm/builder"
-
-# Identifier classes
-require_relative "astm/identifiers/base"
-require_relative "astm/identifiers/standard"
-require_relative "astm/identifiers/iso_dual_published"
-require_relative "astm/identifiers/manual"
-require_relative "astm/identifiers/research_report"
-require_relative "astm/identifiers/data_series"
-require_relative "astm/identifiers/technical_report"
-require_relative "astm/identifiers/monograph"
-require_relative "astm/identifiers/adjunct"
-require_relative "astm/identifiers/work_in_progress"
-
-# Scheme (must be loaded after identifiers)
-require_relative "astm/scheme"
-
 module Pubid
   module Astm
+    autoload :Components, "#{__dir__}/astm/components"
+    autoload :Identifier, "#{__dir__}/astm/identifier"
+    autoload :Identifiers, "#{__dir__}/astm/identifiers"
+    autoload :SingleIdentifier, "#{__dir__}/astm/single_identifier"
+    autoload :Parser, "#{__dir__}/astm/parser"
+    autoload :Builder, "#{__dir__}/astm/builder"
+    autoload :Renderer, "#{__dir__}/astm/renderer"
+    autoload :UrnGenerator, "#{__dir__}/astm/urn_generator"
+    autoload :UrnParser, "#{__dir__}/astm/urn_parser"
+
     def self.parse(str)
       Identifier.parse(str)
     end
-  end
 
-  # Register this flavor with the Pubid registry
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
 end
 
-# Register Uastm flavor with the registry
 Pubid::Registry.register(:astm, Pubid::Astm)
+
+Pubid::Astm::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Astm::SingleIdentifier.format_registry.register(:human, renderer: Pubid::Astm::Renderer)

data/lib/pubid/bsi/builder.rb

@@ -3,12 +3,19 @@
 module Pubid
   module Bsi
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-      end
-
-      def self.build(parsed_data, scheme = Scheme.new)
-        new(scheme).build(parsed_data)
+      # Default typed stage used when an abbreviation lookup yields no match.
+      # Empty/unknown abbreviations fall back to the published British Standard.
+      DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
+        code: :pubbs,
+        stage_code: :published,
+        type_code: :bs,
+        abbr: ["BS"],
+        name: "British Standard",
+        harmonized_stages: %w[60.00 60.60],
+      ).freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
       end
 
       def build(data)
@@ -122,7 +129,7 @@ module Pubid
           return identifier
         end
 
-        # Determine identifier class using Scheme
+        # Determine identifier class using the module's lookup helpers
         identifier = locate_identifier_klass(data).new
         assign_attributes(identifier, data)
 
@@ -934,17 +941,19 @@ module Pubid
         return Identifiers::AdoptedEuropeanNorm if parsed_hash[:adopted_string]&.match?(/^EN\s+\d/)
         return Identifiers::AdoptedInternationalStandard if parsed_hash[:adopted_string]
 
-        # Use type to determine class via Scheme
+        # Use type to determine class via Pubid::Bsi.locate_stage / locate_type.
+        # Unknown abbreviations fall back to DEFAULT_TYPED_STAGE (published BS).
         type_str = parsed_hash[:type] || parsed_hash[:stage] || ""
-        typed_stage = @scheme.locate_typed_stage_by_abbr(type_str)
-        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        typed_stage = Bsi.locate_stage(type_str.to_s.upcase) || DEFAULT_TYPED_STAGE
+        Bsi.locate_type(typed_stage.type_code) || Identifiers::BritishStandard
       end
 
       def cast(type, value)
         case type
         when :type
-          # Lookup from register
-          typed_stage = @scheme.locate_typed_stage_by_abbr(value || "")
+          # Lookup from register via Pubid::Bsi.locate_stage.
+          # Unknown abbreviations fall back to DEFAULT_TYPED_STAGE (published BS).
+          typed_stage = Bsi.locate_stage(value.to_s.upcase) || DEFAULT_TYPED_STAGE
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,

data/lib/pubid/bsi/identifier.rb

@@ -2,7 +2,14 @@
 
 module Pubid
   module Bsi
+    # `extend Pubid::IdentifierFacade` adds polymorphic `from_hash` and pairs
+    # with `include Pubid::Bsi::Identifier` in SingleIdentifier (BSI's common
+    # ancestor — there is no Identifiers::Base) for identity (`is_a?`/`===`), so
+    # a consumer handed this module can deserialize and identity-check BSI ids
+    # through it.
     module Identifier
+      extend Pubid::IdentifierFacade
+
       def self.parse(string)
         # Delegate to IEC for bare IEC identifiers
         # This handles IEC-specific features like VAP suffixes (CSV, RLV, etc.)
@@ -15,73 +22,12 @@ module Pubid
         end
 
         parser = Parser.new
-        scheme = Scheme.new
 
         parsed = parser.parse(string)
-        Builder.build(parsed, scheme)
+        Builder.build(parsed)
       rescue Parslet::ParseFailed => e
         raise StandardError, "Failed to parse '#{string}': #{e.message}"
       end
-
-      # Factory mirroring pubid 1.x's `Pubid::Bsi::Identifier.create` API.
-      # Dispatches via {Pubid::Bsi::Scheme}'s IDENTIFIER_CLASS_MAP and
-      # TYPED_STAGES_REGISTRY; default subclass is BritishStandard.
-      #
-      # BSI's renderer requires BSI-namespaced Component subclasses
-      # (`Bsi::Components::*`), so coercion is inlined rather than reusing
-      # {Pubid::Components::Factory}.
-      def self.create(type: nil, stage: nil, **opts)
-        klass = resolve_create_class(type: type, stage: stage)
-        attrs = coerce_create_attrs(opts)
-        ts = resolve_create_typed_stage(klass, stage)
-        attrs[:typed_stage] = ts if ts
-        klass.new(**attrs)
-      end
-
-      def self.resolve_create_class(type:, stage:)
-        scheme = Scheme.new
-        klass = nil
-        if type
-          klass = scheme.locate_identifier_klass_by_type_code(type)
-        elsif stage
-          ts = scheme.locate_typed_stage_by_abbr(stage.to_s)
-          klass = scheme.locate_identifier_klass_by_type_code(ts.type_code) if ts
-        end
-        klass || Identifiers::BritishStandard
-      end
-
-      def self.resolve_create_typed_stage(klass, stage)
-        if stage
-          Scheme.new.locate_typed_stage_by_abbr(stage.to_s)
-        elsif klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.stage_code.to_sym == :published
-          end
-        end
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {}
-        if (v = opts[:publisher])
-          attrs[:publisher] = Components::Publisher.new(body: v.to_s)
-        end
-        %i[number part subpart].each do |k|
-          v = opts[k]
-          attrs[k] = Components::Code.new(value: v.to_s) unless v.nil?
-        end
-        if (v = opts[:year])
-          attrs[:date] = Components::Date.new(year: v.to_s)
-        end
-        # BSI :edition is a plain string attribute (not a Component).
-        attrs[:edition] = opts[:edition].to_s if opts[:edition]
-        # TODO(create-shim): BSI also has prefix, flex_prefix, iteration,
-        # second_number, month, translation_lang/upper attributes that
-        # aren't yet wired through. Add as call sites require them.
-        attrs
-      end
-      private_class_method :resolve_create_class,
-                           :resolve_create_typed_stage,
-                           :coerce_create_attrs
     end
   end
 end

data/lib/pubid/bsi/identifiers/addendum_document.rb

@@ -10,8 +10,8 @@ module Pubid
       # "BS 1902-2.3:Addendum No. 1:1976"
       # "BS 2000-0:Addendum 1:1983"
       # "BS 6034:1981:Addendum No. 1:1986"
-      class AddendumDocument < Base
-        attribute :base_identifier, Base, polymorphic: true
+      class AddendumDocument < SingleIdentifier
+        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
         attribute :addendum_number, :string
         attribute :addendum_year, :integer
         attribute :addendum_type, :string, default: -> {
@@ -22,37 +22,7 @@ module Pubid
         } # Separator before Addendum (":" or " ")
 
         def to_s(lang: :en, lang_single: false)
-          result = base_identifier.to_s(lang: lang, lang_single: lang_single)
-
-          # Determine separator - if separator is explicitly ":", use it
-          # Otherwise if base has year and doesn't already have double colon, use space
-          base_has_year = base_identifier.to_s =~ /:(\d{4})$/
-
-          sep = if separator == ":"
-                  ":"
-                elsif base_has_year && base_identifier.to_s !~ /:\d{4}:/
-                  " "
-                else
-                  separator
-                end
-
-          # Format: "BASE:Addendum No. N:YEAR" or "BASE Addendum No. N:YEAR" or "BASE:Addendum N:YEAR"
-          result += sep
-          result += "Addendum"
-
-          # Add space after "Addendum" if there's a type prefix (like "No.")
-          if addendum_type.empty?
-            # No type prefix, but still need space before number
-          else
-            result += " #{addendum_type}"
-          end
-          result += " "
-          result += " "
-
-          result += addendum_number.to_s
-          result += ":#{addendum_year}" if addendum_year
-
-          result
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
 
         def publisher

data/lib/pubid/bsi/identifiers/adopted_european_norm.rb

@@ -7,7 +7,7 @@ module Pubid
       # Example: "BS EN 10077-1:2006" where EN 10077-1:2006 is a CEN identifier object
       # Example: "BS EN ISO 8601:2019" where EN ISO 8601:2019 is a CEN AdoptedEuropeanNorm wrapping ISO
       class AdoptedEuropeanNorm < BritishStandard
-        attribute :adopted_identifier, Base, polymorphic: true # CEN object
+        attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true # CEN object
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -16,53 +16,17 @@ module Pubid
         attribute :expert_commentary, :boolean
         attribute :expert_commentary_topic, :string
 
-        def to_s(lang: :en, lang_single: false)
-          # Get the BSI prefix (BS, PD, DD)
-          prefix = case publisher
-                   when Components::Publisher
-                     publisher.body
-                   when Array
-                     publisher.join("/")
-                   when String
-                     publisher
-                   else
-                     "BS"
-                   end
-
-          result = prefix
-          result += " #{adopted_identifier}" if adopted_identifier
-          result += " ED#{edition}" if edition
-
-          # Reaffirmation notation like (R2004)
-          result += " (R#{reaffirmation_year})" if reaffirmation_year
-
-          # Translation - preserve the "version" or "Translation" suffix if present
-          if translation_lang
-            result += if translation_suffix_type == "version"
-                        " (#{translation_lang} version)"
-                      elsif translation_suffix_type == "Translation"
-                        " (#{translation_lang} Translation)"
-                      else
-                        " (#{translation_lang})"
-                      end
-          elsif translation_upper
-            result += if translation_suffix_type == "Translation"
-                        " (#{translation_upper} Translation)"
-                      else
-                        " (#{translation_upper})"
-                      end
-          end
-
-          # ExpertCommentary suffix
-          if expert_commentary
-            result += if expert_commentary_topic
-                        " ExComm (#{expert_commentary_topic})"
-                      else
-                        " ExComm"
-                      end
-          end
+        # Override self.type to return nil so this polymorphic wrapper is not
+        # registered as a base type. Inherits `:bs` from BritishStandard which
+        # would otherwise shadow it in Bsi.locate_type(:bs) auto-discovery.
+        # AdoptedEuropeanNorm is constructed explicitly by the builder, not
+        # selected by type-code lookup.
+        def self.type
+          nil
+        end
 
-          result
+        def to_s(lang: :en, lang_single: false)
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
 
         # Delegate common methods to adopted identifier

data/lib/pubid/bsi/identifiers/adopted_international_standard.rb

@@ -7,7 +7,7 @@ module Pubid
       # Example: "BS ISO 8601:2019" where ISO 8601:2019 is an ISO identifier object
       # Example: "BS IEC 62600:2020" where IEC 62600:2020 is an IEC identifier object
       class AdoptedInternationalStandard < BritishStandard
-        attribute :adopted_identifier, Base, polymorphic: true # ISO/IEC object
+        attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true # ISO/IEC object
         attribute :edition, :string
         attribute :translation_lang, :string
         attribute :translation_upper, :string
@@ -16,44 +16,17 @@ module Pubid
         attribute :expert_commentary, :boolean
         attribute :expert_commentary_topic, :string
 
-        def to_s
-          # Get the BSI prefix (BS, PD, DD)
-          prefix = case publisher
-                   when Components::Publisher
-                     publisher.body
-                   when Array
-                     publisher.join("/")
-                   when String
-                     publisher
-                   else
-                     "BS"
-                   end
-
-          result = prefix
-          result += " #{adopted_identifier}" if adopted_identifier
-          result += " ED#{edition}" if edition
-
-          # Reaffirmation notation like (R2004)
-          result += " (R#{reaffirmation_year})" if reaffirmation_year
-
-          # Translation - normalize to just "(Language)" format
-          # "(French version)", "(French Translation)", "(French)" all become "(French)"
-          if translation_lang
-            result += " (#{translation_lang})"
-          elsif translation_upper
-            result += " (#{translation_upper})"
-          end
-
-          # ExpertCommentary suffix
-          if expert_commentary
-            result += if expert_commentary_topic
-                        " ExComm (#{expert_commentary_topic})"
-                      else
-                        " ExComm"
-                      end
-          end
+        # Override self.type to return nil so this polymorphic wrapper is not
+        # registered as a base type. Inherits `:bs` from BritishStandard which
+        # would otherwise shadow it in Bsi.locate_type(:bs) auto-discovery.
+        # AdoptedInternationalStandard is constructed explicitly by the builder,
+        # not selected by type-code lookup.
+        def self.type
+          nil
+        end
 
-          result
+        def to_s
+          render(format: :human)
         end
 
         # Delegate common methods to adopted identifier

data/lib/pubid/bsi/identifiers/aerospace_standard.rb

@@ -54,63 +54,13 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :aerospace, title: "Aerospace/Specialized Standard",
+          { key: :aerospace,
+            web: :aerospace_standard, title: "Aerospace/Specialized Standard",
             short: "BS" }
         end
 
         def to_s(lang: :en, lang_single: false)
-          parts = []
-          parts << "BS" # Always BS for aerospace
-          parts << prefix if prefix
-
-          # Number with part/subpart and letter suffix edition
-          if number
-            number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
-
-            # Part and subpart
-            if part
-              part_val = part.is_a?(Components::Code) ? part.value : part
-              number_str += "-#{part_val}"
-            end
-            if subpart
-              subpart_val = subpart.is_a?(Components::Code) ? subpart.value : subpart
-              number_str += "-#{subpart_val}"
-            end
-
-            parts << number_str
-          end
-
-          result = parts.join(" ")
-
-          # Letter suffix edition (for aerospace/specialized standards)
-          # Append directly to number/part without space or v prefix
-          # e.g., BS AU 145e:2018, BS AU 200-1a:1984
-          if edition&.match?(/^[a-zA-Z]$/)
-            result += edition
-          end
-
-          # Date
-          if date
-            year_val = date.is_a?(Components::Date) ? date.year : date.to_i
-            result += ":#{year_val}"
-            # Month if present
-            result += "-#{format('%02d', month)}" if month
-          end
-
-          # Regular edition (non-letter suffix, like v1.0)
-          # Only add if edition is not a single letter (already handled above)
-          if edition && !edition.match?(/^[a-zA-Z]$/)
-            result += " v#{edition}"
-          end
-
-          # Translation
-          if translation_lang
-            result += " (#{translation_lang})"
-          elsif translation_upper
-            result += " (#{translation_upper})"
-          end
-
-          result
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

data/lib/pubid/bsi/identifiers/amendment.rb

@@ -5,30 +5,14 @@ module Pubid
     module Identifiers
       # Amendment Identifier
       # Contains a base identifier plus amendment parameters
-      class Amendment < Base
-        attribute :base_identifier, Base, polymorphic: true
+      class Amendment < SingleIdentifier
+        attribute :base_identifier, ::Pubid::Identifier, polymorphic: true
         attribute :amendment_number, :string
         attribute :amendment_year, :integer
         attribute :separator, :string, default: -> { "+" }
 
         def to_s
-          if base_identifier
-            if amendment_year
-              "#{base_identifier}#{separator}A#{amendment_number}:#{amendment_year}"
-            elsif amendment_number&.match?(/^[A-Z]+$/)
-              # Letter suffixes (AA, AB, etc.) have a space, numeric suffixes don't
-              "#{base_identifier} AMD #{amendment_number}"
-            else
-              "#{base_identifier} AMD#{amendment_number}"
-            end
-          elsif amendment_year
-            "#{separator}A#{amendment_number}:#{amendment_year}"
-          elsif amendment_number&.match?(/^[A-Z]+$/)
-            # Letter suffixes (AA, AB, etc.) have a space, numeric suffixes don't
-            "AMD #{amendment_number}"
-          else
-            "AMD#{amendment_number}"
-          end
+          render(format: :human)
         end
 
         def publisher

data/lib/pubid/bsi/identifiers/british_industrial_practice.rb

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # British Industrial Practice (BIP)
       # Examples: "BIP 2225:2022", "BIP 0142:2014", "BIP 0009:2020"
-      class BritishIndustrialPractice < Base
+      class BritishIndustrialPractice < SingleIdentifier
         attribute :number, Bsi::Components::Code
         attribute :date, Bsi::Components::Date
 
@@ -17,9 +17,7 @@ module Pubid
         end
 
         def to_s(lang: :en, lang_single: false)
-          result = "BIP #{number}"
-          result += ":#{date.year}" if date
-          result
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end

data/lib/pubid/bsi/identifiers/british_standard.rb

@@ -25,7 +25,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :bs, title: "British Standard", short: "BS" }
+          { key: :bs,
+            web: :british_standard, title: "British Standard", short: "BS" }
         end
       end
     end

data/lib/pubid/bsi/identifiers/bundled_identifier.rb

@@ -11,95 +11,14 @@ module Pubid
       #   BS 2SP 68 to BS 2SP 71:1973
       #   BS SP 13; 14; 15 and 16:1949
       #   BS 4048:Parts 1 and 2:1966
-      class BundledIdentifier < Base
-        attribute :identifiers, Base, collection: true, polymorphic: true
+      class BundledIdentifier < SingleIdentifier
+        attribute :identifiers, ::Pubid::Identifier, collection: true, polymorphic: true
         attribute :separators, :string, collection: true # Separators between identifiers
         attribute :common_year, Bsi::Components::Date # Year applied to all if present
         attribute :bundle_type, :string # "Parts", "Sections", or nil for regular bundles
 
         def to_s(lang: :en, lang_single: false)
-          return "" if identifiers.nil? || identifiers.empty?
-
-          # Special case: Parts/Sections bundles like "BS 4048:Parts 1 and 2:1966"
-          if bundle_type
-            base_id = identifiers.first
-            parts_list = identifiers[1..].map do |id|
-              # Extract just the part number
-              part_val = id.class.attributes.key?(:part) ? id.part : nil
-              if part_val
-                pv = part_val.is_a?(Components::Code) ? part_val.value : part_val
-                pv.to_s
-              else
-                id.to_s
-              end
-            end.join(" and ")
-
-            result = "#{base_id.to_s.sub(/:.*$/,
-                                         '')}:#{bundle_type} #{parts_list}"
-            result += ":#{common_year.year}" if common_year
-            return result
-          end
-
-          # Regular bundle: render based on explicit markers
-          parts = []
-
-          identifiers.each_with_index do |id, i|
-            # Check metadata flags for how item was parsed
-            explicit_prefix = id.explicit_prefix
-            explicit_publisher = id.explicit_publisher
-
-            if i.zero?
-              # First item always uses full form
-              parts << id.to_s
-            elsif explicit_publisher
-              # Full form: has explicit publisher (e.g., "BS SP 50")
-              parts << id.to_s
-            elsif explicit_prefix
-              # Prefix-only form: has explicit prefix but no publisher (e.g., "SP 138")
-              abbrev_str = ""
-              prefix = id.class.attributes.key?(:prefix) ? id.prefix : nil
-              if prefix && !prefix.to_s.empty?
-                abbrev_str = prefix.to_s
-              end
-              if id.number
-                number_val = id.number.is_a?(Components::Code) ? id.number.value : id.number
-                abbrev_str += " " if !abbrev_str.empty?
-                abbrev_str += number_val.to_s
-              end
-              if id.part
-                part_val = id.part.is_a?(Components::Code) ? id.part.value : id.part
-                abbrev_str += "-#{part_val}"
-              end
-              parts << abbrev_str
-            else
-              # Minimal form: no explicit markers (e.g., "125")
-              abbrev_str = ""
-              if id.number
-                number_val = id.number.is_a?(Components::Code) ? id.number.value : id.number
-                abbrev_str = number_val.to_s
-              end
-              if id.part
-                part_val = id.part.is_a?(Components::Code) ? id.part.value : id.part
-                abbrev_str += "-#{part_val}"
-              end
-              parts << abbrev_str
-            end
-
-            # Add separator - preserve original spacing
-            if i < identifiers.length - 1
-              sep = separators[i] || " and "
-              parts << sep
-            end
-          end
-
-          result = parts.join
-
-          # Add common year if present and not already in last identifier
-          if common_year && !result.match?(/:#{common_year.year}$/)
-            result += ":#{common_year.year}"
-          end
-
-          result
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
 
         def <=>(other)

data/lib/pubid/bsi/identifiers/committee_document.rb

@@ -30,20 +30,7 @@ module Pubid
         end
 
         def to_s(lang: :en, lang_single: false)
-          # Committee documents use a unique format: YY/NNNNNNNN DC
-          # The year is 2-digit (extracted from date or use current date format)
-          # Note: Assumes 2000s for years 00-99 (Y2K assumption)
-          year_str = if date
-                       if date.is_a?(Components::Date)
-                         date.year.to_s[-2, 2]
-                       else
-                         date.to_s[-2, 2]
-                       end
-                     else
-                       "00" # Default if no date
-                     end
-
-          "#{year_str}/#{document_number} DC"
+          render(format: :human, lang: lang, lang_single: lang_single)
         end
       end
     end