arelle-release 2.17.1__py3-none-any.whl → 2.37.71__py3-none-any.whl

arelle/plugin/validate/ESEF/ESEF_Current/ValidateXbrlFinally.py

@@ -6,15 +6,16 @@ from __future__ import annotations
 import os
 import zipfile
 from collections import defaultdict
-from datetime import datetime
+from datetime import datetime, timedelta
 from math import isnan
-from typing import Any, List, cast
+from typing import Any, cast
 
 import regex as re
-import tinycss2  # type: ignore[import-untyped]
-from lxml.etree import EntityBase, _Comment, _ElementTree, _ProcessingInstruction
+import tinycss2.ast  # type: ignore[import-untyped]
+from lxml.etree import _Comment, _Element, _ElementTree, _Entity, _ProcessingInstruction
 
 from arelle import LeiUtil, ModelDocument, XbrlConst
+from arelle.FunctionIxt import ixtNamespacesByVersion
 from arelle.ModelDtsObject import ModelConcept
 from arelle.ModelDtsObject import ModelResource
 from arelle.ModelInstanceObject import ModelContext
@@ -25,9 +26,15 @@ from arelle.ModelRelationshipSet import ModelRelationshipSet
 from arelle.ModelValue import QName
 from arelle.ModelValue import qname
 from arelle.ModelXbrl import ModelXbrl
-from arelle.PythonUtil import normalizeSpace
+
+from arelle.utils.validate.ESEFImage import ImageValidationParameters, checkSVGContentElt, validateImageAndLog
+from arelle.utils.validate.ValidationUtil import etreeIterWithDepth
+from arelle.PythonUtil import isLegacyAbs, normalizeSpace
 from arelle.PythonUtil import strTruncate
-from arelle.UrlUtil import isHttpUrl
+from arelle.utils.Contexts import partitionModelXbrlContexts
+from arelle.utils.Units import partitionModelXbrlUnits
+from arelle.utils.validate.DetectScriptsInXhtml import containsScriptMarkers
+from arelle.UrlUtil import isHttpUrl, isExternalUrl
 from arelle.ValidateUtr import ValidateUtr
 from arelle.ValidateXbrl import ValidateXbrl
 from arelle.ValidateXbrlCalcs import inferredDecimals, rangeValue
@@ -40,35 +47,35 @@ from arelle.XbrlConst import (
     notAll as hc_notAll,
     parentChild,
     standardLabel,
-    summationItem,
+    summationItems,
     widerNarrower,
     xhtml,
 )
 from arelle.XmlValidateConst import VALID
 from arelle.typing import TypeGetText
 from .DTS import checkFilingDTS
-from .Image import checkSVGContentElt, validateImage
 from ..Const import (
     DefaultDimensionLinkroles,
     FOOTNOTE_LINK_CHILDREN,
-    IXT_NAMESPACES,
     LineItemsNotQualifiedLinkroles,
-    PERCENT_TYPE, datetimePattern,
+    PERCENT_TYPES, datetimePattern,
     docTypeXhtmlPattern,
     esefMandatoryElementNames2020,
     esefPrimaryStatementPlaceholderNames,
-    esefStatementsOfMonetaryDeclarationNames,
     mandatory,
     styleCssHiddenPattern,
-    styleIxHiddenPattern,
+    supportedImgTypes,
     untransformableTypes,
+    reportBasenamePattern,
+    reportBasenameRegex
 )
 from ..Dimensions import checkFilingDimensions
-from ..Util import checkForMultiLangDuplicates, etreeIterWithDepth, getEsefNotesStatementConcepts, hasEventHandlerAttributes, isExtension, getDisclosureSystemYear
+from ..Util import checkForMultiLangDuplicates, getEsefNotesStatementConcepts, isExtension, getDisclosureSystemYear
 
 _: TypeGetText  # Handle gettext
 
 ifrsNsPattern = re.compile(r"https?://xbrl.ifrs.org/taxonomy/[0-9-]{10}/ifrs-full")
+escapeWorthyStr = re.compile(r".*[<&]")
 
 
 def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
@@ -90,17 +97,30 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
         assert isinstance(modelXbrl.fileSource.fs, zipfile.ZipFile)
 
         maxMB = float(reportPackageMaxMB)
+        _size: int | None = None
+        _sizeExact = True
         if val.authParam["reportPackageMeasurement"] == "unzipped":
             _size = sum(zi.file_size for zi in modelXbrl.fileSource.fs.infolist())
+            _sizeExact = False
         else:
-            _size = sum(zi.compress_size for zi in modelXbrl.fileSource.fs.infolist())
-            # not usable because zip may be posted or streamed: _size = os.path.getsize(modelXbrl.fileSource.basefile)
-        if _size > maxMB * 1048576:
+            try:
+                _size = modelXbrl.fileSource.getBytesSize()
+            except Exception:
+                pass
+            if _size is None:
+                _size = modelXbrl.fileSource.getBytesSizeEstimate()
+                _sizeExact = False
+        modelXbrl.info("arelle.ESEF.reportPackageSize",
+                       _("The %(estimated)s report package %(reportPackageMeasurement)s size is %(size)s bytes."),
+                       estimated=_("exact") if _sizeExact else _("estimated"),
+                       reportPackageMeasurement=_(val.authParam["reportPackageMeasurement"]) or _("zipped"),
+                       size=_size)
+        if _size is not None and _size > maxMB * 1048576:
             modelXbrl.error("arelle.ESEF.maximumReportPackageSize",
                             _("The authority %(authority)s requires a report package size under %(maxSize)s MB, size is %(size)s."),
                             modelObject=modelXbrl, authority=val.authority, maxSize=reportPackageMaxMB, size=_size)
 
-    if val.authority == "UKFRC":
+    if val.authority and val.authority.startswith("UKFRC"):
         if modelXbrl.fileSource and modelXbrl.fileSource.taxonomyPackage and modelXbrl.fileSource.taxonomyPackage["publisherCountry"] != "GB":
             modelXbrl.error("UKFRC.1.2.publisherCountrySetting",
                         _("The \"Publisher Country\" element of the report package metadata for a UKSEF report MUST be set to \"GB\" but was \"%(publisherCountry)s\"."),
@@ -130,7 +150,6 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
         esefNotesConcepts = getEsefNotesStatementConcepts(val.modelXbrl)
 
     esefPrimaryStatementPlaceholders = set(qname(_ifrsNs, n) for n in esefPrimaryStatementPlaceholderNames)
-    esefStatementsOfMonetaryDeclaration = set(qname(_ifrsNs, n) for n in esefStatementsOfMonetaryDeclarationNames)
     esefMandatoryElements2020 = set(qname(_ifrsNs, n) for n in esefMandatoryElementNames2020)
 
     if modelDocument.type == ModelDocument.Type.INSTANCE and not val.unconsolidated:
@@ -146,14 +165,14 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
     checkFilingDTS(val, modelXbrl.modelDocument, esefNotesConcepts, [], ifrsNses=_ifrsNses)
     modelXbrl.profileActivity("... filer DTS checks", minTimeToShow=1.0)
 
-    if getDisclosureSystemYear(modelXbrl) >= 2023:
-        instanceNumber = 0
-        if modelXbrl.fileSource.dir:
+    esefDisclosureSystemYear = getDisclosureSystemYear(modelXbrl)
+    if esefDisclosureSystemYear >= 2023:
+        if val.unconsolidated and modelXbrl.fileSource.dir:
+            instanceNumber = 0
             for file in modelXbrl.fileSource.dir:
                 if not file.endswith("/"):
-                    from arelle.ModelDocument import Type
-                    fileType = Type.identify(modelXbrl.fileSource, "{}/{}".format(modelXbrl.fileSource.basefile, file))
-                    if fileType == Type.INLINEXBRL:
+                    fileType = ModelDocument.Type.identify(modelXbrl.fileSource, "{}/{}".format(modelXbrl.fileSource.basefile, file))
+                    if fileType == ModelDocument.Type.INLINEXBRL:
                         instanceNumber += 1
             if instanceNumber > 1:
                 modelXbrl.error("ESEF.4.1.1.SingleXhtmlFiles",
@@ -176,7 +195,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                     if ifrs_year != esef_year:
                         # this check isn't precise enough, but the list of available concept isn't available in esef_cor
                         modelXbrl.warning("ESEF.1.2.IFRSNotYetIncluded",
-                                        _("Elements available in the IFRS Taxonomy that were not yet included in the ESEF taxonomy sould not be used."),
+                                        _("Elements available in the IFRS Taxonomy that were not yet included in the ESEF taxonomy should not be used."),
                                         modelObject=modelXbrl)
 
     if val.consolidated and not (val.hasExtensionSchema and val.hasExtensionPre and val.hasExtensionCal and val.hasExtensionDef and val.hasExtensionLbl):
@@ -225,12 +244,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _baseName, _baseExt = os.path.splitext(doc.basename)
                 if _baseExt not in (".xhtml",".html"):
                     if val.consolidated:
-                        XHTMLExtensionGuidance = "2.6.1"
+                        errorCode = "ESEF.2.6.1.incorrectFileExtension"
                         reportType = _("Inline XBRL document included within a ESEF report package")
                     else:
-                        XHTMLExtensionGuidance = "4.1.1"
+                        errorCode = "ESEF.4.1.1.incorrectFileExtension"
                         reportType = _("Stand-alone XHTML document")
-                    modelXbrl.error(f"ESEF.{XHTMLExtensionGuidance}.incorrectFileExtension",
+                    modelXbrl.error(errorCode,
                                     _("%(reportType)s MUST have a .html or .xhtml extension: %(fileName)s"),
                                     modelObject=doc, fileName=doc.basename, reportType=reportType)
                 docinfo = doc.xmlRootElement.getroottree().docinfo
@@ -249,33 +268,40 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                         modelXbrl.error("ESEF.RTS.Annex.III.Par.1.invalidInlineXBRL",
                             _("Invalid inline XBRL namespace: %(namespace)s"),
                             modelObject=doc, namespace=doc.ixNS)
-                    # check location in a taxonomy package
-                    # ixds loading for ESEF expects all xhtml instances to be combined into single IXDS regardless of directory in report zip
-                    docDirPath = re.split(r"[/\\]", doc.uri)
-                    reportCorrectlyPlacedInPackage = reportIsInZipFile = False
-                    for i, dir in enumerate(docDirPath):
-                        if dir.lower().endswith(".zip"):
-                            if reportIsInZipFile: # report package was nested in a zip file
-                                ixdsDocDirs.clear() # ignore containing zip
-                            reportIsInZipFile = True
-                            packageName = dir[:-4] # web service posted zips are always named POSTupload.zip instead of the source file name
-                            if len(docDirPath) >= i + 2 and packageName in (docDirPath[i+1],"POSTupload") and docDirPath[i+2] == "reports":
-                                ixdsDocDirs.add("/".join(docDirPath[i+3:-1]))
-                                reportCorrectlyPlacedInPackage = True
-                            else:
-                                ixdsDocDirs.add("/".join(docDirPath[i+1:len(docDirPath)-1])) # needed for error msg on orphaned instance docs
-                    if not reportIsInZipFile:
-                        modelXbrl.error("ESEF.2.6.1.reportIncorrectlyPlacedInPackage",
-                            _("Inline XBRL document MUST be included within an ESEF report package as defined in "
-                               "http://www.xbrl.org/WGN/report-packages/WGN-2018-08-14/report-packages-WGN-2018-08-14"
-                               ".html: %(fileName)s (Document is not in a zip archive)"),
-                            modelObject=doc, fileName=doc.basename)
-                    elif not reportCorrectlyPlacedInPackage:
-                        modelXbrl.error("ESEF.2.6.1.reportIncorrectlyPlacedInPackage",
-                             _("Inline XBRL document MUST be included within an ESEF report package as defined in "
-                               "http://www.xbrl.org/WGN/report-packages/WGN-2018-08-14/report-packages-WGN-2018-08-14"
-                               ".html: %(fileName)s (Document file not in correct place in package)"),
-                            modelObject=doc, fileName=doc.basename)
+                    if esefDisclosureSystemYear <= 2023:
+                        # check location in a taxonomy package
+                        # ixds loading for ESEF expects all xhtml instances to be combined into single IXDS regardless of directory in report zip
+                        docDirPath = re.split(r"[/\\]", doc.uri)
+                        reportCorrectlyPlacedInPackage = reportIsInZipFile = False
+                        for i, dir in enumerate(docDirPath):
+                            if dir.lower().endswith(".zip"):
+                                if reportIsInZipFile: # report package was nested in a zip file
+                                    ixdsDocDirs.clear() # ignore containing zip
+                                reportIsInZipFile = True
+                                packageName = dir[:-4] # web service posted zips are always named POSTupload.zip instead of the source file name
+                                if len(docDirPath) >= i + 2 and packageName in (docDirPath[i+1],"POSTupload") and docDirPath[i+2] == "reports":
+                                    ixdsDocDirs.add("/".join(docDirPath[i+3:-1]))
+                                    reportCorrectlyPlacedInPackage = True
+                                else:
+                                    ixdsDocDirs.add("/".join(docDirPath[i+1:len(docDirPath)-1])) # needed for error msg on orphaned instance docs
+                        if not reportIsInZipFile:
+                            modelXbrl.error("ESEF.2.6.1.reportIncorrectlyPlacedInPackage",
+                                _("Inline XBRL document MUST be included within an ESEF report package as defined in "
+                                "http://www.xbrl.org/WGN/report-packages/WGN-2018-08-14/report-packages-WGN-2018-08-14"
+                                ".html: %(fileName)s (Document is not in a zip archive)"),
+                                modelObject=doc, fileName=doc.basename)
+                        elif not reportCorrectlyPlacedInPackage:
+                            modelXbrl.error("ESEF.2.6.1.reportIncorrectlyPlacedInPackage",
+                                _("Inline XBRL document MUST be included within an ESEF report package as defined in "
+                                "http://www.xbrl.org/WGN/report-packages/WGN-2018-08-14/report-packages-WGN-2018-08-14"
+                                ".html: %(fileName)s (Document file not in correct place in package)"),
+                                modelObject=doc, fileName=doc.basename)
+                    elif esefDisclosureSystemYear >= 2025:
+                        m = reportBasenameRegex.match(_baseName)
+                        if not m:
+                            modelXbrl.error("ESEF.2.6.3.incorrectNamingConventionReportPackageReportFile",
+                                _("Inline XBRL document filename SHOULD match %(pattern)s"),
+                                modelObject=doc, fileName=doc.basename, pattern=reportBasenamePattern)
                 else: # non-consolidated
                     if docTypeMatch:
                         if not docTypeMatch.group(1) or docTypeMatch.group(1).lower() == "html":
@@ -284,7 +310,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                 modelObject=doc, doctype=docinfo.doctype)
 
         reportIncorrectlyPlacedInPackageRef = "https://www.xbrl.org/Specification/report-package/CR-2023-05-03/report-package-CR-2023-05-03.html"
-        if getDisclosureSystemYear(modelXbrl) < 2023:
+        if esefDisclosureSystemYear < 2023:
             reportIncorrectlyPlacedInPackageRef = "http://www.xbrl.org/WGN/report-packages/WGN-2018-08-14/report-packages-WGN-2018-08-14.html"
 
         if len(ixdsDocDirs) > 1 and val.consolidated:
@@ -293,14 +319,32 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                        "%(url)s: %(documentSets)s (Document files appear to be in multiple document sets)"),
                 modelObject=doc, documentSets=", ".join(sorted(ixdsDocDirs)), url=reportIncorrectlyPlacedInPackageRef)
         ixTargetUsage = val.authParam["ixTargetUsage"]
+        earliestTRVersion = val.authParam.get("earliestTransformationRegistryVersion", min(ixtNamespacesByVersion.keys()))
+        if earliestTRVersion not in ixtNamespacesByVersion:
+            raise ValueError(f'Unsupported "earliestTransformationRegistryVersion" disclosure system config setting: {earliestTRVersion}')
+        allowedTRnamespaces = frozenset(
+            ns for version, ns in ixtNamespacesByVersion.items()
+            if version >= earliestTRVersion
+        )
+        if styleIxHiddenProperty := val.authParam.get("styleIxHiddenProperty"):
+            styleIxHiddenPattern = re.compile(rf"(.*[^\w]|^){styleIxHiddenProperty}\s*:\s*([\w.-]+).*")
+        else:
+            styleIxHiddenPattern = None
         if modelDocument.type in (ModelDocument.Type.INLINEXBRL, ModelDocument.Type.INLINEXBRLDOCUMENTSET, ModelDocument.Type.UnknownXML):
             hiddenEltIds = {}
             presentedHiddenEltIds = defaultdict(list)
             eligibleForTransformHiddenFacts = []
             requiredToDisplayFacts = []
-            requiredToDisplayFactIds: dict[Any, Any] = {}
             firstIxdsDoc = True
             contentOtherThanXHTMLGuidance = 'ESEF.2.5.1' if val.consolidated else 'ESEF.4.1.3'  # Different reference for iXBRL and stand-alone XHTML
+            imageValidationParameters = ImageValidationParameters(
+                checkMinExternalResourceSize=True,
+                consolidated = val.consolidated,
+                contentOtherThanXHTMLGuidance=contentOtherThanXHTMLGuidance,
+                missingMimeTypeIsIncorrect=True,
+                recommendBase64EncodingEmbeddedImages=True,
+                supportedImgTypes=supportedImgTypes,
+            )
             # ModelDocument.load has None as a return type. For typing reasons, we need to guard against that here.
             assert modelXbrl.modelDocument is not None
             for ixdsHtmlRootElt in (modelXbrl.ixdsHtmlElements if val.consolidated else # ix root elements for all ix docs in IXDS
@@ -315,7 +359,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                     elt = cast(Any, uncast_elt)
 
                     eltTag = elt.tag
-                    if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, EntityBase)):
+                    if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction, _Entity)):
                         continue # comment or other non-parsed element
                     else:
                         eltTag = elt.tag
@@ -326,31 +370,48 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                 if xmlLang:
                                     reportXmlLang = xmlLang
                                     firstRootmostXmlLangDepth = depth
-                        if ((eltTag in ("object", "script")) or
-                            (eltTag == "a" and "javascript:" in elt.get("href", "")) or
-                            (eltTag == "img" and "javascript:" in elt.get("src", "")) or
-                            (hasEventHandlerAttributes(elt))):
+                        if containsScriptMarkers(elt):
                             modelXbrl.error(f"{contentOtherThanXHTMLGuidance}.executableCodePresent",
                                 _("Inline XBRL documents MUST NOT contain executable code: %(element)s"),
                                 modelObject=elt, element=eltTag)
+                            externalReferenceFound = False
+                            if eltTag == "object":
+                                # Check if the attribute 'archive' contains an external reference!
+                                archiveAttr = elt.get("archive", "").strip()
+                                for possibleURI in archiveAttr.split(" "):
+                                    if isExternalUrl(possibleURI.strip()):
+                                        externalReferenceFound = True
+                                        break
+                            elif eltTag == "script":
+                                # Check if the attribute 'src' contains an external reference!
+                                srcAttr = elt.get("src", "").strip()
+                                if isExternalUrl(srcAttr):
+                                    externalReferenceFound = True
+                            if externalReferenceFound:
+                                modelXbrl.error(
+                                    "ESEF.4.1.6.xHTMLDocumentContainsExternalReferences" if val.unconsolidated
+                                    else "ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
+                                    _("Inline XBRL instance documents MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
+                                    modelObject=elt, element=eltTag,
+                                    messageCodes=("ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
+                                                  "ESEF.4.1.6.xHTMLDocumentContainsExternalReferences"))
                         elif eltTag == "a" and "mailto" in elt.get("href", ""):
                             modelXbrl.warning(f"{contentOtherThanXHTMLGuidance}.executableCodePresent.mailto",
                                             _("Inline XBRL documents SHOULD NOT contain any 'mailto' URI: %(element)s"),
                                             modelObject=elt, element=eltTag)
                         elif eltTag == "{http://www.w3.org/2000/svg}svg":
-                            checkSVGContentElt(elt, elt.modelDocument.baseForElement(elt), modelXbrl, elt,
-                                           contentOtherThanXHTMLGuidance, val)
+                            checkSVGContentElt(elt, elt.modelDocument.baseForElement(elt), modelXbrl, [elt], imageValidationParameters, val)
                         elif eltTag == "img":
                             src = elt.get("src","").strip()
                             evaluatedMsg = _('On line {line}, "alt" attribute value: "{alt}"').format(line=elt.sourceline, alt=elt.get("alt"))
-                            validateImage(elt.modelDocument.baseForElement(elt), src, modelXbrl, val, elt, evaluatedMsg, contentOtherThanXHTMLGuidance)
+                            validateImageAndLog(elt.modelDocument.baseForElement(elt), src, modelXbrl, val, elt, evaluatedMsg, imageValidationParameters)
                         # links to external documents are allowed as of 2021 per G.2.5.1
                         #    Since ESEF is a format requirement and is not expected to impact the 'human readable layer' of a report,
                         #    this guidance should not be seen as limiting the inclusion of links to external websites, to other documents
                         #    or to other sections of the annual financial report.'''
                         #elif eltTag == "a":
                         #    href = elt.get("href","").strip()
-                        #    if scheme(href) in ("http", "https", "ftp"):
+                        #    if isExternalUrl(href):
                         #        modelXbrl.error("ESEF.4.1.6.xHTMLDocumentContainsExternalReferences" if val.unconsolidated
                         #                        else "ESEF.3.5.1.inlineXbrlDocumentContainsExternalReferences",
                         #            _("Inline XBRL instance documents MUST NOT contain any reference pointing to resources outside the reporting package: %(element)s"),
@@ -370,7 +431,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
 
                             with elt.modelXbrl.fileSource.file(normalizedUri, binary=True)[0] as fh:
                                 cssContents = fh.read()
-                                validateCssUrl(cssContents.decode(), normalizedUri, modelXbrl, val, elt, contentOtherThanXHTMLGuidance)
+                                validateCssUrl(cssContents.decode(), normalizedUri, modelXbrl, val, elt, imageValidationParameters)
                                 cssContents = None
                             if val.unconsolidated:
                                 modelXbrl.warning("ESEF.4.1.4.externalCssFileForXhtmlDocument",
@@ -378,7 +439,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                     modelObject=elt, element=eltTag)
                             elif len(modelXbrl.ixdsHtmlElements) > 1:
                                 _file = elt.get("href")
-                                if not _file or isHttpUrl(_file) or os.path.isabs(_file):
+                                if not _file or isHttpUrl(_file) or isLegacyAbs(_file):
                                     modelXbrl.warning("ESEF.2.5.4.externalCssReportPackage",
                                         _("The CSS file should be physically stored within the report package: %{file}s."),
                                         modelObject=elt, file=_file)
@@ -387,7 +448,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                     _("Where an Inline XBRL document set contains a single document, the CSS SHOULD be embedded within the document."),
                                     modelObject=elt, element=eltTag)
                         elif eltTag == "style" and elt.get("type") == "text/css":
-                            validateCssUrl(elt.stringValue, elt.modelDocument.baseForElement(elt), modelXbrl, val, elt, contentOtherThanXHTMLGuidance)
+                            validateCssUrl(elt.stringValue, elt.modelDocument.baseForElement(elt), modelXbrl, val, elt, imageValidationParameters)
                             if not val.unconsolidated:
                                 if len(modelXbrl.ixdsHtmlElements) > 1:
                                     modelXbrl.warning("ESEF.2.5.4.embeddedCssForMultiHtmlIXbrlDocumentSets",
@@ -412,7 +473,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                     modelObject=elt, qname=elt.qname)
                         elif any(character in elt.stringValue for character in ['&lt;', '&amp;', '&', '<']):
                             if not (hasattr(elt, 'attrib')) or ('escape' not in elt.attrib or elt.attrib.get('escape').lower() != 'true'):
-                                modelXbrl.error("ESEF.2.2.6.escapedHTMLUsedInBlockTagWithSpecialCharacters" if getDisclosureSystemYear(modelXbrl) < 2023 else "ESEF.2.2.7.escapedHTMLUsedInBlockTagWithSpecialCharacters",
+                                modelXbrl.error("ESEF.2.2.6.escapedHTMLUsedInBlockTagWithSpecialCharacters" if esefDisclosureSystemYear < 2023 else "ESEF.2.2.7.escapedHTMLUsedInBlockTagWithSpecialCharacters",
                                         _("A text block containing '&' or '<' character MUST have an 'escape' attribute: %(qname)s."),
                                         modelObject=elt, qname=elt.qname)
                         # Check that continuation elements are in the order of html text as rendered to user
@@ -446,7 +507,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                     elif isinstance(elt, ModelResource) and elt.qname == XbrlConst.qnLinkFootnote:
                         checkFootnote(elt, elt.value)
                     elif isinstance(elt, ModelInlineFact):
-                        if elt.format is not None and elt.format.namespaceURI not in IXT_NAMESPACES:
+                        if elt.format is not None and elt.format.namespaceURI not in allowedTRnamespaces:
                             transformRegistryErrors.add(elt)
                 ixHiddenFacts = set()
                 for ixHiddenElt in ixdsHtmlRootElt.iterdescendants(tag=ixNStag + "hidden"):
@@ -463,7 +524,7 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                                 hiddenEltIds[ixElt.id] = ixElt
                             ixHiddenFacts.add(ixElt)
                 # maliciously hidden facts
-                for cssHiddenElt in ixdsHtmlRootElt.getroottree().iterfind("//{http://www.w3.org/1999/xhtml}*[@style]"):
+                for cssHiddenElt in ixdsHtmlRootElt.getroottree().iterfind(".//{http://www.w3.org/1999/xhtml}*[@style]"):
                     if styleCssHiddenPattern.match(cssHiddenElt.get("style","")):
                         for tag in (ixNStag + "nonNumeric", ixNStag+"nonFraction"):
                             for ixElt in cssHiddenElt.iterdescendants(tag=tag):
@@ -486,28 +547,29 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                     countEligible=len(eligibleForTransformHiddenFacts),
                     elements=", ".join(sorted(set(str(f.qname) for f in eligibleForTransformHiddenFacts))))
             for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
-                for ixElt in ixdsHtmlRootElt.getroottree().iterfind("//{http://www.w3.org/1999/xhtml}*[@style]"):
+                for ixElt in ixdsHtmlRootElt.getroottree().iterfind(".//{http://www.w3.org/1999/xhtml}*[@style]"):
                     styleValue = ixElt.get("style","")
-                    hiddenFactRefMatch = styleIxHiddenPattern.match(styleValue)
 
                     if styleValue:
-                        for declaration in tinycss2.parse_declaration_list(styleValue):
+                        for declaration in tinycss2.parse_blocks_contents(styleValue):
                             if isinstance(declaration, tinycss2.ast.Declaration):
                                 validateCssUrlContent(declaration.value, ixElt.modelDocument.baseForElement(ixElt),
-                                                      modelXbrl, val, ixElt, contentOtherThanXHTMLGuidance)
+                                                      modelXbrl, val, ixElt, imageValidationParameters)
                             elif isinstance(declaration, tinycss2.ast.ParseError):
                                 modelXbrl.warning("ix.CssParsingError",
                                                   _("The style attribute contains erroneous CSS declaration \"%(styleContent)s\": %(parseError)s"),
                                                   modelObject=ixElt, parseError=declaration.message,
                                                   styleContent=styleValue)
-                    if hiddenFactRefMatch:
-                        hiddenFactRef = hiddenFactRefMatch.group(2)
-                        if hiddenFactRef not in hiddenEltIds:
-                            modelXbrl.error("ESEF.2.4.1.esefIxHiddenStyleNotLinkingFactInHiddenSection",
-                                _("\"-esef-ix-hidden\" style identifies id attribute of a fact that is not in ix:hidden section: %(factId)s"),
-                                modelObject=ixElt, factId=hiddenFactRef)
-                        else:
-                            presentedHiddenEltIds[hiddenFactRef].append(ixElt)
+                    if styleIxHiddenPattern is not None:
+                        hiddenFactRefMatch = styleIxHiddenPattern.match(styleValue)
+                        if hiddenFactRefMatch:
+                            hiddenFactRef = hiddenFactRefMatch.group(2)
+                            if hiddenFactRef not in hiddenEltIds:
+                                modelXbrl.error("ESEF.2.4.1.esefIxHiddenStyleNotLinkingFactInHiddenSection",
+                                    _("\"%(styleIxHiddenProperty)s\" style identifies id attribute of a fact that is not in ix:hidden section: %(factId)s"),
+                                    modelObject=ixElt, styleIxHiddenProperty=styleIxHiddenProperty, factId=hiddenFactRef)
+                            else:
+                                presentedHiddenEltIds[hiddenFactRef].append(ixElt)
             for hiddenEltId, ixElt in hiddenEltIds.items():
                 if (hiddenEltId not in presentedHiddenEltIds and
                     getattr(ixElt, "xValid", 0) >= VALID and # may not be validated
@@ -535,8 +597,8 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
         contextsWithDisallowedOCEcontent = []
         contextsWithPeriodTime: list[ModelContext] = []
         contextsWithPeriodTimeZone: list[ModelContext] = []
+        contextsWithWrongInstantDate: list[ModelContext] = []
         contextIdentifiers = defaultdict(list)
-        nonStandardTypedDimensions: dict[Any, Any] = defaultdict(set)
         for context in modelXbrl.contexts.values():
             for uncast_elt in context.iterdescendants("{http://www.xbrl.org/2003/instance}startDate",
                                                "{http://www.xbrl.org/2003/instance}endDate",
@@ -549,6 +611,9 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                         contextsWithPeriodTime.append(context)
                     if m.group(3):
                         contextsWithPeriodTimeZone.append(context)
+
+            if esefDisclosureSystemYear >= 2024 and context.instantDate and context.instantDate.day == 1 and context.instantDate.month == 1:
+                contextsWithWrongInstantDate.append(context)
             for elt in context.iterdescendants("{http://www.xbrl.org/2003/instance}segment"):
                 contextsWithDisallowedOCEs.append(context)
                 break
@@ -565,11 +630,11 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
         if contextsWithDisallowedOCEs:
             modelXbrl.error("ESEF.2.1.3.segmentUsed",
                 _("xbrli:segment container MUST NOT be used in contexts: %(contextIds)s"),
-                modelObject=contextsWithDisallowedOCEs, contextIds=", ".join(c.id for c in contextsWithDisallowedOCEs))
+                modelObject=contextsWithDisallowedOCEs, contextIds=", ".join(c.id for c in contextsWithDisallowedOCEs if c.id is not None))
         if contextsWithDisallowedOCEcontent:
             modelXbrl.error("ESEF.2.1.3.scenarioContainsNonDimensionalContent",
                 _("xbrli:scenario in contexts MUST NOT contain any other content than defined in XBRL Dimensions specification: %(contextIds)s"),
-                modelObject=contextsWithDisallowedOCEcontent, contextIds=", ".join(c.id for c in contextsWithDisallowedOCEcontent))
+                modelObject=contextsWithDisallowedOCEcontent, contextIds=", ".join(c.id for c in contextsWithDisallowedOCEcontent if c.id is not None))
         if len(contextIdentifiers) > 1:
             modelXbrl.error("ESEF.2.1.4.multipleIdentifiers",
                 _("All entity identifiers in contexts MUST have identical content: %(contextIds)s"),
@@ -598,31 +663,26 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
             modelXbrl.error("ESEF.2.1.2.periodWithTimeZone",
                 _("The xbrli:startDate, xbrli:endDate and xbrli:instant elements MUST identify periods using whole days (i.e. specified without a time zone): %(contextIds)s"),
                 modelObject=contextsWithPeriodTimeZone, contextIds=", ".join(c.id for c in contextsWithPeriodTimeZone if c.id))
+        if contextsWithWrongInstantDate:
+            for context in contextsWithWrongInstantDate:
+                modelXbrl.error("ESEF.2.1.2.inappropriateInstantDate",
+                                _("Instant date %(actualValue)s in context %(contextID)s shall be replaced by %(expectedValue)s to ensure a better comparability between the facts."),
+                                modelObject=context, actualValue=context.instantDate, expectedValue=context.instantDate - timedelta(days=1), contextID=context.id)
 
         # identify unique contexts and units
         mapContext = {}
         mapUnit = {}
-        uniqueContextHashes: dict[Any, Any] = {}
-        for context in modelXbrl.contexts.values():
-            h = context.contextDimAwareHash
-            if h in uniqueContextHashes:
-                if context.isEqualTo(uniqueContextHashes[h]):
-                    mapContext[context] = uniqueContextHashes[h]
-            else:
-                uniqueContextHashes[h] = context
-        del uniqueContextHashes
-        uniqueUnitHashes: dict[Any, Any] = {}
+        for exemplar_context, *contexts in partitionModelXbrlContexts(modelXbrl).values():
+            for context in contexts:
+                mapContext[context] = exemplar_context
         utrValidator = ValidateUtr(modelXbrl)
         utrUnitIds = set(u.unitId
                          for unitItemType in utrValidator.utrItemTypeEntries.values()
                          for u in unitItemType.values())
+        for exemplar_unit, *units in partitionModelXbrlUnits(modelXbrl).values():
+            for unit in units:
+                mapUnit[unit] = exemplar_unit
         for unit in modelXbrl.units.values():
-            h = unit.hash
-            if h in uniqueUnitHashes:
-                if unit.isEqualTo(uniqueUnitHashes[h]):
-                    mapUnit[unit] = uniqueUnitHashes[h]
-            else:
-                uniqueUnitHashes[h] = unit
             # check if any custom measure is in UTR
             for measureTerm in unit.measures:
                 for measure in measureTerm:
@@ -632,7 +692,6 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                             modelXbrl.warning("ESEF.RTS.III.1.G1-7-1.customUnitInUtr",
                                 _("Custom measure SHOULD NOT duplicate a UnitID of UTR: %(measure)s"),
                                 modelObject=unit, measure=measure)
-        del uniqueUnitHashes
 
         reportedMandatory: set[QName] = set()
         precisionFacts = set()
@@ -640,22 +699,39 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
         textFactsByConceptContext = defaultdict(list)
         footnotesRelationshipSet = modelXbrl.relationshipSet(XbrlConst.factFootnote, XbrlConst.defaultLinkRole)
         noLangFacts = []
-        textFactsMissingReportLang: list[Any] = []
         conceptsUsed = set()
         langsUsedByTextFacts = set()
 
-        hasNoFacts = True
+        factsMissingId = []
         for qn, facts in modelXbrl.factsByQname.items():
-            hasNoFacts = False
             if qn in mandatory:
                 reportedMandatory.add(qn)
             for f in facts:
+                if esefDisclosureSystemYear >= 2024:
+                    if not f.id:
+                        factsMissingId.append(f)
+                    if isinstance(f, ModelInlineFact) and f.concept is not None and esefDisclosureSystemYear >= 2024:
+                        if esefDisclosureSystemYear == 2024:
+                            hasEscapeIssue = f.isEscaped != f.concept.isTextBlock
+                        elif esefDisclosureSystemYear >= 2025:
+                            hasEscapeIssue = not f.isEscaped and (
+                                f.concept.isTextBlock or
+                                (f.value and escapeWorthyStr.match(f.value)))
+                        if hasEscapeIssue:
+                            modelXbrl.error("ESEF.2.2.7.improperApplicationOfEscapeAttribute",
+                                              _("Facts with datatype 'dtr-types:textBlockItemType' MUST use the 'escape' attribute set to 'true'. Facts with any other datatype MUST use the 'escape' attribute set to 'false' - fact %(conceptName)s"),
+                                              modelObject=f, conceptName=f.concept.qname)
+                    if f.effectiveValue in ["0", "-0"] and f.xValue != 0:
+                        modelXbrl.warning("ESEF.2.2.5.roundedValueBelowScaleNotNull",
+                                          _("A value that has been rounded and is below the scale should show a value of zero. It has been found to have the value %(value)s - fact %(conceptName)s"),
+                                          modelObject=f, value=f.value, conceptName=getattr(f.concept, "qname", ""))
                 if f.precision is not None:
                     precisionFacts.add(f)
                 if f.isNumeric and f.concept is not None and getattr(f, "xValid", 0) >= VALID:
                     numFactsByConceptContextUnit[(f.qname, mapContext.get(f.context,f.context), mapUnit.get(f.unit, f.unit))].append(f)
                     if not f.isNil and cast(int, f.xValue) > 1 and f.concept.type is not None and (
-                        f.concept.type.qname == PERCENT_TYPE or f.concept.type.isDerivedFrom(PERCENT_TYPE)):
+                        f.concept.type.qname in PERCENT_TYPES
+                        or any(f.concept.type.isDerivedFrom(percentType) for percentType in PERCENT_TYPES)):
                         modelXbrl.warning("ESEF.2.2.2.percentGreaterThan100",
                             _("A percent fact should have value <= 100: %(element)s in context %(context)s value %(value)s"),
                             modelObject=f, element=f.qname, context=f.context.id, value=f.xValue)
@@ -679,7 +755,22 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                         #elif dim.isTyped:
                         #    conceptsUsed.add(dim.typedMember)
                 '''
+        # identify report date
+        reportDate = None
+        for f in modelXbrl.factsByLocalName.get("DateOfEndOfReportingPeriod2013", ()):
+            if getattr(f, "xValid", 0) >= VALID:
+                reportDate = f.xValue
+                break
+        if not reportDate: # no report period, take name's end context
+            for f in modelXbrl.factsByLocalName.get("NameOfReportingEntityOrOtherMeansOfIdentification", ()):
+                if getattr(f, "xValid", 0) >= VALID:
+                    reportDate = f.context.endDate
+                    break
 
+        if esefDisclosureSystemYear >= 2024 and factsMissingId:
+            modelXbrl.warning("ESEF.2.2.8.missingFactID",
+                              _("All facts should have a unique identifier. Facts %(elements)s have no identifier."),
+                              modelObject=f, elements=", ".join([str(f.qname) for f in factsMissingId]), )
         if noLangFacts:
             modelXbrl.error("ESEF.2.5.2.undefinedLanguageForTextFact",
                 _("Each tagged text fact MUST have the 'xml:lang' attribute assigned or inherited."),
@@ -744,8 +835,8 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
 
         if transformRegistryErrors:
             modelXbrl.error("ESEF.2.2.3.incorrectTransformationRuleApplied",
-                              _("ESMA recommends applying the Transformation Rules Registry 4, as published by XBRL International or any more recent versions of the Transformation Rules Registry provided with a 'Recommendation' status, for these elements: %(elements)s."),
-                              modelObject=transformRegistryErrors,
+                              _("ESMA recommends applying the Transformation Rules Registry %(earliestTrNum)s, as published by XBRL International or any more recent versions of the Transformation Rules Registry provided with a 'Recommendation' status, for these elements: %(elements)s."),
+                              modelObject=transformRegistryErrors, earliestTrNum=earliestTRVersion,
                               elements=", ".join(sorted(str(fact.qname) for fact in transformRegistryErrors)))
 
         if orphanedFootnotes:
@@ -780,12 +871,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 _("The xlink:role attribute of a link:footnote and link:footnoteLink element as well as xlink:arcrole attribute of a link:footnoteArc MUST be defined in the XBRL Specification 2.1."),
                 modelObject=footnoteRoleErrors)
 
-        nonStdFootnoteElts = list()
+        nonStdFootnoteElts: list[_Element] = list()
         for modelLink in modelXbrl.baseSets[("XBRL-footnotes",None,None,None)]:
             for uncast_elt in modelLink.iterchildren():
                 elt = cast(Any, uncast_elt)
 
-                if isinstance(elt, (_ElementTree, _Comment, _ProcessingInstruction)):
+                if isinstance(elt, (_Comment, _ElementTree, _Entity, _ProcessingInstruction)):
                     continue # comment or other non-parsed element
                 if elt.qname not in FOOTNOTE_LINK_CHILDREN:
                     nonStdFootnoteElts.append(elt)
@@ -801,7 +892,12 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
 
         # 3.1.1 test
         hasOutdatedUrl = False
-        for e in val.authParam["outdatedTaxonomyURLs"]:
+        outdatedTaxonomyURLs = val.authParam["outdatedTaxonomyURLs"].copy()
+        if reportDate:
+            for expiringTaxonomyURLs in val.authParam.get("expiringTaxonomyURLs", ()):
+                if expiringTaxonomyURLs["lastReportableDate"] < str(reportDate):
+                    outdatedTaxonomyURLs.update(expiringTaxonomyURLs["URLs"])
+        for e in outdatedTaxonomyURLs:
             if e in val.extensionImportedUrls:
                 val.modelXbrl.error("ESEF.3.1.2.incorrectEsefTaxonomyVersionUsed",
                      _("The issuer's extension taxonomies MUST import the applicable version of the taxonomy files prepared by ESMA. Outdated entry point: %(url)s"),
@@ -817,17 +913,17 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
 
         if not hasOutdatedUrl and not any(e in val.extensionImportedUrls for e in val.authParam["effectiveTaxonomyURLs"]):
             val.modelXbrl.error(
-                "UKFRC22.1.requiredUksefEntryPointNotImported" if val.authority == "UKFRC" else
+                "UKFRC22.1.requiredUksefEntryPointNotImported" if val.authority and val.authority.startswith("UKFRC") else
                 "ESEF.3.1.2.requiredEntryPointNotImported",
                 _("The issuer's extension taxonomies MUST import the entry point of the taxonomy files prepared by %(authority)s."),
                 modelObject=modelDocument, authority=val.authParam["authorityName"])
 
 
         # unused elements in linkbases
-        unreportedLbElts = set()
+        unreportedLbLocs = set()
         for arcroles, error, checkRoots, lbType in (
                     ((parentChild,), "elements{}UsedForTagging{}AppliedInPresentationLinkbase", True, "presentation"),
-                    ((summationItem,), "elements{}UsedForTagging{}AppliedInCalculationLinkbase", False, "calculation"),
+                    ((summationItems,), "elements{}UsedForTagging{}AppliedInCalculationLinkbase", False, "calculation"),
                     ((hc_all, hc_notAll, dimensionDomain,domainMember), "elements{}UsedForTagging{}AppliedInDefinitionLinkbase", False, "definition")):
             if lbType == "calculation":
                 reportedEltsNotInLb = set(c for c in conceptsUsedByFacts if c.isNumeric)
@@ -837,17 +933,33 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                 for rel in modelXbrl.relationshipSet(arcrole).modelRelationships:
                     fr = rel.fromModelObject
                     to = rel.toModelObject
-                    if arcrole in (parentChild, summationItem):
+                    if arcrole in (parentChild, summationItems):
                         if fr is not None and not fr.isAbstract and fr not in conceptsUsed and isExtension(val, rel):
-                            unreportedLbElts.add(fr)
+                            unreportedLbLocs.add(rel.fromLocator)
                         if to is not None and not to.isAbstract and to not in conceptsUsed and isExtension(val, rel):
-                            unreportedLbElts.add(to)
+                            unreportedLbLocs.add(rel.toLocator)
                     elif arcrole in (hc_all, domainMember, dimensionDomain):
                         # all primary items
-                        if fr is not None and not fr.isAbstract and rel.isUsable and fr not in conceptsUsed and isExtension(val, rel) and not fr.type.isDomainItemType:
-                            unreportedLbElts.add(to)
-                        if to is not None and not to.isAbstract and rel.isUsable and to not in conceptsUsed and isExtension(val, rel) and not to.type.isDomainItemType:
-                            unreportedLbElts.add(to)
+                        if (
+                            fr is not None
+                            and fr.type is not None
+                            and not fr.isAbstract
+                            and rel.isUsable
+                            and fr not in conceptsUsed
+                            and isExtension(val, rel)
+                            and not fr.type.isDomainItemType
+                        ):
+                            unreportedLbLocs.add(rel.fromLocator)
+                        if (
+                            to is not None
+                            and to.type is not None
+                            and not to.isAbstract
+                            and rel.isUsable
+                            and to not in conceptsUsed
+                            and isExtension(val, rel)
+                            and not to.type.isDomainItemType
+                        ):
+                            unreportedLbLocs.add(rel.toLocator)
                     reportedEltsNotInLb.discard(fr)
                     reportedEltsNotInLb.discard(to)
 
@@ -862,11 +974,11 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
             if reportedEltsNotInLb and lbType != "calculation":
                 modelXbrl.warning(f"ESEF.3.4.6.UsableConceptsNotIncludedIn{lbType.title()}Link",
                     _("All concepts used by tagged facts SHOULD be in extension taxonomy %(linkbaseType)s relationships: %(elements)s."),
-                    modelObject=reportedEltsNotInLb, elements=", ".join(sorted((str(c.qname) for c in reportedEltsNotInLb))), linkbaseType=lbType)
-        if unreportedLbElts:
+                    modelObject=reportedEltsNotInLb, elements=", ".join(sorted(str(c.qname) for c in reportedEltsNotInLb)), linkbaseType=lbType)
+        if unreportedLbLocs:
             modelXbrl.warning("ESEF.3.4.6.UsableConceptsNotAppliedByTaggedFacts",
                 _("All usable concepts in extension taxonomy relationships SHOULD be applied by tagged facts: %(elements)s."),
-                modelObject=unreportedLbElts, elements=", ".join(sorted((str(c.qname) for c in unreportedLbElts))))
+                modelObject=unreportedLbLocs, elements=", ".join(sorted(str(loc.dereference().qname) for loc in unreportedLbLocs)))
 
         anchoringToAbstractConcept = set()
         for rel in modelXbrl.relationshipSet(widerNarrower).modelRelationships:
@@ -1052,11 +1164,26 @@ def validateXbrlFinally(val: ValidateXbrl, *args: Any, **kwargs: Any) -> None:
                         _("Extension elements must not duplicate the existing elements from the core taxonomy and be identifiable %(qname)s."),
                         modelObject=(c,_i), qname=c.qname)
 
+        extensionTaxonomyDirectoryPrefix = val.authParam["reportPackageExtensionTaxonomyDirectoryPrefix"]
+        if extensionTaxonomyDirectoryPrefix is not None and val.modelXbrl.fileSource.dir is not None:
+            for filepath in val.modelXbrl.fileSource.dir:
+                filepath_parts = filepath.split('/')
+                if filepath_parts[1] in ['META-INF', 'reports']:
+                    continue
+                if not filepath_parts[1].startswith(extensionTaxonomyDirectoryPrefix):
+                    modelXbrl.error(
+                        'arelle.ESEF.reportPackageExtensionTaxonomyDirectoryPrefix',
+                        _('The XBRL linkbase files must live within the report package under a directory that starts '
+                          'with `{}`').format(extensionTaxonomyDirectoryPrefix),
+                        modelObject=val.modelXbrl
+                    )
+                    break
+
     modelXbrl.profileActivity(_statusMsg, minTimeToShow=0.0)
     modelXbrl.modelManager.showStatus(None)
 
 
-def validateCssUrl(cssContent:str, normalizedUri:str, modelXbrl: ModelXbrl, val: ValidateXbrl, elt: ModelObject, contentOtherThanXHTMLGuidance: str) -> None:
+def validateCssUrl(cssContent:str, normalizedUri:str, modelXbrl: ModelXbrl, val: ValidateXbrl, elt: ModelObject, params: ImageValidationParameters) -> None:
     css_elements = tinycss2.parse_stylesheet(cssContent)
     for css_element in css_elements:
         if isinstance(css_element, tinycss2.ast.AtRule):
@@ -1064,18 +1191,30 @@ def validateCssUrl(cssContent:str, normalizedUri:str, modelXbrl: ModelXbrl, val:
                 for css_rule in css_element.content:
                     if isinstance(css_rule, tinycss2.ast.URLToken) and "data:font" not in css_rule.value:
                         modelXbrl.warning(
-                            "ESEF.%s.fontIncludedAndNotEmbeddedAsBase64EncodedString" % contentOtherThanXHTMLGuidance,
+                            "ESEF.%s.fontIncludedAndNotEmbeddedAsBase64EncodedString" % params.contentOtherThanXHTMLGuidance,
                             _("Fonts SHOULD be included in the XHTML document as a base64 encoded string: %(file)s."),
                             modelObject=elt, file=css_rule.value)
         if isinstance(css_element, tinycss2.ast.QualifiedRule):
-            validateCssUrlContent(css_element.content, normalizedUri, modelXbrl, val, elt, contentOtherThanXHTMLGuidance)
-
-
-def validateCssUrlContent(cssRules: List[Any], normalizedUri:str, modelXbrl: ModelXbrl, val: ValidateXbrl, elt: ModelObject, contentOtherThanXHTMLGuidance: str) -> None:
+            validateCssUrlContent(css_element.content, normalizedUri, modelXbrl, val, elt, params, css_element.prelude)
+
+
+def validateCssUrlContent(
+        cssRules: list[Any],
+        normalizedUri:str,
+        modelXbrl: ModelXbrl,
+        val: ValidateXbrl,
+        elt: ModelObject,
+        params: ImageValidationParameters,
+        prelude: list[Any] | None = None,
+) -> None:
     for css_rule in cssRules:
         if isinstance(css_rule, tinycss2.ast.FunctionBlock):
             if css_rule.lower_name == "url":
                 if len(css_rule.arguments):
                     css_rule_url = css_rule.arguments[0].value  # url or base64
                     evaluatedMsg = _('On line {line}').format(line=1) #css_element.source_line)
-                    validateImage(normalizedUri, css_rule_url, modelXbrl, val, elt, evaluatedMsg, contentOtherThanXHTMLGuidance)
+                    validateImageAndLog(normalizedUri, css_rule_url, modelXbrl, val, elt, evaluatedMsg, params, prelude)
+        elif isinstance(css_rule, tinycss2.ast.URLToken):
+            value = css_rule.value
+            evaluatedMsg = _('On line {line}').format(line=1) #css_element.source_line)
+            validateImageAndLog(normalizedUri, value, modelXbrl, val, elt, evaluatedMsg, params, prelude)