Erstellung LibRML mit Kitodo.Production Export XSLT auf Basis der internen Metadaten

[andre-hohmann]

Allgemeine Informationen

In dieser Diskussion wird gezeigt, wie LibRML zusammen mit weiteren Rechteinformationen mit dem Export-XSLT in Kitodo.Production in die METS/MODS-Datei eingetragen werden kann.
Um möglich reale Beispiele zu erzeugen, werden weitere Metadaten transformiert. Die METS-Abschnitte mets:fileSec und mets:structLink können außerhalb von Kitodo.Production nicht vollständig erstellt werden.

Grundlagen sind eine interne Beispiel-Datei und das zugehöriges Export-XSLT der SLUB Dresden, angepasst für die Verarbeitung von LibRML. Sie sind im Abschnitt Beispiel-Dateien als eingeklappte XML-Codeblöcke eingefügt.

Interne Beispiel-Datei, in der Elemente enthalten sind, um Rechteinformationen und Beschränkungen zu beschreiben:

• <kitodo:metadata name="LegalNoteAndTermsOfUse"> enthält codierte Informationen über das Rechte- und Beschränkungsszenario
  • Mögliche Werte, die im Export-XSLT ausgewertet werden: CC01.0, CCBYSA4.0, CCBYNCND4.0, CCBYNCSA4.0, FZRV1.0, NIWE1.0, PDM1.0, TODR2.0, VW1.0, EZAM1.0INC1.0, EZAMUA1.0INC1.0, GERE1.0INC1.0, ILMA1.0INC1.0, KRBU1.0INC1.0, SCZT1.0,
• <kitodo:metadataGroup name="embargo"> enthält Informationen über Beginn und Ende der Schutzdauer oder Embargo-Zeiten

Vorteile dieser Anwendung:

• Es sind keine weiteren Systeme, Prozesse oder Werkzeuge notwendig, um LibRML zu verwalten oder in die METS-Datei einzutragen.
• Objektspezifische Informationen wie Schutzfristen oder Embargo-Zeiten können ausgewertet und im LibRML ergänzt werden, ohne dass sie in MODS oder anderen Austauschformaten für eine weitere Auswertung eingetragen werden müssen Beispiele: Mapping Rechtehinweise und Nutzungshinweise zu LibRML
• Kitodo.Production ist die zentrale Quelle für alle Rechteinformationen. Zumindest, wenn die Rechteinformationen bereits für die Präsentationssysteme und DDB verwaltet werden.
• Geringer administrativer Aufwand.

Nachteile dieser Anwendung:

• Es besteht keine Sicherung der LibRML-Codeblöcke, beziehungsweise sind unbeabsichtigte Änderungen möglich.
• Das XSLT wird sehr umfangreich, wenn viele Beschränkungs-Szenarien und/oder granulare Beschränkungs-Szenarien erstellt werden müssen.
• Fehlende Flexibilität für komplexe Beschränkungs-Szenarien.

Beispiel-Dateien

Hier klicken, um den XML-Code der Beispiel-Datei anzuzeigen

<?xml version="1.0" encoding="UTF-8"?>
<mets:mets xmlns:mets="http://www.loc.gov/METS/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.loc.gov/METS/ http://www.loc.gov/standards/mets/mets.xsd http://www.w3.org/1999/xlink http://www.loc.gov/standards/mets/xlink.xsd http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/mods.xsd info:lc/xmlns/premis-v2 http://www.loc.gov/standards/premis/v2/premis-v2-0.xsd http://www.loc.gov/mix/v10 http://www.loc.gov/standards/mix/mix10/mix10.xsd">
    <mets:metsHdr CREATEDATE="2019-04-03T07:52:06">
        <mets:agent OTHERTYPE="SOFTWARE" ROLE="CREATOR" TYPE="OTHER">
            <mets:name>Kitodo - kitodo-ugh-2.1.1-kitodo-ugh-2.1.1 - 21−January−2019</mets:name>
            <mets:note>Kitodo</mets:note>
        </mets:agent>
        <mets:metsDocumentID>71391</mets:metsDocumentID>
    </mets:metsHdr>
    <mets:dmdSec ID="DMDLOG_0000">
        <mets:mdWrap MDTYPE="OTHER" OTHERMDTYPE="KITODO">
            <mets:xmlData>
                <kitodo:kitodo xmlns:kitodo="http://meta.kitodo.org/v1/" version="1.0">
                    <kitodo:metadata name="CatalogIDDigital">381915700</kitodo:metadata>
                    <kitodo:metadata name="DocLanguage">ger</kitodo:metadata>
                    <kitodo:metadata name="PlaceOfPublication">Dresden</kitodo:metadata>
                    <kitodo:metadata name="PublicationYear">[1889]</kitodo:metadata>
                    <kitodo:metadata name="PublicationYearSorting">1889</kitodo:metadata>
                    <kitodo:metadata name="PublisherName">Meinhold</kitodo:metadata>
                    <kitodo:metadata name="SizeSourcePrint">[1] Bl.</kitodo:metadata>
                    <kitodo:metadata name="TitleDocMain">Tafel-Lied zum neunten Stiftungsfeste des Vereins der Beamten der Königl. Sammlungen am 1. November 1889</kitodo:metadata>
                    <kitodo:metadata name="singleDigCollection">Musik</kitodo:metadata>
                    <kitodo:metadata name="singleDigCollection">Saxonica</kitodo:metadata>
                    <kitodo:metadata name="shelfmarksource">Hist.Sax.G.366,20.s-9</kitodo:metadata>
                    <kitodo:metadata name="slub_script">Fraktur</kitodo:metadata>
                    <kitodo:metadata name="docType">Monograph</kitodo:metadata>
                    <kitodo:metadata name="LegalNoteAndTermsOfUse">PDM1.0</kitodo:metadata>
                    <kitodo:metadata name="age">16</kitodo:metadata>
                    <kitodo:metadataGroup name="embargo">
                        <kitodo:metadata name="embargoStart">1957-01-01</kitodo:metadata>
                        <kitodo:metadata name="embargoEnd">2026-12-31</kitodo:metadata>
                    </kitodo:metadataGroup>
                </kitodo:kitodo>
            </mets:xmlData>
        </mets:mdWrap>
    </mets:dmdSec>
    <mets:amdSec>
        <mets:rightsMD ID="uuid-2e47d8d8-cb0b-339c-9907-27cc3a0fe9ea">
            <mets:mdWrap>
                <mets:xmlData>
                    <kitodo:kitodo xmlns:kitodo="http://meta.kitodo.org/v1/" version="1.0">
                        <kitodo:metadata name="ownerLogo">http://digital.slub-dresden.de/fileadmin/images/dfgviewer_logo_slub.gif</kitodo:metadata>
                        <kitodo:metadata name="ownerContact">mailto:digital@slub-dresden.de</kitodo:metadata>
                        <kitodo:metadata name="owner">Sächsische Landesbibliothek - Staats- und Universitätsbibliothek Dresden</kitodo:metadata>
                    </kitodo:kitodo>
                </mets:xmlData>
            </mets:mdWrap>
        </mets:rightsMD>
        <mets:digiprovMD ID="uuid-32a3c6af-54ef-3770-85ce-5b03238cc663">
            <mets:mdWrap>
                <mets:xmlData>
                    <kitodo:kitodo xmlns:kitodo="http://meta.kitodo.org/v1/" version="1.0">
                    </kitodo:kitodo>
                </mets:xmlData>
            </mets:mdWrap>
        </mets:digiprovMD>
    </mets:amdSec>
    <mets:fileSec>
        <mets:fileGrp USE="LOCAL">
            <mets:file ID="FILE_0001" MIMETYPE="image/tiff">
                <mets:FLocat LOCTYPE="URL"/>
            </mets:file>
            <mets:file ID="FILE_0002" MIMETYPE="image/tiff">
                <mets:FLocat LOCTYPE="URL"/>
            </mets:file>
        </mets:fileGrp>
    </mets:fileSec>
    <mets:structMap TYPE="LOGICAL">
        <mets:div DMDID="DMDLOG_0000" ID="LOG_0000" LABEL="Tafel-Lied zum neunten Stiftungsfeste des Vereins der Beamten der Königl. Sammlungen am 1. November 1889" ORDERLABEL="Tafel-Lied zum neunten Stiftungsfeste des Vereins der Beamten der Königl. Sammlungen am 1. November 1889" TYPE="Monograph"/>
    </mets:structMap>
    <mets:structMap TYPE="PHYSICAL">
        <mets:div ID="PHYS_0000">
            <mets:div ID="PHYS_0001" ORDER="1" ORDERLABEL="uncounted" TYPE="page">
                <mets:fptr FILEID="FILE_0001"/>
            </mets:div>
            <mets:div ID="PHYS_0002" ORDER="2" ORDERLABEL="uncounted" TYPE="page">
                <mets:fptr FILEID="FILE_0002"/>
            </mets:div>
        </mets:div>
    </mets:structMap>
    <mets:structLink>
        <mets:smLink/>
        <mets:smLink/>
    </mets:structLink>
</mets:mets>

Im folgenden XSLT werden Rechteinformationen in den folgenden Templates verarbeitet:

• <xsl:template match="mets:amdSec">: <mets:rightsMD ID="LibRML">
• <xsl:template match="mets:amdSec/mets:rightsMD/mets:mdWrap/mets:xmlData/kitodo:kitodo">: <dv:license>
• <xsl:if test="$rights">: <mods:accessCondition>

Hier klicken, um den Export-XSLT anzuzeigen

<?xml version="1.0" encoding="UTF-8" ?>
<!--
 *
 * (c) Kitodo. Key to digital objects e. V. <contact@kitodo.org>
 *
 * This file is part of the Kitodo project.
 *
 * It is licensed under GNU General Public License version 3 or later.
 *
 * For the full copyright and license information, please read the
 * GPL3-License.txt file that was distributed with this source code.
 *
-->

<xsl:stylesheet version="2.0"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:dv="http://dfg-viewer.de/"
                xmlns:kitodo="http://meta.kitodo.org/v1/"
                xmlns:libRML="http://librml.org/schema" 
                xmlns:mods="http://www.loc.gov/mods/v3"
                xmlns:mets="http://www.loc.gov/METS/"
                xmlns:slub="http://www.slub-dresden.de/namespace"
                xmlns:xlink="http://www.w3.org/1999/xlink"
                xmlns:slubarchiv="http://slubarchiv.slub-dresden.de/rights1"
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                exclude-result-prefixes="#all"
                >

    <xsl:output method="xml" indent="yes" encoding="utf-8" omit-xml-declaration="no"/>

    <xsl:strip-space elements="*"/>

    <!-- Add schemalocations, namespaces and attribute OBJID for old Kalliope processes in element <mets:mets> -->
    <xsl:template match="/*">
        <xsl:variable name="dmSecId1" select="//mets:div[@TYPE='SubinventoryMigrated']/mets:div[1][@TYPE='ManuscriptKalliopeMigrated']/@DMDID"/>
        <xsl:variable name="catalogIDDigital" select="/mets:mets/mets:dmdSec[@ID=$dmSecId1]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='CatalogIDDigital']"/>
        <xsl:copy>
            <xsl:attribute name="xsi:schemaLocation">http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/mods.xsd http://www.loc.gov/METS/ http://www.loc.gov/standards/mets/mets.xsd</xsl:attribute>
            <xsl:if test="$dmSecId1">
                <xsl:attribute name="OBJID">
                    <xsl:value-of select="concat('oai:de:slub-dresden:db:id-', $catalogIDDigital)"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:namespace name="dv">
                <xsl:value-of select="'http://dfg-viewer.de/'"/>
            </xsl:namespace>
            <xsl:namespace name="mods">
                <xsl:value-of select="'http://www.loc.gov/mods/v3'"/>
            </xsl:namespace>
            <xsl:namespace name="slub">
                <xsl:value-of select="'http://www.slub-dresden.de/namespace'"/>
            </xsl:namespace>
            <xsl:namespace name="xlink">
                <xsl:value-of select="'http://www.w3.org/1999/xlink'"/>
            </xsl:namespace>
            <xsl:namespace name="slubarchiv">
                <xsl:value-of select="'http://slubarchiv.slub-dresden.de/rights1'"/>
            </xsl:namespace>
            <xsl:namespace name="libRML">
                <xsl:value-of select="'http://librml.org/schema'"/>
            </xsl:namespace>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>

    <!-- Add attribute @ID="AMD" in <mets:amdSec> -->
    <xsl:template match="mets:amdSec">
        <xsl:variable name="rights" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='LegalNoteAndTermsOfUse']"/>
        <xsl:copy>
            <xsl:attribute name="ID">AMD</xsl:attribute>
            <xsl:apply-templates select="@*"/>
            <xsl:apply-templates select="mets:rightsMD"/>
            <!-- Analysis of the rights information and mapping to LibRML -->
            <mets:rightsMD ID="LibRML">
                <mets:mdWrap MDTYPE="OTHER" MIMETYPE="text/xml" OTHERMDTYPE="LibRML">
                    <mets:xmlData>
                        <libRML:libRML>
                            <xsl:choose>
                                <xsl:when test="$rights = 'CC01.0' or $rights = 'CCBYSA4.0' or $rights = 'CCBYNCND4.0' or 
                                                $rights = 'CCBYNCSA4.0' or $rights = 'FZRV1.0' or $rights = 'NIWE1.0' or 
                                                $rights = 'PDM1.0' or $rights = 'TODR2.0' or $rights = 'VW1.0'">
                                    <libRML:item>
                                        <xsl:attribute name="usageguide">
                                            <xsl:choose>
                                                <xsl:when test="$rights = 'CC01.0'">https://creativecommons.org/publicdomain/zero/1.0/</xsl:when>
                                                <xsl:when test="$rights = 'CCBYSA4.0'">https://creativecommons.org/licenses/by-sa/4.0/</xsl:when>
                                                <xsl:when test="$rights = 'CCBYNCND4.0'">https://creativecommons.org/licenses/by-nc-nd/4.0/</xsl:when>
                                                <xsl:when test="$rights = 'CCBYNCSA4.0'">https://creativecommons.org/licenses/by-nc-sa/4.0/</xsl:when>
                                                <xsl:when test="$rights = 'FZRV1.0'">https://nutzungshinweis.slub-dresden.de/fz-rv/1.0/</xsl:when>
                                                <xsl:when test="$rights = 'NIWE1.0'">https://nutzungshinweis.slub-dresden.de/ni-we/1.0/</xsl:when>
                                                <xsl:when test="$rights = 'PDM1.0'">https://creativecommons.org/publicdomain/mark/1.0/</xsl:when>
                                                <xsl:when test="$rights = 'TODR2.0'">https://nutzungshinweis.slub-dresden.de/to-dr/2.0/</xsl:when>
                                                <xsl:when test="$rights = 'VW1.0'">https://nutzungshinweis.slub-dresden.de/ve-we/1.0/</xsl:when>
                                            </xsl:choose>
                                        </xsl:attribute>
                                        <libRML:action type="displaymetadata" permission="true"/>
                                        <libRML:action type="download" permission="true"/>
                                        <libRML:action type="index" permission="true"/>  
                                        <libRML:action type="read" permission="true"/>
                                    </libRML:item>
                                </xsl:when>
                                <xsl:when test="($rights = 'EZAM1.0INC1.0')">
                                    <libRML:item usageguide="https://nutzungshinweis.slub-dresden.de/ez-am/1.0/">
                                        <libRML:action type="displaymetadata" permission="true"/>
                                        <libRML:action type="download" permission="false"/>
                                        <libRML:action type="index" permission="true">
                                            <libRML:restriction type="concurrent" sessions="1"/>
                                            <libRML:restriction type="location" inside="SLUB-PC-Arbeitsplaetze-Mediathek"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="read" permission="true">
                                            <libRML:restriction type="concurrent" sessions="1"/>
                                            <libRML:restriction type="location" inside="SLUB-PC-Arbeitsplaetze-Mediathek"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                    </libRML:item>
                                </xsl:when>
                                <xsl:when test="($rights = 'EZAMUA1.0INC1.0')">
                                    <libRML:item usageguide="https://nutzungshinweis.slub-dresden.de/ez-am-ua/1.0/">
                                        <libRML:action type="displaymetadata" permission="true"/>
                                        <libRML:action type="download" permission="false"/>
                                        <libRML:action type="index" permission="true">
                                            <libRML:restriction type="concurrent" sessions="1"/>
                                            <libRML:restriction type="location" inside="SLUB-PC-Arbeitsplaetze-Lesesaal_Sammlungen"/>
                                            <libRML:restriction type="agreement" required="true"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="read" permission="true">
                                            <libRML:restriction type="concurrent" sessions="1"/>
                                            <libRML:restriction type="location" inside="SLUB-PC-Arbeitsplaetze-Lesesaal_Sammlungen"/>
                                            <libRML:restriction type="mets" filegroups="AUDIO DEFAULT VIDEO"/>
                                            <libRML:restriction type="agreement" required="true"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                    </libRML:item>
                                </xsl:when>
                                <xsl:when test="($rights = 'GERE1.0INC1.0')">
                                    <libRML:item usageguide="https://nutzungshinweis.slub-dresden.de/ge-re/1.0/">
                                        <libRML:action type="displaymetadata" permission="true"/>
                                        <libRML:action type="download" permission="true">
                                            <libRML:restriction type="mets" filegroups="DEFAULT DOWNLOAD"/>
                                            <libRML:restriction type="mets" fileformats="FULLTEXT-TXT FULLTEXT-XML IIIF-JSON"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="index" permission="true">
                                            <libRML:restriction type="mets" filegroups="FULLTEXT"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="read" permission="true">
                                            <libRML:restriction type="mets" filegroups="DEFAULT FULLTEXT THUMBS"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                    </libRML:item>
                                </xsl:when>
                                <xsl:when test="($rights = 'ILMA1.0INC1.0')">
                                    <libRML:item usageguide="https://nutzungshinweis.slub-dresden.de/il-ma/1.0/">
                                        <libRML:action type="displaymetadata" permission="true"/>
                                        <libRML:action type="download" permission="true">
                                            <libRML:restriction type="mets" filegroups="DEFAULT DOWNLOAD"/>
                                            <libRML:restriction type="mets" fileformats="FULLTEXT-TXT FULLTEXT-XML IIIF-JSON"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="index" permission="true">
                                            <libRML:restriction type="mets" filegroups="FULLTEXT"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="read" permission="true">
                                            <libRML:restriction type="mets" filegroups="DEFAULT FULLTEXT THUMBS"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                    </libRML:item>
                                </xsl:when>
                                <xsl:when test="($rights = 'KRBU1.0INC1.0')">
                                    <libRML:item usageguide="https://nutzungshinweis.slub-dresden.de/kr-bu/1.0/">
                                        <libRML:action type="displaymetadata" permission="true"/>
                                        <libRML:action type="download" permission="true">
                                            <libRML:restriction type="mets" filegroups="DOWNLOAD"/>
                                            <libRML:restriction type="mets" fileformats="FULLDOWNLOAD-PDF FULLTEXT-TXT FULLTEXT-XML IIIF-JSON"/>
                                            <libRML:restriction type="parts" percentage="10"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="index" permission="true">
                                            <libRML:restriction type="concurrent" sessions="1"/>
                                            <libRML:restriction type="location" inside="SLUB-PC-Arbeitsplaetze"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="read" permission="true">
                                            <libRML:restriction type="concurrent" sessions="1"/>
                                            <libRML:restriction type="location" inside="SLUB-PC-Arbeitsplaetze"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                    </libRML:item>
                                </xsl:when>
                                <xsl:when test="($rights = 'SCZT1.0')">
                                    <libRML:item usageguide="https://nutzungshinweis.slub-dresden.de/sc-zt/1.0/">
                                        <libRML:action type="displaymetadata" permission="true"/>
                                        <libRML:action type="download" permission="true">
                                            <libRML:restriction type="group" groups="SLUB-Nutzende"/>
                                            <libRML:restriction type="mets" filegroups="DOWNLOAD ORIGINAL"/>
                                            <libRML:restriction type="mets" fileformats="FULLDOWNLOAD-PDF FULLTEXT-TXT FULLTEXT-XML IIIF-JSON"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="index" permission="true">
                                            <libRML:restriction type="group" groups="SLUB-Nutzende"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                        <libRML:action type="read" permission="true">
                                            <libRML:restriction type="group" groups="SLUB-Nutzende"/>
                                            <xsl:call-template name="date"/>
                                        </libRML:action>
                                    </libRML:item>
                                  </xsl:when>
                                <!-- Fallback if rights information does not match and LibRML mapping is not possible -->
                                <xsl:otherwise>
                                  <libRML:item usageguide="https://nutzungshinweis.slub-dresden.de/unknown/1.0/"/>
                                </xsl:otherwise>
                            </xsl:choose>
                        </libRML:libRML>
                    </mets:xmlData>
                </mets:mdWrap>
            </mets:rightsMD>
            <xsl:apply-templates select="node()[not(self::mets:rightsMD)]"/>
        </xsl:copy>
    </xsl:template>

    <xsl:template name="date">
        <xsl:variable name="kitodo" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo"/>
        <xsl:variable name="fromdate" select="$kitodo/kitodo:metadataGroup[@name='embargo']/kitodo:metadata[@name='embargoStart']"/>
        <xsl:variable name="todate" select="$kitodo/kitodo:metadataGroup[@name='embargo']/kitodo:metadata[@name='embargoEnd']"/>
        <xsl:if test="$todate">
        <libRML:restriction type="date" todate="{normalize-space($todate)}"/>
        </xsl:if>
    </xsl:template>

    <!-- Correct attribute @ADMID="AMD" in <mets:structMap TYPE="LOGICAL"> -->
    <xsl:template match="@ADMID">
        <xsl:attribute name="ADMID">
            <xsl:choose>
                <xsl:when test="starts-with(. , 'uuid')">
                    <xsl:text>AMD</xsl:text>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="(.)"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:attribute>
    </xsl:template>

    <!-- Delete empty <mets:fileSec>-Elements in METS-files of superordinate processes -->
    <xsl:template match="/mets:mets/mets:fileSec">
        <xsl:if test="not (/mets:mets/mets:fileSec/mets:fileGrp)">
           <xsl:apply-templates/>
        </xsl:if>
        <xsl:if test="/mets:mets/mets:fileSec/mets:fileGrp">
            <xsl:copy>
                <xsl:apply-templates select="@* | node()"/>
            </xsl:copy>
        </xsl:if>
    </xsl:template>

    <!-- Replace in METS-attribute ORDERLABEL the value "uncounted" with the value " - " -->
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='PHYSICAL']/mets:div/mets:div/@ORDERLABEL">
        <xsl:attribute name="ORDERLABEL">
            <xsl:if test=".='uncounted'">
               <xsl:text> - </xsl:text>
            </xsl:if>
            <xsl:if test="not (.='uncounted')">
               <xsl:value-of select="."/>
            </xsl:if>
        </xsl:attribute>
    </xsl:template>

    <!-- Delete empty <mets:structMap[@TYPE='PHYSICAL']>-Elements in METS-files of superordinate processes -->
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='PHYSICAL']">
        <xsl:if test="not (/mets:mets/mets:structMap[@TYPE='PHYSICAL']/mets:div/mets:div)">
           <xsl:apply-templates/>
        </xsl:if>
        <xsl:if test="//mets:mets/mets:structMap[@TYPE='PHYSICAL']/mets:div/mets:div">
            <xsl:copy>
                <xsl:apply-templates select="@* | node()"/>
            </xsl:copy>
        </xsl:if>
    </xsl:template>

    <!-- Delete empty <mets:structMap[@TYPE='PHYSICAL']>-Elements in METS-files of superordinate processes -->
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='PHYSICAL']/mets:div">
        <xsl:if test="not (/mets:mets/mets:structMap[@TYPE='PHYSICAL']/mets:div/mets:div)">
           <xsl:apply-templates/>
        </xsl:if>
        <xsl:if test="//mets:mets/mets:structMap[@TYPE='PHYSICAL']/mets:div/mets:div">
            <xsl:copy>
                <!-- Add attribute @TYPE="physSequence" in <mets:structMap[@TYPE='PHYSICAL']> -->
                <xsl:attribute name="TYPE">physSequence</xsl:attribute>
                <xsl:apply-templates select="@* | node()"/>
            </xsl:copy>
        </xsl:if>
    </xsl:template>

    <!-- Delete empty <mets:structLink>-Elements in METS-files of superordinate processes -->
    <xsl:template match="/mets:mets/mets:structLink">
        <xsl:if test="not (/mets:mets/mets:structLink/mets:smLink)">
           <xsl:apply-templates/>
        </xsl:if>
        <xsl:if test="/mets:mets/mets:structLink/mets:smLink">
            <xsl:copy>
                <xsl:apply-templates select="@* | node()"/>
            </xsl:copy>
        </xsl:if>
    </xsl:template>

    <!-- Delete only incorrect ORDERLABEL (YYYY-MM) for Issues in year-processes -->
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/mets:div/mets:div/mets:div[@TYPE='PeriodicalIssue']/@ORDERLABEL">
        <xsl:choose>
            <xsl:when test="matches(.,'^([0-9]{1,4}-[0-9]{1,2})')"><!-- Delete ORDERLABEL only when it matches for example "1867-05", because these values are incorrect -->
            </xsl:when>
            <xsl:otherwise>
                <xsl:copy>
                    <xsl:apply-templates select="@* | node()"/><!-- Other ORDERLABEL as for example "01-Frühausgabe", "02-Abendausgabe", "01-Orchesterkonzert", ... should not be deleted -->
                </xsl:copy>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!-- Add attribute @MDTYPE="MODS" in mets:dmdSec/mets:mdWrap> -->
    <xsl:template match="mets:dmdSec/mets:mdWrap">
        <xsl:copy>
            <xsl:attribute name="MDTYPE">MODS</xsl:attribute>
            <xsl:apply-templates select="node()"/>
        </xsl:copy>
    </xsl:template>

    <!-- Add several attributes in mets:amdSec/mets:rightsMD/mets:mdWrap -->
    <xsl:template match="mets:amdSec/mets:rightsMD/mets:mdWrap">
        <xsl:copy>
            <xsl:attribute name="MDTYPE">OTHER</xsl:attribute>
            <xsl:attribute name="MIMETYPE">text/xml</xsl:attribute>
            <xsl:attribute name="OTHERMDTYPE">DVRIGHTS</xsl:attribute>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>

    <!-- Add several attributes in mets:amdSec/mets:digiprovMD/mets:mdWrap -->
    <xsl:template match="mets:amdSec/mets:digiprovMD/mets:mdWrap">
        <xsl:copy>
            <xsl:attribute name="MDTYPE">OTHER</xsl:attribute>
            <xsl:attribute name="MIMETYPE">text/xml</xsl:attribute>
            <xsl:attribute name="OTHERMDTYPE">DVLINKS</xsl:attribute>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>

    <!-- Delete empty LABEL attributes. Otherwise the values of "titleDocMain" and "currentNo" cannot be inserted. -->
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/@LABEL">
        <xsl:variable name="docType" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='docType']"/>
        <xsl:choose>
            <xsl:when test="($docType = 'Monograph' or $docType = 'Manuscript'or $docType = 'Periodical'or $docType = 'MultiVolumeWork')">
                <xsl:apply-templates select="@*"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:copy>
                    <xsl:apply-templates select="@* | node()"/>
                </xsl:copy>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/@LABEL">
        <xsl:variable name="docType" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='docType']"/>
        <xsl:choose>
            <xsl:when test="($docType = 'PeriodicalVolume' or $docType = 'Volume')">
                <xsl:apply-templates select="@*"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:copy>
                    <xsl:apply-templates select="@* | node()"/>
                </xsl:copy>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!-- Delete empty ORDERLABEL attributes. Otherwise the values of "titleDocMain" and "currentNo" cannot be inserted. -->
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/@ORDERLABEL">
        <xsl:variable name="docType" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='docType']"/>
        <xsl:choose>
            <xsl:when test="($docType = 'Monograph' or $docType = 'Manuscript'or $docType = 'Periodical'or $docType = 'MultiVolumeWork')">
                <xsl:apply-templates select="@*"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:copy>
                    <xsl:apply-templates select="@* | node()"/>
                </xsl:copy>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/@ORDERLABEL">
        <xsl:variable name="docType" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='docType']"/>
        <xsl:choose>
            <xsl:when test="($docType = 'PeriodicalVolume' or $docType = 'Volume')">
                <xsl:apply-templates select="@*"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:copy>
                    <xsl:apply-templates select="@* | node()"/>
                </xsl:copy>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!-- Add @LABEL and @ORDERLABEL to all structure elements -->
     <xsl:template match="@DMDID">
        <xsl:variable name="dmSecId" select="."/>
        <xsl:variable name="TitleDocMain" select="/mets:mets/mets:dmdSec[@ID=$dmSecId]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='TitleDocMain']"/>
        <xsl:variable name="TitleDocMainShort" select="/mets:mets/mets:dmdSec[@ID=$dmSecId]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='TitleDocMainShort']"/>
        <xsl:variable name="CurrentNoSorting" select="/mets:mets/mets:dmdSec[@ID=$dmSecId]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='CurrentNoSorting']"/>
        <xsl:variable name="CurrentNo" select="/mets:mets/mets:dmdSec[@ID=$dmSecId]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='CurrentNo']"/>
            <xsl:if test="$TitleDocMain !=''">
                <xsl:attribute name="LABEL">
                   <xsl:value-of select="/mets:mets/mets:dmdSec[@ID=$dmSecId]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='TitleDocMain']"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$CurrentNo !='' and not ($TitleDocMain)">
                <xsl:attribute name="LABEL">
                   <xsl:value-of select="/mets:mets/mets:dmdSec[@ID=$dmSecId]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='CurrentNo']"/>
                </xsl:attribute>
                <xsl:attribute name="ORDERLABEL">
                   <xsl:value-of select="/mets:mets/mets:dmdSec[@ID=$dmSecId]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='CurrentNo']"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$TitleDocMainShort !=''">
                <xsl:attribute name="ORDERLABEL">
                    <xsl:choose>
                        <xsl:when test="starts-with($TitleDocMainShort, 'Der')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMainShort,'Der ', ''))"/>
                        </xsl:when>
                        <xsl:when test="starts-with($TitleDocMainShort, 'Die')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMainShort,'Die ', ''))"/>
                        </xsl:when>
                        <xsl:when test="starts-with($TitleDocMainShort, 'Das')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMainShort,'Das ', ''))"/>
                        </xsl:when>
                        <xsl:when test="starts-with($TitleDocMainShort, 'Eine')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMainShort,'Eine ', ''))"/>
                        </xsl:when>
                        <xsl:when test="starts-with($TitleDocMainShort, 'Ein')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMainShort,'Ein ', ''))"/>
                        </xsl:when>
                       <xsl:otherwise>
                            <xsl:value-of select="($TitleDocMainShort)"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="not($TitleDocMainShort) and $TitleDocMain !=''">
                <xsl:attribute name="ORDERLABEL">
                    <xsl:choose>
                        <xsl:when test="starts-with($TitleDocMain, 'Der')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMain,'Der ', ''))"/>
                        </xsl:when>
                        <xsl:when test="starts-with($TitleDocMain, 'Die')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMain,'Die ', ''))"/>
                        </xsl:when>
                        <xsl:when test="starts-with($TitleDocMain, 'Das')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMain,'Das ', ''))"/>
                        </xsl:when>
                        <xsl:when test="starts-with($TitleDocMain, 'Eine')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMain,'Eine ', ''))"/>
                        </xsl:when>
                        <xsl:when test="starts-with($TitleDocMain, 'Ein')">
                            <xsl:value-of select="normalize-space(replace($TitleDocMain,'Ein ', ''))"/>
                        </xsl:when>
                       <xsl:otherwise>
                            <xsl:value-of select="($TitleDocMain)"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:attribute>
            </xsl:if>
        <xsl:copy>
            <xsl:apply-templates select="@*"/>
        </xsl:copy>
    </xsl:template>

    <!-- Sorting of <mets:file>-Elements in mets:fileGrp according to "@xlink:href" -->
    <xsl:template match="mets:fileGrp">
        <xsl:copy>
            <xsl:apply-templates select="@*" />
            <xsl:apply-templates select="mets:file">
                <xsl:sort select="mets:FLocat/@xlink:href" order="ascending"/>
            </xsl:apply-templates>
        </xsl:copy>
    </xsl:template>

    <!-- add @TYPE="month" and @TYPE="day" to untyped Elements and add ORDERLABEL -->
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/mets:div/mets:div[not(@TYPE)][mets:div[@TYPE='PeriodicalIssue']]">
    <xsl:variable name="orderlabel" select="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/mets:div/mets:div/@ORDERLABEL"/>
        <xsl:copy>
            <xsl:attribute name="TYPE">day</xsl:attribute>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>
    <xsl:template match="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/mets:div[not(@TYPE)][mets:div/mets:div[@TYPE='PeriodicalIssue']]">
    <xsl:variable name="orderlabel" select="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/mets:div/mets:div/@ORDERLABEL"/>
        <xsl:copy>
            <xsl:attribute name="TYPE">month</xsl:attribute>
                <xsl:if test="$orderlabel">
                    <xsl:attribute name="ORDERLABEL"><xsl:value-of select="substring($orderlabel,1,7)"/></xsl:attribute>
                </xsl:if>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>

    <xsl:template match="mets:amdSec/mets:rightsMD/mets:mdWrap/mets:xmlData/kitodo:kitodo">
        <xsl:variable name="license" select="kitodo:metadata[@name='license']"/>
        <xsl:variable name="owner" select="kitodo:metadata[@name='owner']"/>
        <xsl:variable name="ownerContact" select="kitodo:metadata[@name='ownerContact']"/>
        <xsl:variable name="ownerLogo" select="kitodo:metadata[@name='ownerLogo']"/>
        <xsl:variable name="ownerSiteURL" select="kitodo:metadata[@name='ownerSiteURL']"/>
        <xsl:variable name="rights" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='LegalNoteAndTermsOfUse']"/>
        <xsl:variable name="docType" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='docType']"/>
        <dv:rights>
            <xsl:if test="$owner">
                <dv:owner>
                    <xsl:value-of select="normalize-space($owner)"/>
                </dv:owner>
            </xsl:if>
            <xsl:if test="$ownerLogo">
                <dv:ownerLogo>
                    <xsl:value-of select="normalize-space($ownerLogo)"/>
                </dv:ownerLogo>
            </xsl:if>
            <xsl:if test="$ownerSiteURL">
                <dv:ownerSiteURL>
                    <xsl:value-of select="normalize-space($ownerSiteURL)"/>
                </dv:ownerSiteURL>
            </xsl:if>
            <xsl:if test="$ownerContact">
                <dv:ownerContact>
                    <xsl:value-of select="normalize-space($ownerContact)"/>
                </dv:ownerContact>
            </xsl:if>
            <xsl:if test="$rights and not ($rights = 'FZRV1.0' 
                                        or $rights = 'TODR1.0' 
                                        or $rights = 'TODR2.0' 
                                        or $rights = 'DONZ1.0FZRV1.0')">
                <dv:license>
                    <xsl:choose>
                        <xsl:when test="($rights = 'PDM1.0')">
                            <xsl:text>pdm</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'CC01.0')">
                            <xsl:text>cc0</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'CCBY4.0')">
                            <xsl:text>cc-by</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'CCBYSA4.0')">
                            <xsl:text>cc-by-sa</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'CCBYNCND4.0')">
                            <xsl:text>cc-by-nc-nd</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'CCBYNCSA4.0')">
                            <xsl:text>cc-by-nc-sa</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'DONZ1.0FZRV1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'DONZ1.0FZRV1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'DONZ1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'DONZ1.0PDM1.0')">
                            <xsl:text>pdm</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'DONZ1.0NIWE1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'DONZ1.0VW1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'FOZW1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'FZRV1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'EZAM1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'EZAMUA1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'GERE1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'ILMA1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'KRBU1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'SCZT1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'POSTDR1.0INC1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'NIWE1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <xsl:when test="($rights = 'VW1.0')">
                            <xsl:text>http://rightsstatements.org/vocab/InC/1.0/</xsl:text>
                        </xsl:when>
                        <!--
                        Disabled, because in the DDB, "reserved" is transformed to "Urheberrechtsschutz nicht bewertet" (http://rightsstatements.org/vocab/CNE/1.0/), which is not correct.
                        The objects are thus not ingested to the DDB.
                        <xsl:when test="($rights = 'TODR1.0')">
                            <xsl:text>reserved</xsl:text>
                        </xsl:when>
                        -->
                    </xsl:choose>
                </dv:license>
            </xsl:if>
            <xsl:if test="not ($rights) and (
                $docType = 'Bundle' or
                $docType = 'Inventory' or
                $docType = 'InventoryMigrated' or
                $docType = 'MultiVolumeWork' or
                $docType = 'Periodical' or
                $docType = 'Subinventory' or
                $docType = 'SubinventoryMigrated')">
                <!-- This is applied, because the DDB demands rights information for superordinate objects. To avoid inconsitencies between rights information of the superordinate and subordinate objects, the rights statement "Urheberrechtsschutz nicht bewertet" is applied here, but not in MODS, because it should not be shown in the digital collections. -->
                <dv:license>
                    <xsl:text>http://rightsstatements.org/vocab/CNE/1.0/</xsl:text>
                </dv:license>
            </xsl:if>
        </dv:rights>
    </xsl:template>

    <xsl:template match="mets:amdSec/mets:digiprovMD/mets:mdWrap/mets:xmlData/kitodo:kitodo">
        <xsl:variable name="owner" select="/mets:mets/mets:amdSec/mets:rightsMD/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='owner']"/>
        <xsl:variable name="catalogIDDigital" select="/mets:mets/mets:dmdSec[1]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='CatalogIDDigital']"/>
        <xsl:variable name="processTitle" select="/mets:mets/mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='processTitle']"/>
        <xsl:variable name="extractedPPN">
            <xsl:choose>
                <xsl:when test="matches($catalogIDDigital, '^[0-9]{8,9}[0-9X]')">
                    <xsl:value-of select="replace($catalogIDDigital, '^([0-9]{8,9}[0-9X]).*$', '$1')"/>
                </xsl:when>
                <xsl:when test="matches($processTitle, '_([0-9]{8,9}[0-9X]{1})-')">
                    <xsl:value-of select="replace($processTitle, '^.*_([0-9]{8,9}[0-9X]{1})-.*$', '$1')"/>
                </xsl:when>
            </xsl:choose>
        </xsl:variable>
        <dv:links>
            <dv:presentation>
                <xsl:choose>
                    <xsl:when test="$catalogIDDigital">
                        <xsl:value-of select="normalize-space(concat('https://digital.slub-dresden.de/id', $catalogIDDigital))"/>
                    </xsl:when>
                    <xsl:when test="matches($processTitle, '_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10})')">
                        <xsl:value-of select="normalize-space(replace($processTitle, '^.*_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10}).*$', 'https://digital.slub-dresden.de/id$1-$2'))"/>
                    </xsl:when>
                </xsl:choose>
            </dv:presentation>
            <dv:reference>
                <xsl:choose>
                    <xsl:when test="starts-with($catalogIDDigital, 'DE-611-')">
                        <xsl:value-of select="concat('http://kalliope-verbund.info/', $catalogIDDigital)"/>
                    </xsl:when>
                    <xsl:when test="matches($catalogIDDigital, '^[0-9]{8}Z$')">
                        <xsl:variable name="anchor" select="/mets:mets/mets:dmdSec[1]/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='CatalogIDDigitalAnchor']"/>
                        <xsl:value-of select="concat('https://katalog.slub-dresden.de/ppn/', $anchor)"/>
                    </xsl:when>
                    <xsl:when test="normalize-space($extractedPPN)">
                        <xsl:variable name="baseUrl">
                            <xsl:choose>
                                <xsl:when test="$owner = 'Stadtbibliothek Chemnitz'">http://www.stadtbibliothek-chemnitz.de/fileadmin/tpl/swb.php?PPN=</xsl:when>
                                <xsl:otherwise>https://katalog.slub-dresden.de/ppn/</xsl:otherwise>
                            </xsl:choose>
                        </xsl:variable>
                        <xsl:if test="not($owner = ('Hochschule für Musik und Theater Felix Mendelssohn Bartholdy Leipzig', 'Universitätsbibliothek Georgius Agricola Freiberg'))">
                            <xsl:value-of select="concat($baseUrl, $extractedPPN)"/>
                        </xsl:if>
                    </xsl:when>
                </xsl:choose>
            </dv:reference>
        </dv:links>
    </xsl:template>

    <xsl:template name="dmdSec" match="mets:dmdSec/mets:mdWrap/mets:xmlData/kitodo:kitodo">
        <xsl:variable name="title" select="kitodo:metadata[@name='TitleDocMain']"/>
        <xsl:variable name="subTitle" select="kitodo:metadata[@name='TitleDocSub1']"/>
        <xsl:variable name="parallelTitle" select="kitodo:metadata[@name='TitleDocParallel']"/>
        <xsl:variable name="translatedTitle" select="kitodo:metadata[@name='TitleDocTranslated']"/>
        <xsl:variable name="uniformTitle" select="kitodo:metadata[@name='slub_uniformtitle']"/>
        <xsl:variable name="personGroup" select="kitodo:metadataGroup[@name='Person']"/>
        <xsl:variable name="contributorPersonGroup" select="kitodo:metadataGroup[@name='ContributorPerson']"/>
        <xsl:variable name="contributorPersonOtherGroup" select="kitodo:metadataGroup[@name='ContributorPersonOther']"/>
        <xsl:variable name="corporationGroup" select="kitodo:metadataGroup[@name='Corporation']"/>
        <xsl:variable name="contributorCorporationGroup" select="kitodo:metadataGroup[@name='ContributorCorporation']"/>
        <xsl:variable name="contributorCorporationOtherGroup" select="kitodo:metadataGroup[@name='ContributorCorporationOther']"/>
        <xsl:variable name="slubOwnerOrig" select="kitodo:metadata[@name='slub_ownerOrig']"/>
        <xsl:variable name="slubOwnerOrigPerson" select="kitodo:metadata[@name='slub_ownerOrigPerson']"/>
        <xsl:variable name="slubOwnerDigi" select="kitodo:metadata[@name='slub_ownerDigi']"/>
        <xsl:variable name="slubLicensor" select="kitodo:metadata[@name='slub_licensor']"/>
        <xsl:variable name="slubLicensorAdditional" select="kitodo:metadata[@name='slub_licensorAdditional']"/>
        <xsl:variable name="slubFinance" select="kitodo:metadata[@name='slub_Finance']"/>
        <xsl:variable name="slubPermittingAgency" select="kitodo:metadata[@name='slub_permittingAgency']"/>
        <xsl:variable name="slubPictureAgency" select="kitodo:metadata[@name='slub_pictureAgency']"/>
        <xsl:variable name="genre" select="kitodo:metadata[@name='slub_Genre']"/>
        <xsl:variable name="textType" select="kitodo:metadata[@name='slub_textType']"/>
        <xsl:variable name="genreWorkingField" select="kitodo:metadata[@name='slub_genre']"/>
        <xsl:variable name="publicationPlace" select="kitodo:metadata[@name='PlaceOfPublication']"/>
        <xsl:variable name="publisher" select="kitodo:metadata[@name='PublisherName']"/>
        <xsl:variable name="publicationDate" select="kitodo:metadata[@name='PublicationDate']"/>
        <xsl:variable name="dateIssued" select="kitodo:metadata[@name='PublicationYear']"/>
        <xsl:variable name="dateIssuedSorting" select="kitodo:metadata[@name='PublicationYearSorting']"/>
        <xsl:variable name="publicationStart" select="kitodo:metadata[@name='PublicationStart']"/>
        <xsl:variable name="publicationEnd" select="kitodo:metadata[@name='PublicationEnd']"/>
        <xsl:variable name="edition" select="kitodo:metadata[@name='slub_edition']"/>
        <xsl:variable name="productionPlace" select="kitodo:metadata[@name='PlaceOfProduction']"/>
        <xsl:variable name="producer" select="kitodo:metadata[@name='ProducerName']"/>
        <xsl:variable name="cyclestart" select="kitodo:metadata[@name='slub_cyclestart']"/>
        <xsl:variable name="cycleend" select="kitodo:metadata[@name='slub_cycleend']"/>
        <xsl:variable name="legislativeperiodStart" select="kitodo:metadata[@name='slub_legislativeperiodstart']"/>
        <xsl:variable name="legislativeperiodEnd" select="kitodo:metadata[@name='slub_legislativeperiodend']"/>
        <xsl:variable name="date" select="kitodo:metadata[@name='slub_date']"/>
        <xsl:variable name="dateCreated" select="kitodo:metadata[@name='slub_dateCreated']"/>
        <xsl:variable name="reportingYear" select="kitodo:metadata[@name='ReportingYear']"/>
        <xsl:variable name="language" select="kitodo:metadata[@name='DocLanguage']"/>
        <xsl:variable name="script" select="kitodo:metadata[@name='slub_script']"/>
        <xsl:variable name="physicalDescription" select="kitodo:metadata[@name='FormatSourcePrint']"/>
        <xsl:variable name="sizeSourcePrint" select="kitodo:metadata[@name='SizeSourcePrint']"/>
        <xsl:variable name="physicalForm" select="kitodo:metadata[@name='slub_physicalForm']"/>
        <xsl:variable name="method" select="kitodo:metadata[@name='slub_method']"/>
        <xsl:variable name="bindingMaterial" select="kitodo:metadata[@name='slub_BindingMaterial']"/>
        <xsl:variable name="waterMark" select="kitodo:metadata[@name='slub_WaterMark']"/>
        <xsl:variable name="supralibros" select="kitodo:metadata[@name='slub_Supralibros']"/>
        <xsl:variable name="digitalOrigin" select="kitodo:metadata[@name='CatalogIDDigital']"/>
        <xsl:variable name="motive" select="kitodo:metadata[@name='slub_motive']"/>
        <xsl:variable name="abstractKalliope" select="kitodo:metadata[@name='slub_abstractKalliope']"/>
        <xsl:variable name="attachment" select="kitodo:metadata[@name='slub_attachment']"/>
        <xsl:variable name="annotation" select="kitodo:metadata[@name='slub_annotation']"/>
        <xsl:variable name="comment" select="kitodo:metadata[@name='slub_comment']"/>
        <xsl:variable name="musicFormat" select="kitodo:metadata[@name='slub_music_format']"/>
        <xsl:variable name="keyword" select="kitodo:metadata[@name='slub_Keyword']"/>
        <xsl:variable name="placeSWDID" select="kitodo:metadata[@name='slub_PlaceSWDID']"/>
        <xsl:variable name="place" select="kitodo:metadata[@name='slub_Place']"/>
        <xsl:variable name="time" select="kitodo:metadata[@name='slub_Time']"/>
        <xsl:variable name="subjectGenre" select="kitodo:metadata[@name='slub_subjectGenre']"/>
        <xsl:variable name="collection" select="kitodo:metadata[@name='singleDigCollection']"/>
        <xsl:variable name="serial" select="kitodo:metadata[@name='slub_serial']"/>
        <xsl:variable name="serialGroup" select="kitodo:metadataGroup[@name='slub_serialGroup']"/>
        <xsl:variable name="catalogIDDigital" select="kitodo:metadata[@name='CatalogIDDigital']"/>
        <xsl:variable name="processTitle" select="kitodo:metadata[@name='processTitle']"/>
        <xsl:variable name="catalogIDSourceKXP" select="kitodo:metadata[@name='CatalogIDSourceKXP']"/>
        <xsl:variable name="catalogIDSource" select="kitodo:metadata[@name='CatalogIDSource']"/>
        <xsl:variable name="VD16" select="kitodo:metadata[@name='VD16']"/>
        <xsl:variable name="VD17" select="kitodo:metadata[@name='VD17']"/>
        <xsl:variable name="VD18" select="kitodo:metadata[@name='VD18']"/>
        <xsl:variable name="KalliopeID" select="kitodo:metadata[@name='KalliopeID']"/>
        <xsl:variable name="rismID" select="kitodo:metadata[@name='slub_rismID']"/>
        <xsl:variable name="rism1" select="kitodo:metadata[@name='slub_rism'][1]"/>
        <xsl:variable name="rism2" select="kitodo:metadata[@name='slub_rism'][2]"/>
        <xsl:variable name="ISSN" select="kitodo:metadata[@name='ISSN']"/>
        <xsl:variable name="ZDBID" select="kitodo:metadata[@name='CatalogIDPeriodicalDB']"/>
        <xsl:variable name="FUD" select="kitodo:metadata[@name='slub_letterid']"/>
        <xsl:variable name="KitodoID" select="/mets:mets/mets:metsHdr/mets:metsDocumentID"/>
        <xsl:variable name="shelfLocator" select="kitodo:metadata[@name='shelfmarksource']"/>
        <xsl:variable name="rights" select="kitodo:metadata[@name='LegalNoteAndTermsOfUse']"/>
        <xsl:variable name="contractTitle" select="kitodo:metadata[@name='ContractTitle']"/>
        <xsl:variable name="contractDate" select="kitodo:metadata[@name='ContractDate']"/>
        <xsl:variable name="contractShortTitle" select="kitodo:metadata[@name='ContractShortTitle']"/>
        <xsl:variable name="rightsinfo" select="kitodo:metadata[@name='slub_rightsinfo']"/>
        <xsl:variable name="currentNo" select="kitodo:metadata[@name='CurrentNo']"/>
        <xsl:variable name="currentNoSorting" select="kitodo:metadata[@name='CurrentNoSorting']"/>
        <xsl:variable name="recordIdentifierHost" select="kitodo:metadata[@name='CatalogIDDigitalAnchor']"/>
        <xsl:variable name="TSL_ATS" select="kitodo:metadata[@name='TSL_ATS']"/>
        <xsl:variable name="catalogTitle" select="kitodo:metadata[@name='slub_CatalogTitle']"/>
        <xsl:variable name="catalogPPN" select="kitodo:metadata[@name='slub_CatalogPPN']"/>
        <xsl:variable name="catalogImage" select="kitodo:metadata[@name='slub_CatalogImage']"/>
        <xsl:variable name="facsimileTitle" select="kitodo:metadata[@name='slub_FacsimileTitle']"/>
        <xsl:variable name="facsimilePPN" select="kitodo:metadata[@name='slub_FacsimilePPN']"/>
        <xsl:variable name="footer" select="kitodo:metadata[@name='slub_footer']"/>
        <xsl:variable name="linktext" select="kitodo:metadata[@name='slub_linktext']"/>
        <xsl:variable name="link" select="kitodo:metadata[@name='slub_link']"/>
        <xsl:variable name="linkgroup" select="kitodo:metadataGroup[@name='slub_link_group']"/>
        <xsl:variable name="provenanceGroup" select="kitodo:metadataGroup[@name='slub_provenance']"/>
        <xsl:variable name="provenanceMODSNAME" select="kitodo:metadataGroup[@name='slub_provenance']/kitodo:metadata[@name='slub_provenanceInstitution']"/>
        <xsl:variable name="owner" select="/mets:mets/mets:amdSec/mets:rightsMD/mets:mdWrap/mets:xmlData/kitodo:kitodo/kitodo:metadata[@name='owner']"/>
        <xsl:variable name="docType" select="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/mets:div[@TYPE='issue']"/>
        <xsl:variable name="docTypeIssue1" select="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/@TYPE"/>
        <xsl:variable name="docTypeIssue2" select="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div//mets:div/@TYPE"/>
        <xsl:variable name="docTypeIssue3" select="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div//mets:div/mets:div/@TYPE"/>
        <xsl:variable name="docTypeYear" select="/mets:mets/mets:structMap[@TYPE='LOGICAL']/mets:div/mets:div/@TYPE"/>
        <xsl:variable name="docTypeMODS" select="kitodo:metadata[@name='docType']"/>
        <mods:mods>
            <xsl:if test="$title or $subTitle">
                <mods:titleInfo>
                    <xsl:if test="$title">
                        <xsl:for-each select="$title">
                            <mods:title>
                                <xsl:value-of select="normalize-space($title)"/>
                            </mods:title>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:if test="$subTitle">
                        <xsl:for-each select="$subTitle">
                            <mods:subTitle>
                                <xsl:value-of select="($subTitle)"/>
                            </mods:subTitle>
                        </xsl:for-each>
                    </xsl:if>
                </mods:titleInfo>
            </xsl:if>
            <xsl:if test="$translatedTitle">
                <mods:titleInfo type="translated">
                    <mods:title>
                        <xsl:value-of select="($translatedTitle)"/>
                    </mods:title>
                </mods:titleInfo>
            </xsl:if>
            <xsl:if test="$parallelTitle">
                <xsl:for-each select="$parallelTitle">
                    <mods:titleInfo type="alternative">
                        <mods:title>
                            <xsl:value-of select="(.)"/>
                        </mods:title>
                    </mods:titleInfo>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$uniformTitle">
                <mods:titleInfo type="uniform">
                    <mods:title>
                        <xsl:value-of select="($uniformTitle)"/>
                    </mods:title>
                </mods:titleInfo>
            </xsl:if>
            <xsl:apply-templates select="$personGroup"/>
            <xsl:apply-templates select="$contributorPersonGroup"/>
            <xsl:apply-templates select="$contributorPersonOtherGroup"/>
            <xsl:apply-templates select="$corporationGroup"/>
            <xsl:apply-templates select="$contributorCorporationGroup"/>
            <xsl:apply-templates select="$contributorCorporationOtherGroup"/>
            <xsl:if test="($docTypeMODS = 'PeriodicalIssue')">
                <mods:typeOfResource>
                    <xsl:text>text</xsl:text>
                </mods:typeOfResource>
            </xsl:if>
            <xsl:if test="$genre">
                <xsl:for-each select="$genre">
                    <mods:genre>
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:genre>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$textType">
                <xsl:for-each select="$textType">
                    <mods:genre type='class'>
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:genre>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$genreWorkingField">
                <xsl:for-each select="$genreWorkingField">
                    <mods:genre type='workingField'>
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:genre>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="($publicationPlace or $publisher or $publicationDate or $dateIssued or $dateIssuedSorting or $edition or ($processTitle and $script != '')) and not ($productionPlace) and not ($dateCreated)">
                <!-- and not ($dateCreated) : Prevent creation <mods:originInfo eventType="publication"> for bundle. Therefore <mods:originInfo eventType="production"> is created.  -->
                <mods:originInfo eventType="publication">
                    <xsl:if test="$publicationPlace">
                        <mods:place>
                            <xsl:for-each select="$publicationPlace">
                                <mods:placeTerm type="text">
                                    <xsl:value-of select="(.)"/>
                                </mods:placeTerm>
                            </xsl:for-each>
                        </mods:place>
                    </xsl:if>
                    <xsl:if test="$publisher">
                        <xsl:for-each select="$publisher">
                            <mods:publisher>
                                <xsl:value-of select="(.)"/>
                            </mods:publisher>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:for-each select="$publicationDate">
                        <xsl:choose>
                            <xsl:when test="matches($publicationDate,'^(([0-9]{4})-([0-9]{2})-([0-9]{2})$)')">
                                <mods:dateIssued encoding="iso8601" keyDate="yes">
                                    <xsl:value-of select="normalize-space($publicationDate)"/>
                                </mods:dateIssued>
                            </xsl:when>
                            <xsl:when test="matches($publicationDate,'^([0-9]{2}).([0-9]{2}).([0-9]{4})$')">
                                <mods:dateIssued encoding="iso8601" keyDate="yes">
                                    <xsl:value-of select="replace($publicationDate, '^([0-9]{2}).([0-9]{2}).([0-9]{4})$', '$3-$2-$1')"/>
                                </mods:dateIssued>
                            </xsl:when>
                        </xsl:choose>
                    </xsl:for-each>
                    <xsl:if test="($dateIssuedSorting or $processTitle)">
                        <xsl:variable name="extractedDate">
                            <xsl:if test="$processTitle">
                                <xsl:value-of select="normalize-space(replace($processTitle, '^.*?_.*?-([0-9]{4})([0-9]{2})([0-9]{2}).*$', '$1-$2-$3'))"/>
                            </xsl:if>
                        </xsl:variable>
                        <xsl:if test="$dateIssued">
                            <mods:dateIssued encoding="iso8601" keyDate="yes">
                                <xsl:value-of select="normalize-space($dateIssuedSorting)"/>
                            </mods:dateIssued>
                        </xsl:if>
                        <xsl:if test="$processTitle and matches($extractedDate, '^\d{4}-\d{2}-\d{2}$')">
                            <mods:dateIssued encoding="iso8601" keyDate="yes">
                                <xsl:value-of select="$extractedDate"/>
                            </mods:dateIssued>
                            <mods:displayDate>
                                <xsl:value-of select="$extractedDate"/>
                            </mods:displayDate>
                        </xsl:if>
                    </xsl:if>
                    <xsl:if test="not($dateIssuedSorting or $processTitle) and not ($dateCreated)">
                        <xsl:if test="$dateIssued">
                            <mods:dateIssued encoding="iso8601" keyDate="yes">
                                <xsl:value-of select="normalize-space(replace($dateIssued,'^(.*)([0-9]{4})(.*)', '$2'))"/>
                            </mods:dateIssued>
                        </xsl:if>
                    </xsl:if>
                    <xsl:if test="$dateIssued or $processTitle and not ($docTypeYear)">
                        <xsl:if test="$dateIssued">
                            <mods:displayDate>
                                <xsl:value-of select="normalize-space($dateIssued)"/>
                            </mods:displayDate>
                        </xsl:if>
                    </xsl:if>
                    <xsl:for-each select="$publicationStart">
                        <xsl:choose>
                            <xsl:when test="matches($publicationStart,'^(([0-9]{4})-([0-9]{2})-([0-9]{2})$)')">
                                <mods:dateIssued point="start" encoding="w3cdtf">
                                    <xsl:value-of select="normalize-space($publicationStart)"/>
                                </mods:dateIssued>
                            </xsl:when>
                            <xsl:when test="matches($publicationStart,'^([0-9]{2}).([0-9]{2}).([0-9]{4})$')">
                                <mods:dateIssued point="start" encoding="w3cdtf">
                                    <xsl:value-of select="replace($publicationStart, '^([0-9]{2}).([0-9]{2}).([0-9]{4})$', '$3-$2-$1')"/>
                                </mods:dateIssued>
                            </xsl:when>
                        </xsl:choose>
                    </xsl:for-each>
                    <xsl:for-each select="$publicationEnd">
                        <xsl:choose>
                            <xsl:when test="matches($publicationEnd,'^(([0-9]{4})-([0-9]{2})-([0-9]{2})$)')">
                                <mods:dateIssued point="end" encoding="w3cdtf">
                                    <xsl:value-of select="normalize-space($publicationEnd)"/>
                                </mods:dateIssued>
                            </xsl:when>
                            <xsl:when test="matches($publicationEnd,'^([0-9]{2}).([0-9]{2}).([0-9]{4})$')">
                                <mods:dateIssued point="end" encoding="w3cdtf">
                                    <xsl:value-of select="replace($publicationEnd, '^([0-9]{2}).([0-9]{2}).([0-9]{4})$', '$3-$2-$1')"/>
                                </mods:dateIssued>
                            </xsl:when>
                        </xsl:choose>
                    </xsl:for-each>
                    <xsl:if test="$edition">
                        <mods:edition>
                            <xsl:value-of select="normalize-space($edition)"/>
                        </mods:edition>
                    </xsl:if>
                </mods:originInfo>
            </xsl:if>
            <xsl:if test="$productionPlace or $producer or $dateCreated">
                <mods:originInfo eventType="production">
                    <xsl:if test="$productionPlace">
                        <mods:place>
                            <xsl:for-each select="$productionPlace">
                                <mods:placeTerm type="text">
                                    <xsl:value-of select="(.)"/>
                                </mods:placeTerm>
                            </xsl:for-each>
                        </mods:place>
                    </xsl:if>
                    <xsl:if test="$producer">
                        <xsl:for-each select="$producer">
                            <mods:publisher>
                                <xsl:value-of select="(.)"/>
                            </mods:publisher>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:if test="$dateIssued or $dateIssuedSorting">
                        <xsl:for-each select="$dateIssued">
                            <mods:dateCreated encoding="iso8601" keyDate="yes">
                                <xsl:value-of select="($dateIssuedSorting)"/>
                            </mods:dateCreated>
                            <mods:displayDate>
                                <xsl:value-of select="($dateIssued)"/>
                            </mods:displayDate>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:if test="$dateCreated">
                        <xsl:if test="$publicationPlace">
                        <!-- For bundle: merge publicationPlace and dateCreate in <mods:originInfo eventType="production"> -->
                            <mods:place>
                                <xsl:for-each select="$publicationPlace">
                                    <mods:placeTerm type="text">
                                        <xsl:value-of select="(.)"/>
                                    </mods:placeTerm>
                                </xsl:for-each>
                            </mods:place>
                        </xsl:if>
                        <xsl:for-each select="$dateCreated">
                            <mods:dateCreated encoding="iso8601" keyDate="yes">
                                <xsl:value-of select="(.)"/>
                            </mods:dateCreated>
                            <mods:displayDate>
                                <xsl:value-of select="(.)"/>
                            </mods:displayDate>
                        </xsl:for-each>
                    </xsl:if>
                </mods:originInfo>
            </xsl:if>
            <xsl:if test="$script or $language">
                <mods:language>
                    <xsl:if test="($language != '')">
                        <xsl:for-each select="$language">
                            <mods:languageTerm type="code" authority="rfc3066">
                                <xsl:value-of select="(.)"/>
                            </mods:languageTerm>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:if test="not($language) and ($catalogIDDigital !='')">
                        <mods:languageTerm type="code" authority="rfc3066">
                            <xsl:text>und</xsl:text>
                        </mods:languageTerm>
                    </xsl:if>
                    <xsl:if test="($script = 'Antiqua') or ($script = 'Fraktur')">
                        <mods:scriptTerm type="code" authority="iso15924">
                            <xsl:choose>
                                <xsl:when test="($script = 'Fraktur')">
                                    <xsl:text>Latf</xsl:text>
                                </xsl:when>
                                <xsl:when test="($script = 'Antiqua')">
                                    <xsl:text>Latn</xsl:text>
                                </xsl:when>
                            </xsl:choose>
                        </mods:scriptTerm>
                    </xsl:if>
                </mods:language>
            </xsl:if>
            <xsl:if test="$physicalDescription or $sizeSourcePrint or $physicalForm or $method or $bindingMaterial or $waterMark or $supralibros or $catalogIDDigital">
                <mods:physicalDescription>
                    <xsl:for-each select="$sizeSourcePrint">
                        <mods:extent>
                            <xsl:value-of select="(.)"/>
                        </mods:extent>
                    </xsl:for-each>
                    <xsl:for-each select="$physicalDescription">
                        <mods:extent>
                            <xsl:value-of select="(.)"/>
                        </mods:extent>
                    </xsl:for-each>
                    <xsl:for-each select="$physicalForm">
                        <mods:note>
                            <xsl:value-of select="(.)"/>
                        </mods:note>
                    </xsl:for-each>
                    <xsl:for-each select="$method">
                        <mods:form type="technique">
                            <xsl:value-of select="(.)"/>
                        </mods:form>
                    </xsl:for-each>
                    <xsl:for-each select="$bindingMaterial">
                        <mods:note type="material">
                            <xsl:value-of select="(.)"/>
                        </mods:note>
                    </xsl:for-each>
                    <xsl:for-each select="$waterMark">
                        <mods:note type="watermark">
                            <xsl:value-of select="(.)"/>
                        </mods:note>
                    </xsl:for-each>
                    <xsl:for-each select="$supralibros">
                        <mods:note type="supralibros">
                            <xsl:value-of select="(.)"/>
                        </mods:note>
                    </xsl:for-each>
                    <xsl:for-each select="$catalogIDDigital">
                        <xsl:choose>
                            <xsl:when test="matches($catalogIDDigital,'(.*)')">
                                <mods:digitalOrigin>
                                    <xsl:text>reformatted digital</xsl:text>
                                </mods:digitalOrigin>
                            </xsl:when>
                        </xsl:choose>
                    </xsl:for-each>
                </mods:physicalDescription>
            </xsl:if>
            <xsl:if test="$motive">
                <xsl:for-each select="$motive">
                    <mods:abstract type="motif">
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:abstract>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$abstractKalliope">
                <xsl:for-each select="$abstractKalliope">
                    <mods:abstract type="content">
                        <xsl:value-of select="normalize-space($abstractKalliope)"/>
                    </mods:abstract>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$attachment">
                <xsl:for-each select="$attachment">
                    <mods:tableOfContents type="attachment">
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:tableOfContents>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$annotation">
                <xsl:for-each select="$annotation">
                    <mods:note type="annotation">
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:note>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$comment">
                <xsl:for-each select="$comment">
                    <mods:note type="comment">
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:note>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$musicFormat">
                <xsl:for-each select="$musicFormat">
                    <mods:note type="format of notated music">
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:note>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$keyword or $place or $placeSWDID or $subjectGenre or $time">
                <mods:subject>
                    <xsl:if test="$keyword">
                        <xsl:for-each select="$keyword">
                            <mods:topic>
                                <xsl:value-of select="normalize-space(.)"/>
                            </mods:topic>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:if test="$place and not($placeSWDID)">
                        <xsl:for-each select="$place">
                            <mods:geographic>
                                <xsl:value-of select="normalize-space(.)"/>
                            </mods:geographic>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:if test="$placeSWDID and $place">
                        <xsl:for-each select="$place">
                            <mods:geographic authorityURI="http://d-nb.info/gnd/">
                                    <xsl:attribute name="valueURI">
                                        <xsl:value-of select="normalize-space(concat('http://d-nb.info/gnd/',$placeSWDID))"/>
                                    </xsl:attribute>
                                        <xsl:value-of select="normalize-space(.)"/>
                            </mods:geographic>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:if test="$subjectGenre">
                        <xsl:for-each select="$subjectGenre">
                            <mods:genre>
                                <xsl:value-of select="normalize-space(.)"/>
                            </mods:genre>
                        </xsl:for-each>
                    </xsl:if>
                    <xsl:if test="$time">
                        <xsl:for-each select="$time">
                            <mods:temporal>
                                <xsl:value-of select="normalize-space(.)"/>
                            </mods:temporal>
                        </xsl:for-each>
                    </xsl:if>
                </mods:subject>
            </xsl:if>
            <xsl:if test="$recordIdentifierHost or $processTitle">
                <mods:relatedItem type="host">
                    <mods:recordInfo>
                        <xsl:variable name="project" select="$collection = 'Projekt: Illustrierte Magazine der Klassischen Moderne' or $collection = 'Projekt: Gebrauchsgrafik'"/>
                        <xsl:variable name="prefix">
                            <xsl:choose>
                                <xsl:when test="$owner = 'Hochschule für Musik und Theater Felix Mendelssohn Bartholdy Leipzig'">hmt-leipzig</xsl:when>
                                <xsl:when test="$owner = 'Stadtbibliothek Chemnitz'">sb-chemnitz</xsl:when>
                                <xsl:otherwise>slub-dresden</xsl:otherwise>
                            </xsl:choose>
                        </xsl:variable>
                        <xsl:variable name="sourceUrl">
                            <xsl:choose>
                                <xsl:when test="$project">https://www.arthistoricum.net/oai/</xsl:when>
                                <xsl:otherwise>http://digital.slub-dresden.de/oai/</xsl:otherwise>
                            </xsl:choose>
                        </xsl:variable>
                        <xsl:variable name="ID">
                            <xsl:choose>
                                <xsl:when test="$recordIdentifierHost">
                                    <xsl:value-of select="$recordIdentifierHost"/>
                                </xsl:when>
                                <xsl:when test="matches($processTitle, '^.*_([0-9]{8,9}[0-9X]{1})-')">
                                    <xsl:value-of select="replace($processTitle, '^.*_([0-9]{8,9}[0-9X]{1})-.*$', '$1')"/>
                                </xsl:when>
                                <xsl:when test="$project and $catalogIDDigital">
                                    <xsl:value-of select="$catalogIDDigital"/>
                                </xsl:when>
                            </xsl:choose>
                        </xsl:variable>
                        <xsl:if test="normalize-space($ID) != ''">
                            <mods:recordIdentifier source="{$sourceUrl}">
                                <xsl:value-of select="normalize-space(concat('oai:de:', $prefix, ':db:id-', $ID))"/>
                            </mods:recordIdentifier>
                        </xsl:if>
                    </mods:recordInfo>
                </mods:relatedItem>
            </xsl:if>
            <xsl:if test="$collection">
                <xsl:for-each select="$collection">
                    <mods:relatedItem type="series">
                        <mods:titleInfo>
                            <mods:title lang="ger">
                                <xsl:value-of select="normalize-space(.)"/>
                            </mods:title>
                        </mods:titleInfo>
                    </mods:relatedItem>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="not ($collection) and ($docTypeMODS = 'NewspaperYear')">
                <mods:relatedItem type="series">
                    <mods:titleInfo>
                        <mods:title lang="ger">
                            <xsl:text>Zeitungen</xsl:text>
                        </mods:title>
                    </mods:titleInfo>
                </mods:relatedItem>
            </xsl:if>
            <xsl:if test="not ($collection) and ($docTypeMODS = 'EphemeraYear')">
                <mods:relatedItem type="series">
                    <mods:titleInfo>
                        <mods:title lang="ger">
                            <xsl:text>Performance Ephemera</xsl:text>
                        </mods:title>
                    </mods:titleInfo>
                </mods:relatedItem>
            </xsl:if>
            <xsl:if test="$serial">
                <xsl:for-each select="$serial">
                    <mods:relatedItem type="series">
                        <mods:titleInfo>
                            <mods:title>
                                <xsl:value-of select="normalize-space(.)"/>
                            </mods:title>
                        </mods:titleInfo>
                    </mods:relatedItem>
                </xsl:for-each>
            </xsl:if>
            <xsl:apply-templates select="$serialGroup"/>
            <xsl:if test="$catalogIDDigital or $processTitle">
                <xsl:variable name="idSuffix">
                <xsl:choose>
                    <xsl:when test="$catalogIDDigital">
                        <xsl:value-of select="$catalogIDDigital"/>
                    </xsl:when>
                    <xsl:when test="matches($processTitle, '^.*_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10})')">
                        <xsl:value-of select="replace($processTitle, '^.*_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10}).*$', '$1-$2')"/>
                    </xsl:when>
                </xsl:choose>
                </xsl:variable>
                <xsl:variable name="urnNamespace">
                    <xsl:choose>
                        <xsl:when test="$slubOwnerDigi = 'Stadtbibliothek Chemnitz'">59:1</xsl:when>
                        <xsl:otherwise>14</xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>
                <xsl:if test="normalize-space($idSuffix)">
                    <mods:identifier type="purl">
                        <xsl:value-of select="concat('http://digital.slub-dresden.de/id', $idSuffix)"/>
                    </mods:identifier>
                </xsl:if>
                <xsl:if test="normalize-space($idSuffix) and $owner != 'Universitätsbibliothek Georgius Agricola Freiberg'">
                    <mods:identifier type="urn">
                        <xsl:value-of select="concat('urn:nbn:de:bsz:', $urnNamespace, '-db-id', $idSuffix)"/>
                    </mods:identifier>
                </xsl:if>
            </xsl:if>
            <xsl:if test="$catalogIDDigital">
                <xsl:choose>
                    <xsl:when test="matches($catalogIDDigital,'^[0-9]{9}[0-9X]{1}$')">
                        <mods:identifier type="kxp-ppn-digital">
                            <xsl:value-of select="normalize-space($catalogIDDigital)"/>
                        </mods:identifier>
                    </xsl:when>
                </xsl:choose>
                <xsl:choose>
                    <xsl:when test="matches($catalogIDDigital,'^[0-9]{8}[0-9X]{1}$')">
                        <mods:identifier type="swb-ppn-digital">
                            <xsl:value-of select="normalize-space($catalogIDDigital)"/>
                        </mods:identifier>
                    </xsl:when>
                </xsl:choose>
                <xsl:choose>
                    <xsl:when test="matches($catalogIDDigital,'^[0-9]{8}[YZ]$')">
                        <mods:identifier type="barcode">
                            <xsl:value-of select="normalize-space($catalogIDDigital)"/>
                        </mods:identifier>
                    </xsl:when>
                </xsl:choose>
            </xsl:if>
            <xsl:if test="$catalogIDSourceKXP">
                <xsl:for-each select="$catalogIDSourceKXP">
                    <xsl:choose>
                        <xsl:when test="$catalogIDSourceKXP">
                            <mods:identifier type="kxp-ppn-source">
                                <xsl:value-of select="(.)"/>
                            </mods:identifier>
                        </xsl:when>
                    </xsl:choose>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="$catalogIDSource">
                <xsl:for-each select="$catalogIDSource">
                    <xsl:choose>
                        <xsl:when test="matches(.,'^[0-9]{8}[0-9X]{1}$')">
                            <mods:identifier type="swb-ppn-source">
                                <xsl:value-of select="."/>
                            </mods:identifier>
                        </xsl:when>
                    </xsl:choose>
                </xsl:for-each>
                <xsl:for-each select="$catalogIDSource">
                    <xsl:choose>
                        <xsl:when test="matches(.,'^[0-9]{9}[0-9X]{1}$')">
                            <mods:identifier type="kxp-ppn-source">
                                <xsl:value-of select="."/>
                            </mods:identifier>
                        </xsl:when>
                    </xsl:choose>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="($KitodoID and $catalogIDDigital or $processTitle) and ($docTypeMODS !='SubinventoryMigrated')">
                <!-- $catalogIDDigital and $processTitle are necessary, because otherwise, the Kitodo-ID is written in every dmdSec -->
                <mods:identifier type="kitodo">
                    <xsl:value-of select="$KitodoID"/>
                </mods:identifier>
            </xsl:if>
            <xsl:if test="($KitodoID and $catalogIDDigital and $docTypeMODS ='SubinventoryMigrated' and $slubOwnerOrig !='')">
                <!-- $catalogIDDigital and $processTitle are necessary, because otherwise, the Kitodo-ID is written in every dmdSec -->
                <mods:identifier type="kitodo">
                    <xsl:value-of select="$KitodoID"/>
                </mods:identifier>
            </xsl:if>
            <xsl:if test="$rights">
                <xsl:choose>
                    <xsl:when test="$rights = ('DONZ1.0NIWE1.0', 'DONZ1.0FZRV1.0INC1.0', 'NIWE1.0', 'VW1.0', DONZ1.0VW1.0, 'EZAM1.0INC1.0', 'EZAMUA1.0INC1.0', 'FOZW1.0', 'GERE1.0INC1.0', 'ILMA1.0INC1.0', 'KRBU1.0INC1.0', 'SCZT1.0', 'POSTDR1.0')">
                        <mods:accessCondition type="use and reproduction" xlink:href="http://rightsstatements.org/vocab/InC/1.0/">Urheberrechtsschutz 1.0</mods:accessCondition>
                    </xsl:when>
                    <xsl:when test="$rights = 'CC01.0'">
                        <mods:accessCondition type="use and reproduction" xlink:href="https://creativecommons.org/publicdomain/zero/1.0/">CC0 1.0</mods:accessCondition>
                    </xsl:when>
                    <xsl:when test="contains($rights, 'PDM1.0')">
                        <mods:accessCondition type="use and reproduction" xlink:href="https://creativecommons.org/publicdomain/mark/1.0/">Public Domain Mark 1.0</mods:accessCondition>
                    </xsl:when>
                    <xsl:when test="starts-with($rights, 'CCBY')">
                        <xsl:variable name="cc-mapping" select="
                            if ($rights='CCBY4.0') then 'https://creativecommons.org/licenses/by/4.0/|CC BY 4.0'
                            else if ($rights='CCBYSA4.0') then 'https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0'
                            else if ($rights='CCBYNCND4.0') then 'https://creativecommons.org/licenses/by-nc-nd/4.0/|CC BY-NC-ND 4.0'
                            else if ($rights='CCBYNCSA4.0') then 'https://creativecommons.org/licenses/by-nc-sa/4.0/|CC BY-NC-SA 4.0'
                            else ''"/>
                        <mods:accessCondition type="use and reproduction" xlink:href="{substring-before($cc-mapping, '|')}">
                            <xsl:value-of select="substring-after($cc-mapping, '|')"/>
                        </mods:accessCondition>
                    </xsl:when>
                </xsl:choose>
                <xsl:if test="contains($rights, 'FZRV1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/fz-rv/1.0/">Freier Zugang - Rechte vorbehalten 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'DONZ1.0')">
                    <mods:accessCondition type="local terms of use" displayLabel="Additional Information" xlink:href="https://nutzungshinweis.slub-dresden.de/do-nz/1.0/">Dokumente der NS-Zeit 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'NIWE1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/ni-we/1.0/">Nicht verfügbare Werke 1.0</mods:accessCondition>
                    <mods:accessCondition type="out of commerce">Wahrnehmung der Rechte durch die VG WORT und VG BILD-KUNST (§ 52 VGG). Nutzung nach § 44b Abs. 2 in Verbindung mit Abs. 3 UrhG für Zwecke des Text- und Data-Minings vorbehalten.</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'VW1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/ve-we/1.0/">Vergriffene Werke 1.0</mods:accessCondition>
                    <mods:accessCondition type="out of print work">Wahrnehmung der Rechte durch die VG WORT (§ 51 VGG)</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'EZAM1.0INC1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/ez-am/1.0/">Eingeschränkter Zugang - Arbeitsplätze Mediathek 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'EZAMUA1.0INC1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/ez-am-ua/1.0/">Eingeschränkter Zugang - Arbeitsplätze Mediathek - Unter Aufsicht 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'FOZW1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/fo-zw/1.0/">Form und Zweck 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'GERE1.0INC1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/ge-re/1.0/">Gebrauchs- und Reklamegrafik 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'ILMA1.0INC1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/il-ma/1.0/">Illustrierte Magazine 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'KRBU1.0INC1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/kr-bu/1.0/">Künstlerbücher 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'POSTDR1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/po-st-dr/1.0/">Politischer Samisdat DDR 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="contains($rights, 'SCZT1.0')">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/sc-zt/1.0/">Sächsische Zeitung 1.0</mods:accessCondition>
                </xsl:if>
                <xsl:if test="$rights = 'TODR2.0'">
                    <mods:accessCondition type="local terms of use" xlink:href="https://nutzungshinweis.slub-dresden.de/to-dr/2.0/">Totengedenkbuch Dresden 2.0</mods:accessCondition>
                </xsl:if>
                <!--<mods:accessCondition type="restriction on access" xlink:href="http://purl.org/coar/access_right/c_abf2" displayLabel="Access Status">Open Access</mods:accessCondition>-->
                <xsl:choose>
                    <xsl:when test="$rights = ('EZAM1.0INC1.0', 'EZAMUA1.0INC1.0', 'KRBU1.0INC1.0', 'SCZT1.0')">
                        <mods:accessCondition type="restriction on access" xlink:href="http://purl.org/coar/access_right/c_16ec" displayLabel="Access Status">Restricted Access</mods:accessCondition>
                    </xsl:when>
                    <xsl:otherwise>
                        <mods:accessCondition type="restriction on access" xlink:href="http://purl.org/coar/access_right/c_abf2" displayLabel="Access Status">Open Access</mods:accessCondition>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:if>
            <xsl:if test="$rights or $contractTitle or $contractDate or $contractShortTitle">
                <mods:accessCondition type="slubRightsRecord">
                    <slubarchiv:rightsRecord>
                        <slubarchiv:copyrightStatus>
                            <xsl:choose>
                                <xsl:when test="$rights = ('DONZ1.0PDM1.0', 'PDM1.0')">
                                    <xsl:text>publicdomain</xsl:text>
                                </xsl:when>
                                <xsl:when test="$rights = ('DONZ1.0FZRV1.0', 'FZRV1.0', 'TODR1.0', 'TODR2.0')">
                                    <xsl:text>undefined</xsl:text>
                                </xsl:when>
                                <xsl:when test="normalize-space($rights)">
                                    <xsl:text>copyrighted</xsl:text>
                                </xsl:when>
                            </xsl:choose>
                        </slubarchiv:copyrightStatus>
                        <xsl:variable name="hasSpecialRights" select="$rights = ('CC01.0', 'CCBY4.0', 'CCBYSA4.0', 'CCBYNCND4.0', 'CCBYNCSA4.0', 'DONZ1.0NIWE1.0', 'DONZ1.0VW1.0', 'NIWE1.0', 'VW1.0')"/>
                        <xsl:if test="$contractDate or $contractTitle or $contractShortTitle or $hasSpecialRights">
                            <slubarchiv:permissions>
                                <xsl:if test="$contractDate or $contractTitle">
                                    <slubarchiv:contract date="{normalize-space($contractDate)}">
                                        <xsl:value-of select="normalize-space($contractTitle)"/>
                                    </slubarchiv:contract>
                                </xsl:if>
                                <xsl:if test="$rights = ('NIWE1.0', 'DONZ1.0NIWE1.0')">
                                    <slubarchiv:contract date="2025-03-21">Rahmenvertrag zur Nutzung von nicht verfügbaren Werken in verlegten Schriften zwischen Bund, Ländern, Verwertungsgesellschaft WORT und Verwertungsgesellschaft Bild-Kunst</slubarchiv:contract>
                                    <slubarchiv:outOfCommerceWork>Nicht verfügbares Werk</slubarchiv:outOfCommerceWork>
                                </xsl:if>
                                <xsl:if test="$rights = ('VW1.0', 'DONZ1.0VW1.0')">
                                    <slubarchiv:contract date="2015-01-01">Rahmenvertrag zur Nutzung von vergriffenen Werken in Büchern zwischen Bund, Ländern, Verwertungsgesellschaft WORT und Verwertungsgesellschaft Bild-Kunst</slubarchiv:contract>
                                    <slubarchiv:outOfPrintWork>Vergriffenes Werk</slubarchiv:outOfPrintWork>
                                </xsl:if>
                                <xsl:choose>
                                    <xsl:when test="$rights = 'CC01.0'"><slubarchiv:license url="https://creativecommons.org/publicdomain/zero/1.0/">CC0 1.0</slubarchiv:license></xsl:when>
                                    <xsl:when test="$rights = 'CCBY4.0'"><slubarchiv:license url="https://creativecommons.org/licenses/by/4.0/">CC BY 4.0</slubarchiv:license></xsl:when>
                                    <xsl:when test="$rights = 'CCBYSA4.0'"><slubarchiv:license url="https://creativecommons.org/licenses/by-sa/4.0/">CC BY-SA 4.0</slubarchiv:license></xsl:when>
                                    <xsl:when test="$rights = 'CCBYNCND4.0'"><slubarchiv:license url="https://creativecommons.org/licenses/by-nc-nd/4.0/">CC BY-NC-ND 4.0</slubarchiv:license></xsl:when>
                                    <xsl:when test="$rights = 'CCBYNCSA4.0'"><slubarchiv:license url="https://creativecommons.org/licenses/by-nc-sa/4.0/">CC BY-NC-SA 4.0</slubarchiv:license></xsl:when>
                                </xsl:choose>
                            </slubarchiv:permissions>
                        </xsl:if>
                    </slubarchiv:rightsRecord>
                </mods:accessCondition>
            </xsl:if>
            <xsl:if test="$rightsinfo">
                <xsl:for-each select="$rightsinfo">
                    <mods:accessCondition type="info">
                        <xsl:value-of select="normalize-space(.)"/>
                    </mods:accessCondition>
                </xsl:for-each>
            </xsl:if>
            <xsl:if test="($currentNo or $currentNoSorting) and ($docTypeMODS ='PeriodicalVolume' or $docTypeMODS ='Volume' or $docTypeMODS ='Subinventory' or $docTypeMODS ='Folder')">
                <mods:part type="host">
                    <xsl:if test="$currentNoSorting">
                        <xsl:attribute name="order">
                            <xsl:value-of select="$currentNoSorting"/>
                        </xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$currentNo">
                        <mods:detail type="volume">
                            <mods:number>
                                <xsl:value-of select="$currentNo"/>
                            </mods:number>
                       </mods:detail>
                    </xsl:if>
                </mods:part>
            </xsl:if>
            <xsl:if test="$currentNo and ($docTypeIssue1 or $docTypeIssue2 or $docTypeIssue3 = 'PeriodicalVolumeIssue') and not ($docTypeMODS ='PeriodicalVolume' or $docTypeMODS ='Volume' or $docTypeMODS ='Subinventory' or $docTypeMODS ='Folder' or $docTypeMODS ='PeriodicalIssue')">
                <mods:part>
                    <xsl:if test="$currentNo">
                        <mods:detail type="issue">
                            <mods:number>
                                <xsl:value-of select="$currentNo"/>
                            </mods:number>
                       </mods:detail>
                    </xsl:if>
                </mods:part>
            </xsl:if>
            <xsl:if test="$processTitle and $docTypeMODS = 'PeriodicalIssue' and not($currentNo)">
                <xsl:variable name="Id" select="replace($processTitle, '^.*-([0-9]{4,10}).*$', '$1')" />
                <xsl:variable name="formattedDate" select="replace($Id, '^([0-9]{4})([0-9]{2})([0-9]{2}).*$', '$1-$2-$3')" />
                <mods:part type="host" order="{$Id}">
                    <mods:detail type="issue">
                        <mods:number>
                            <xsl:value-of select="normalize-space($formattedDate)"/>
                        </mods:number>
                        <xsl:if test="$title">
                            <mods:title>
                                <xsl:value-of select="$title"/>
                            </mods:title>
                        </xsl:if>
                    </mods:detail>
                </mods:part>
            </xsl:if>
            <xsl:if test="$catalogIDDigital or $catalogIDSourceKXP or $catalogIDSource or $TSL_ATS or $footer or $catalogTitle or $catalogImage or catalogPPN or $facsimileTitle or $facsimilePPN or $link or $linktext or $processTitle or $linkgroup">
                <mods:extension>
                    <!-- Mandant SLUB -->
                    <xsl:if test="(($catalogIDDigital or $processTitle or $linkgroup))">
                        <slub:slub>
                            <xsl:if test="$catalogIDDigital">
                                <xsl:for-each select="$catalogIDDigital">
                                    <slub:id type="digital">
                                        <xsl:value-of select="normalize-space(.)"/>
                                    </slub:id>
                                </xsl:for-each>
                            </xsl:if>
                            <xsl:if test="$processTitle">
                                <xsl:for-each select="$processTitle">
                                    <slub:id type="digital">
                                        <xsl:choose>
                                            <xsl:when test="matches($processTitle,'^(.*)_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10})_(.*)')"><!-- identifier for newspaper issues -->
                                                <xsl:value-of select="normalize-space(replace($processTitle,'^(.*)_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10})_(.*)', '$2-$3'))"/>
                                            </xsl:when>
                                            <xsl:when test="matches($processTitle,'^(.*)_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10})')"><!-- identifier for newspaper issues -->
                                                <xsl:value-of select="normalize-space(replace($processTitle,'^(.*)_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10})', '$2-$3'))"/>
                                            </xsl:when>
                                            <xsl:when test="matches($processTitle,'^(.*)_([0-9]{8,9}[0-9X]{1})-([0-9]{4})')"><!-- identifier for newspaper year -->
                                                <xsl:value-of select="normalize-space(replace($processTitle,'^(.*)_([0-9]{8,9}[0-9X]{1})-([0-9]{4})', '$2-$3'))"/>
                                            </xsl:when>
                                        </xsl:choose>
                                    </slub:id>
                                </xsl:for-each>
                            </xsl:if>
                            <xsl:if test="$catalogIDSourceKXP">
                                <xsl:for-each select="$catalogIDSourceKXP">
                                    <slub:id type="source">
                                        <xsl:value-of select="normalize-space(.)"/>
                                    </slub:id>
                                </xsl:for-each>
                            </xsl:if>
                            <xsl:if test="$catalogIDSource">
                                <xsl:for-each select="$catalogIDSource">
                                    <slub:id type="source">
                                        <xsl:value-of select="normalize-space(.)"/>
                                    </slub:id>
                                </xsl:for-each>
                            </xsl:if>
                            <xsl:if test="$TSL_ATS">
                                <slub:id type="tsl-ats">
                                    <xsl:for-each select="$TSL_ATS">
                                        <xsl:value-of select="normalize-space(.)"/>
                                    </xsl:for-each>
                                </slub:id>
                            </xsl:if>
                            <xsl:if test="$footer">
                                <slub:footer>
                                    <xsl:for-each select="$footer">
                                        <xsl:value-of select="normalize-space(.)"/>
                                    </xsl:for-each>
                                </slub:footer>
                            </xsl:if>
                            <xsl:if test="$catalogTitle or $catalogImage or catalogPPN">
                                <slub:catalog>
                                    <xsl:if test="$catalogTitle">
                                        <xsl:attribute name="displayLabel">
                                            <xsl:for-each select="$catalogTitle">
                                                <xsl:value-of select="normalize-space(.)"/>
                                            </xsl:for-each>
                                        </xsl:attribute>
                                    </xsl:if>
                                    <xsl:if test="$catalogImage">
                                        <slub:anchor type="image">
                                            <xsl:for-each select="$catalogImage">
                                                <xsl:value-of select="normalize-space(.)"/>
                                            </xsl:for-each>
                                        </slub:anchor>
                                    </xsl:if>
                                    <xsl:if test="$catalogPPN">
                                        <slub:identifier type="http://digital.slub-dresden.de/oai/">
                                            <xsl:for-each select="$catalogPPN">
                                                <xsl:value-of select="normalize-space(.)"/>
                                            </xsl:for-each>
                                        </slub:identifier>
                                    </xsl:if>
                                </slub:catalog>
                            </xsl:if>
                            <xsl:if test="$facsimileTitle or $facsimilePPN">
                                <slub:facsimile>
                                    <xsl:if test="$facsimileTitle">
                                        <xsl:attribute name="displayLabel">
                                            <xsl:for-each select="$facsimileTitle">
                                                <xsl:value-of select="normalize-space(.)"/>
                                            </xsl:for-each>
                                        </xsl:attribute>
                                    </xsl:if>
                                    <xsl:if test="$facsimilePPN">
                                        <slub:identifier type="http://digital.slub-dresden.de/oai/">
                                            <xsl:for-each select="$facsimilePPN">
                                                <xsl:value-of select="normalize-space(.)"/>
                                            </xsl:for-each>
                                        </slub:identifier>
                                    </xsl:if>
                                </slub:facsimile>
                            </xsl:if>
                            <xsl:if test="$linktext or $link">
                                <slub:link>
                                    <xsl:if test="$linktext">
                                        <xsl:attribute name="displayLabel">
                                            <xsl:for-each select="$linktext">
                                                <xsl:value-of select="normalize-space(.)"/>
                                            </xsl:for-each>
                                        </xsl:attribute>
                                    </xsl:if>
                                    <xsl:if test="$link">
                                        <xsl:for-each select="$link">
                                            <slub:target>
                                                <xsl:value-of select="normalize-space(.)"/>
                                            </slub:target>
                                        </xsl:for-each>
                                    </xsl:if>
                                </slub:link>
                            </xsl:if>
                            <xsl:apply-templates select="$linkgroup"/>
                            <xsl:apply-templates select="$provenanceGroup"/>
                        </slub:slub>
                    </xsl:if>
                </mods:extension>
            </xsl:if>
            <xsl:if test="$catalogIDDigital or $processTitle">
                <mods:recordInfo>
                    <xsl:variable name="ID">
                        <xsl:choose>
                            <xsl:when test="$catalogIDDigital">
                                <xsl:value-of select="$catalogIDDigital"/>
                            </xsl:when>
                            <xsl:when test="matches($processTitle, '_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10})')">
                                <xsl:value-of select="replace($processTitle, '^.*_([0-9]{8,9}[0-9X]{1})-([0-9]{4,10}).*$', '$1-$2')"/>
                            </xsl:when>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:variable name="project" select="$collection = 'Projekt: Illustrierte Magazine der Klassischen Moderne' or $collection = 'Projekt: Gebrauchsgrafik'"/>
                    <xsl:variable name="prefix">
                        <xsl:choose>
                            <xsl:when test="$owner = 'Hochschule für Musik und Theater Felix Mendelssohn Bartholdy Leipzig'">hmt-leipzig</xsl:when>
                            <xsl:when test="$owner = 'Stadtbibliothek Chemnitz'">sb-chemnitz</xsl:when>
                            <xsl:otherwise>slub-dresden</xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:variable name="sourceUrl">
                        <xsl:choose>
                            <xsl:when test="$project">https://www.arthistoricum.net/oai/</xsl:when>
                            <xsl:otherwise>http://digital.slub-dresden.de/oai/</xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:if test="normalize-space($ID)">
                        <mods:recordIdentifier source="{$sourceUrl}">
                            <xsl:value-of select="concat('oai:de:', $prefix, ':db:id-', $ID)"/>
                        </mods:recordIdentifier>
                    </xsl:if>
                </mods:recordInfo>
            </xsl:if>
        </mods:mods>
    </xsl:template>

    <xsl:template name="personGroup" match="kitodo:kitodo/kitodo:metadataGroup[@name='Person']">
        <xsl:variable name="firstName" select="kitodo:metadata[@name='FirstName']"/>
        <xsl:variable name="lastName" select="kitodo:metadata[@name='LastName']"/>
        <xsl:variable name="displayForm" select="kitodo:metadata[@name='DisplayForm']"/>
        <xsl:variable name="personalName" select="kitodo:metadata[@name='PersonalName']"/>
        <xsl:variable name="additionalMetadataPerson" select="kitodo:metadata[@name='AdditionalMetadataPerson']"/>
        <xsl:variable name="count" select="kitodo:metadata[@name='Count']"/>
        <xsl:variable name="roleCode" select="kitodo:metadata[@name='RoleCode']"/>
        <xsl:variable name="identifierGND" select="kitodo:metadata[@name='IdentifierGND']"/>
        <xsl:variable name="identifierGNDURI" select="kitodo:metadata[@name='IdentifierGNDURI']"/>
        <xsl:variable name="authority" select="kitodo:metadata[@name='Authority']"/>
        <xsl:variable name="identifierPPN" select="kitodo:metadata[@name='IdentifierPPN']"/>
        <mods:name type="personal">
            <xsl:if test="$authority !=''">
                <xsl:attribute name="authority">
                    <xsl:value-of select="$authority"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$identifierGNDURI !=''">
                <xsl:attribute name="valueURI">
                    <xsl:value-of select="$identifierGNDURI"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$personalName !=''">
                <mods:namePart>
                    <xsl:value-of select="normalize-space($personalName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$lastName !=''">
                <mods:namePart type="family">
                    <xsl:value-of select="normalize-space($lastName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$firstName !=''">
                <mods:namePart type="given">
                    <xsl:value-of select="normalize-space($firstName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$additionalMetadataPerson !=''">
                <mods:namePart type="termsOfAddress">
                    <xsl:choose>
                        <xsl:when test="(boolean($additionalMetadataPerson) = boolean($count))">
                            <xsl:value-of select="concat($count, ', ',$additionalMetadataPerson)"/>
                        </xsl:when>
                        <xsl:when test="(boolean($additionalMetadataPerson) != boolean($count))">
                            <xsl:value-of select="($additionalMetadataPerson)"/>
                        </xsl:when>
                    </xsl:choose>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$displayForm !=''">
                <mods:displayForm>
                    <xsl:value-of select="normalize-space($displayForm)"/>
                </mods:displayForm>
            </xsl:if>
            <xsl:if test="$identifierGND !='' or $authority !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$authority">
                        <xsl:attribute name="type">
                            <xsl:value-of select="$authority"/>
                        </xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierGND">
                        <xsl:value-of select="normalize-space($identifierGND)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$identifierPPN !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$identifierPPN">
                        <xsl:attribute name="type">ppn</xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierPPN">
                        <xsl:value-of select="normalize-space($identifierPPN)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$roleCode !=''">
                <xsl:for-each select="$roleCode">
                    <mods:role>
                        <mods:roleTerm type="code" authority="marcrelator">
                            <xsl:value-of select="normalize-space(.)"/>
                        </mods:roleTerm>
                    </mods:role>
                </xsl:for-each>
            </xsl:if>
        </mods:name>
    </xsl:template>

    <xsl:template name="contributorPersonGroup" match="kitodo:kitodo/kitodo:metadataGroup[@name='ContributorPerson']">
        <xsl:variable name="firstName" select="kitodo:metadata[@name='FirstName']"/>
        <xsl:variable name="lastName" select="kitodo:metadata[@name='LastName']"/>
        <xsl:variable name="displayForm" select="kitodo:metadata[@name='DisplayForm']"/>
        <xsl:variable name="personalName" select="kitodo:metadata[@name='PersonalName']"/>
        <xsl:variable name="additionalMetadataPerson" select="kitodo:metadata[@name='AdditionalMetadataPerson']"/>
        <xsl:variable name="count" select="kitodo:metadata[@name='Count']"/>
        <xsl:variable name="roleCode" select="kitodo:metadata[@name='RoleCode']"/>
        <xsl:variable name="identifierGND" select="kitodo:metadata[@name='IdentifierGND']"/>
        <xsl:variable name="identifierGNDURI" select="kitodo:metadata[@name='IdentifierGNDURI']"/>
        <xsl:variable name="authority" select="kitodo:metadata[@name='Authority']"/>
        <xsl:variable name="identifierPPN" select="kitodo:metadata[@name='IdentifierPPN']"/>
        <mods:name type="personal">
            <xsl:if test="$authority !=''">
                <xsl:attribute name="authority">
                    <xsl:value-of select="$authority"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$identifierGNDURI !=''">
                <xsl:attribute name="valueURI">
                    <xsl:value-of select="$identifierGNDURI"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$personalName !=''">
                <mods:namePart>
                    <xsl:value-of select="normalize-space($personalName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$lastName !=''">
                <mods:namePart type="family">
                    <xsl:value-of select="normalize-space($lastName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$firstName !=''">
                <mods:namePart type="given">
                    <xsl:value-of select="normalize-space($firstName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$additionalMetadataPerson !=''">
                <mods:namePart type="termsOfAddress">
                    <xsl:choose>
                        <xsl:when test="(boolean($additionalMetadataPerson) = boolean($count))">
                            <xsl:value-of select="concat($count, ', ',$additionalMetadataPerson)"/>
                        </xsl:when>
                        <xsl:when test="(boolean($additionalMetadataPerson) != boolean($count))">
                            <xsl:value-of select="($additionalMetadataPerson)"/>
                        </xsl:when>
                    </xsl:choose>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$displayForm !=''">
                <mods:displayForm>
                    <xsl:value-of select="normalize-space($displayForm)"/>
                </mods:displayForm>
            </xsl:if>
            <xsl:if test="$identifierGND !='' or $authority !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$authority">
                        <xsl:attribute name="type">
                            <xsl:value-of select="$authority"/>
                        </xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierGND">
                        <xsl:value-of select="normalize-space($identifierGND)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$identifierPPN !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$identifierPPN">
                        <xsl:attribute name="type">ppn</xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierPPN">
                        <xsl:value-of select="normalize-space($identifierPPN)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$roleCode !=''">
                <xsl:for-each select="$roleCode">
                    <mods:role>
                        <mods:roleTerm type="code" authority="marcrelator">
                            <xsl:value-of select="normalize-space(.)"/>
                        </mods:roleTerm>
                    </mods:role>
                </xsl:for-each>
            </xsl:if>
        </mods:name>
    </xsl:template>

    <xsl:template name="contributorPersonOtherGroup" match="kitodo:kitodo/kitodo:metadataGroup[@name='ContributorPersonOther']">
        <xsl:variable name="firstName" select="kitodo:metadata[@name='FirstName']"/>
        <xsl:variable name="lastName" select="kitodo:metadata[@name='LastName']"/>
        <xsl:variable name="displayForm" select="kitodo:metadata[@name='DisplayForm']"/>
        <xsl:variable name="personalName" select="kitodo:metadata[@name='PersonalName']"/>
        <xsl:variable name="additionalMetadataPerson" select="kitodo:metadata[@name='AdditionalMetadataPerson']"/>
        <xsl:variable name="count" select="kitodo:metadata[@name='Count']"/>
        <xsl:variable name="roleCode" select="kitodo:metadata[@name='RoleCode']"/>
        <xsl:variable name="identifierGND" select="kitodo:metadata[@name='IdentifierGND']"/>
        <xsl:variable name="identifierGNDURI" select="kitodo:metadata[@name='IdentifierGNDURI']"/>
        <xsl:variable name="authority" select="kitodo:metadata[@name='Authority']"/>
        <xsl:variable name="identifierPPN" select="kitodo:metadata[@name='IdentifierPPN']"/>
        <mods:name type="personal">
            <xsl:if test="$authority !=''">
                <xsl:attribute name="authority">
                    <xsl:value-of select="$authority"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$identifierGNDURI !=''">
                <xsl:attribute name="valueURI">
                    <xsl:value-of select="$identifierGNDURI"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$personalName !=''">
                <mods:namePart>
                    <xsl:value-of select="normalize-space($personalName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$lastName !=''">
                <mods:namePart type="family">
                    <xsl:value-of select="normalize-space($lastName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$firstName !=''">
                <mods:namePart type="given">
                    <xsl:value-of select="normalize-space($firstName)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$additionalMetadataPerson !=''">
                <mods:namePart type="termsOfAddress">
                    <xsl:choose>
                        <xsl:when test="(boolean($additionalMetadataPerson) = boolean($count))">
                            <xsl:value-of select="concat($count, ', ',$additionalMetadataPerson)"/>
                        </xsl:when>
                        <xsl:when test="(boolean($additionalMetadataPerson) != boolean($count))">
                            <xsl:value-of select="($additionalMetadataPerson)"/>
                        </xsl:when>
                    </xsl:choose>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$displayForm !=''">
                <mods:displayForm>
                    <xsl:value-of select="normalize-space($displayForm)"/>
                </mods:displayForm>
            </xsl:if>
            <xsl:if test="$identifierGND !='' or $authority !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$authority">
                        <xsl:attribute name="type">
                            <xsl:value-of select="$authority"/>
                        </xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierGND">
                        <xsl:value-of select="normalize-space($identifierGND)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$identifierPPN !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$identifierPPN">
                        <xsl:attribute name="type">ppn</xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierPPN">
                        <xsl:value-of select="normalize-space($identifierPPN)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$roleCode !=''">
                <xsl:for-each select="$roleCode">
                    <mods:role>
                        <mods:roleTerm type="code" authority="marcrelator">
                            <xsl:value-of select="normalize-space(.)"/>
                        </mods:roleTerm>
                    </mods:role>
                </xsl:for-each>
            </xsl:if>
        </mods:name>
    </xsl:template>

    <xsl:template name="corporationGroup" match="kitodo:kitodo/kitodo:metadataGroup[@name='Corporation']">
        <xsl:variable name="nameMainUnit" select="kitodo:metadata[@name='NameMainUnit']"/>
        <xsl:variable name="additionalMetadataCorporation" select="kitodo:metadata[@name='AdditionalMetadataCorporation']"/>
        <xsl:variable name="nameSubordinateUnit" select="kitodo:metadata[@name='NameSubordinateUnit']"/>
        <xsl:variable name="displayForm" select="kitodo:metadata[@name='DisplayForm']"/>
        <xsl:variable name="roleCode" select="kitodo:metadata[@name='RoleCode']"/>
        <xsl:variable name="identifierGND" select="kitodo:metadata[@name='IdentifierGND']"/>
        <xsl:variable name="identifierGNDURI" select="kitodo:metadata[@name='IdentifierGNDURI']"/>
        <xsl:variable name="authority" select="kitodo:metadata[@name='Authority']"/>
        <xsl:variable name="identifierPPN" select="kitodo:metadata[@name='IdentifierPPN']"/>
        <mods:name type="corporate">
            <xsl:if test="$authority !=''">
                <xsl:attribute name="authority">
                    <xsl:value-of select="$authority"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$identifierGNDURI !=''">
                <xsl:attribute name="valueURI">
                    <xsl:value-of select="$identifierGNDURI"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$nameMainUnit !=''">
                <mods:namePart>
                    <xsl:value-of select="($nameMainUnit)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$additionalMetadataCorporation !=''">
                <mods:namePart>
                    <xsl:value-of select="($additionalMetadataCorporation)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$nameSubordinateUnit !=''">
                <mods:namePart>
                    <xsl:value-of select="($nameSubordinateUnit)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$displayForm !=''">
                <mods:displayForm>
                    <xsl:value-of select="($displayForm)"/>
                </mods:displayForm>
            </xsl:if>
            <xsl:if test="$identifierGND !='' or $authority !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$authority">
                        <xsl:attribute name="type">
                            <xsl:value-of select="($authority)"/>
                        </xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierGND">
                        <xsl:value-of select="($identifierGND)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$identifierPPN !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$identifierPPN">
                        <xsl:attribute name="type">ppn</xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierPPN">
                        <xsl:value-of select="normalize-space($identifierPPN)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$roleCode !=''">
                <xsl:for-each select="$roleCode">
                    <mods:role>
                        <mods:roleTerm type="code" authority="marcrelator">
                            <xsl:value-of select="normalize-space(.)"/>
                        </mods:roleTerm>
                    </mods:role>
                </xsl:for-each>
            </xsl:if>
        </mods:name>
    </xsl:template>

    <xsl:template name="contributorCorporationGroup" match="kitodo:kitodo/kitodo:metadataGroup[@name='ContributorCorporation']">
        <xsl:variable name="nameMainUnit" select="kitodo:metadata[@name='NameMainUnit']"/>
        <xsl:variable name="additionalMetadataCorporation" select="kitodo:metadata[@name='AdditionalMetadataCorporation']"/>
        <xsl:variable name="nameSubordinateUnit" select="kitodo:metadata[@name='NameSubordinateUnit']"/>
        <xsl:variable name="displayForm" select="kitodo:metadata[@name='DisplayForm']"/>
        <xsl:variable name="roleCode" select="kitodo:metadata[@name='RoleCode']"/>
        <xsl:variable name="identifierGND" select="kitodo:metadata[@name='IdentifierGND']"/>
        <xsl:variable name="identifierGNDURI" select="kitodo:metadata[@name='IdentifierGNDURI']"/>
        <xsl:variable name="authority" select="kitodo:metadata[@name='Authority']"/>
        <xsl:variable name="identifierPPN" select="kitodo:metadata[@name='IdentifierPPN']"/>
        <mods:name type="corporate">
            <xsl:if test="$authority !=''">
                <xsl:attribute name="authority">
                    <xsl:value-of select="$authority"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$identifierGNDURI !=''">
                <xsl:attribute name="valueURI">
                    <xsl:value-of select="$identifierGNDURI"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$nameMainUnit !=''">
                <mods:namePart>
                    <xsl:value-of select="($nameMainUnit)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$additionalMetadataCorporation !=''">
                <mods:namePart>
                    <xsl:value-of select="($additionalMetadataCorporation)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$nameSubordinateUnit !=''">
                <mods:namePart>
                    <xsl:value-of select="($nameSubordinateUnit)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$displayForm !=''">
                <mods:displayForm>
                    <xsl:value-of select="($displayForm)"/>
                </mods:displayForm>
            </xsl:if>
            <xsl:if test="$identifierGND !='' or $authority !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$authority">
                        <xsl:attribute name="type">
                            <xsl:value-of select="($authority)"/>
                        </xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierGND">
                        <xsl:value-of select="($identifierGND)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$identifierPPN !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$identifierPPN">
                        <xsl:attribute name="type">ppn</xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierPPN">
                        <xsl:value-of select="normalize-space($identifierPPN)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$roleCode !=''">
                <xsl:for-each select="$roleCode">
                    <mods:role>
                        <mods:roleTerm type="code" authority="marcrelator">
                            <xsl:value-of select="normalize-space(.)"/>
                        </mods:roleTerm>
                    </mods:role>
                </xsl:for-each>
            </xsl:if>
        </mods:name>
    </xsl:template>

    <xsl:template name="contributorCorporationOtherGroup" match="kitodo:kitodo/kitodo:metadataGroup[@name='ContributorCorporationOther']">
        <xsl:variable name="nameMainUnit" select="kitodo:metadata[@name='NameMainUnit']"/>
        <xsl:variable name="additionalMetadataCorporation" select="kitodo:metadata[@name='AdditionalMetadataCorporation']"/>
        <xsl:variable name="nameSubordinateUnit" select="kitodo:metadata[@name='NameSubordinateUnit']"/>
        <xsl:variable name="displayForm" select="kitodo:metadata[@name='DisplayForm']"/>
        <xsl:variable name="roleCode" select="kitodo:metadata[@name='RoleCode']"/>
        <xsl:variable name="identifierGND" select="kitodo:metadata[@name='IdentifierGND']"/>
        <xsl:variable name="identifierGNDURI" select="kitodo:metadata[@name='IdentifierGNDURI']"/>
        <xsl:variable name="authority" select="kitodo:metadata[@name='Authority']"/>
        <xsl:variable name="identifierPPN" select="kitodo:metadata[@name='IdentifierPPN']"/>
        <mods:name type="corporate">
            <xsl:if test="$authority !=''">
                <xsl:attribute name="authority">
                    <xsl:value-of select="$authority"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$identifierGNDURI !=''">
                <xsl:attribute name="valueURI">
                    <xsl:value-of select="$identifierGNDURI"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$nameMainUnit !=''">
                <mods:namePart>
                    <xsl:value-of select="($nameMainUnit)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$additionalMetadataCorporation !=''">
                <mods:namePart>
                    <xsl:value-of select="($additionalMetadataCorporation)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$nameSubordinateUnit !=''">
                <mods:namePart>
                    <xsl:value-of select="($nameSubordinateUnit)"/>
                </mods:namePart>
            </xsl:if>
            <xsl:if test="$displayForm !=''">
                <mods:displayForm>
                    <xsl:value-of select="($displayForm)"/>
                </mods:displayForm>
            </xsl:if>
            <xsl:if test="$identifierGND !='' or $authority !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$authority">
                        <xsl:attribute name="type">
                            <xsl:value-of select="($authority)"/>
                        </xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierGND">
                        <xsl:value-of select="($identifierGND)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$identifierPPN !=''">
                <mods:nameIdentifier>
                    <xsl:if test="$identifierPPN">
                        <xsl:attribute name="type">ppn</xsl:attribute>
                    </xsl:if>
                    <xsl:if test="$identifierPPN">
                        <xsl:value-of select="normalize-space($identifierPPN)"/>
                    </xsl:if>
                </mods:nameIdentifier>
            </xsl:if>
            <xsl:if test="$roleCode !=''">
                <xsl:for-each select="$roleCode">
                    <mods:role>
                        <mods:roleTerm type="code" authority="marcrelator">
                            <xsl:value-of select="normalize-space(.)"/>
                        </mods:roleTerm>
                    </mods:role>
                </xsl:for-each>
            </xsl:if>
        </mods:name>
    </xsl:template>

    <xsl:template match="@TYPE">
        <xsl:attribute name="TYPE">
            <xsl:choose>
                <xsl:when test=". = 'Acknowledgment'">
                    <xsl:text>acknowledgment</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Addendum'">
                    <xsl:text>addendum</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Advertising'">
                    <xsl:text>advertising</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Appendix'">
                    <xsl:text>appendix</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Article'">
                    <xsl:text>article</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'AttachedWork'">
                    <xsl:text>attached_work</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Autograph'">
                    <xsl:text>autograph</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Bundle'">
                    <xsl:text>bundle</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Chapter'">
                    <xsl:text>chapter</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'CoatOfArms'">
                    <xsl:text>coat_of_arms</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'ContainedWork'">
                    <xsl:text>contained_work</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Cover'">
                    <xsl:text>cover</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'cover_back'">
                    <xsl:text>cover_back</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'cover_front'">
                    <xsl:text>cover_front</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'CurriculumVitae'">
                    <xsl:text>curriculum_vitae</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Dedication'">
                    <xsl:text>dedication</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Headword'">
                    <xsl:text>entry</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'edge'">
                    <xsl:text>edge</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Emblem'">
                    <xsl:text>emblem</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Ephemera'">
                    <xsl:text>ephemera</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'EphemeraYear'">
                    <xsl:text>year</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'EphemeraMonth'">
                    <xsl:text>month</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'EphemeraDay'">
                    <xsl:text>day</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Epilogue'">
                    <xsl:text>epilogue</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Errata'">
                    <xsl:text>corrigenda</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Exlibris'">
                    <xsl:text>bookplate</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Fascicle'">
                    <xsl:text>fascicle</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Figure'">
                    <xsl:text>image</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Folder'">
                    <xsl:text>folder</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'GroundPlan'">
                    <xsl:text>ground_plan</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'HandDrawing'">
                    <xsl:text>hand_drawing</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IllustrationDescription'">
                    <xsl:text>illustration_description</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Imprint'">
                    <xsl:text>imprint</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Incipit'">
                    <xsl:text>incipit</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Index'">
                    <xsl:text>index</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IndexAuthor'">
                    <xsl:text>index_author</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IndexLocation'">
                    <xsl:text>index_location</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IndexOverall'">
                    <xsl:text>index_overall</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IndexOfChronology'">
                    <xsl:text>index_chronology</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IndexPersons'">
                    <xsl:text>index_persons</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IndexSpecial'">
                    <xsl:text>index_special</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IndexSubject'">
                    <xsl:text>index_subject</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'IndexVolume'">
                    <xsl:text>index_volume</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Initial'">
                    <xsl:text>initial</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Introduction'">
                    <xsl:text>introduction</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Inventory'">
                    <xsl:text>inventory</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'InventoryMigrated'">
                    <xsl:text>inventory</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Label'">
                    <xsl:text>label</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Letter'">
                    <xsl:text>letter</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'ListOfIllustrations'">
                    <xsl:text>list_illustrations</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'ListOfMaps'">
                    <xsl:text>list_maps</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'ListOfTables'">
                    <xsl:text>list_tables</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Manuscript'">
                    <xsl:text>manuscript</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'ManuscriptKalliope'">
                    <xsl:text>manuscript</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'ManuscriptKalliopeMigrated'">
                    <xsl:text>manuscript</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Map'">
                    <xsl:text>map</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'mark'">
                    <xsl:text>mark</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Monogram'">
                    <xsl:text>monogram</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Monograph'">
                    <xsl:text>monograph</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Motto'">
                    <xsl:text>motto</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'MultiVolumeWork'">
                    <xsl:text>multivolume_work</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Newspaper'">
                    <xsl:text>newspaper</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'NewspaperYear'">
                    <xsl:text>year</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'NewspaperMonth'">
                    <xsl:text>month</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'NewspaperDay'">
                    <xsl:text>day</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Note'">
                    <xsl:text>note</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Obituary'">
                    <xsl:text>obituary</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'OtherDocStrct'">
                    <xsl:text>other</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'PartOfWork'">
                    <xsl:text>part</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Periodical'">
                    <xsl:text>periodical</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'PeriodicalIssue'">
                    <xsl:text>issue</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'PeriodicalVolumeIssue'">
                    <xsl:text>issue</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'PeriodicalPart'">
                    <xsl:text>periodical_part</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'PeriodicalVolume'">
                    <xsl:text>volume</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Preface'">
                    <xsl:text>preface</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Prepage'">
                    <xsl:text>endsheet</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'PrintersMark'">
                    <xsl:text>printers_mark</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Provenance'">
                    <xsl:text>provenance</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Remarks'">
                    <xsl:text>remarks</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Seal'">
                    <xsl:text>seal</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'SheetMusic'">
                    <xsl:text>musical_notation</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Shelfmark'">
                    <xsl:text>shelfmark</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_AdLectorem'">
                    <xsl:text>ad_lectorem</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_Binding'">
                    <xsl:text>binding</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_BindingCollectedEdition'">
                    <xsl:text>binding_collections</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_Chronogramm'">
                    <xsl:text>chronogramm</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_Censorship'">
                    <xsl:text>censorship</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_Colophon'">
                    <xsl:text>colophon</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_EngravingTitlePage'">
                    <xsl:text>engraved_titlepage</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_ExhibitionList'">
                    <xsl:text>exhibition_list</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_IllustrationCatalogue'">
                    <xsl:text>illustration_catalogue</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_jacket'">
                    <xsl:text>jacket</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_MarginaleNote'">
                    <xsl:text>annotation</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_partmusic'">
                    <xsl:text>music_part</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_PastDown'">
                    <xsl:text>paste_down</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_Protocol'">
                    <xsl:text>protocol</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_score'">
                    <xsl:text>score</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_Speech'">
                    <xsl:text>speech</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_Street'">
                    <xsl:text>street</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_verse'">
                    <xsl:text>verse</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'slub_watermarkstrct'">
                    <xsl:text>watermark</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'spine'">
                    <xsl:text>spine</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Stamp'">
                    <xsl:text>stamp</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Subinventory'">
                    <xsl:text>subinventory</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'SubinventoryMigrated'">
                    <xsl:text>subinventory</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Supplement'">
                    <xsl:text>additional</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Supralibros'">
                    <xsl:text>supralibros</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Table'">
                    <xsl:text>table</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'TableOfAbbreviations'">
                    <xsl:text>table_abbreviations</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'TableOfContents'">
                    <xsl:text>contents</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'TableDescription'">
                    <xsl:text>table_description</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'TableOfLiteratureRefs'">
                    <xsl:text>table_references</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Text'">
                    <xsl:text>text</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Theses'">
                    <xsl:text>theses</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'TitlePage'">
                    <xsl:text>title_page</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'Volume'">
                    <xsl:text>volume</xsl:text>
                </xsl:when>
                <xsl:when test=". = 'BoundBook'">
                    <xsl:text>physSequence</xsl:text>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="(.)"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:attribute>
    </xsl:template>

    <!-- pass-through rule -->
    <xsl:template match="@* | node()">
        <xsl:copy>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>
</xsl:stylesheet>