pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/nist/series/base.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    module Series
-      # Default series behavior. All hooks return the "generic" answer so a
-      # series bug can be fixed by overriding the relevant hook in a subclass.
-      class Base
-        # Whether an uppercase letter at the end of `first_number` stays in the
-        # number (true) or is extracted as a separate Part component (false).
-        def self.preserve_letter_suffix?(parsed_hash)
-          parsed_hash[:parsed_format] == :mr
-        end
-
-        # Cast a `:letter_number` parser hash (e.g., from "800-56A").
-        # Return a cast hash, or nil to skip assignment.
-        # Default: split letter suffix into a Part component.
-        def self.cast_letter_number(value, _parsed_hash)
-          full = combine_letter_suffix(value)
-          return nil if full.nil? || full.empty?
-
-          { part: Components::Part.new(type: "", value: full.upcase) }
-        end
-
-        # Whether the edition-year cast should use modern (numeric) date format
-        # instead of preserving historical month names. FIPS uses modern.
-        def self.modern_edition_date?
-          false
-        end
-
-        # Whether `part_num` alongside `second_num` becomes a Part component
-        # (true) or is folded into the compound number (false). IR uses Part.
-        def self.part_num_as_component?
-          false
-        end
-
-        # Hook: build compound number when `letter_num` is present.
-        # Return true if the series handled it; false to fall back to default.
-        def self.handle_letter_num_compound?(_identifier,
-                                              first_num:, letter_base:,
-                                              letter_suffix:)
-          false
-        end
-
-        # Hook: post-process the identifier after compound number is assigned.
-        # Override to reverse series-specific preprocessing side effects.
-        def self.finalize_identifier(_identifier, _parsed_hash); end
-
-        # Combine `:letter_suffix` and `:letter_suffix_extra` (e.g., "U" + "r").
-        def self.combine_letter_suffix(value)
-          suffix = value[:letter_suffix].to_s.strip
-          extra = value[:letter_suffix_extra].to_s.strip
-          extra.empty? ? suffix : "#{suffix}#{extra}"
-        end
-      end
-    end
-  end
-end

data/lib/pubid/nist/series/crpl.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    module Series
-      # CRPL series: letter suffix preserved in first_number.
-      # Range parsing ("2_3-1") is handled by the dedicated :crpl_range case
-      # in the caster; this class only carries the letter-suffix policy.
-      class Crpl < LetterPreserving
-      end
-    end
-  end
-end

data/lib/pubid/nist/series/fips.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    module Series
-      # FIPS series: letter suffix preserved; edition dates use modern format.
-      class Fips < LetterPreserving
-        def self.modern_edition_date?
-          true
-        end
-      end
-    end
-  end
-end

data/lib/pubid/nist/series/ir.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    module Series
-      # IR (Interagency Report) series carries the most series-specific logic:
-      #
-      # - "R" or "Ur" letter suffix becomes revision "r1" (e.g., "79-1786R").
-      # - part_num alongside second_num becomes a Part component (type "pt").
-      # - Preprocessing converts "84-2946" → "84e2946"; this class reverses
-      #   that side effect so IR keeps the compound number form.
-      class Ir < LetterPreserving
-        def self.cast_letter_number(value, _parsed_hash)
-          full = combine_letter_suffix(value)
-          return nil if full.nil? || full.empty?
-
-          if ["R", "Ur"].include?(full)
-            value[:letter_suffix] = full
-            value
-          else
-            super
-          end
-        end
-
-        def self.part_num_as_component?
-          true
-        end
-
-        def self.handle_letter_num_compound?(identifier,
-                                             first_num:, letter_base:,
-                                             letter_suffix:)
-          return false unless letter_suffix == "R"
-
-          identifier.number = Components::Code.new(
-            value: "#{first_num.value}-#{letter_base}",
-          )
-          edition_obj = Components::Edition.new(type: "r", id: "1")
-          identifier.edition = edition_obj
-          true
-        end
-
-        def self.finalize_identifier(identifier, _parsed_hash)
-          return unless identifier.number
-
-          value = identifier.number.value.to_s
-          match = value.match(/^(\d+)e(\d{4})$/)
-          return unless match
-
-          identifier.number = Components::Code.new(
-            value: "#{match[1]}-#{match[2]}",
-          )
-          identifier.edition = nil
-        end
-      end
-    end
-  end
-end

data/lib/pubid/nist/series/letter_preserving.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    module Series
-      # Series where the letter suffix on `first_number` stays in the number.
-      # Used for: RPT, MP, LC, CRPL, MONO, FIPS, IR (subclasses refine further).
-      class LetterPreserving < Base
-        def self.preserve_letter_suffix?(_parsed_hash)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/pubid/nist/series/mono.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    module Series
-      # MONO series: letter suffix preserved in first_number AND in
-      # letter_number (e.g., "NBS MONO 1A" — letter stays in the number).
-      class Mono < LetterPreserving
-        def self.cast_letter_number(value, _parsed_hash)
-          full = combine_letter_suffix(value)
-          return nil if full.nil? || full.empty?
-
-          value[:letter_suffix] = full
-          value
-        end
-      end
-    end
-  end
-end

data/lib/pubid/nist/series/ncstar.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    module Series
-      # NCSTAR series: letter suffix in letter_number stays in the number
-      # (e.g., "NIST NCSTAR 1-1A" — "1A" remains the compound suffix).
-      # Unlike MONO, first_number letter suffix is NOT preserved.
-      class Ncstar < Base
-        def self.cast_letter_number(value, _parsed_hash)
-          full = combine_letter_suffix(value)
-          return nil if full.nil? || full.empty?
-
-          value[:letter_suffix] = full
-          value
-        end
-      end
-    end
-  end
-end

data/lib/pubid/nist/series.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    # Per-series behavior policies for the NIST caster and builder.
-    #
-    # Series-specific casting decisions (letter-suffix preservation, IR revision
-    # handling, FIPS date format, etc.) live behind this interface so the
-    # caster and builder never read `parsed_hash[:series]` directly. A series
-    # bug now lives in exactly one file.
-    module Series
-      autoload :Base, "#{__dir__}/series/base"
-      autoload :LetterPreserving, "#{__dir__}/series/letter_preserving"
-      autoload :Crpl, "#{__dir__}/series/crpl"
-      autoload :Fips, "#{__dir__}/series/fips"
-      autoload :Ir, "#{__dir__}/series/ir"
-      autoload :Mono, "#{__dir__}/series/mono"
-      autoload :Ncstar, "#{__dir__}/series/ncstar"
-
-      # Order matters: longer / more-specific codes first so that substrings
-      # do not shadow them (e.g., LCIRC must be matched before IR, since
-      # "LCIRC" contains "IR").
-      REGISTRY = [
-        ["LCIRC", LetterPreserving],
-        ["FIPS",  Fips],
-        ["CRPL",  Crpl],
-        ["NCSTAR", Ncstar],
-        ["MONO",  Mono],
-        ["IR",    Ir],
-        ["MP",    LetterPreserving],
-        ["RPT",   LetterPreserving],
-        ["LC",    LetterPreserving],
-      ].freeze
-
-      def self.for(parsed_hash)
-        return Base if parsed_hash.nil?
-
-        series_code = parsed_hash[:series]
-        return Base if series_code.nil?
-
-        series_str = series_code.to_s.upcase
-        REGISTRY.each do |code, klass|
-          return klass if series_str.include?(code)
-        end
-        Base
-      end
-    end
-  end
-end

data/lib/pubid/nist/urn_parser.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Nist
-    # Parses NIST URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:nist:{type}:{code}[.{revision}].supp
-    #
-    # type is the lowercase series (sp, fips, ir, nistcir, …). code is the
-    # alphanumeric designation. revision is `r{N}` when present. The `.supp`
-    # suffix marks the series as supplementable.
-    #
-    # Examples:
-    # - urn:nist:sp:800-53.supp        → NIST SP 800-53
-    # - urn:nist:sp:800-53.r5.supp     → NIST SP 800-53r5
-    # - urn:nist:fips:199.supp         → NIST FIPS 199
-    class UrnParser < Pubid::UrnParser::Base
-      TYPE_UPCASE = {
-        "sp" => "SP",
-        "fips" => "FIPS",
-        "ir" => "IR",
-        "nistcir" => "NISTCIR",
-        "nbs" => "NBS",
-        "nistir" => "NISTIR",
-        "csf" => "CSF",
-        "gcr" => "GCR",
-        "itl" => "ITL",
-        "jres" => "JRES",
-        "lcirc" => "LCIRC",
-        "mon" => "MONO",
-        "ms" => "MS",
-        "nsrds" => "NSRDS",
-        "tn" => "TN",
-        "wp" => "WP",
-      }.freeze
-
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        type_token, payload = parts
-        code, revision = parse_payload(payload)
-
-        text = "NIST #{type_label(type_token)} #{code}"
-        text += revision if revision
-        flavor_parse(text)
-      end
-
-      private
-
-      def parse_payload(payload)
-        # Strip the trailing ".supp" supplement marker.
-        stripped = payload.sub(/\.supp\z/, "")
-        # Split revision suffix from code (e.g., "800-53.r5" → ["800-53", "r5"]).
-        match = stripped.match(/^(.*)\.(r\d+)$/i)
-        return [stripped, nil] unless match
-
-        [match[1], match[2]]
-      end
-
-      def type_label(token)
-        TYPE_UPCASE.fetch(token.downcase) { token.upcase }
-      end
-    end
-  end
-end

data/lib/pubid/oasis/builder.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oasis
-    # Turns the parse tree into an `Identifiers::Standard`: stores the slug
-    # verbatim in `original`, then performs a best-effort, ORDER-INDEPENDENT
-    # decomposition into number / version / stage / part / label.
-    #
-    # Decomposition splits `original` on "-" and classifies each *whole*
-    # fragment (so a stage-like substring inside a spec name — e.g. "CSDL" — is
-    # never mistaken for a stage). `number` is the specification name: the run
-    # of leading name fragments before the first recognized fragment, and the
-    # key relaton-index sorts and binary-searches on. `version`/`stage`/`part`
-    # are the first fragment of each recognized kind; `label` is any name
-    # fragment appearing after the first recognized one. Anything the
-    # classifier cannot place stays only in `original`, so the printed form
-    # always round-trips.
-    class Builder
-      # A fragment is a version when it is `v?N(.N)+` (e.g. "3.0", "v1.2.1",
-      # "V1.0"). Bare integers are deliberately NOT versions (too ambiguous
-      # with spec-name tokens).
-      VERSION_RE = /\Av?\d+(?:\.\d+)+\z/i
-      # OASIS approval-stage tokens (+ optional revision digits). Longest-first
-      # so shared prefixes classify correctly (CSPRD/CSD before CS, COS before
-      # CS/OS).
-      STAGE_RE = /\A(?:CSPRD|CSD|COS|CS|WD|OS|PS|PRD|CD|Errata)\d*\z/
-      # Part tokens across the three observed spellings, plus bare "Pt"/"P".
-      PART_RE = /\A(?:Part|Pt|part|P)\d*\z/
-
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        original = data[:original].to_s
-        Identifiers::Standard.new(original: original, **decompose(original))
-      end
-
-      private
-
-      # @return [Hash] best-effort { number:, version:, stage:, part:, label: }.
-      # Each fragment is classified once into a [fragment, kind] pair. `number`
-      # is the leading run of name fragments; `label` is any name fragment after
-      # the first recognized one; version/stage/part are the first of each kind.
-      def decompose(original)
-        pairs = original.split("-").map { |f| [f, classify(f)] }
-        lead = pairs.take_while { |_, kind| kind.nil? }
-        rest = pairs.drop(lead.length)
-        {
-          number: names(lead),
-          version: first_of(rest, :version),
-          stage: first_of(rest, :stage),
-          part: first_of(rest, :part),
-          label: names(rest),
-        }
-      end
-
-      # @return [Symbol, nil] :version / :stage / :part, or nil for a name token
-      def classify(fragment)
-        return :version if fragment.match?(VERSION_RE)
-        return :stage if fragment.match?(STAGE_RE)
-        return :part if fragment.match?(PART_RE)
-
-        nil
-      end
-
-      # First fragment of the given kind among [fragment, kind] pairs, or nil.
-      def first_of(pairs, kind)
-        pairs.find { |_, k| k == kind }&.first
-      end
-
-      # Name (unclassified) fragments among the pairs, re-joined, or nil.
-      def names(pairs)
-        fragments = pairs.select { |_, kind| kind.nil? }.map(&:first)
-        fragments.empty? ? nil : fragments.join("-")
-      end
-    end
-  end
-end

data/lib/pubid/oasis/identifier.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oasis
-    # Base class for every OASIS identifier AND the flavor's parse/create entry
-    # point. The single concrete type `Identifiers::Standard` descends from this
-    # class, so a parsed OASIS id is an instance of `Pubid::Oasis::Identifier`.
-    #
-    # OASIS identifiers are free-form slugs with an inconsistent internal
-    # structure (spec name + version + approval stage + part + label, in
-    # varying order). To guarantee a lossless round-trip we always keep the
-    # exact printed slug verbatim in `original` (which alone drives `to_s`); the
-    # remaining component fields are a best-effort decomposition for relaton
-    # querying and can be nil without ever affecting the rendered string.
-    class Identifier < ::Pubid::Identifier
-      # The exact slug printed after "OASIS " — always set. Drives `to_s`, so
-      # the printed form round-trips verbatim regardless of decomposition.
-      attribute :original, :string
-      # Best-effort decomposition (any may be nil). `number`/`label` are plain
-      # slug fragments; `version`/`stage`/`part` carry the recognized fragment
-      # verbatim (e.g. "3.0", "v1.2.1", "PS01", "Errata01", "Pt8", "Part1").
-      #
-      # `number` holds the specification name ("OSLC-CM", "STIX", "amqp-core").
-      # It is the key relaton-index sorts and binary-searches on
-      # (`id.root.number.to_s`), and it deliberately CLUSTERS: every version,
-      # stage and part of one specification shares it, the same shape as an
-      # IETF draft slug or an IANA registry slug.
-      #
-      # `number`/`stage`/`part` intentionally override the inherited
-      # Components::Code / Components::Stage attributes with plain strings (the
-      # mechanism JIS uses for `number` and W3C for `date`): OASIS names,
-      # stages and parts are opaque tokens that must round-trip exactly and are
-      # never re-parsed as structured parts. Redefining an inherited attribute
-      # is only deterministic under multi-flavor load because this class body
-      # lives in ONE file and is never reopened, so lutaml has finished
-      # building the table before `Identifiers::Standard` snapshots it — DO NOT
-      # split this class across two files.
-      attribute :number, :string
-      attribute :version, :string
-      attribute :stage, :string
-      attribute :part, :string
-      attribute :label, :string
-
-      # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
-      # the subclass's polymorphic_name to its class name so a stored hash
-      # rebuilds the correct identifier type via from_hash.
-      OASIS_TYPE_MAP = {
-        "pubid:oasis:standard" => "Pubid::Oasis::Identifiers::Standard",
-      }.freeze
-
-      key_value do
-        map "_type", to: :_type, polymorphic_map: OASIS_TYPE_MAP
-        map "original", to: :original
-        map "number", to: :number
-        map "version", to: :version
-        map "stage", to: :stage
-        map "part", to: :part
-        map "label", to: :label
-      end
-
-      # Publisher is always "OASIS". A plain constant (not a `publisher` method)
-      # so it doesn't shadow the inherited lutaml `publisher` attribute, which
-      # would otherwise fail serialization type validation.
-      PUBLISHER = "OASIS"
-
-      attr_reader :with_publisher
-
-      def to_s(with_publisher: true, **opts)
-        @with_publisher = with_publisher
-        render(format: :human, **opts)
-      end
-
-      # The decomposition fields. Excluding any of them must also clear
-      # `original`, which still spells the excluded value out verbatim.
-      DECOMPOSITION_KEYS = %i[number version stage part label].freeze
-
-      # Widen a partial reference. `#matches?` is
-      # `exclude(*ignore) == other.exclude(*ignore)`, and `original` carries
-      # every component verbatim, so without this a bare "OASIS WSDM" could
-      # never match "OASIS WSDM-v1.1" however much the caller ignored.
-      #
-      # `original` is cleared ONLY when the exclusion touches the
-      # decomposition — the "reset the whole cluster" rule CSA applies to its
-      # year-format siblings. A plain `==` still compares `original`, so two
-      # slugs that decompose alike but print differently stay distinct: the
-      # decomposition loses fragment order and drops repeated fragments, so it
-      # is not by itself an identity.
-      def exclude(*args)
-        result = super
-        result.original = nil if args.intersect?(DECOMPOSITION_KEYS)
-        result
-      end
-
-      # MR string hooks. `to_slug` delegates to `to_mr_string` and consumers
-      # use it as an output FILENAME, so the slug must be unique per document.
-      #
-      # The publisher lives in the PUBLISHER constant rather than the inherited
-      # lutaml attribute, so the base `mr_publisher` returns nil (the BIPM and
-      # IANA case) and is supplied here.
-      def mr_publisher
-        PUBLISHER.downcase
-      end
-
-      # The whole verbatim slug, not the decomposed fields: decomposition loses
-      # fragment order and drops repeated fragments, so "x-1.0-os-Pt1" and
-      # "x-1.0-Pt1-os" would assemble to one slug. `original` cannot collide.
-      def mr_number_with_part
-        mr_sanitize(original)
-      end
-
-      # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
-      # OASIS_TYPE_MAP remains as the key_value polymorphic_map.
-
-      # Parse an OASIS identifier string into an identifier object
-      # @param identifier [String] The OASIS identifier string to parse
-      # @return [Identifier] The Standard identifier object
-      # @raise [Pubid::Errors::ParseError] If parsing fails
-      def self.parse(identifier)
-        # Reject pathological inputs before they reach the parser
-        # (CodeQL rb/polynomial-redos barrier — inline .length by design).
-        unless identifier.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      end
-
-      private
-
-      # Filter by CHARSET, not by an enumerated escape list, so a field added
-      # later cannot leak an unsafe character (the BIPM `mr_slug` precedent).
-      # Three characters need it today: the "." in every version —
-      # Renderers::MrString joins SEGMENTS with ".", so a dot inside one breaks
-      # the documented segment structure — plus the space and "]" of a few
-      # malformed records.
-      #
-      # A RUN of non-alphanumerics collapses to one "-", which is why "-" is
-      # outside the kept set (BIPM's form, not ETSI's): "v3.0]-PS01" would
-      # otherwise print a bare "--".
-      #
-      # Caveat, the same one BIPM records: "-" is both the intra-slug join and
-      # the substitute, so two slugs differing ONLY in which non-slug character
-      # they use collapse onto one MR string. The corpus has exactly one such
-      # pair, the malformed "OpenC2-MQTT-v1.0] -CS01" spelled once with a
-      # normal space and once with a non-breaking one — two spellings of one
-      # document. Every genuinely distinct identifier keeps its own slug.
-      def mr_sanitize(value)
-        slug = value.to_s.downcase.gsub(/[^a-z0-9]+/, "-")
-          .gsub(/\A-+|-+\z/, "")
-        slug.empty? ? nil : slug
-      end
-    end
-  end
-end

data/lib/pubid/oasis/identifiers/standard.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oasis
-    module Identifiers
-      # The sole OASIS identifier type. OASIS records carry no document-type
-      # distinction in the printed id (every record is `type: OASIS`); the
-      # approval stage lives in the `stage` component field, not in the class.
-      # Example: "OASIS OSLC-CoreShapes-3.0-PS01-Pt8".
-      class Standard < Identifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :oasis,
-            stage_code: :published,
-            type_code: :oasis,
-            abbr: ["OASIS"],
-            name: "OASIS Standard",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :oasis, web: :standard, title: "OASIS Standard",
-            short: "OASIS" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/oasis/identifiers.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oasis
-    module Identifiers
-      autoload :Standard, "#{__dir__}/identifiers/standard"
-    end
-  end
-end

data/lib/pubid/oasis/parser.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Oasis
-    # Parslet grammar for printed OASIS identifiers, e.g.
-    #   "OASIS OSLC-CoreShapes-3.0-PS01-Pt8"
-    #   "OASIS amqp-core"
-    #
-    # OASIS slugs are free-form with a highly inconsistent internal structure
-    # (varying fragment order, three part spellings, mixed case, a few
-    # malformed records with spaces or stray characters). The grammar therefore
-    # only strips the "OASIS " publisher prefix and captures the remainder
-    # verbatim; the spec/version/stage/part/label decomposition is done in the
-    # Builder with order-independent fragment classification. Keeping
-    # decomposition out of the PEG avoids brittle backtracking and guarantees a
-    # lossless round-trip.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:prefix) { str("OASIS") >> str(" ") }
-
-      # The whole slug, captured verbatim (any character, incl. spaces / "]").
-      rule(:slug) { any.repeat(1).as(:original) }
-
-      rule(:identifier) { prefix >> slug }
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
-    end
-  end
-end

data/lib/pubid/oasis/renderer.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oasis
-    # Human-readable renderer for OASIS identifiers.
-    #
-    # Renders the verbatim slug (`original`), prefixed with the "OASIS "
-    # publisher token unless `id.with_publisher == false`. Because rendering is
-    # a pure echo of `original`, the printed form always round-trips exactly.
-    #
-    #   "OASIS OSLC-CoreShapes-3.0-PS01-Pt8"  (with publisher)
-    #   "OSLC-CoreShapes-3.0-PS01-Pt8"        (without)
-    class Renderer < ::Pubid::Renderers::Base
-      PUBLISHER = "OASIS"
-
-      def render(context: nil, **opts)
-        id = @id
-        body = id.original.to_s
-        with_publisher?(id) ? "#{PUBLISHER} #{body}" : body
-      end
-
-      private
-
-      def with_publisher?(id)
-        id.with_publisher != false
-      end
-    end
-  end
-end