From 1ce6c08ecca2bfc7ce6ffdda46c677a3f259c5ec Mon Sep 17 00:00:00 2001 From: Hannes Stiebitzhofer Date: Tue, 6 Oct 2026 11:02:15 +0200 Subject: [PATCH 1/2] feat(EN10168): generate the v0.5.0 qr-code symbol at render time (#346) Mirror of material-identity/schema#447. EN10168 v0.5.0 has carried `qr-code` in KeyValueObject.Type since the url/phone/email/image types were added (2ab1e35), but nothing generated a symbol: the stylesheet drew whatever image the value held, and the product's supplementary information never passed Type to KeyValue, so a url there printed as text and a qr-code as its raw value. The rule now, in v0.5.0 in place (no schema change): the value is the text the symbol encodes (typically a URL) and the renderer generates the symbol. A value that is already a data: image URI keeps rendering as that image. - QrSymbol (zxing core 3.5.3; SVG path data, ISO/IEC 18004 quiet zone, EC level M) is the same encoder as schema's :shared. - QrCodeValues replaces every encodable qr-code value with the symbol's SVG data URI on a copy of the certificate before the XSLT runs, in both the service (SchemasServiceImpl.renderPdf) and json2pdf (CommandLineApp); the attached JSON stays the certificate as issued. - The EN10168 v0.5.0 stylesheet is byte-identical to schema's legacy copy again: the B-section passes Type to KeyValue (schema#370) and the qr-code branch's comment states the semantics. - Fixture valid_certificate_11 (url + qr-code pair in B20/B21) with its reference PDF; tests round-trip the symbol, pin the substitution rules and gate the generated FO. RenderTest's attachment check covers the as-issued JSON. Co-Authored-By: Claude Fable 5.1 --- pom.xml | 7 + schemas/EN10168/v0.5.0/stylesheet.xsl | 4 +- .../schemaservice/CommandLineApp.java | 4 +- .../schemaservice/QrCodeValues.java | 69 ++++ .../schemaservice/QrSymbol.java | 164 ++++++++ .../service/SchemasServiceImpl.java | 5 +- .../schemaservice/QrCodeValuesTest.java | 119 ++++++ .../schemaservice/QrSymbolTest.java | 126 ++++++ .../EN10168/v0.5.0/valid_certificate_11.json | 369 ++++++++++++++++++ .../EN10168/v0.5.0/valid_certificate_11.pdf | Bin 0 -> 72652 bytes 10 files changed, 864 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/materialidentity/schemaservice/QrCodeValues.java create mode 100644 src/main/java/com/materialidentity/schemaservice/QrSymbol.java create mode 100644 src/test/java/com/materialidentity/schemaservice/QrCodeValuesTest.java create mode 100644 src/test/java/com/materialidentity/schemaservice/QrSymbolTest.java create mode 100644 test/fixtures/EN10168/v0.5.0/valid_certificate_11.json create mode 100644 test/fixtures/EN10168/v0.5.0/valid_certificate_11.pdf diff --git a/pom.xml b/pom.xml index c1829e83..a5927a59 100644 --- a/pom.xml +++ b/pom.xml @@ -134,6 +134,13 @@ + + + com.google.zxing + core + 3.5.3 + com.networknt json-schema-validator diff --git a/schemas/EN10168/v0.5.0/stylesheet.xsl b/schemas/EN10168/v0.5.0/stylesheet.xsl index ef38c34e..0c78efd6 100644 --- a/schemas/EN10168/v0.5.0/stylesheet.xsl +++ b/schemas/EN10168/v0.5.0/stylesheet.xsl @@ -1588,7 +1588,9 @@ - + diff --git a/src/main/java/com/materialidentity/schemaservice/CommandLineApp.java b/src/main/java/com/materialidentity/schemaservice/CommandLineApp.java index 190a5491..c69f10f5 100644 --- a/src/main/java/com/materialidentity/schemaservice/CommandLineApp.java +++ b/src/main/java/com/materialidentity/schemaservice/CommandLineApp.java @@ -202,8 +202,10 @@ private static void convertJsonToPdf(String inputFile, String outputFile, String } // Build PDF using the command-line builder pattern (with font loading fixes) + // The stylesheet renders a copy with every qr-code symbol generated (#346); the attached + // jsonContent is the certificate as issued. CommandLinePDFBuilder pdfBuilder = new CommandLinePDFBuilder() - .withXsltTransformer(new XsltTransformer(xsltSource, certificate, baseUri)) + .withXsltTransformer(new XsltTransformer(xsltSource, QrCodeValues.embedSymbols(certificate), baseUri)) .withTranslations(new TranslationLoader(translationsPattern, languages)) .withAttachment(new AttachmentManager(jsonContent, Paths.get(outputFile).getFileName().toString().replace(".pdf", ""), diff --git a/src/main/java/com/materialidentity/schemaservice/QrCodeValues.java b/src/main/java/com/materialidentity/schemaservice/QrCodeValues.java new file mode 100644 index 00000000..2dfefe01 --- /dev/null +++ b/src/main/java/com/materialidentity/schemaservice/QrCodeValues.java @@ -0,0 +1,69 @@ +// SPDX-License-Identifier: Apache-2.0 +package com.materialidentity.schemaservice; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; + +/** + * Generates the symbol of every {@code qr-code} key-value entry before the stylesheet runs (#346, mirrors schema#447). + * + *

EN10168 v0.5.0's {@code KeyValueObject.Type} has carried {@code qr-code} since the {@code url}, + * {@code phone}, {@code email} and {@code image} types were added, but nothing ever generated a + * symbol: the stylesheet drew whatever image the value happened to hold, so a certificate had to + * ship a hand-made picture next to the URL it showed. The rule now: the value is the text the + * symbol encodes (typically a URL) and the renderer generates the symbol. A value that is + * already a {@code data:} image URI keeps rendering as that image, so certificates issued under + * the earlier reading render exactly as before. + * + *

Done on the JSON rather than in XSLT because Saxon-HE has no QR encoder and the + * transformer factory registers no extension functions. The symbol arrives as an SVG {@code data:} URI, which + * the stylesheet's existing {@code fo:external-graphic} branch draws and the sandboxed FOP resolver + * admits without a fetch. Only the stylesheet sees the substituted document: the JSON attached to + * the PDF stays the certificate as issued. + */ +public final class QrCodeValues { + + /** The {@code Type} whose value is encoded. */ + static final String TYPE = "qr-code"; + + private QrCodeValues() { + } + + /** + * A copy of the certificate in which every encodable {@code qr-code} value is replaced by the + * SVG data URI of its symbol. The given node is not modified. + */ + public static JsonNode embedSymbols(JsonNode certificate) { + JsonNode copy = certificate.deepCopy(); + embedInto(copy); + return copy; + } + + private static void embedInto(JsonNode node) { + if (node.isObject()) { + // Children first: a Value is text, never an object, so nothing substituted is revisited. + node.forEach(QrCodeValues::embedInto); + ObjectNode object = (ObjectNode) node; + if (encodes(object)) { + object.put("Value", QrSymbol.of(object.get("Value").asText()).toSvgDataUri()); + } + } else if (node.isArray()) { + node.forEach(QrCodeValues::embedInto); + } + } + + /** A {@code qr-code} entry whose value is text to encode rather than a ready image. */ + static boolean encodes(JsonNode object) { + JsonNode type = object.get("Type"); + JsonNode value = object.get("Value"); + return type != null && TYPE.equals(type.asText()) + && value != null && value.isTextual() + && !value.asText().isBlank() + && !isDataUri(value.asText()); + } + + /** RFC 2397: the scheme is case-insensitive. */ + private static boolean isDataUri(String value) { + return value.regionMatches(true, 0, "data:", 0, 5); + } +} diff --git a/src/main/java/com/materialidentity/schemaservice/QrSymbol.java b/src/main/java/com/materialidentity/schemaservice/QrSymbol.java new file mode 100644 index 00000000..8b5ce3f6 --- /dev/null +++ b/src/main/java/com/materialidentity/schemaservice/QrSymbol.java @@ -0,0 +1,164 @@ +// SPDX-License-Identifier: Apache-2.0 +package com.materialidentity.schemaservice; + +import com.google.zxing.EncodeHintType; +import com.google.zxing.WriterException; +import com.google.zxing.common.BitMatrix; +import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel; +import com.google.zxing.qrcode.encoder.ByteMatrix; +import com.google.zxing.qrcode.encoder.Encoder; +import com.google.zxing.qrcode.encoder.QRCode; + +import java.nio.charset.StandardCharsets; +import java.util.Base64; +import java.util.EnumMap; +import java.util.Map; + +/** + * One QR symbol (ISO/IEC 18004) encoding one string, emitted as SVG path data. + * + *

A copy of {@code QrSymbol} in material-identity/schema's {@code :shared} (schema#447), which the + * DPP data carrier and the legacy EN10168 pipeline there share; here it generates an EN10168 v0.5.0 + * {@code qr-code} key-value entry's symbol from its value (#346). Same encoder, quiet zone and path + * format, so a symbol rendered by either service is the same picture. + * + *

Vector rather than raster: a PNG would have to be either an external reference or a base64 + * blob that bloats every rendered view; path data is smaller, stays sharp when printed, and is the + * same input for an HTML view and an XSL-FO page. + * + *

The quiet zone is not decoration. ISO/IEC 18004 requires four modules of clear margin, and a + * QR printed flush against surrounding content is one many scanners will not read. + * + *

Error-correction level M (~15 %): the data is typically a URL of moderate length, and the + * symbol may end up on a label, a delivery note, or a certificate that has been folded and + * handled. L would be smaller and more fragile than that use deserves. + */ +public record QrSymbol( + String encodedData, + int moduleCount, + String pathData, + boolean[][] modules) { + + /** ISO/IEC 18004 requires a four-module clear margin around the symbol. */ + public static final int QUIET_ZONE = 4; + + private static final String SVG_DATA_URI_PREFIX = "data:image/svg+xml;base64,"; + + /** + * Encode one string. + * + * @throws IllegalArgumentException for a blank string (an empty QR is worse than none: it + * scans, and yields nothing) or one too long for a single symbol + */ + public static QrSymbol of(String data) { + if (data == null || data.isBlank()) { + throw new IllegalArgumentException("A QR symbol encodes a string; none was given"); + } + Map hints = new EnumMap<>(EncodeHintType.class); + hints.put(EncodeHintType.CHARACTER_SET, "UTF-8"); + + QRCode qr; + try { + qr = Encoder.encode(data, ErrorCorrectionLevel.M, hints); + } catch (WriterException e) { + throw new IllegalArgumentException( + "Cannot encode as one QR symbol (" + data.length() + " characters): " + + abbreviate(data), e); + } + + ByteMatrix matrix = qr.getMatrix(); + int size = matrix.getWidth(); + boolean[][] modules = new boolean[size][size]; + for (int y = 0; y < size; y++) { + for (int x = 0; x < size; x++) { + modules[y][x] = matrix.get(x, y) == 1; + } + } + + return new QrSymbol(data, size + 2 * QUIET_ZONE, buildPath(modules, size), modules); + } + + /** + * One SVG path covering every dark module, offset by the quiet zone. + * + *

A single path rather than one {@code } per module: a symbol of this size has several + * hundred dark modules, and the element-per-module form would add tens of kilobytes of markup + * to every rendered view for no visual difference. Horizontal runs are merged into one + * rectangle each, which roughly halves it again. + * + *

Returned as an attribute value, never as markup — so a stylesheet emits the SVG elements + * itself and nothing has to escape past the serializer. + */ + private static String buildPath(boolean[][] modules, int size) { + StringBuilder path = new StringBuilder(); + for (int y = 0; y < size; y++) { + int runStart = -1; + for (int x = 0; x <= size; x++) { + boolean dark = x < size && modules[y][x]; + if (dark && runStart < 0) { + runStart = x; + } else if (!dark && runStart >= 0) { + int width = x - runStart; + path.append('M').append(runStart + QUIET_ZONE).append(' ').append(y + QUIET_ZONE) + .append('h').append(width).append("v1h-").append(width).append('z'); + runStart = -1; + } + } + } + return path.toString(); + } + + /** + * The symbol as a zxing {@link BitMatrix}, without the quiet zone. + * + *

Exists so a test can decode the symbol back and assert it yields the encoded string + * exactly. That round trip is what turns "the symbol encodes the value" from a claim in a + * comment into a verified property. + */ + public BitMatrix toBitMatrix() { + int size = modules.length; + BitMatrix bits = new BitMatrix(size, size); + for (int y = 0; y < size; y++) { + for (int x = 0; x < size; x++) { + if (modules[y][x]) { + bits.set(x, y); + } + } + } + return bits; + } + + /** + * A standalone SVG document: black modules on a white ground, quiet zone included, scaling + * crisply to any size. The encoded string travels in {@code data-encoded} and in the title, so + * a viewer can say what the symbol opens without decoding it. + */ + public String toSvg() { + int n = moduleCount; + String text = escape(encodedData); + return "" + + "" + text + "" + + "" + + "" + + "\n"; + } + + /** + * {@link #toSvg()} as a {@code data:} URI, so a stylesheet's {@code fo:external-graphic} can draw + * the symbol with no resource fetch at all. + */ + public String toSvgDataUri() { + return SVG_DATA_URI_PREFIX + + Base64.getEncoder().encodeToString(toSvg().getBytes(StandardCharsets.UTF_8)); + } + + private static String escape(String s) { + return s.replace("&", "&").replace("<", "<").replace(">", ">").replace("\"", """); + } + + private static String abbreviate(String s) { + return s.length() <= 80 ? s : s.substring(0, 77) + "..."; + } +} diff --git a/src/main/java/com/materialidentity/schemaservice/service/SchemasServiceImpl.java b/src/main/java/com/materialidentity/schemaservice/service/SchemasServiceImpl.java index 2d484c14..007b9407 100644 --- a/src/main/java/com/materialidentity/schemaservice/service/SchemasServiceImpl.java +++ b/src/main/java/com/materialidentity/schemaservice/service/SchemasServiceImpl.java @@ -35,6 +35,7 @@ import com.materialidentity.schemaservice.PDFBuilder; import com.materialidentity.schemaservice.TranslationLoader; import com.materialidentity.schemaservice.WatermarkManager; +import com.materialidentity.schemaservice.QrCodeValues; import com.materialidentity.schemaservice.XsltTransformer; import com.materialidentity.schemaservice.config.SchemaControllerConstants; import com.materialidentity.schemaservice.config.SchemasAndVersions; @@ -206,8 +207,10 @@ public ResponseEntity renderPdf(Boolean attachJson, JsonNode certificate // Derive classpath root URI so json-doc() can resolve relative paths String baseUri = deriveClasspathRootUri(xsltResource, xsltPath); + // The stylesheet renders a copy with every qr-code symbol generated (#346); the JSON attached + // below (certificateJson) is the certificate as issued. PDFBuilder pdfBuilder = new PDFBuilder() - .withXsltTransformer(new XsltTransformer(xsltSource, certificate, baseUri)) + .withXsltTransformer(new XsltTransformer(xsltSource, QrCodeValues.embedSymbols(certificate), baseUri)) .withTranslations(new TranslationLoader(translationsPattern, languages)) .withAttachment( new AttachmentManager(certificateJson, diff --git a/src/test/java/com/materialidentity/schemaservice/QrCodeValuesTest.java b/src/test/java/com/materialidentity/schemaservice/QrCodeValuesTest.java new file mode 100644 index 00000000..42ae94c8 --- /dev/null +++ b/src/test/java/com/materialidentity/schemaservice/QrCodeValuesTest.java @@ -0,0 +1,119 @@ +package com.materialidentity.schemaservice; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Base64; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +/** + * EN10168 v0.5.0 {@code qr-code} entries get their symbol generated at render time (#346, mirrors + * material-identity/schema#447): the value is the text the symbol encodes, a ready {@code data:} + * image is left alone, and the given certificate is never modified. Asserted on the JSON + * substitution and on the generated XSL-FO — {@link RenderTest} compares extracted text only, and + * a symbol has none; it does assert that the JSON attached to the PDF is the fixture as issued. + */ +class QrCodeValuesTest { + + private static final ObjectMapper MAPPER = new ObjectMapper(); + private static final Path FIXTURE = Paths.get("test", "fixtures", "EN10168", "v0.5.0", "valid_certificate_11.json"); + private static final Path STYLESHEET = Paths.get("schemas", "EN10168", "v0.5.0", "stylesheet.xsl"); + private static final String URL = "https://dpp.example.org/dpp/steelmill/1607219-0001"; + private static final String PNG = "data:image/png;base64,iVBORw0KGgo="; + + private static ObjectNode entry(String type, String value) { + ObjectNode entry = MAPPER.createObjectNode(); + entry.put("Key", "Digital Product Passport"); + if (value != null) entry.put("Value", value); + entry.put("Type", type); + return entry; + } + + private static String svgOf(String dataUri) { + assertTrue(dataUri.startsWith("data:image/svg+xml;base64,"), dataUri.substring(0, Math.min(40, dataUri.length()))); + return new String(Base64.getDecoder().decode(dataUri.substring(dataUri.indexOf(',') + 1)), StandardCharsets.UTF_8); + } + + @Test + @DisplayName("A qr-code value is replaced by the SVG data URI of the symbol encoding it") + void urlBecomesTheSymbol() { + JsonNode out = QrCodeValues.embedSymbols(entry("qr-code", URL)); + assertEquals(QrSymbol.of(URL).toSvg(), svgOf(out.get("Value").asText())); + assertEquals("qr-code", out.get("Type").asText()); + assertEquals("Digital Product Passport", out.get("Key").asText()); + } + + @Test + @DisplayName("A ready data: image keeps rendering as that image — certificates issued earlier do not change") + void readyImageIsLeftAlone() { + assertEquals(PNG, QrCodeValues.embedSymbols(entry("qr-code", PNG)).get("Value").asText()); + String upper = "DATA:image/png;base64,iVBORw0KGgo="; + assertEquals(upper, QrCodeValues.embedSymbols(entry("qr-code", upper)).get("Value").asText()); + } + + @Test + @DisplayName("Every other type, a blank value and a missing value are untouched") + void onlyEncodableQrCodeEntriesChange() { + for (String type : new String[] {"url", "string", "image"}) { + assertEquals(URL, QrCodeValues.embedSymbols(entry(type, URL)).get("Value").asText(), type); + } + assertEquals(" ", QrCodeValues.embedSymbols(entry("qr-code", " ")).get("Value").asText()); + assertFalse(QrCodeValues.embedSymbols(entry("qr-code", null)).has("Value")); + } + + @Test + @DisplayName("Entries are found anywhere in the certificate, and the given node is not modified") + void walksTheWholeCertificateWithoutMutatingIt() throws Exception { + JsonNode cert = MAPPER.readTree(FIXTURE.toFile()); + ((ObjectNode) cert.at("/Certificate/Validation/SupplementaryInformation")) + .set("Z10", entry("qr-code", URL)); + String before = cert.toString(); + + JsonNode out = QrCodeValues.embedSymbols(cert); + + assertEquals(before, cert.toString(), "the certificate handed in must stay as issued"); + assertEquals(URL, out.at("/Certificate/ProductDescription/SupplementaryInformation/B20/Value").asText()); + for (String pointer : new String[] { + "/Certificate/ProductDescription/SupplementaryInformation/B21/Value", + "/Certificate/Validation/SupplementaryInformation/Z10/Value"}) { + assertEquals(QrSymbol.of(URL).toSvg(), svgOf(out.at(pointer).asText()), pointer); + } + } + + @Test + @DisplayName("The B-section reaches the stylesheet's qr-code branch: B20 links, B21 draws the symbol") + void foDrawsTheSymbolNextToTheLink() throws Exception { + String fo = renderFo(FIXTURE); + assertTrue(fo.contains(""), "B20 should be a link"); + Matcher graphic = Pattern.compile( + "]*src=\"(data:image/svg\\+xml;base64,[^\"]*)\"[^>]*/>").matcher(fo); + assertTrue(graphic.find(), "B21 should be drawn from an SVG data URI"); + assertEquals(QrSymbol.of(URL).toSvg(), svgOf(graphic.group(1))); + // The URL is printed once, as B20's link text; B21 carries it only inside the symbol. + assertEquals(1, Pattern.compile(Pattern.quote(">" + URL + "<")).matcher(fo).results().count()); + assertTrue(fo.contains("B21 "), "the B21 key row is still printed"); + } + + /** The certificate's XSL-FO as the service hands it to FOP, with the working-tree stylesheet. */ + static String renderFo(Path fixture) throws Exception { + JsonNode cert = MAPPER.readTree(fixture.toFile()); + JsonNode rendered = QrCodeValues.embedSymbols(cert); + String[] languages = MAPPER.convertValue(cert.at("/Certificate/CertificateLanguages"), String[].class); + String translationsPattern = Paths.get("schemas", "EN10168", "v0.5.0", "translation*.json").toString(); + ((ObjectNode) rendered).set("Translations", new TranslationLoader(translationsPattern, languages).load()); + + String source = Files.readString(STYLESHEET, StandardCharsets.UTF_8); + return new XsltTransformer(source, rendered, Paths.get("").toUri().toString()).transform(); + } +} diff --git a/src/test/java/com/materialidentity/schemaservice/QrSymbolTest.java b/src/test/java/com/materialidentity/schemaservice/QrSymbolTest.java new file mode 100644 index 00000000..71ce6e0c --- /dev/null +++ b/src/test/java/com/materialidentity/schemaservice/QrSymbolTest.java @@ -0,0 +1,126 @@ +// SPDX-License-Identifier: Apache-2.0 +package com.materialidentity.schemaservice; + +import com.google.zxing.common.BitMatrix; +import com.google.zxing.qrcode.decoder.Decoder; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.nio.charset.StandardCharsets; +import java.util.Base64; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * The shared QR encoder, verified by decoding its output back — asserting that the encoder was + * called with the right string would only test that the code says what it says. + */ +class QrSymbolTest { + + private static final String URL = "https://dpp.s1seven.com/dpp/sms/H26-204517"; + + /** The modules an SVG's {@code M x yhWv1h-Wz} runs paint, without the quiet zone. */ + static BitMatrix modulesOf(String svg) { + int size = Integer.parseInt(match(svg, "data-modules=\"(\\d+)\"")); + String d = match(svg, " d=\"([^\"]*)\""); + BitMatrix bits = new BitMatrix(size, size); + Matcher run = Pattern.compile("M(\\d+) (\\d+)h(\\d+)v1h-\\d+z").matcher(d); + while (run.find()) { + int x = Integer.parseInt(run.group(1)) - QrSymbol.QUIET_ZONE; + int y = Integer.parseInt(run.group(2)) - QrSymbol.QUIET_ZONE; + for (int i = 0; i < Integer.parseInt(run.group(3)); i++) { + bits.set(x + i, y); + } + } + return bits; + } + + private static String match(String s, String regex) { + Matcher m = Pattern.compile(regex).matcher(s); + assertTrue(m.find(), "no " + regex); + return m.group(1); + } + + @ParameterizedTest(name = "{0}") + @ValueSource(strings = { + "https://dpp.s1seven.com/dpp/sms/H26-204517", + "https://id.s1seven.com/01/09506000134352/10/H24-118273", + "urn:epc:id:sgtin:4012345.000009.SN0001", + "0088:4012345000009", + "Chargen-Nr. 1607219/0001 — Prüfbescheinigung" + }) + @DisplayName("The matrix decodes back to exactly the encoded string") + void matrixRoundTrips(String data) throws Exception { + assertEquals(data, new Decoder().decode(QrSymbol.of(data).toBitMatrix()).getText()); + } + + @Test + @DisplayName("The SVG's own path data decodes back to the encoded string") + void svgRoundTrips() throws Exception { + String svg = QrSymbol.of(URL).toSvg(); + assertEquals(URL, new Decoder().decode(modulesOf(svg)).getText()); + assertTrue(svg.contains("" + URL + "")); + } + + @Test + @DisplayName("The data URI is the SVG, base64-encoded") + void dataUriIsTheSvg() { + QrSymbol symbol = QrSymbol.of(URL); + String uri = symbol.toSvgDataUri(); + assertTrue(uri.startsWith("data:image/svg+xml;base64,"), uri.substring(0, 40)); + String decoded = new String(Base64.getDecoder().decode(uri.substring(uri.indexOf(',') + 1)), + StandardCharsets.UTF_8); + assertEquals(symbol.toSvg(), decoded); + } + + @Test + @DisplayName("Markup in the encoded string is escaped in the attributes and the title") + void escapesMarkup() { + String svg = QrSymbol.of("a\"&c").toSvg(); + assertTrue(svg.contains("data-encoded=\"a"<b>&c\"")); + assertTrue(svg.contains("a"<b>&c")); + } + + @Test + @DisplayName("The symbol carries the ISO/IEC 18004 four-module quiet zone") + void quietZoneIsPresent() { + QrSymbol symbol = QrSymbol.of(URL); + assertEquals(4, QrSymbol.QUIET_ZONE); + assertEquals(symbol.modules().length + 2 * QrSymbol.QUIET_ZONE, symbol.moduleCount()); + assertTrue(symbol.pathData().startsWith("M" + QrSymbol.QUIET_ZONE + " " + QrSymbol.QUIET_ZONE), + "the finder pattern's first dark run starts one quiet zone in: " + symbol.pathData()); + } + + @Test + @DisplayName("Path data is emitted as an attribute value, never as markup") + void pathDataIsAttributeSafe() { + String path = QrSymbol.of(URL).pathData(); + assertFalse(path.isEmpty()); + for (char c : new char[] {'<', '>', '"', '&'}) { + assertFalse(path.indexOf(c) >= 0, "a markup character would have to be escaped past the serializer"); + } + } + + @Test + @DisplayName("A blank string is refused rather than encoded as an empty symbol") + void blankRefused() { + assertThrows(IllegalArgumentException.class, () -> QrSymbol.of(null)); + assertThrows(IllegalArgumentException.class, () -> QrSymbol.of(" ")); + } + + @Test + @DisplayName("A string too long for one symbol is refused with the length, not the whole string") + void tooLongRefused() { + String tooLong = "x".repeat(8000); + IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> QrSymbol.of(tooLong)); + assertTrue(e.getMessage().contains("8000 characters"), e.getMessage()); + assertTrue(e.getMessage().length() < 200, "the message must not echo the oversized input"); + } +} diff --git a/test/fixtures/EN10168/v0.5.0/valid_certificate_11.json b/test/fixtures/EN10168/v0.5.0/valid_certificate_11.json new file mode 100644 index 00000000..1a296692 --- /dev/null +++ b/test/fixtures/EN10168/v0.5.0/valid_certificate_11.json @@ -0,0 +1,369 @@ +{ + "RefSchemaUrl": "https://schemas.materialidentity.org/en10168-schemas/v0.5.0/schema.json", + "Certificate": { + "CertificateLanguages": [ + "EN" + ], + "CommercialTransaction": { + "A01": { + "Name": "Steel Mill SE", + "Street": [ + "Stahlstrasse 1" + ], + "ZipCode": "4040", + "City": "Linz", + "Country": "AT" + }, + "A02": "Mill Certificate EN 10204 3.1", + "A03": "1866645/001", + "A04": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXwAAACpCAMAAAAfvXbQAAAC6FBMVEX///8WkU8fuGQMZjX+/v78/f3//v/9/v4NZjUIUwAGSwAna0H7/Pz9//4MZTMhaj4HTgANaDYgaTwIVQAJWAAla0Dq7+wdaTwXkU8jaj8RZzYZaDogklLb498GSQAOZjYHUQAVjUMJWQEVZziIno73+vlboHKcsaMoa0ISZzinua32+fcWkE/5+/oLXyLX4Ntvj3kKXiG4x763xrwqbEKFoY8ft2IXkk9Qf2EXk1Dj6ubf5uLBzsYLYSTG0ssMYzHZ4dz09/bp7+sMZDXo7urs8e4Uh0mVrJ0guWROf18gvGbv9PHy9vTU3tiSq5tylH4KXRKEoI4MYy7m7OnN2NF3l4LP2tMgumUKXx3u8/Dl6+e/zMR5mYQVjk0ubUUyumrd5eC0xLp8m4cWkU0YZzgJWw4CKADw9vKgs6aPqJeIo5GCnotqkHgslFcajE4KXRnh6eTa4t66yL8xbkccZzoCLgCywbeMppQdpFvS3dYwuWkDNADg6OPK1s/I1MysvrKcsKOYr6B/nIlgiW4suWgkuGUrcUgbaTsMZjALYisLYSgKXAWvwLWpu68ouWZDeVYmk1QzdE0ScT8WaDnR29WSqZmLoZFvkntnjXVbhmohtWRUgmQetVcJWQgFQAABIQDW39rD0MhHfFsMXzMKXTAABAD+/f2muKzE0cmkt6p1loFXhGcViksMZS0EPAAesk29y8Ietl09eFQetFI5dVA1cUsdsUghbkMcbECQqpqPpZVkjHIThBwFRQAZaz4OajodsUUUiDMkcEYBGACFno19loQesmEcrV4ZoFcYllIMYygThiYDOADo9O3g8OU0ll0eskoSaTvZ7N/R6dm+4cqq2bmd1K+S0ad3yJRaoHIPbj7I49Gz3cGFzJ1Lf14Ym1QVjkcVizz0+fa91sakx7FXwH9AvHLa5N+wzruUv6Rkw4Zjq35MvnhBnGYbqVuAtJNrxYx0r4pco3aLuZxQoHA2pmQTgkYapCALxmwgAAAjtElEQVR42uyZP2vbQBjGXw5Jt+Q+QKEUWkiHFq/6BB2E071TudHfQfNp1QcI/gKFghACz54KHRxM/LfYoRBwKGkoWUrX+uymb9qovki+s6XmfkuIEHe60+l9Xj8PWPaMp2EIExfUaBizGg9uqRcOWPZVfajjUPOfqKej2FSjsOpjvfGUgaU8XumtP5mOWwC0MmKqaVZvZ+fbK7JW/OsC9CbtLBHzBnj0zh2lYDlD4AX1c5U7XeyOdikeQ5tAeuVeMAU4H/mJEKHfXcyW/9N/rdjZ5hSVv73grNt/YOoxPT0fM3XAHV50gpAQEvG0Pz2V1xRDGLjw30xSrNgPLrspD8iKOGxnkx4AtX2naZjU2bOkzSPyGyGSdHQui5FlO1h+2cStPxq3szAmfxBGnYvhATjUQNdVhdbOoMmhBnX2cB71Y0H+JuB+93KwvMOefjPIoj676pKQ5BHxdn96Yku/ZlBnT687qSz2+cRh1p70bOlHNOrsK6mzMckDlZeMXtZ1+ytqDMtT3xqnUmcVhKRzNWSovNXXsb2/E8WqKEBjzqXOqol42rke5JV+rybBR0VioVs6u+j6nChA5U3OrPJq09lpvs5uUt5xy7rNW8JW5mUmdbYQIu7H8wYAfVBhija5QPMyTYQghflldzr1bHxUmH+l1IGDpXkZhaQYqLxod5pRQkPBh2d4EjVUmpdSZwNSkpiv7U6Xwf1gBVdUn3ZSsSQvx7yc9tG8LIUIk3T0GoDqClOMt5/qScyHKXQdEvKYlAXtTr6yO+vaoO86TMGQkGwD2p2Lge367/+jiq5DwsJYuxPZMiTURhxmWVXszgqHKY6LIaFOhEh8GzRuBkNCnWDQ6AKz278pJExiQUwQ8DQ3aGQlUmWkXhWJbQ4JO6SEzlq7U1tIaAa0O4+k3WnDFByfYUhoCLQ7o/nhwwtTNszKMCQ0CAaNM2v039p792tXCLIbIt788cU2nTc4cPDp4/EbshP8oPn92TtwwXKz+c+fPv4WBMQ8fvP4/aMnL+zmo9zKzX/7+YO5w4/H/ic75xfbVBXH8Z/23N57+/eu7d21bdY2bRZaZ4djRZG5zc3hJAw2NsAh2EzChOHiGJtMI38EEvYPQ3AqkGWIaCaOYIyBICFAYkz8E1981AdfffPRZ3/ntJfT7Xa9Xeve/AFh93fvOff0029//Z3f78I7H36RUhB+cWVX4wXlO6CgY3VvYrQM/Gdfe3a1xY+yf+vz5gq77X/lLwk7Tzz72OqJn8u+osLC4Rs14iSEQHlWbjOl/JsQakWOQuX/jvAfe2z1xM9lb7Ho8I2LJ0LGTQSCDnYs4m/+B42AU8x14i8nOLmDmkh3cfSYOoyEiD5UIPoJUR+eOS+yoYQdUC+7Ca8+Mlu2OZ0daBXErIONoHNm78rOc2PKfwzpP8XFv0qy5/ANRn1isqXFwX5ezkhRLmdxInUWvAHJ53YaPIYyDSRrOpL0RRDzIg95BJ+K/7m/X3l59WS/PHxCILnj4OCG8+dvjDUl2cKTw1XchvE3/kpCMsfB/q6BmmHuYD/h+IZh5ugTDWyT+pQvdABhKBz6QJyeQMsLmbNtdE1teDCMBy1AssM3rc2c3gIkr4Aazp2evfbt5oWjbQAiG7GRTshtbSWQfPCZ+H9C8a+O7AvAJwCfzSpKf+3UVK8cmt0FRIBWr2+xRb3TbdAW9S7yKQ1wOLLkwh6ouaVE6ckL1UsYEZzAF6UX9b63DgTmeVXOeLzRNnDA1Std+PPQr+0gCND+6xAedF25CkKW7uvv9bLBe/IoSISNp6dD3rrGyVpfaOIDgV5CYB9OyG3ovS9zRjo5/Kz4f0Tx/8eyf5GhN8LnAhgI1cVVLTgzE/SnhpSjeEllhWex+TV3JbQ90Nw5PnvjMTjc7c/xuP0VCH92UvV41O4NRviVDzxsgrS8BgTGc5ecZgO1B5V4tDaa0s/Owxp2Ku174RH8I8qI5tFGIs/nU9D1XtmT8gSDsaCW2n+/swVEdB7ypT3cRiInQcijfC7+Z15ZDdkXCjuHrqTH8WQgZpEsLi1+pR6g8mYgYMkxKeH6DeFXuDJeiVpgfAjhN8bC3JWI3UT4G+qCkhSs3WyE31rhSkh4sce7F4iTidlmp6MDropKVP5arxsPVAXhC7BGUS2WsN/L4a9jF8dtRvgCnAgF6EkJlyO5AiO2QQcNXetlN18dvvyTeZW/CuLn0T4/fKf+Yb4y4sKVabFuN+WYUOW10PabqvpVzYKk8E9Q9dvdcQ4/oI2iaf7aDHzu8ngmioEvBesyHwuMLYqaH74I79NTEoUvmsEXoWcoRlcb80yOBhG1aySEc3D4Qba8tJKFTwzKNxF/6bIvpHwCu+80x6jio40jXhcF6fcNQquiRCLKXIyNig3RA7lNhx9o7mLW623Q4Qe6uzI2nYFvyQ+/Mqv8hCRVMqTOwTltEXwPg/8+hb+mePgEBiJxutJJ7+2uuiAVjCd6DAQdfqCXLe6Xr58sEHYM4i9f9ibwMZCGUi4MBL7Onpr6rnEJ121Xqqrvtre3v99ZN0NV0zv4Ph6d2pKFr/VfOtyQsRrYyOBrvoWNWVfSHD6a27sWBHR03JqM5YG/hsM3DzssD5oIBCRLovnB8ZqqPxuRPr6IUzr8cKzxxMY+uri+TUAKhB0u/v9c9hy+NXfd2+lHPRC42YZH22U3W/eXwOx4iL3Y0BFgRtkFKLh9oFsWvl8+xF3Vy8C3cvhZgCIc7hoPlwPfqkd8RWUDjwKB4wpehffHyJaFv7+3khM3gc/FX7bszZRPIDlLI7Tm6wTRAXtsdibLN0EQiQOus0N7qB4chIhiFr7HuxPonlREy8J3y9tBYA6RFKV8u0Jr2wKCQmg6fCE37AgrUL4AH9AzkjZ9GBw0jiZo+tBd+Qh+7UbQV2cCn4u/XNkb4Uc+WAq/5fzUjMToEQG2etP+uD09d0kEghc26fCzSbkOf68uIJIDn+iualP4+gABzuEdOHxDtlNkzBfgoGKnkzxsxWuTN6bidrtq9/Vx+K/ypRSK+Vz8P//4SnmyN9rtrw8uhX/gdndMkjy+BQr/hchQxGbzRi86wFkQPikHfljC75HLLBUci/gxN8kXduZXAJ9AO7t2dAgVDo4zis9mi/T+MpwLXzSBbyL+MmUvWcZV2+yxpWWTmmtTQUzRus8eoMr7o3Pg5PNXe2oAzQi/dSl80RS+MdXENFySYs3f78bRwr0u3GG4pIIxf20xys+s1HYdJ3FcuvzmV+s+atgikELKt/Kwk9cM4i9L9vE6+WASyKIWhBNETPbYuo/gupMtWb8RvnWp8q1LlW8tCN+qww833/nNFfZE+3DSLWe7Y66Z71wSj/nFhh3eTOFnNN9FsBLSob81pBTlc/E/heJfqeylvLIP2pVrW/WapSFcohQf9oAjW7YVSenKN/3CjdX+uaE2YVea8HZ9UU9i8ta1qYQxzycrCDsiDHvdEhv5OgiPXoS1HPhc/OXL3j6ltNeAQLgQdfgfRdh3nqd/tgMcTuC2fMzfyVIbslj56BFIETE/6BvcLmtx20mE3aSoQV/npf5gGXm+ld1zcy0GTyk86j2OQ/kNF2c7kGO8mYJmIv7yon0srlzYsUyp3nF5SMNrXKrvxiYQzOHzPJ+AaMjzzZU/7l34QPH75TFwYIaouiPtO71aobBjnmrStCmUdqH2Y1K0CQjh8Bfn+QTyNlNMxF+W7F1qt23sAMwTyGMC7LClLBLSt/suYBw2h4873Ia+vr6/enjYwW3C4aq+hqo2IEXA39kUceMkAqGbOtW2bp9M4bfm5vlFK59nzHUeVsSJRY4CiIvhx6ZO4PL6+pIrCDtc/O+g+EuO9rGU/F3Tsh0qJwZXphrUfu00lY0ZfCzkTE9P994/DSQDX3fVXhkDcdmwY9Xh+zob6vbPdF/ogOTloaBH3oXwedgpSfmZ922GFaLU0F0hc55XNQND0en+aFcrkBXB5+IvNdr7JdubmzhTgxFw7rOlLTTyeGJKPRCnGXwsYWpayntIh6+70vI2IGYxH+EPbjk/FRwdOobl/eaYa+LVTNhpLSnmc/p7QiqjH06HFqpB4MqnNqppnlFsGeTf4ZqL//FXSpF9IuWd2LOM7HmJYSHE6Ftm1NA5IKbwpUAg4JfX6/B1lxq5WwR8rf+ecNGnqcpxZO2fqdvc0unLE/PnVwYfRDw7qtG4b0lH7mFusQh+OBBISA8rS1I+Ez+2GFcoe8nl3h9aaDP7rwAEcIyF7Ky6mIiHWLJWKNXEQGZX1ZE5rnzd5TNTfiuDfwZOKWrcdg6+sdk1TJ0GfVoZ2Q4Pn59FJ/0sfqYjg0kgufD9djWu3smFbzVXvrn4ueyNFk75euuXyt7KP3a6QwTMO0bHLRLSp4oUCsLHqrmiKPLbe3OUH5uirjfWw3KFNWsO/HtQH7KrkY9xi6EiaAP8YpspVsg1Qjfoc/EMfdsYlQGP+TIuzya38c2IifLNxG8ue48WGtzI2JsZAXje180+tMHmiVYQ88HXq5rBoTO7duzYcbyKwx/vH/yIuvqKyHa0uXu4t1DpbnSf14P1ah1+idkONwHaZuVUhv59umae7Ryhy9tRDc6Swg4Xv4nsuaX6o+ecZui5bLbenGRNJVXeC1ZnMXk+GPN8AuYxP3oJehr3B2v/3H15aMYvb4WL5YYdTr/lYoRpP8A2tTzP3wQG42GnSOOPFZrKXvPbLvchnmKf2nNA1c3uIB2ZsmHgMdvhoi3Z4TrQJaLLrJmi+Qaxmtc43p3edXsyEb7ZCp0+T8nNFMO3107ZTj/AauQQkJwdLlte6fC5+F8uRva93q8cQAGZm5NQbAK869PCuG5tbpAyNKnnl1zbwXjjhJ0+tytxatyFyU4NLCD8kpsp/K0VBQH91Zf7PZkebgMIhqpmOfCRPhO/meyDqrJ5LRQXcgSivwNwlNXYJM90A2JdrWYK7oYpWJz5mkWic8FeL4XfuvKqJjdReBQ+X70ZTuhNu5KaKebiLyj7eGNkTU1RsmcUHZu2HhnY7gAQztDyuiXF0s3VaqZg30aEb+jM3RJyPgj4vesur5nC7tPR8NmXl6pwkqOspYj1C9FQ1SxL+Vz8y8veEowr3+4qUvZOqH597MxDWbl/PsmqjPTV+eUBIKvWTMGvDCdclf24N6D63ANwGuEXSDXNmykEdrV3Xoja5K8/wjMdFyZj9EmGO7sLtBGtYC0JPnug/KdlZW+fVD7uQNkX9e85CLRMhOpc/vT+bw+ASJsbCb0nsVrNFDcOx5kk1sz1e68ifNldeIdr3kxp/7R2UrPflptovNoW8dOeYv+xZduI1hLCDrfn/vk8v+xjqcjZE0XInse9S1NqQgq7JipBtALu9C20wZoEUlj51pK/cBn8anxmQu+bww+yu7xmigBH5ZFYILNSAWNanL2vW5fAt+biLx3+U8+95MrLXm22rd/CqmhF0/844tefYiI0AiD8ulmEXyjVLCfm021C9kb4Ns8mGfzy8nzsCMmqJOnf1NeVDPx3F8M3muP3MuAbq2hyxfNmsjdWA1MsOTgJyXl4Oqqxp9dQGoXz/Pl5kYjzucoXmCO3vFADAl4lkKXwT+N0X7KpMz9/IvuNyhdyGugOkaBx+HvAgcei6Hy019v9oDlBn4m4IUCSPoOHA4NdhyE3zyd0yCI1lK78F/NU0WKhfZVF/4eaHEggIEn4+EIPwHDvfkSpRtrzZzutK3lirW4DY2NUvvwmTvcZm1q1fQUOCp+nmgbly3368Cz8VKjJ8CqQsp+lCvWIdLBfs0iJ7tsHCj+xRv4z+BJW0by/HEFkVliRCTDAUpzx3lsnnzzbOIMz4Ra3UKqZmDy/7e7dbWgDlVn4salr7ehBu7ubKZ8+TXt2YBv1HVoHxJnTTPHLP+B0VT5PmCU7HH7eZgpOvY9NffdUC9Sz9QRrL57Sb08exR0lRRkE+re9PjhH82Va8hYyzz9KgebtbI729SeAS9NZNnwu+3/ZO/eftqo4gH+N9+EtLXRQmJ2uq2gztKlTBhEHmyuhaQx0bLyyApqBobw2mUwghJdAgrhBGDrGiBmvBPfAEUJYRDdcNvQXnVn0R38wGk3UGGN8/AF+z2nvTumlXNAWwfRs4d5+77nnnPu5337P43vO6eum4WLVHaWUtQFajqPbUfWjH3nLpMkjU/Rj6qZtq/Vwkb6ZBmnRN0sZRaf1Xpm+2Asf9e0FKohrqGXVQSaF/wTw3rnRSAhtCnyk1Hy5wiX0DSRpyXTNTeBTSQVKiKiV+QuhMC4qGuk/Ipkq3ozGp0gyu/xmKcfROwxjV4APg+anXKxoVLf2eJ1TyvpGT+2iQ/JRyD76TaO+edWxHURtJCE+5TM6P/8hCsQrirqV74OP9KnolKGawfdq/nk6razuTXmS4Edm48pNTSN9tO3xmEzS4wPZMnyc/UXySrp2UoaPx+LD0TFkSM2YRFcVnFp0+i+OiPWWReoIA/xdOzQ3WhGXKnrHHgV9/OwcNcZj+54u7EjJM9ElTxS+dComJuaUOVmGvxBrjLkfjAT+vt4of1E8XRaUl8RkLy+DvxCDLpePQCQLdk7FJOW9ayF2z3DKGLtAKtyDZ14mGUpem09yl0PUDoSfbPaTGKMofDYPQHr2ZZx16lWOlMVyHji6LCiGBX/4QqjMDs7IfSpgFI2TqxbBf/jj8v7dfitTGP2nEqUd8UkpKUkxb5k+KPDB4iHDc1GSpIueRt94flac5B/iTOnQqpeWh3ywD5r84iW2HGFdMkwABWiHeOj3VEiGmVzSPvikJRETy0L4rhkDuaXBSeA7GxL98tL3uqGMlIeJqNlh9JvnNKeNUfgQ8TskcxWyx3+ldw3sBnwSn9nhQqj5dBySV90SfuewtNjvH4/RP1a7zawxaTSGuUv3uwkijBeef+KJJ85fbfMtrHQ/sTx0ZUFC7XLRJw6wOD/xE5z/tJFpvlsWiOAqPI+ne0lmjZ+SbLKBh5PkDMX15LtRTz6whD/KgTZSHhZqM4FbNpj/1ECcxmTSmLfVHgSvG7FjWRrnCyfY6woZ/MRnVH6sA4m7Ow2G6/LGF8p9JRMKyvoa6w/aSVzlmuTQ/iC1jt3IsYIKwLEYQTJTeUb7nvrGxrI2B8blVAusCxl8AGHVrWq1yQv6mFi2MkU5rszOWEnlEChgciFQJNyPJbJYASnSs8BTITBDZWY6UZH9ch1SnHGKRMIBX2W/1OZu0wtRQZf/s30Ntvj+g5zIk6D2EOGHL7BvY1aN+XAKToz3wo/8bEeobf4qfiprxzVzvHc6UWS/nQ3RfGZx2r8xPU67ihH4CmdKaOEL3r+sedlaqn86ZQdanOXwhUAlwMKs80fRBX+B4BMHCLi1/wa6Is2gAlg1V2XglMUQwmZ2BN8BKedUnYmLeoSiZ/BDbnaFEBl7IQQChSxYmcMEn/VxSwY1242Kdbhb9Mf71pyJoBqDOVPCBJ+Dg8c1byXhiFkg/E21nzHLZONTC5vm89C+WJf0DkPP4G+d30QNb+DCCD/ZdD16xeX/IbcBOlX9021G8xampibzzcoh0tQMr+YLEfibx+xE4K8ahP8UPjPVKoJQGmllmkQgrM+uq15RzzVidtYfNq3ZUcDXbDX4/2QQdZMMrAXCz9Akyd71LQJ/DWFrjGrK8HEOXewLuyLwQ9vDjQ6Er1tZ85OeTeyR6f9vnSnC5nKm8DBB4OP6oMHmanNMRPM3xOwI9+HjROmkp83OSjIjbEX4m29oTAh/JiytMDlTKPzLmpeNmskigDXA10Hg7OmgzhQdz60cg/3KgHg/CouKGZAchODOFI4XZSocjRy8GJjVaraG4wP8RBvtTEH4cXnSbisWFD6SlPAF5fxZjgsy7yQwOhMECLngc3l4mhQjowyB94tcMLy6oL+BznOseKqD/lwYNf/A2LSLHEU4r4Qf6NMBR342OSrLqwugqT2XQwTKJA5mWH1vIL0EowRStecn0Bl8QaBwYJ04CBzN0JLgcLgtChcji7pnwhqEK80hwfUfO1MQ/iEb1QROBT6JkVOjn0msIbvyUHxEteRz2FkM3P3PPOydqgYRLQN+llcfc/QFHVkqBl5HouyeOgai7wY51G+bMU0X4cWcZi0ILH35BJGN1YIo0Cmvhl69NF9lB5oJJ/piMaNS6ski12QpS8vlwIzFkalm4NlFAQ8it5HOFAAbyJNCP5HUWjvlLc6MJikdRCYSfaXXfnYJONkwodQ1MEuv8T6ZKPuoD0n59CMPT42mk6P8GqkNHLsw25FIlqHsNVvl9GgUnUjv4sARNwReYcFMbknj8bFS3zp42fYx01WTuHznHJ7IUR/cM5eJvl0ZySdFpRUNM4kbOW+HaQXUxi2HLyhW60hdeMwm33grcrR6v/LZdN5mgqYPtNRuJNjwgEcC1CqCPdsLHSodNK8hUzY4eKKYl1rSCQPebUW2viLo3RiRpDN0q1JHydjdvvstbi2h5NB/5INf5KkCsN0wpQNnseFlHZHnZNMDZu2AajPC11p5jIUF4fBArBQP43fbAYVauzfh7Bz6rngrnuIb38h5O6zFUR4AHxTwj764kyiPAF2TVsiZqyXWZjrxcKodCm7F9pxJJpPejpoHxsksbmkWONu081JchZPAdF0wmHMdZJZ9Yt+A1L0PtF740D5vOHpF1rpU014tOdoKe2O/fteC6JsOG9J2kiqpv9fwASqsP/yGN8AGTTMugKZC17Zr2QCZ5RWGtALyjjPu6Lu767IASqQ9AIe+Jt+Bsp64z6ossPfa64NnzgF03qILLboNicNkY+vxbcm5+jvtIG6g5rM8cG8DFZvfORZXXmIBEZ7Js0N23TCAbX4yfaLaDgmHzKmz6QCz18oun/raDnBuai8IljRTV0HNFFlQ1fTi5bLRWuBR86cvd4xeEL2ajwSbimfvlvlm9jdrZt7tR2MgXp77oOyyFnS55gMnh7ehal7xNOZ3jh6DQM3Pn0fbAkekhcJOG9gHpL1t0zNIe+fMdNHeqLwswMrHhdc1mQDJU6XnOros0Fqu75zFK02LeOdJ8/yBkre2OQCaTdc6Dlw/7ABuA+Gz5UoGNfjasm5Tw41KgFyjHSp7rwJkJz6DZMhikaVk+VtU1rATwOWpR81/cYCHfJMTRKpPufFWgKHFYoAuzT7wws89us9mOT4gG11X137PmQI8uXGHBx5ea6jSapsbMsBdN2y3ZSV2InyzDL/A9G5N4dGGfuBR/Q+QdzcxVQbQupiKucz8CFAjId16jwvP4rLAMtBjBVrWkqVmvJ9aJdjdgJcnlvA+V0s/QB9+5P8D+DpcVr66M4XUq+ldng5Eth01/7NclFxpMQ03ExIeYvNRky51penPoR6NJSP8yW9skGmuJomd6yzs6clGLJoswn3cC9/6bvTg13d6yVJ239w5d4eUZgNt951KTG9CM/f224NowY5dnL/z9WAAfP182rupbQAcYkaLRpax7AHe/nK3CBd6c8gCz0yEP+YiZ1ngSCwnu+lwPJR52kllU61H+IUX3VjoUSfCb8AHSx5rDg18DM+/H3RIWVBM17yqqvlA6LZ0IvwYK1h7CXx4bfd+wz5k6ykjD1RmupDcNNp8H/4kwtdXY+qp5tT6kVsUPj5y591jXvjakeuZjoRKq3/1M/JBJfDdPXbQkldqzXLnWCBLn2rPdORYuGVm5w25sVVjziLdxL4xfO05vRd0UFiXA1S1Ef44nuH17P3PeG9EwgXAi174tSTOsZbdPvh7x1whg//c+yo9XIYeHHSfAwZf0b2F4twim7Z/KYMUeR+8ZijFGIgzY6mZ2O4+ALBXlAL033WRR6kHwZaGSpyAbUPYg1UAHF+oBHCajoF7cNAKtKkJVQ1FAFm0SagD0dmfA+NSLiB8Ehcchmd4EI9pgZ8mZjndTkRDMvy7VQierpxsMmQCno17PgS4vHQFoLOhHbKnr2WS0tWD9cbpLIBh/Y9gOyZiHwQ1H96DoTjkXkYKdmUKBeMz+AT1LQr4uhDC51aepJzT13Ma2QfXfBScMzW8nDJ21cZBu2e+sEfTrYOEMzd2f5xmAciXtg1mgPaG2Vk+31AAUDTViJp/65YNspZqARIMc7sv9Ca6AWob5mqvezAq7WRB9uTd3Nyxau/SKPvIVMXA6BnSujnkmcy1IIyGhU96RlsRjdnQNT01AbST9R4tTtvUkNxFKR8jTXYBOj0jpaPfoEKkS3HHB64v5gM4tpk/new1kXXzkuGJuaN4sbnl+tw4lmQpE8ByvCX3gqdW5LCJgC+tcaoohPAV4/krorc3DmrycKNVFbPjaEytmaXm+UB5U3FJI4C2qKmwn66NKzjiREXOdOaWOarQDBUPjePVjg4t5LwxgYm5UguLWqusACV9rx2pKSIt9gInGmp86+VHMkia9Ave7iy/lE+Sq6yqradN1ENXq1pJT3lfVeFQM3AkOV/kk852eb1gxhuV3jZ7e015Yw65/2BT7Wvpb+RgBq3VhUU78ToPJzuvVmHiWIbaKuQ+gZdFsCR3HSnR4tViZxHA+JBys6mwwGfoy+ZNeUmPq/pwOXZQXNAt79uzzqLOK1CmQaOwC4qLyvuUA3PsBjosqbxfeba8iOwWmsZKfVwuTPBp88KaPGB6KwXRq8IHjufwP7VBeBR5ciL6JORIY/DyCbnKkzxEepnDGOSEF/GEDSmzNOkHEf/TM18kWYCxfSf8e6w09Og/Ts1zrDg8R6UiEckZstL7bmL5s2IvC0IYzI7g03rL7KTmdMo7a529wKl6H9bpx1O5RS0T9STUBbrVcwoxfKb1tpI0zf4UrGhV4asvRGGCzT4ZZO2ZhNzsMPTajGnNswy9Ar76Q6sXP0SO7n9/v/q3RVD5DfRQwRcQLX9gRHM0iS0GCv3KFEE9wpbIRPvHtyGEj2DF9m5NHUOv+IW4yOwFv9bOvdv3Hn7g4ZD0cEkLpO2G/nDUiuhRtv16Q1UEvt/ezm2/3nzlxAOIf53wHwqEzwsABcf1FVHbg6B/J+WwuZx0NdYdNtPsklDW3wJYf3r+87Nn1635u5S7jpwb1l9E9BhW3HnwtKa7CGBrb64Q4iACuH/+7vaJs6/8K/gArqtmQ1D0D0Xt0MzN8qTzHwkB4wCtv33+3YlH12F7nnv1SX/4hmcOlkqG+NgHg4SYGH1vvx0i9j7Iniy/3Pz2BNa864PP9hZMlOJjgqHfHhVnGMpE9BGTE2RWGP/9rzcfPrEOzY9eRj/WiH+D7K5cpy/cuSr6zdEP3fAqWvDfo+qHV1jNqwr/S4TPwq5dFL0y7EjKM420AYjiJloBq5JmOATqtifz59u3Tzz6ysNrha8e4h/XDCZrgYsY+zXg/+r3zx8j+EMBH383xGjef6UyUs+uDb8IUPTHGmreh9Xh4/68UYa4pnxi7P+Xg5KhDyIHtu/v3Xz0LAJWgy8b+WCdqmc1wwcjTZx1vVIeoPKHb2+vWvPii3n1Y4QfHP2uqBdMae3kuxSSmjBEfo7wO1NCYfrz/7z93Wqm/+FXHg0OH+XG1/UflFm2grH/j9uswor4f/z95mOkz6sOXxli46W6Kjei3yRbP61VIPwDrKpprt/xI3IAbX/dfOnEKvBfCAL/kaSLUuo+2dgLW7aB/l9kwjpdtp/Ofo41bxD4Cy/sWrme3a+54ML7IyNoKkENf/YPj+Fw53rgYz07OaGLDF6GpNO17zdlzUvhn10JvjFWf6vPuhXq2S0QiALvUQ53UvgfyPCZkzBeOtPpiLTsQ9np0n3PHI1K+MxJmFRh7kqPoA8tfpAdjUr4DP2OlNMm4iQUOfX5WizCOmOE47VyIWnsh+9JeAAHOhrR9PvBP3GHwJc7VcRJWBJxErIQ2pr3JHU00pqXwWdOwmjqJNzyQ1sb7ExRFwQ6Ghl85iQ8RJ2EW6k3u7mcKetyNCL8HoRPJ+PU6Ut3RurZ8AbmaPTBz9tFnIRvmUYKCPrI/sjhDTrE/wV1NCL8ewifOgnrqZMwsjl12ANzNBL4MUbzZ5ciTsL1hH/nLuDeo47Gl87eG4z1OQl1iiT+hWA9zpRQu1vCmIl6ENbjaLy3YMrdOk7CTWsC/x7JrSXQ5tonJ5vtQGM/1LFkcN15QktbEWKUFP0u2uBdKGzDIhGyDWLTsA13ggv7UTAwYOhdYkhUghwmto6CUTAKRgFFBRQvwdkBTAFizWSjxBIKvIYwgo0kS1gIWYLJRjVidGPawAIADZRzdOGVexUAAAAASUVORK5CYII=", + "A05": "Factory Production Control", + "A06": { + "Name": "Steel Trading AG", + "Street": [ + "Handelsgasse 1" + ], + "ZipCode": "10115", + "City": "Berlin", + "Country": "DE" + }, + "A07": "0334/2019/ZZS", + "A08": "958722", + "A09": "TR-12456", + "A97": "1", + "A98": "DN-1583836", + "A99": "AV-87682933", + "SupplementaryInformation": { + "A10": { + "Key": "Buyer Reference Number", + "Value": "BRN-1583836", + "Type": "string" + }, + "A11": { + "Key": "Reference Date", + "Value": "2018-10-23", + "Type": "date" + } + } + }, + "ProductDescription": { + "B01": "Seamleass Steel Tubes Hot Roild", + "B02": { + "SteelDesignation": [ + "S355J2H", + "P355NH/TC1", + "E355+N" + ], + "ProductNorm": [ + "EN 10219-1:2006" + ], + "MassNorm": [ + "EN 10220" + ], + "MaterialNorm": [ + "EN 10297-1:2003-06" + ] + }, + "B03": "Ausführung lt. EN 10219 Teil 1+2 /--/", + "B04": "normalized", + "B06": "SST 200x150x6", + "B07": [ + "7282841" + ], + "B08": 16, + "B09": { + "Form": "RectangularTube", + "Width": 200, + "Height": 150, + "WallThickness": 6.5, + "Unit": "mm" + }, + "B10": { + "Property": "Length", + "Value": 12000, + "Unit": "mm" + }, + "B11": { + "Property": "Corner radius", + "Value": 1.5, + "Unit": "mm" + }, + "B12": { + "Property": "Theoretical mass", + "Value": 5738.3, + "Unit": "kg" + }, + "B13": { + "Property": "Actual mass", + "Value": 5739.3, + "Unit": "kg" + }, + "SupplementaryInformation": { + "B20": { + "Key": "Digital Product Passport", + "Value": "https://dpp.example.org/dpp/steelmill/1607219-0001", + "Type": "url" + }, + "B21": { + "Key": "Digital Product Passport (QR code)", + "Value": "https://dpp.example.org/dpp/steelmill/1607219-0001", + "Type": "qr-code" + } + } + }, + "Inspection": [ + { + "C00": "Charge Chemical Analysis", + "ChemicalComposition": { + "C70": "Y", + "C71": { + "Actual": { + "Value": "0.1500" + }, + "Symbol": "C", + "Unit": "%" + }, + "C72": { + "Actual": { + "Value": "0.0050" + }, + "Symbol": "Si", + "Unit": "%" + }, + "C73": { + "Actual": { + "Value": "1.0000" + }, + "Symbol": "Mn", + "Unit": "%" + }, + "C74": { + "Actual": { + "Value": "0.0140" + }, + "Symbol": "P", + "Unit": "%" + }, + "C75": { + "Actual": { + "Value": "0.0070" + }, + "Symbol": "S", + "Unit": "%" + }, + "C76": { + "Actual": { + "Value": "0.0410" + }, + "Symbol": "Al", + "Unit": "%" + }, + "C77": { + "Actual": { + "Value": "0.0200" + }, + "Symbol": "Cr", + "Unit": "%" + }, + "C78": { + "Actual": { + "Value": "0.0090" + }, + "Symbol": "Ni", + "Unit": "%" + }, + "C79": { + "Actual": { + "Value": "0.0020" + }, + "Symbol": "Mo", + "Unit": "%" + }, + "SupplementaryInformation": { + "C116": { + "Key": "Sample Identifier", + "Value": "10001011/175508", + "Type": "string" + } + } + } + }, + { + "C00": "Charge TensileTest", + "C02": "0001 längs", + "C03": "-20 Celsius", + "TensileTest": { + "C11": { + "Property": "Streckgrenze ReH/RP0,2", + "Value": 377.12, + "Unit": "MPa" + }, + "C12": { + "Property": "Zugfestigkeit Rm", + "Value": 456.18, + "Unit": "MPa" + }, + "C13": { + "Property": "Bruchdehnung A5/A80", + "Value": 29.7, + "Unit": "%" + }, + "SupplementaryInformation": { + "C14": { + "Key": "Re/Rm", + "Value": "0.83", + "Type": "number" + }, + "C15": { + "Key": "Sample Identifier", + "Value": "10001011/175508", + "Type": "string" + } + } + } + }, + { + "C00": "Charge HardnessTest", + "C03": "-20 Celsius", + "HardnessTest": { + "C30": "Brunell", + "C31": [ + { + "Value": 71.3, + "Unit": "J" + }, + { + "Value": 84.2, + "Unit": "J" + }, + { + "Value": 85.2, + "Unit": "J" + } + ], + "C32": { + "Value": 80.3, + "Unit": "J", + "Minimum": 78.5, + "Maximum": 90.6 + } + } + }, + { + "C00": "Charge NotchedImpactTest", + "C03": "-20 Celsius", + "NotchedBarImpactTest": { + "C40": "0001 längs", + "C41": { + "Property": "Width", + "Value": 5, + "Unit": "mm" + }, + "C42": [ + { + "Value": 71.2, + "Unit": "J" + }, + { + "Value": 84.2, + "Unit": "J" + }, + { + "Value": 85.2, + "Unit": "J" + } + ], + "C43": { + "Value": 80.3, + "Unit": "J", + "Minimum": 78.5, + "Maximum": 90.6 + }, + "SupplementaryInformation": { + "C44": { + "Key": "Sample Identifier", + "Value": "10001011/175508", + "Type": "string" + } + } + } + } + ], + "OtherTests": { + "D01": "Marking", + "NonDestructiveTests": { + "D02": { + "Key": "Visual En 10219-1", + "Value": "100", + "Unit": "%", + "Interpretation": "Positive", + "Type": "number" + }, + "D03": { + "Key": "Non destructive test EN ISO 10893-2", + "Value": "100", + "Unit": "%", + "Interpretation": "Positive", + "Type": "number" + }, + "D04": { + "Key": "Dimensional Inspection EN 10219-2", + "Value": "1", + "Unit": "Lot", + "Interpretation": "Positive", + "Type": "number" + } + }, + "OtherProductTests": { + "D51": { + "Key": "Tensile flattening test", + "Value": "100", + "Unit": "%", + "Interpretation": "Positive", + "Type": "number" + } + } + }, + "Validation": { + "Z01": "We hereby certify, that the material described above has been tested and complies with the terms of the order. This certificate has been created by a data processing system and does not contain a personal signature but the name and the offical address of the appointet department.", + "Z02": "2018-10-23", + "Z03": { + "Name": "John D. Keller", + "Title": "Quality Manager" + }, + "Z04": { + "NotifiedBodyNumber": "0780", + "DoCYear": "19", + "DoCNumber": "0780-CPD-P012", + "CE_Image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFoAAABACAMAAACtO5DNAAAAmVBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjHWqVAAAAMnRSTlMAzexb/E0FmyQJ+NLj3/Hn2qynhlOiuZJ8VzsqFQyf1caPjG5CMCEP9b6wgHVpHZRHHxEaALYAAAHuSURBVFjDxZjZcoMwDEUNYQ0QAoSUACFbsy9t9f8f14d2bIfgIjOj6X2+PgO2LEtiKh3tollH5tgyI5vh5Y2yJAgn1smMug1VZljANUJiHbsJQajD4d8N4MKjDxuTr+hGL28xgD66yvlvqtCLEEAfvdxysAr9mAMMQNth17JniwkD0M4GoA99BRiArtfQh3ZcGII+TKEP7STwInOdNG5zeWdqeTG0ZU3nqevmc+5pf/Mknx1Yr+qotSy4ln7Lkz07jIXPEFoGIGvs7jvC58mywmaNFGTljw7LlynvVeYgyXcZHHUfyVk+uxKd5cYgdDl2ekaSZeoxrOSr+6FIzbFErtHkmUTeKDyFsMQeQ2sllqWqCDLFCZZsyEcbqkjdCU/G8DJEOFcqTyDi2cGT98BVIDw2w2vLV4V+vydgGhJRtWP9+7HQIFcijyk/uu7x9J69i4ihlGlIZHd1Ni8G7Qfjb8vJQeRFT4PsWDyojRfd2pE/YRry4A+9/Zoiflt10CUGzRPIWQf9iUHzdJ7ooGeEaMIN+a9jJAw+witDcNEJ0hNdUqV8CggfMMpnl7JYICxxKAszynKStAimLN1JGw7SNom4uaNvSQkbacL2n2BoQTBqoRsQ0Y+16Idx9CNE+sEn/bhWDJnznyFzOHDI/A3NAGlA3stefgAAAABJRU5ErkJggg==" + }, + "SupplementaryInformation": { + "Z05": { + "Key": "Quality Department Tel.", + "Value": "+43 732 1000 8888", + "Type": "phone" + }, + "Z06": { + "Key": "Quality Department Fax", + "Value": "+43 732 1000 8889", + "Type": "phone" + }, + "Z07": { + "Key": "Quality Department Email", + "Value": "quality@steelmill.se", + "Type": "email" + }, + "Z08": { + "Key": "Ultra Green Steel", + "Value": "https://www.steelmill.com/ultragreensteel", + "Type": "url" + }, + "Z09": { + "Key": "Steel Mill Green Steel", + "Value": "data:image/png;base64,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", + "Type": "image" + } + } + } + } +} diff --git a/test/fixtures/EN10168/v0.5.0/valid_certificate_11.pdf b/test/fixtures/EN10168/v0.5.0/valid_certificate_11.pdf new file mode 100644 index 0000000000000000000000000000000000000000..fd3c5728496c5bbcc5cdf3c3a08001073394693f GIT binary patch literal 72652 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

{`-(V?WioGLNI%IPzC%TZN_NP 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 literal 0 HcmV?d00001 From 27249b7b944b146e3b024e6357be464963fa7977 Mon Sep 17 00:00:00 2001 From: Hannes Stiebitzhofer Date: Tue, 6 Oct 2026 11:55:43 +0200 Subject: [PATCH 2/2] fix(deps): postcss-selector-parser 7.1.6; accept source-map-js advisory until 1.2.2 clears the release-age window MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The weekly Grype DB of 2026-10-06 flags two packages in ui/package-lock.json on every branch, main included: - postcss-selector-parser 6.1.4 (GHSA-rj75-hqrm-r3gf, Medium): quadratic selector parsing. Pinned to 7.1.6 via npm overrides; tailwindcss 3.4.3 and postcss-nested asked for ^6 but build identically against 7.1.6 — the Angular build output is byte-identical before and after. - source-map-js 1.2.1 (GHSA-68fv-2mgg-jv7q, High): event-loop DoS on untrusted source maps. The fix, 1.2.2, was published 2026-09-30 and the repo's .npmrc (min-release-age=7) quarantines it until 2026-10-07. Reached only through postcss/sass inside the Angular CLI build, never deployed; accepted in .grype.yaml until the window clears, bump tracked in #348. Co-Authored-By: Claude Fable 5.1 --- .grype.yaml | 8 ++++++++ ui/package-lock.json | 33 +++------------------------------ ui/package.json | 3 ++- 3 files changed, 13 insertions(+), 31 deletions(-) diff --git a/.grype.yaml b/.grype.yaml index d0b36edb..b953c589 100644 --- a/.grype.yaml +++ b/.grype.yaml @@ -60,6 +60,14 @@ ignore: # Remove this entry as soon as a patched braces is published and picked up by the lockfiles. - vulnerability: GHSA-vfj7-8cjw-p6xm + # source-map-js 1.2.1 (GHSA-68fv-2mgg-jv7q, High, published 2026-09-18): event-loop DoS through + # indexed source-map section offsets in untrusted source maps. Reached only through postcss and + # sass inside the Angular CLI build (ui/), which parses our own sources at build time; nothing of + # it is deployed. The fix, 1.2.2, exists (published 2026-09-30) but the repo's .npmrc + # (min-release-age=7) quarantines it until 2026-10-07. Accepted until then — bump and remove this + # entry per #348. + - vulnerability: GHSA-68fv-2mgg-jv7q + # Registry configuration (if needed for private registries) # registry: # auth: diff --git a/ui/package-lock.json b/ui/package-lock.json index bffff5e8..7c29dbf5 100644 --- a/ui/package-lock.json +++ b/ui/package-lock.json @@ -11245,24 +11245,10 @@ "postcss": "^8.2.14" } }, - "node_modules/postcss-nested/node_modules/postcss-selector-parser": { - "version": "6.1.4", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.4.tgz", - "integrity": "sha512-bIoJLOmjCO1S9XdY/DcnR5hJxvrDir1PbGChrzXG3vw0/FOliy/fA3dmdhQ441kah4gKv+TwckGzex6wNS5cnQ==", - "license": "MIT", - "dependencies": { - "cssesc": "^3.0.0", - "util-deprecate": "^1.0.2" - }, - "engines": { - "node": ">=4" - } - }, "node_modules/postcss-selector-parser": { - "version": "7.1.4", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.4.tgz", - "integrity": "sha512-HeP7D2wyhkR+XaK6v4W8oRF62Dsz4flyuczALJp61GckGm42u1saSSJ/0auvcBqxs3jMRFEcPK34At/0JBKdOg==", - "dev": true, + "version": "7.1.6", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.6.tgz", + "integrity": "sha512-7qASPzhKF2l2KLboRZux8CCTRMdGiV08vWmyKzPz22qZ7ZjQBOeY7rNzNoCLSUiftJ7HUq0GERHmxw/t0dCdMw==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -12794,19 +12780,6 @@ "url": "https://github.com/sponsors/jonschlinkert" } }, - "node_modules/tailwindcss/node_modules/postcss-selector-parser": { - "version": "6.1.4", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.4.tgz", - "integrity": "sha512-bIoJLOmjCO1S9XdY/DcnR5hJxvrDir1PbGChrzXG3vw0/FOliy/fA3dmdhQ441kah4gKv+TwckGzex6wNS5cnQ==", - "license": "MIT", - "dependencies": { - "cssesc": "^3.0.0", - "util-deprecate": "^1.0.2" - }, - "engines": { - "node": ">=4" - } - }, "node_modules/tailwindcss/node_modules/readdirp": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", diff --git a/ui/package.json b/ui/package.json index 926cc89a..dd288769 100644 --- a/ui/package.json +++ b/ui/package.json @@ -42,7 +42,8 @@ "immutable": "5.1.9", "body-parser": "1.20.6", "nanoid": "3.3.18", - "brace-expansion": "2.1.4" + "brace-expansion": "2.1.4", + "postcss-selector-parser": "7.1.6" }, "devDependencies": { "@angular-devkit/build-angular": "19.2.23",