Repository navigation
Description
I found two independent problems while validating dotnet/extensions#7962. Both reproduce on the published packages (CommunityToolkit.DocumentExtraction.* 1.0.0-preview on Microsoft.Extensions.Documents.Abstractions 11.0.0-preview.1.26560.3), and neither depends on dotnet/extensions#7962. Part 3 is follow-up work for after that change ships.
TL;DR
| # | Problem | Impact | Fix size |
|---|---|---|---|
| 1 | The Azure DI and CU adapters throw when the service reports a cell inside another cell's span | The whole document fails (InvalidOperationException) |
~70 lines in a shared helper plus 2 call sites, and 3 shared regression tests (prototype below: 650/650 tests pass) |
| 2 | Provider READMEs and the root README teach traversal loops that skip table cells, nested sections and/or image.Text |
On hard pages, readers see 48–50 % (CU/DI) of the text the document actually contains | Docs only |
| 3 | After dotnet/extensions#7962 ships: adopt GetText() / EnumerateContent() and drop dead cell is null checks |
Simpler docs, a single supported reading path | Docs plus a version bump |
1. Bug: overlapping cell spans abort the whole document (Document Intelligence and Content Understanding)
Repro
- Document: ParseBench-2,
complex_table_headers/complex_header_006(https://huggingface.co/datasets/llamaindex/ParseBench-2). Any page whoseprebuilt-layouttable has a multi-row header with blank sub-header slots behaves the same way. - Code:
var client = new DocumentIntelligenceClient(endpoint, new DefaultAzureCredential())
.AsDocumentExtractionClient(new() { DefaultModel = "prebuilt-layout" });
await using var pdf = File.OpenRead("complex_header_006.pdf");
var document = await client.ExtractAsync(pdf, "complex_header_006.pdf", "application/pdf");- Actual:
System.InvalidOperationException: A covered position must be edited through its anchor cell.
at Microsoft.Extensions.Documents.ExtractionDocumentTableCellCollection.set_Item(Int32 row, Int32 column, ...)
at CommunityToolkit.DocumentExtraction.AzureDocumentIntelligence.DocumentIntelligenceExtractionClient.MapTables(...)
- Expected: the document extracts. The offending cells carry no text.
Root cause
Raw prebuilt-layout output (Azure.AI.DocumentIntelligence 1.0.0) for table 1 on that page (28 × 11, 289 cells):
| cell | kind | anchor | span | content |
|---|---|---|---|---|
cells[5] |
columnHeader | [0,5] |
3 × 6 | header text |
cells[9] |
columnHeader | [2,5] |
1 × 1 | (empty) |
cells[10] |
columnHeader | [2,7] |
1 × 1 | (empty) |
cells[11] |
columnHeader | [2,8] |
1 × 1 | (empty) |
cells[12] |
columnHeader | [2,9] |
1 × 1 | (empty) |
cells[13] |
columnHeader | [2,10] |
1 × 1 | (empty) |
cells[9..13] all lie inside the 3 × 6 span anchored at [0,5].
Both Azure adapters assign every provider cell blindly:
src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs:222src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs:247
mappedTable.Cells[cell.RowIndex, cell.ColumnIndex] = mappedCell;ExtractionDocumentTableCellCollection's setter rejects a covered position ("A covered position must be edited through its anchor cell."). It also rejects a span that overlaps an existing anchor ("Cell spans cannot overlap another cell."). Either exception propagates out of ExtractAsync, so one malformed header row loses the entire document.
Precedent: the VLM adapter already validates occupancy up front with a HashSet<(int,int)> and throws a descriptive InvalidDataException (src/VisionLanguageModel/VisionLanguageModelDocumentExtractionClient.cs:273-296). The Azure adapters have no equivalent.
Proposed fix
A fix is ready as a single commit (+148/−6; see Patch at the end). It needs nothing beyond the published abstractions package. I'm happy to open it as a PR.
-
src/Shared/ProviderAdapterHelpers.cs: addReserveTableCell(bool[,] occupied, row, column, rowSpan, columnSpan, isEmpty, context). It returns the span to map, ornullto skip the cell. The policy:Situation Action Lossless? The cell's rectangle is free Map as reported and mark it occupied yes The rectangle overlaps an occupied position and the cell has no text or elements Skip (the observed DI case) yes The rectangle overlaps, the cell has content, and its own [row,col]is freeMap as 1 × 1 (keeps the text, drops the conflicting span) text yes, span no The cell has content and its own [row,col]is coveredInvalidDataException("<provider> table N: cell at row r, column c has content but lies inside another cell's span.")n/a (same as VLM) Address out of range Unchanged: the table setter still throws ArgumentOutOfRangeException(the existingbad-cellcontract test)n/a -
Call sites: allocate
var occupied = new bool[table.RowCount, table.ColumnCount];per table, then:
if (ProviderAdapterHelpers.ReserveTableCell(
occupied, cell.RowIndex, cell.ColumnIndex, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1,
cell.Elements.Count == 0 && string.IsNullOrWhiteSpace(cell.Content),
$"Document Intelligence table {index}") is not { } span)
{
continue;
}
// ...construct the cell with span.RowSpan / span.ColumnSpan instead of cell.RowSpan ?? 1 / cell.ColumnSpan ?? 1- Second passes:
MapSectionsreadstable.Cells[cell.RowIndex, cell.ColumnIndex]!for cells withElements(DI:295, CU:301). These need no change: a cell with elements is never "empty", so it is either mapped at its own anchor or the helper throws.
Maintainer decision: what should happen to a non-empty cell inside another span? The prototype throws, matching VLM. Alternatives: append its text to the covering anchor (which means rebuilding that anchor, because
Contentis get-only), or skip it with a diagnostic. No real document in the 10-page sample hit this case. Only empty overlaps were observed.
Tests
The tests live in the shared partial class test/AzureTestSupport/AzureMappingRegressionTests.cs, which is compiled into both the DI and CU test projects via CONTENT_UNDERSTANDING. The new theory is ExtractAsync_OverlappingCellSpans_DoNotAbortDocument, which adds cells to AzureWireFixture.Create()'s 2 × 3 table (which has a 2 × 2 header anchored at [0,0]):
| Scenario | Added cells | Assertion |
|---|---|---|
empty-covered |
empty 1 × 1 at [1,1] |
succeeds; [0,0] is still 2 × 2 with "Total amount"; Cells[1,1] is null |
text-span-overlap |
"Tax" at [1,2], then "Notes" at [0,2] with rowSpan 2 |
succeeds; "Notes" is 1 × 1 at [0,2]; "Tax" is kept at [1,2] |
text-covered |
"Tax" at [1,1] |
InvalidDataException whose message contains row 1, column 1 |
Validation
| Check | Result |
|---|---|
New tests on current main (74935f4), fix stashed |
6/6 fail with the reported InvalidOperationException (3 DI + 3 CU) |
Full DocumentExtraction suite with fix, published abstractions 11.0.0-preview.1.26560.3 |
650/650 pass (644 existing + 6 new) |
| Same suite against a dotnet/extensions#7962 prototype package | 650/650 pass |
Live prebuilt-layout on complex_header_006 with the patched adapters |
DI: OK (was: throws). Table 1 maps 284 anchors: 289 provider cells minus exactly the 5 empty covered cells, with 6 merged cells kept. CU: OK (unchanged). |
Acceptance criteria
- DI and CU never throw
InvalidOperationExceptionfromExtractionDocumentTableCellCollectionwhile mapping service output. - Empty cells inside another span are dropped without losing any text.
- Non-empty overlaps follow the documented policy, and any exception names the provider, table index, row and column.
- Shared regression tests cover both adapters.
-
ParseBench-2/complex_header_006extracts with DIprebuilt-layout.
2. Docs: the quick starts teach loops that silently skip content
ExtractionDocument is a tree: sections → elements → (nested sections | tables → cells → elements | images with OCR'd Text). DI and CU produce nested trees: every one of the 10 sampled pages for CU, and 8 of 9 for DI, had depth > 1. PdfPig, Mistral and plain VLM output is flat. A loop that works on PdfPig therefore silently loses text on Azure. See dotnet/extensions#7962.
Measured impact
These are live runs: ParseBench-2, 10 hard PDF pages (charts, complex headers, dense and financial tables, multi-column layouts). Recall is the fraction of ground-truth tokens a reader sees.
| Reading pattern | Used in | CU | DI | PdfPig / Mistral / Ollama |
|---|---|---|---|---|
EnumerateContent().OfType<ExtractionDocumentTextElement>() |
DI/CU/PdfPig/VLM READMEs | 0.48 | 0.50 | 0.81 / 0.76 / 0.83 |
Recursive walker with cells and nested sections but no image.Text |
root README PrintElement |
0.84 | 0.77 | same |
Recursive walker with cells, nested sections and image.Text |
proposed | 0.92 | 0.85 | same |
DI covered 9 of 10 pages because of problem 1 above.
Where
At 74935f4:
| File | Line | Pattern | What's skipped |
|---|---|---|---|
DocumentExtraction/README.md |
163–165 | EnumerateContent() + element.Content is TextContent |
table cells, image.Text (≈ B on Azure) |
DocumentExtraction/README.md |
278–315 (PrintElement) |
recursive, reads cells and sections | image.Text; if (cell is null) continue; at :305 hides the covered/anchor distinction |
src/AzureDocumentIntelligence/README.md |
74 | EnumerateContent().OfType<ExtractionDocumentTextElement>() |
table cells, image.Text |
src/AzureContentUnderstanding/README.md |
81 | same | same |
src/PdfPig/README.md |
61, 78 | same | (flat today, so harmless, but it's the pattern people copy) |
src/VisionLanguageModel/README.md |
77 | same | table cells |
src/Mistral/README.md |
89, 166 | EnumerateContent() + Content is TextContent |
table cells |
The prose already warns about this (DI README :158, CU README :152, and the SKILL.md files for CU :81, DI :83, VLM :100 and PdfPig :68 all say "EnumerateContent() does not enter table cells"), but the code right above it doesn't follow the warning.
Proposed fix (works today, no new APIs)
Replace each quick-start loop with one shared, copy-pasteable helper. Put it in the root README and link to it from the provider READMEs:
static IEnumerable<string> ReadText(ExtractionDocumentElement element)
{
switch (element)
{
case ExtractionDocumentTextElement { Content: TextContent text }:
yield return text.Text;
break;
case ExtractionDocumentImageElement image when !string.IsNullOrWhiteSpace(image.Text):
yield return image.Text; // OCR'd text inside figures (DI/CU)
break;
case ExtractionDocumentTableElement table:
for (int r = 0; r < table.Cells.RowCount; r++)
for (int c = 0; c < table.Cells.ColumnCount; c++)
if (table.Cells[r, c]?.Content is { } cell) // null = empty or covered by a merged cell
foreach (string s in ReadText(cell)) yield return s;
break;
case ExtractionDocumentSection section:
foreach (var child in section.Elements)
foreach (string s in ReadText(child)) yield return s;
break;
}
}
foreach (var section in document.Sections)
foreach (var element in section.Elements)
foreach (string text in ReadText(element))
Console.WriteLine(text);The samples repo walker received the same fix in luisquintanilla/dotnet-document-extraction-samples#1. Its recall moved from 0.84/0.77 (CU/DI) to match the whole-document reference (0.92/0.85 in the latest run).
Acceptance criteria
- No README or SKILL.md shows a loop that filters to
ExtractionDocumentTextElementwithout also descending into cells and readingimage.Text. - The root README's
PrintElementreadsimage.Text. - Provider READMEs keep their existing "does not enter table cells" prose only where it is still accurate, and point to the helper.
3. Follow-up after dotnet/extensions#7962 ships (December)
dotnet/extensions#7962 adds GetText() for document, element and cell, and makes ExtractionDocumentTableCellCollection enumerate anchor cells only. Once CTK takes that package:
- Replace the helper from part 2 with
document.GetText(), or withdocument.EnumerateContent()+element.GetText()for per-element reading. - Delete
if (cell is null) continue;(root README :305) and similar null checks when iteratingtable.Cells, since enumeration no longer yields empty positions. - Optionally switch the problem 1 helper to
table.Cells.GetCoveringCell(r, c)instead of a localbool[,]. Keep the current behavior. - Update the SKILL.md wording (CU :81, DI :83, VLM :100, PdfPig :68) to "use
GetText()for complete text, orEnumerateContent()for structure".
Compatibility: the full CTK DocumentExtraction suite passes unchanged against the dotnet/extensions#7962 prototype package (644/644 before the problem 1 fix, 650/650 with it). No source changes are needed to adopt it.
Environment
- CommunityToolkit/AI
main@74935f4. - Azure.AI.DocumentIntelligence 1.0.0 (
prebuilt-layout) and Azure.AI.ContentUnderstanding (prebuilt-layoutanalyzer), both live. - ParseBench-2: 10 pages across
charts,complex_table_headers,dense_tables,financial_tablesand multi-column categories. - Harness, pinned corpus and per-page results:
validation/parsebenchin the samples repo. The overlap failure is recorded in itsresults/summary.md.
Patch (git am, applies to main @ 74935f4)
From 93c3d2955c98c5e160ca44fe7166dda3ee506c5d Mon Sep 17 00:00:00 2001
From: Luis Quintanilla <luisquintanilla@users.noreply.github.com>
Date: Thu, 19 Nov 2026 12:52:48 -0500
Subject: [PATCH] Don't abort extraction when DI/CU report overlapping table
cells
Document Intelligence and Content Understanding can report empty 1x1 cells inside another cell's span (e.g. ParseBench-2 complex_header_006). Assigning them through ExtractionDocumentTableCellCollection throws, aborting the whole document. Track occupied positions while mapping: skip empty covered cells, keep text from a cell whose span overlaps as a 1x1 cell, and raise a descriptive InvalidDataException only when a non-empty cell's own position is covered.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
.../ContentUnderstandingExtractionClient.cs | 13 +++-
.../DocumentIntelligenceExtractionClient.cs | 15 +++--
.../src/Shared/ProviderAdapterHelpers.cs | 66 +++++++++++++++++++
.../AzureMappingRegressionTests.cs | 60 +++++++++++++++++
4 files changed, 148 insertions(+), 6 deletions(-)
diff --git a/DocumentExtraction/src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs b/DocumentExtraction/src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs
index 475ea63..c6e8854 100644
--- a/DocumentExtraction/src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs
+++ b/DocumentExtraction/src/AzureContentUnderstanding/ContentUnderstandingExtractionClient.cs
@@ -223,8 +223,17 @@ private static void MapTables(
IReadOnlyList<ExtractionDocumentSourceReference> tableSources = ParseSources(table.Source, frames, table);
var mappedTable = new ExtractionDocumentTableElement(null, table.RowCount, table.ColumnCount);
elements.Add($"/tables/{index}", mappedTable);
+ var occupied = new bool[table.RowCount, table.ColumnCount];
foreach (Azure.AI.ContentUnderstanding.DocumentTableCell cell in table.Cells)
{
+ if (ProviderAdapterHelpers.ReserveTableCell(
+ occupied, cell.RowIndex, cell.ColumnIndex, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1,
+ cell.Elements.Count == 0 && string.IsNullOrWhiteSpace(cell.Content),
+ $"Content Understanding table {index}") is not { } span)
+ {
+ continue;
+ }
+
IReadOnlyList<ExtractionDocumentSourceReference> cellSources = ParseSources(cell.Source, frames, cell);
ExtractionDocumentElement? cellContent = cell.Elements.Count > 0
? new ExtractionDocumentSection()
@@ -236,9 +245,9 @@ private static void MapTables(
var mappedCell = cellContent is null
? new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(
- cell.RowSpan ?? 1, cell.ColumnSpan ?? 1, cell.Kind?.ToString())
+ span.RowSpan, span.ColumnSpan, cell.Kind?.ToString())
: new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(
- cellContent, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1, cell.Kind?.ToString());
+ cellContent, span.RowSpan, span.ColumnSpan, cell.Kind?.ToString());
foreach (ExtractionDocumentSourceReference source in cellSources)
{
mappedCell.Sources.Add(source);
diff --git a/DocumentExtraction/src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs b/DocumentExtraction/src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs
index f3a7658..e56ffd2 100644
--- a/DocumentExtraction/src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs
+++ b/DocumentExtraction/src/AzureDocumentIntelligence/DocumentIntelligenceExtractionClient.cs
@@ -188,8 +188,17 @@ private static void MapTables(
var mappedTable = new ExtractionDocumentTableElement(null, table.RowCount, table.ColumnCount);
elements.Add($"/tables/{index}", mappedTable);
+ var occupied = new bool[table.RowCount, table.ColumnCount];
foreach (Azure.AI.DocumentIntelligence.DocumentTableCell cell in table.Cells)
{
+ if (ProviderAdapterHelpers.ReserveTableCell(
+ occupied, cell.RowIndex, cell.ColumnIndex, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1,
+ cell.Elements.Count == 0 && string.IsNullOrWhiteSpace(cell.Content),
+ $"Document Intelligence table {index}") is not { } span)
+ {
+ continue;
+ }
+
ExtractionDocumentSourceReference[] cellSources = cell.BoundingRegions
.Select(region => ProviderAdapterHelpers.CreateSource(
frames[region.PageNumber].SourcePage,
@@ -210,10 +219,8 @@ private static void MapTables(
}
var mappedCell = content is null
- ? new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(
- cell.RowSpan ?? 1, cell.ColumnSpan ?? 1, kind)
- : new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(
- content, cell.RowSpan ?? 1, cell.ColumnSpan ?? 1, kind);
+ ? new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(span.RowSpan, span.ColumnSpan, kind)
+ : new Microsoft.Extensions.Documents.ExtractionDocumentTableCell(content, span.RowSpan, span.ColumnSpan, kind);
foreach (ExtractionDocumentSourceReference source in cellSources)
{
mappedCell.Sources.Add(source);
diff --git a/DocumentExtraction/src/Shared/ProviderAdapterHelpers.cs b/DocumentExtraction/src/Shared/ProviderAdapterHelpers.cs
index dd42af9..c3b0e8c 100644
--- a/DocumentExtraction/src/Shared/ProviderAdapterHelpers.cs
+++ b/DocumentExtraction/src/Shared/ProviderAdapterHelpers.cs
@@ -145,6 +145,72 @@ public static ExtractionDocumentSourceReference CreateSource(
(points ?? []).Select(point => new ExtractionDocumentPoint(point.X, point.Y)).ToArray(),
nativeRepresentation);
+ /// <summary>
+ /// Reserves the grid positions of a provider table cell so that overlapping provider cells cannot abort the document.
+ /// </summary>
+ /// <returns>
+ /// The span to map the cell with, or <see langword="null"/> when the cell is empty and lies inside another cell's span.
+ /// A non-empty cell whose own position is free keeps its text as a 1x1 cell when its span would overlap.
+ /// </returns>
+ public static (int RowSpan, int ColumnSpan)? ReserveTableCell(
+ bool[,] occupied, int row, int column, int rowSpan, int columnSpan, bool isEmpty, string context)
+ {
+ int rows = occupied.GetLength(0);
+ int columns = occupied.GetLength(1);
+ if (row < 0 || column < 0 || row >= rows || column >= columns)
+ {
+ // Let the table reject the address with its existing exception.
+ return (rowSpan, columnSpan);
+ }
+
+ if (!Overlaps(rowSpan, columnSpan))
+ {
+ Mark(rowSpan, columnSpan);
+ return (rowSpan, columnSpan);
+ }
+
+ if (isEmpty)
+ {
+ return null;
+ }
+
+ if (!occupied[row, column])
+ {
+ Mark(1, 1);
+ return (1, 1);
+ }
+
+ throw new InvalidDataException(
+ $"{context}: cell at row {row}, column {column} has content but lies inside another cell's span.");
+
+ bool Overlaps(int rs, int cs)
+ {
+ for (int r = row; r < Math.Min(rows, row + rs); r++)
+ {
+ for (int c = column; c < Math.Min(columns, column + cs); c++)
+ {
+ if (occupied[r, c])
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ void Mark(int rs, int cs)
+ {
+ for (int r = row; r < Math.Min(rows, row + rs); r++)
+ {
+ for (int c = column; c < Math.Min(columns, column + cs); c++)
+ {
+ occupied[r, c] = true;
+ }
+ }
+ }
+ }
+
public static string? NormalizeTextRole(string? role)
=> role?.ToLowerInvariant() switch
{
diff --git a/DocumentExtraction/test/AzureTestSupport/AzureMappingRegressionTests.cs b/DocumentExtraction/test/AzureTestSupport/AzureMappingRegressionTests.cs
index f2cb6be..3c24b94 100644
--- a/DocumentExtraction/test/AzureTestSupport/AzureMappingRegressionTests.cs
+++ b/DocumentExtraction/test/AzureTestSupport/AzureMappingRegressionTests.cs
@@ -395,6 +395,66 @@ public async Task ExtractAsync_MultipleContents_DoNotCompareIndependentOffsets()
}
#endif
+ [Theory]
+ [InlineData("empty-covered")]
+ [InlineData("text-span-overlap")]
+ [InlineData("text-covered")]
+ public async Task ExtractAsync_OverlappingCellSpans_DoNotAbortDocument(string scenario)
+ {
+ var root = AzureWireFixture.Create();
+ var cells = AzureWireFixture.Content(root)["tables"]![0]!["cells"]!.AsArray();
+ JsonNode Cell(int row, int column, int rowSpan, string text)
+ {
+ var cell = cells[0]!.DeepClone();
+ cell["rowIndex"] = row;
+ cell["columnIndex"] = column;
+ cell["rowSpan"] = rowSpan;
+ cell["columnSpan"] = 1;
+ cell["kind"] = "content";
+ cell["content"] = text;
+ return cell;
+ }
+
+ switch (scenario)
+ {
+ case "empty-covered":
+ // Document Intelligence reports empty 1x1 cells inside another header's span (ParseBench-2 complex_header_006).
+ cells.Add(Cell(1, 1, 1, ""));
+ break;
+ case "text-span-overlap":
+ cells.Add(Cell(1, 2, 1, "Tax"));
+ cells.Add(Cell(0, 2, 2, "Notes"));
+ break;
+ case "text-covered":
+ cells.Add(Cell(1, 1, 1, "Tax"));
+ break;
+ }
+
+ var transport = Replay(AzureWireFixture.Bytes(root));
+ using var client = Create(transport);
+ using var input = new MemoryStream([1, 2, 3]);
+ if (scenario == "text-covered")
+ {
+ var error = await Assert.ThrowsAsync<InvalidDataException>(() => Extract(client, input));
+ Assert.Contains("row 1, column 1", error.Message, StringComparison.Ordinal);
+ return;
+ }
+
+ var result = await Extract(client, input);
+ var table = Assert.Single(result.EnumerateContent().OfType<ExtractionDocumentTableElement>());
+ var header = Assert.IsType<ExtractionDocumentTableCell>(table.Cells[0, 0]);
+ Assert.Equal((2, 2), (header.RowSpan, header.ColumnSpan));
+ Assert.Equal("Total amount", Text(Assert.IsType<ExtractionDocumentTextElement>(header.Content)));
+ Assert.Null(table.Cells[1, 1]);
+ if (scenario == "text-span-overlap")
+ {
+ var notes = Assert.IsType<ExtractionDocumentTableCell>(table.Cells[0, 2]);
+ Assert.Equal((1, 1), (notes.RowSpan, notes.ColumnSpan));
+ Assert.Equal("Notes", Text(Assert.IsType<ExtractionDocumentTextElement>(notes.Content)));
+ Assert.Equal("Tax", Text(Assert.IsType<ExtractionDocumentTextElement>(table.Cells[1, 2]!.Content)));
+ }
+ }
+
private static JsonObject FigureFixture()
{
var root = AzureWireFixture.Create();
--
2.56.1.windows.1
Activity