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

data/data/bipm/update_codes.yaml

@@ -1,9 +0,0 @@
-# Legacy / docnumber-style BIPM identifier spellings normalized to a canonical,
-# parseable Pubid::Bipm form before parsing. Keys are full-line-anchored plain
-# strings (Regexp.escaped) or /regex/ literals — see lib/pubid/core/update_codes.rb.
-#
-# CIPM MRA:2005 interpretation document (relaton-data-bipm docnumber
-# "CIPM/2005-06(REV)"): strip the slash and the "(REV)" revision marker so both
-# the docnumber and docidentifier spellings map onto the bare "CIPM 2005-06" form.
-"CIPM/2005-06(REV)": CIPM 2005-06
-"CIPM 2005-06(REV)": CIPM 2005-06

data/data/nist/series.yaml

@@ -1,155 +0,0 @@
-long:
-  AMS: Advanced Manufacturing Series
-  BSS: Building Science Series
-  BMS: Building Material Structures Report
-  NBS BRPD-CRPL-D: Basic Radio Propagation Predictions Series
-  BH: Building and Housing
-  CRPL: Central Radio Propagation Laboratory Reports
-  NBS CRPL-F-A: CRPL Ionospheric Data
-  NBS CRPL-F-B: CRPL Solar-Geophysical Data
-  NBS IP: CRPL Ionospheric Predictions
-  CIRC: Circulars
-  NBS CIS: Consumer Information Series
-  CS: Commercial Standards
-  NBS CS-E: Commercial Standards (emergency)
-  CSM: Commercial Standards Monthly
-  FIPS: Federal Information Processing Standards Publication
-  GCR: Grant/Contract Reports
-  HB: Handbooks
-  NBS HR: Hydraulic Research in the United States
-  NBS IRPL: Interservice Radio Propagation Laboratory
-  ITL Bulletin: ITL Bulletin
-  NIST LC: Letter Circular
-  NBS LC: Letter Circular
-  MONO: Monograph
-  MP: Miscellaneous Publications
-  NCSTAR: National Construction Safety Team Act Reports
-  NSRDS: National Standard Reference Data Series
-  NSRDS-NBS: National Standard Reference Data Series
-  IR: IR
-  OWMWP: Office of Weights and Measures White Papers
-  PC: Photographic Laboratory Circulars
-  RPT: Reports
-  NIST PS: Voluntary Product Standards
-  SIBS: Special Interior Ballistics Studies
-  NBS PS: Voluntary Product Standards
-  SP: Special Publication
-  TN: Technical Notes
-  TIBM: Technical Information on Building Materials for Use in the Design of Low Cost Housing
-  TTB: Technology Transfer Briefs
-  NIST DCI: Data Collection Instruments
-  EAB: Economic Analysis Brief
-  NIST Other: Other
-  CSWP: Cybersecurity White Papers
-  CSRC Book: Cybersecurity Resource Center Book
-  CSRC Use Case: Cybersecurity Resource Center Use Case
-  CSRC Building Block: Cybersecurity Resource Center Building Block
-  JPCRD: Journal of Physical and Chemical Reference Data
-  JRES: Journal of Research of NIST
-  VTS: Voting Technology Series
-  AI: NIST Trustworthy and Responsible AI
-abbrev:
-  AMS: Adv. Man. Ser
-  BSS: Bldg. Sci. Ser.
-  FIPS: Federal Inf. Process. Stds.
-  HB: Handb.
-  MONO: Monogr.
-  NCSTAR: Natl. Constr. Tm. Act Rpt.
-  NSRDS: Natl. Stand. Ret. Data Ser.
-  NSRDS-NBS: Natl. Stand. Ret. Data Ser.
-  NIST PS: Prod. Stand.
-  NBS PS: Prod. Stand.
-  SP: Spec. Publ.
-  TN: Tech. Note
-  NIST DCI: Data Collect. Instr.
-  NIST Other: Other
-  CSWP: CSWP
-  CSRC Book: CSRC Book
-  CSRC Use Case: CSRC Use Case
-  CSRC Building Block: CSRC Building Block
-  JPCRD: J. Phys. & Chem. Ref. Data
-  JRES: J. Res. Natl. Inst. Stan.
-  # Issue #150: abbreviated descriptions for series that previously had
-  # none. Convention follows existing entries (shortened, period-suffixed).
-  # Ronald Tse should review and refine as needed.
-  AI: AI
-  BH: Bldg. & Hous.
-  BMS: Bldg. Mat. Struct.
-  CIRC: Circ.
-  CRPL: CRPL
-  CS: Commer. Stand.
-  CSM: Commer. Stand. Mo.
-  EAB: Econ. Anal. Br.
-  GCR: Grant/Contract Rpt.
-  IR: Interag. Rep.
-  ITL Bulletin: ITL Bull.
-  MP: Misc. Publ.
-  NBS BRPD-CRPL-D: Bas. Radio Prop. Pred.
-  NBS CIS: Consum. Inf. Ser.
-  NBS CRPL-F-A: CRPL Ionos. Data
-  NBS CRPL-F-B: CRPL Solar-Geophys. Data
-  NBS CS-E: Commer. Stand. (Emerg.)
-  NBS HR: Hydraul. Res.
-  NBS IP: CRPL Ionos. Pred.
-  NBS IRPL: Interserv. Radio Prop. Lab.
-  NBS LC: Lett. Circ.
-  NIST LC: Lett. Circ.
-  OWMWP: Off. Weights Meas. WP
-  PC: Photo. Lab. Circ.
-  RPT: Rpt.
-  SIBS: Spec. Inter. Ball. Stud.
-  TIBM: Tech. Inf. Bldg. Mat.
-  TTB: Tech. Transf. Br.
-  VTS: Voting Tech. Ser.
-  JPCRD: J. Phys. & Chem. Ref. Data
-  JRES: J. Res. Natl. Inst. Stan.
-mr:
-  AMS: AMS
-  BSS: BSS
-  BMS: BMS
-  NBS BRPD-CRPL-D: NBS.BRPD-CRPL-D
-  BH: BH
-  CRPL: CRPL
-  NBS CRPL-F-A: NBS.CRPL-F-A
-  NBS CRPL-F-B: NBS.CRPL-F-B
-  NBS IP: NBS.IP
-  CIRC: CIRC
-  NBS CIS: NBS.CIS
-  CS: CS
-  NBS CS-E: NBS.CS-E
-  CSM: CSM
-  FIPS: FIPS
-  GCR: GCR
-  HB: HB
-  NBS HR: NBS.HR
-  NBS IRPL: NBS.IRPL
-  ITL Bulletin: NIST.ITLB
-  NIST LC: NIST.LC
-  NBS LC: NBS.LC
-  MONO: MN
-  MP: MP
-  NCSTAR: NCSTAR
-  NSRDS: NSRDS
-  NSRDS-NBS: NBS.NSRDS
-  IR: IR
-  OWMWP: OWMWP
-  PC: PC
-  RPT: RPT
-  NIST PS: NIST.PS
-  SIBS: SIBS
-  NBS PS: NBS.PS
-  SP: SP
-  TN: TN
-  TIBM: TIBM
-  TTB: TTB
-  NIST DCI: NIST.DCI
-  EAB: EAB
-  NIST Other: NIST.O
-  CSWP: CSWP
-  CSRC Book: NIST.CSB
-  CSRC Use Case: NIST.CSUC
-  CSRC Building Block: NIST.CSBB
-  JPCRD: JPCRD
-  JRES: NIST.JRES
-  VTS: VTS
-  AI: AI

data/lib/pubid/adobe/builder.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    # Builds an Adobe identifier object from the Parslet parse tree.
-    class Builder
-      def build(parsed)
-        return build_tech_note(parsed[:tech_note]) if parsed[:tech_note]
-        return build_tech_note_bare(parsed[:tech_note_bare]) if parsed[:tech_note_bare]
-        return build_publication_version(parsed[:publication_version]) if parsed[:publication_version]
-        return build_publication(parsed[:slug]) if parsed[:slug]
-
-        raise ArgumentError, "Unrecognized Adobe parse tree: #{parsed.inspect}"
-      end
-
-      def self.build(parsed)
-        new.build(parsed)
-      end
-
-      private
-
-      def build_tech_note(hash)
-        Identifiers::TechNote.new(
-          number: stringify(hash[:number]),
-          slug:   stringify(hash[:slug]),
-        )
-      end
-
-      def build_tech_note_bare(number_hash)
-        Identifiers::TechNote.new(number: stringify(number_hash))
-      end
-
-      def build_publication(slug_value)
-        Identifiers::Publication.new(slug: stringify(slug_value))
-      end
-
-      def build_publication_version(hash)
-        Identifiers::Publication.new(
-          slug:    stringify(hash[:slug]),
-          version: stringify(hash[:version]),
-        )
-      end
-
-      def stringify(value)
-        return nil if value.nil?
-
-        str = value.to_s
-        str.empty? ? nil : str
-      end
-    end
-  end
-end

data/lib/pubid/adobe/identifier.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    # Base class for all Adobe identifiers. Canonical name
-    # Pubid::Adobe::Identifier; every concrete Adobe identifier
-    # (Identifiers::*) descends from it.
-    #
-    # Adobe identifiers come in two shapes:
-    #
-    #   * TechNote    — `Adobe Technical Note #<number>` / `ATN<number>`
-    #                   e.g. `Adobe Technical Note #5014`, `ATN5014`.
-    #   * Publication — slug-keyed named specs that have no number
-    #                   e.g. `adobe-glyph-list`, `adobe-japan1-7`.
-    class Identifier < ::Pubid::Identifier
-      # Parse an Adobe identifier string into an identifier object.
-      # @param identifier [String]
-      # @return [Pubid::Adobe::Identifier]
-      # @raise [Pubid::Errors::ParseError] If parsing fails
-      def self.parse(identifier)
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      end
-
-      attribute :publisher, :string, default: "Adobe"
-
-      ADOBE_TYPE_MAP = {
-        "pubid:adobe:tech-note"   => "Pubid::Adobe::Identifiers::TechNote",
-        "pubid:adobe:publication" => "Pubid::Adobe::Identifiers::Publication",
-      }.freeze
-
-      key_value do
-        map "_type", to: :_type, polymorphic_map: ADOBE_TYPE_MAP
-      end
-
-      def to_urn
-        UrnGenerator.new(self).generate
-      end
-
-      # Short type code (e.g. "ATN", nil for Publication) — convenience
-      # accessor used by Renderer and UrnGenerator.
-      def type_short
-        self.class.type[:short]
-      end
-    end
-  end
-end

data/lib/pubid/adobe/identifiers/publication.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    module Identifiers
-      # Adobe named publication. Slug-keyed specs that have no tech-note
-      # number — Adobe Glyph List, PostScript Language, character
-      # collections, etc.
-      #
-      # Surface forms:
-      #   * slug `adobe-glyph-list`, `adobe-postscript-language`
-      #   * versioned character collections: `adobe-japan1` + version `7`
-      #   * human render is the slug title-cased (`Adobe Glyph List`,
-      #     `Adobe-Japan1-7`); the full publication title lives in the
-      #     data repo's title attribute, not here.
-      class Publication < Identifier
-        attribute :slug,    :string   # "adobe-glyph-list", "adobe-japan1"
-        attribute :version, :string   # "7", "3", nil
-
-        key_value do
-          map "slug",    to: :slug
-          map "version", to: :version
-        end
-
-        def self.type
-          { key: :publication, title: "Publication", short: nil }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/adobe/identifiers/tech_note.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    module Identifiers
-      # Adobe Technical Note. Numbered 4-digit (5xxx series observed).
-      #
-      # Surface forms:
-      #   * `Adobe Technical Note #5014` — formal citation form
-      #   * `ATN5014`                    — short alias used in Metanorma
-      #                                    anchor ids ([[atn5014,…]])
-      #   * filename `5014.CIDFont_Spec.pdf` (data repo splits filename
-      #     into number + slug before calling the parser)
-      #
-      # The optional `slug` carries the filename's title segment
-      # (`CIDFont_Spec`) so round-trip through the data repo is lossless.
-      class TechNote < Identifier
-        attribute :number, :string   # "5014", "5902"
-        attribute :slug,   :string   # "CIDFont_Spec", "AFM_Spec", nil
-
-        key_value do
-          map "number", to: :number
-          map "slug",   to: :slug
-        end
-
-        def self.type
-          { key: :"tech-note", title: "Technical Note", short: "ATN" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/adobe/identifiers.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    module Identifiers
-      autoload :TechNote,    "#{__dir__}/identifiers/tech_note"
-      autoload :Publication, "#{__dir__}/identifiers/publication"
-    end
-  end
-end

data/lib/pubid/adobe/parser.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Adobe
-    # Parslet grammar for Adobe identifiers.
-    #
-    # Canonical citation forms (what the renderer produces):
-    #
-    #   Adobe TN 5014                  (tech note; replaces the older
-    #                                    "Adobe Technical Note #5014")
-    #   Adobe Publication adobe-glyph-list
-    #   Adobe Publication adobe-japan1-7
-    #
-    # The parser also accepts these legacy forms for back-compat:
-    #
-    #   Adobe Technical Note #5014
-    #   Adobe Technical Note 5014
-    #   Adobe TN5014                   (no space)
-    #   ATN5014                        (short alias)
-    #   5014                           (bare number; data-repo context)
-    #   adobe-glyph-list               (bare slug)
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-
-      root :identifier
-
-      rule(:space)  { str(" ") }
-      rule(:space?) { space.maybe }
-      rule(:hash)   { str("#") }
-      rule(:dot)    { str(".") }
-      rule(:dash)   { str("-") }
-
-      # Canonical short prefix: "Adobe TN" with optional trailing space.
-      # Matches both "Adobe TN 5014" and "Adobe TN5014".
-      rule(:tech_note_tn_prefix) do
-        str("Adobe") >> space >> str("TN") >> space?.maybe
-      end
-
-      # Legacy long prefix: "Adobe Technical Note" with optional "#".
-      rule(:tech_note_long_prefix) do
-        str("Adobe") >> space >> str("Technical") >> space >> str("Note") >>
-          (space? >> hash.maybe >> space?).maybe
-      end
-
-      # Legacy short alias: "ATN" with optional trailing space.
-      rule(:tech_note_atn_prefix) do
-        str("ATN") >> space?.maybe
-      end
-
-      rule(:tech_note_prefix) do
-        tech_note_tn_prefix | tech_note_long_prefix | tech_note_atn_prefix
-      end
-
-      rule(:digits) do
-        match("[0-9]").repeat(1)
-      end
-
-      # 4-digit tech note number, optionally followed by ".<Slug>" from
-      # the filename form. The slug is captured but not required.
-      rule(:slug_chars) do
-        match("[A-Za-z0-9_]").repeat(1)
-      end
-
-      rule(:tech_note) do
-        (tech_note_prefix >>
-          digits.as(:number) >>
-          (dot >> slug_chars.as(:slug)).maybe).as(:tech_note)
-      end
-
-      # Bare number form (e.g. when the data repo passes just "5014"
-      # extracted from a filename). Not advertised in user docs; used
-      # internally by AdobeFetcher::Docid.
-      rule(:bare_number) do
-        digits.as(:number).as(:tech_note_bare)
-      end
-
-      # "Adobe Publication " prefix. Matched literally then discarded —
-      # the publication slug/version is parsed by the inner rule.
-      rule(:publication_prefix) do
-        str("Adobe") >> space >> str("Publication") >> space
-      end
-
-      # Publication slug. Lowercase ASCII letters and digits joined by `-`.
-      # Each segment starts with a letter (so a trailing `-<digits>` is
-      # unambiguously a version suffix, not part of the slug).
-      rule(:slug_segment) do
-        match("[a-z]") >> match("[a-z0-9]").repeat
-      end
-
-      rule(:slug_inner) do
-        slug_segment >> (dash >> slug_segment).repeat
-      end
-
-      rule(:publication_with_version) do
-        (slug_inner.as(:slug) >> dash >> digits.as(:version)).as(:publication_version)
-      end
-
-      rule(:publication_slug_or_version) do
-        # Try with-version first so `adobe-japan1-7` doesn't get captured
-        # as slug `adobe-japan1-7` with no version. The flat `:slug` form
-        # is the fallback for unversioned slugs.
-        publication_with_version | slug_inner.as(:slug)
-      end
-
-      rule(:publication) do
-        # Optional "Adobe Publication " prefix. The prefix is consumed
-        # but not captured — the inner rule produces :slug or
-        # :publication_version as before.
-        publication_prefix.maybe >> publication_slug_or_version
-      end
-
-      rule(:identifier) do
-        tech_note | bare_number | publication
-      end
-
-      # Parse a string and return the raw parslet tree.
-      # @param string [String]
-      # @return [Hash]
-      def self.parse(string)
-        unless string.is_a?(String)
-          raise ::Pubid::Errors::InvalidInputError,
-                ::Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if string.length > ::Pubid::MAX_INPUT_LENGTH
-          raise ::Pubid::Errors::InvalidInputError,
-                ::Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
-        new.parse(string.strip)
-      end
-    end
-  end
-end

data/lib/pubid/adobe/renderer.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    # Human-readable renderer for Adobe identifiers.
-    #
-    # Produces the canonical citation forms:
-    #   "Adobe TN 5014"                       (tech note)
-    #   "Adobe Publication adobe-glyph-list"  (publication, slug)
-    #   "Adobe Publication adobe-japan1-7"    (publication, slug + version)
-    #
-    # The data repo (AdobeFetcher::Docid) overrides #to_s for publications
-    # to use the title from metadata instead of the slug, producing e.g.
-    # "Adobe Publication Adobe Glyph List". Pubid::Adobe itself is purely
-    # structural and renders slug-form citations.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **_opts)
-        id = @id
-
-        return render_tech_note(id) if id.is_a?(Identifiers::TechNote)
-        return render_publication(id) if id.is_a?(Identifiers::Publication)
-
-        raise ArgumentError, "Unknown Adobe identifier class: #{id.class}"
-      end
-
-      private
-
-      def render_tech_note(id)
-        "Adobe TN #{id.number}"
-      end
-
-      def render_publication(id)
-        rendered = "Adobe Publication #{id.slug}"
-        rendered << "-#{id.version}" if id.version
-        rendered
-      end
-    end
-  end
-end

data/lib/pubid/adobe/urn_generator.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    # Generates URN strings for Adobe identifiers.
-    #
-    # Format:
-    #   urn:adobe:tech-note:<number>            e.g. urn:adobe:tech-note:5014
-    #   urn:adobe:publication:<slug>[:v<ver>]   e.g. urn:adobe:publication:adobe-glyph-list
-    #                                             urn:adobe:publication:adobe-japan1:v7
-    class UrnGenerator
-      attr_reader :identifier
-
-      def initialize(identifier)
-        @identifier = identifier
-      end
-
-      def generate
-        if identifier.is_a?(Identifiers::TechNote)
-          generate_tech_note
-        elsif identifier.is_a?(Identifiers::Publication)
-          generate_publication
-        else
-          raise ArgumentError,
-                "Unknown Adobe identifier class: #{identifier.class}"
-        end
-      end
-
-      private
-
-      def generate_tech_note
-        "urn:adobe:tech-note:#{identifier.number}"
-      end
-
-      def generate_publication
-        parts = ["urn:adobe:publication", identifier.slug]
-        parts << "v#{identifier.version}" if identifier.version
-        parts.join(":")
-      end
-    end
-  end
-end

data/lib/pubid/adobe/urn_parser.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    # Parses Adobe URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:adobe:tech-note:<number>
-    #   urn:adobe:publication:<slug>[:v<version>]
-    #
-    # Examples:
-    #   urn:adobe:tech-note:5014                  → Adobe Technical Note #5014
-    #   urn:adobe:publication:adobe-glyph-list    → adobe-glyph-list
-    #   urn:adobe:publication:adobe-japan1:v7     → adobe-japan1-7
-    class UrnParser < Pubid::UrnParser::Base
-      PREFIX = "urn:adobe:".freeze
-
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-        namespace = parts.fetch(0)
-
-        case namespace
-        when "tech-note"
-          parse_tech_note(parts)
-        when "publication"
-          parse_publication(parts)
-        else
-          raise Pubid::UrnParser::Errors::ParseError,
-                "Unknown Adobe URN namespace: #{namespace.inspect} in #{urn.inspect}"
-        end
-      end
-
-      private
-
-      def strip_namespace(urn)
-        unless urn.downcase.start_with?(PREFIX)
-          raise Pubid::UrnParser::Errors::ParseError,
-                "Invalid Adobe URN: #{urn.inspect}"
-        end
-
-        urn[PREFIX.length..]
-      end
-
-      def parse_tech_note(parts)
-        number = parts.fetch(1)
-        flavor_parse("Adobe Technical Note ##{number}")
-      end
-
-      def parse_publication(parts)
-        slug = parts.fetch(1)
-        version_seg = parts[2]
-        if version_seg&.start_with?("v")
-          flavor_parse("#{slug}-#{version_seg.sub(/\Av/, "")}")
-        else
-          flavor_parse(slug)
-        end
-      end
-
-      def split_parts(body)
-        body.split(":")
-      end
-
-      def flavor_parse(text)
-        ::Pubid::Adobe.parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/adobe.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Adobe
-    extend Pubid::PrefixesSupport
-
-    # Leading identifier prefix tokens that an Adobe document id can start
-    # with. Tech notes appear as both `Adobe Technical Note #<n>` and the
-    # short alias `ATN<n>` in citations; both must route to this flavor.
-    # Named publications start with `Adobe` (e.g. `Adobe Glyph List`,
-    # `Adobe-Japan1-7`).
-    PREFIXES = ["Adobe", "ATN"].freeze
-
-    autoload :Builder,      "#{__dir__}/adobe/builder"
-    autoload :Identifier,   "#{__dir__}/adobe/identifier"
-    autoload :Identifiers,  "#{__dir__}/adobe/identifiers"
-    autoload :Parser,       "#{__dir__}/adobe/parser"
-    autoload :Renderer,     "#{__dir__}/adobe/renderer"
-    autoload :UrnGenerator, "#{__dir__}/adobe/urn_generator"
-    autoload :UrnParser,    "#{__dir__}/adobe/urn_parser"
-
-    # Parse an Adobe identifier string into an identifier object.
-    # @param identifier [String]
-    # @return [Pubid::Adobe::Identifier]
-    def self.parse(identifier)
-      Identifier.parse(identifier)
-    end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    # with the Adobe-specific renderer.
-    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Adobe::Renderer)
-
-    # Auto-discover identifier types from the Identifiers namespace.
-    # @return [Array<Class>]
-    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 < Pubid::Identifier }
-        .reject { |c| c == Identifier }
-    end
-
-    # Lookup: type key → identifier class
-    # @param code [String, Symbol]
-    # @return [Class, nil]
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    # Lookup: type short letter (e.g. "ATN") → identifier class
-    # @param short [String]
-    # @return [Class<Identifier>]
-    def self.identifier_klass_for_short(short)
-      @by_short ||= identifier_types.to_h { |klass| [klass.type[:short].to_s, klass] }
-      @by_short.fetch(short.to_s)
-    end
-  end
-end
-
-Pubid::Registry.register(:adobe, Pubid::Adobe)