@glossarist/concept-browser 0.7.43 → 0.7.45

package/src/adapters/factory.ts

@@ -3,16 +3,30 @@ import type { RoutingEntry as ConfigRoutingEntry } from '../config/types';
 import { DatasetAdapter } from './DatasetAdapter';
 import { ReferenceResolver } from './ReferenceResolver';
 import { UriRouter } from './UriRouter';
+import { NonVerbalEntityResolver } from './non-verbal-resolver';
+import { BibliographyAdapter } from './bibliography-adapter';
 
 export class AdapterFactory {
   private adapters = new Map<string, DatasetAdapter>();
+  private bibliographyAdapters = new Map<string, BibliographyAdapter>();
   private crossRefIndex: Record<string, string[]> | null = null;
   readonly uriRouter: UriRouter;
   readonly resolver: ReferenceResolver;
+  readonly nonVerbalResolver: NonVerbalEntityResolver;
 
   constructor() {
     this.uriRouter = new UriRouter();
     this.resolver = new ReferenceResolver(this.uriRouter);
+    this.nonVerbalResolver = new NonVerbalEntityResolver();
+  }
+
+  bibliography(datasetId: string): BibliographyAdapter {
+    let a = this.bibliographyAdapters.get(datasetId);
+    if (!a) {
+      a = new BibliographyAdapter(datasetId);
+      this.bibliographyAdapters.set(datasetId, a);
+    }
+    return a;
   }
 
   async discoverDatasets(datasetsUrl: string): Promise<DatasetAdapter[]> {

package/src/adapters/model-bridge.ts

@@ -169,6 +169,9 @@ interface JsonLdConcept {
   'gl:localizedConcept'?: Record<string, JsonLdLocalizedConcept>;
   'gl:related'?: JsonLdRelated[];
   'gl:tags'?: string[];
+  'gl:figureRef'?: unknown[];
+  'gl:tableRef'?: unknown[];
+  'gl:formulaRef'?: unknown[];
 }
 
 // ── Bridges for fields not yet in glossarist-js ────────────────────────────
@@ -540,6 +543,9 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
     localizations,
     related,
     tags,
+    figures: normalizeEntityRefs(doc['gl:figureRef']),
+    tables: normalizeEntityRefs(doc['gl:tableRef']),
+    formulas: normalizeEntityRefs(doc['gl:formulaRef']),
     status: null,
   });
 
@@ -547,6 +553,51 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   return concept;
 }
 
+/**
+ * Normalize JSON-LD structural entity refs (`gl:figureRef` / `gl:tableRef`
+ * / `gl:formulaRef`) into the shape `NonVerbalReference.fromJSON` expects.
+ *
+ * Accepts three wire forms — bare string ID, `{ "@id": "../kind/foo" }`,
+ * or `{ "@id": "../kind/foo", "gl:display": "Figure 3" }` — and emits the
+ * canonical `{ ref, display? }` shape. The path's last segment is the
+ * entity id; the field name (`figureRef` vs `tableRef` vs `formulaRef`)
+ * is the kind discriminator upstream.
+ */
+function normalizeEntityRefs(raw: unknown): unknown[] {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(normalizeOneEntityRef).filter((v): v is Record<string, string> => v !== null);
+}
+
+function normalizeOneEntityRef(entry: unknown): Record<string, string> | null {
+  if (typeof entry === 'string') {
+    const trimmed = entry.trim();
+    return trimmed ? { ref: trimmed } : null;
+  }
+  if (!entry || typeof entry !== 'object') return null;
+  const obj = entry as Record<string, unknown>;
+  const atId = typeof obj['@id'] === 'string' ? (obj['@id'] as string) : null;
+  const explicitRef = typeof obj.ref === 'string' ? obj.ref
+    : typeof obj.entityId === 'string' ? obj.entityId
+    : typeof obj.entity_id === 'string' ? obj.entity_id
+    : null;
+  const entityId = (atId ? lastPathSegment(atId) : null) ?? explicitRef;
+  if (!entityId) return null;
+  const out: Record<string, string> = { ref: entityId };
+  const display = typeof obj['gl:display'] === 'string' ? obj['gl:display']
+    : typeof obj['gloss:display'] === 'string' ? obj['gloss:display']
+    : typeof obj.display === 'string' ? obj.display
+    : null;
+  if (display) out.display = display;
+  return out;
+}
+
+function lastPathSegment(p: string): string | null {
+  const cleaned = p.replace(/[?#].*$/, '').replace(/\/+$/, '');
+  const segments = cleaned.split('/');
+  const last = segments[segments.length - 1];
+  return last ? decodeURIComponent(last) : null;
+}
+
 // ── Public API ────────────────────────────────────────────────────────────
 
 export function conceptFromJson(doc: Record<string, unknown>): Concept {

package/src/adapters/non-verbal/figure-bridge.ts

@@ -0,0 +1,101 @@
+/**
+ * Figure bridge — JSON-LD → Figure (TS model).
+ *
+ * Wire format (per task 11 + glossarist-ruby's planned export):
+ *
+ *   {
+ *     "@id": "https://glossarist.org/{ds}/figure/{id}",
+ *     "@type": "gl:Figure" | "gloss:Figure",
+ *     "gl:id": "{id}",
+ *     "gl:identifier": "Figure 7c",            // plain string
+ *     "gl:caption": { "eng": "...", "fra": "..." },
+ *     "gl:altText": { "eng": "..." },           // mapped to model.alt
+ *     "gl:description": { "eng": "..." },
+ *     "gl:image": [
+ *       { "gl:src": "x.png", "gl:format": "png", "gl:role": "raster",
+ *         "gl:width": 1600, "gl:height": 1200, "gl:scale": 1 }
+ *     ],
+ *     "gl:subfigure": [ ... recursive Figure docs ... ],
+ *     "gl:source": [ ... NonVerbalSource docs ... ]
+ *   }
+ *
+ * The wire field `gl:altText` is mapped to the model field `alt` to avoid
+ * ambiguity with the HTML `<img alt>` attribute.
+ */
+
+import type { Figure, FigureImage, FigureImageFormat, FigureImageRole } from './types';
+import { isType, pickField, pickFieldArray, pickFieldRecord, localized } from './prefix';
+import { sourcesFromJsonLd } from './source-bridge';
+
+const FORMAT_SET: ReadonlySet<string> = new Set(['svg', 'png', 'jpg', 'jpeg', 'gif', 'webp', 'avif']);
+
+const ROLE_SET: ReadonlySet<string> = new Set(['vector', 'raster', 'dark', 'light', 'print']);
+
+function imageFromJsonLd(raw: Record<string, unknown>): FigureImage | null {
+  const src = pickField<string>(raw, 'src');
+  if (!src) return null;
+  const formatRaw = (pickField<string>(raw, 'format') ?? '').toLowerCase();
+  const format = (FORMAT_SET.has(formatRaw) ? formatRaw : 'svg') as FigureImageFormat;
+  const roleRaw = pickField<string>(raw, 'role');
+  const role = roleRaw && ROLE_SET.has(roleRaw) ? (roleRaw as FigureImageRole) : undefined;
+  const width = pickField<number>(raw, 'width');
+  const height = pickField<number>(raw, 'height');
+  const scale = pickField<number>(raw, 'scale');
+  const img: FigureImage = { src, format };
+  if (role) img.role = role;
+  if (typeof width === 'number') img.width = width;
+  if (typeof height === 'number') img.height = height;
+  if (typeof scale === 'number') img.scale = scale;
+  return img;
+}
+
+function imagesFromJsonLd(raw: unknown): FigureImage[] {
+  if (!Array.isArray(raw)) return [];
+  const out: FigureImage[] = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object') continue;
+    const img = imageFromJsonLd(entry as Record<string, unknown>);
+    if (img) out.push(img);
+  }
+  return out;
+}
+
+function subfiguresFromJsonLd(raw: unknown): Figure[] | undefined {
+  if (!Array.isArray(raw)) return undefined;
+  const out: Figure[] = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object') continue;
+    const sub = figureFromJsonLd(entry as Record<string, unknown>);
+    if (sub) out.push(sub);
+  }
+  return out.length ? out : undefined;
+}
+
+export function figureFromJsonLd(doc: Record<string, unknown>): Figure | null {
+  if (!isType(doc, 'Figure')) return null;
+
+  const id = pickField<string>(doc, 'id') ?? '';
+  if (!id) return null;
+
+  const identifier = pickField<string>(doc, 'identifier');
+  const caption = localized(doc, 'caption');
+  const alt = localized(doc, 'altText');
+  const description = localized(doc, 'description');
+  const images = imagesFromJsonLd(pickFieldArray(doc, 'image'));
+  const subfigures = subfiguresFromJsonLd(pickField(doc, 'subfigure'));
+  const sources = sourcesFromJsonLd(pickField(doc, 'source'));
+
+  const fig: Figure = { kind: 'figure', id, images };
+  if (identifier) fig.identifier = identifier;
+  if (caption) fig.caption = caption;
+  if (alt) fig.alt = alt;
+  if (description) fig.description = description;
+  if (subfigures) fig.subfigures = subfigures;
+  if (sources.length) fig.sources = sources;
+
+  // pickFieldRecord is unused for figures; keep the import meaningful by
+  // ensuring no stray image fields leak through (silent no-op).
+  void pickFieldRecord;
+
+  return fig;
+}

package/src/adapters/non-verbal/formula-bridge.ts

@@ -0,0 +1,48 @@
+/**
+ * Formula bridge — JSON-LD → Formula (TS model).
+ *
+ * Wire format:
+ *
+ *   {
+ *     "@type": "gl:Formula",
+ *     "gl:id": "{id}",
+ *     "gl:identifier": "Formula 5",
+ *     "gl:caption": { ... },
+ *     "gl:description": { ... },
+ *     "gl:expression": { "eng": "E = mc^2", "fra": "E = mc^2" },
+ *     "gl:notation": "latex" | "mathml" | "asciimath",
+ *     "gl:source": [ ... ]
+ *   }
+ */
+
+import type { Formula, FormulaNotation } from './types';
+import { isType, pickField, localized } from './prefix';
+import { sourcesFromJsonLd } from './source-bridge';
+
+const NOTATION_SET: ReadonlySet<string> = new Set(['latex', 'mathml', 'asciimath']);
+
+export function formulaFromJsonLd(doc: Record<string, unknown>): Formula | null {
+  if (!isType(doc, 'Formula')) return null;
+
+  const id = pickField<string>(doc, 'id') ?? '';
+  if (!id) return null;
+
+  const expression = localized(doc, 'expression');
+  if (!expression) return null;
+
+  const notationRaw = (pickField<string>(doc, 'notation') ?? '').toLowerCase();
+  const notation = NOTATION_SET.has(notationRaw) ? (notationRaw as FormulaNotation) : 'latex';
+
+  const identifier = pickField<string>(doc, 'identifier');
+  const caption = localized(doc, 'caption');
+  const description = localized(doc, 'description');
+  const sources = sourcesFromJsonLd(pickField(doc, 'source'));
+
+  const f: Formula = { kind: 'formula', id, expression, notation };
+  if (identifier) f.identifier = identifier;
+  if (caption) f.caption = caption;
+  if (description) f.description = description;
+  if (sources.length) f.sources = sources;
+
+  return f;
+}

package/src/adapters/non-verbal/index.ts

@@ -0,0 +1,55 @@
+/**
+ * Public API for the non-verbal entity model layer.
+ *
+ * Re-exports the types, bridges, and dispatch table. Components and
+ * composables import from here — never from individual files — so the
+ * internal layout can evolve without breaking the public surface.
+ */
+
+export type {
+  LocalizedString,
+  NonVerbalKind,
+  FigureImage,
+  FigureImageFormat,
+  FigureImageRole,
+  NonVerbalSource,
+  NonVerbalSourceOrigin,
+  NonVerbalSourceRef,
+  NonVerbalSourceLocality,
+  NonVerbalEntityBase,
+  Figure,
+  Table,
+  TableContent,
+  TableFormat,
+  Formula,
+  FormulaNotation,
+  NonVerbalEntity,
+  NonVerbRepV3,
+  NonVerbalReference,
+} from './types';
+
+export { isFigure, isTable, isFormula } from './types';
+
+export { figureFromJsonLd } from './figure-bridge';
+export { tableFromJsonLd } from './table-bridge';
+export { formulaFromJsonLd } from './formula-bridge';
+
+export {
+  KIND_TO_DIR,
+  KIND_TO_TYPE_FIELD,
+  KIND_TO_BRIDGE,
+  ALL_KINDS,
+  MENTION_KIND_TO_ENTITY_KIND,
+  kindFromType,
+  entityKindFromMentionKind,
+} from './kind';
+
+export type { BridgeFn } from './kind';
+
+export {
+  pickField,
+  pickFieldArray,
+  pickFieldRecord,
+  isType,
+  localized,
+} from './prefix';

package/src/adapters/non-verbal/kind.ts

@@ -0,0 +1,46 @@
+import type { NonVerbalEntity, NonVerbalKind } from './types';
+import {
+  ENTITY_DIRECTORIES,
+  ENTITY_TYPES,
+} from 'glossarist';
+import { figureFromJsonLd } from './figure-bridge';
+import { tableFromJsonLd } from './table-bridge';
+import { formulaFromJsonLd } from './formula-bridge';
+
+export type BridgeFn = (doc: Record<string, unknown>) => NonVerbalEntity | null;
+
+export const KIND_TO_DIR: Readonly<Record<NonVerbalKind, string>> = Object.freeze(
+  Object.fromEntries(ENTITY_DIRECTORIES),
+) as Readonly<Record<NonVerbalKind, string>>;
+
+export const KIND_TO_TYPE_FIELD: Readonly<Record<NonVerbalKind, string>> = {
+  figure: 'Figure',
+  table: 'Table',
+  formula: 'Formula',
+};
+
+export const KIND_TO_BRIDGE: Readonly<Record<NonVerbalKind, BridgeFn>> = {
+  figure: figureFromJsonLd,
+  table: tableFromJsonLd,
+  formula: formulaFromJsonLd,
+};
+
+export const ALL_KINDS: readonly NonVerbalKind[] = ENTITY_TYPES as readonly NonVerbalKind[];
+
+export const MENTION_KIND_TO_ENTITY_KIND: Readonly<Record<string, NonVerbalKind>> = {
+  'fig-ref': 'figure',
+  'table-ref': 'table',
+  'formula-ref': 'formula',
+};
+
+export function kindFromType(typeField: string): NonVerbalKind | null {
+  const bare = typeField.replace(/^(gl|gloss):/, '');
+  for (const k of ALL_KINDS) {
+    if (bare === KIND_TO_TYPE_FIELD[k]) return k;
+  }
+  return null;
+}
+
+export function entityKindFromMentionKind(mentionKind: string): NonVerbalKind | null {
+  return MENTION_KIND_TO_ENTITY_KIND[mentionKind] ?? null;
+}

package/src/adapters/non-verbal/prefix.ts

@@ -0,0 +1,67 @@
+/**
+ * Vocabulary prefix helper.
+ *
+ * The concept-browser JSON-LD corpus uses the `gl:` prefix. glossarist-ruby's
+ * `glossarist export` is planned to emit `gloss:` prefix. Until the
+ * cross-repo vocabulary issue is resolved (see AUDIT.figures.md §"Open
+ * issue: vocabulary prefix"), bridges must accept both prefixes.
+ *
+ * `pickField` is the single accessor every bridge uses — centralizing the
+ * dual-prefix handling here means removing the legacy prefix later is a
+ * one-file change.
+ */
+
+const PREFIXES = ['gl', 'gloss'] as const;
+
+export function pickField<T = unknown>(
+  doc: Record<string, unknown>,
+  field: string,
+): T | undefined {
+  for (const p of PREFIXES) {
+    const k = `${p}:${field}`;
+    if (doc[k] !== undefined) return doc[k] as T;
+  }
+  return undefined;
+}
+
+export function pickFieldArray<T = unknown>(
+  doc: Record<string, unknown>,
+  field: string,
+): T[] {
+  const v = pickField<T[]>(doc, field);
+  return Array.isArray(v) ? v : [];
+}
+
+export function pickFieldRecord<V = unknown>(
+  doc: Record<string, unknown>,
+  field: string,
+): Record<string, V> | undefined {
+  const v = pickField<unknown>(doc, field);
+  if (v && typeof v === 'object' && !Array.isArray(v)) {
+    return v as Record<string, V>;
+  }
+  return undefined;
+}
+
+export function isType(doc: Record<string, unknown>, typeShort: string): boolean {
+  const t = doc['@type'];
+  if (typeof t !== 'string') return false;
+  for (const p of PREFIXES) {
+    if (t === `${p}:${typeShort}`) return true;
+  }
+  return false;
+}
+
+export function localized(doc: Record<string, unknown>, field: string): Record<string, string> | undefined {
+  const v = pickField<unknown>(doc, field);
+  if (!v) return undefined;
+  if (typeof v === 'string') return { eng: v };
+  if (typeof v === 'object' && !Array.isArray(v)) {
+    const out: Record<string, string> = {};
+    for (const [k, val] of Object.entries(v)) {
+      if (typeof val === 'string') out[k] = val;
+    }
+    return Object.keys(out).length ? out : undefined;
+  }
+  return undefined;
+}

package/src/adapters/non-verbal/source-bridge.ts

@@ -0,0 +1,81 @@
+/**
+ * Source bridge — converts JSON-LD source entries to NonVerbalSource.
+ *
+ * Shared by Figure, Table, Formula bridges (all three use the same source
+ * shape, mirroring glossarist's ConceptSource). One function, one shape.
+ */
+
+import type { NonVerbalSource, NonVerbalSourceOrigin, NonVerbalSourceRef, NonVerbalSourceLocality } from './types';
+import { pickField } from './prefix';
+
+function refFromJsonLd(raw: Record<string, unknown> | string | undefined): NonVerbalSourceRef | undefined {
+  if (!raw) return undefined;
+  if (typeof raw === 'string') return { source: raw };
+  const r: NonVerbalSourceRef = {};
+  const source = pickField<string>(raw, 'source');
+  const id = pickField<string>(raw, 'id');
+  const version = pickField<string>(raw, 'version');
+  const text = pickField<string>(raw, 'text');
+  if (source) r.source = source;
+  if (id) r.id = id;
+  if (version) r.version = version;
+  if (text) r.text = text;
+  return Object.keys(r).length ? r : undefined;
+}
+
+function localityFromJsonLd(raw: Record<string, unknown> | undefined): NonVerbalSourceLocality | undefined {
+  if (!raw) return undefined;
+  const out: NonVerbalSourceLocality = {};
+  const t = pickField<string>(raw, 'localityType') ?? (raw.type as string | undefined);
+  const rf = pickField<string>(raw, 'referenceFrom') ?? (raw.reference_from as string | undefined);
+  const rt = pickField<string>(raw, 'referenceTo') ?? (raw.reference_to as string | undefined);
+  if (t) out.type = t;
+  if (rf) out.referenceFrom = rf;
+  if (rt) out.referenceTo = rt;
+  return Object.keys(out).length ? out : undefined;
+}
+
+function originFromJsonLd(raw: Record<string, unknown> | undefined): NonVerbalSourceOrigin | undefined {
+  if (!raw) return undefined;
+  const out: NonVerbalSourceOrigin = {};
+  const ref = refFromJsonLd(pickField<Record<string, unknown>>(raw, 'ref'));
+  const locality = localityFromJsonLd(pickField<Record<string, unknown>>(raw, 'locality'));
+  const link = pickField<string>(raw, 'link');
+  const id = pickField<string>(raw, 'id');
+  const version = pickField<string>(raw, 'version');
+  const source = pickField<string>(raw, 'source');
+  if (ref) out.ref = ref;
+  if (locality) out.locality = locality;
+  if (link) out.link = link;
+  if (id) out.id = id;
+  if (version) out.version = version;
+  if (source) out.source = source;
+  return Object.keys(out).length ? out : undefined;
+}
+
+export function sourceFromJsonLd(raw: Record<string, unknown> | undefined): NonVerbalSource | undefined {
+  if (!raw) return undefined;
+  const out: NonVerbalSource = {};
+  const id = pickField<string>(raw, 'id');
+  const type = pickField<string>(raw, 'sourceType') ?? pickField<string>(raw, 'type');
+  const status = pickField<string>(raw, 'sourceStatus') ?? pickField<string>(raw, 'status');
+  const modification = pickField<string>(raw, 'modification');
+  const origin = originFromJsonLd(pickField<Record<string, unknown>>(raw, 'origin'));
+  if (id) out.id = id;
+  if (type) out.type = type;
+  if (status) out.status = status;
+  if (modification) out.modification = modification;
+  if (origin) out.origin = origin;
+  return Object.keys(out).length ? out : undefined;
+}
+
+export function sourcesFromJsonLd(raw: unknown): NonVerbalSource[] {
+  if (!Array.isArray(raw)) return [];
+  const out: NonVerbalSource[] = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object') continue;
+    const s = sourceFromJsonLd(entry as Record<string, unknown>);
+    if (s) out.push(s);
+  }
+  return out;
+}

package/src/adapters/non-verbal/table-bridge.ts

@@ -0,0 +1,98 @@
+/**
+ * Table bridge — JSON-LD → Table (TS model).
+ *
+ * Wire format:
+ *
+ *   {
+ *     "@type": "gl:Table",
+ *     "gl:id": "{id}",
+ *     "gl:identifier": "Table 2",
+ *     "gl:caption": { ... },
+ *     "gl:description": { ... },
+ *     "gl:content": {
+ *       "gl:type": "structured" | "markup",
+ *       "gl:headers": [ { "eng": "..." }, ... ],   // structured
+ *       "gl:rows": [ [ { "eng": "..." }, ... ], ... ],   // structured
+ *       "gl:markup": { "eng": "<table>...</table>" }   // markup
+ *     },
+ *     "gl:format": "html" | "markdown" | "asciidoc",
+ *     "gl:source": [ ... ]
+ *   }
+ */
+
+import type { Table, TableContent, TableFormat } from './types';
+import { isType, pickField, localized } from './prefix';
+import { sourcesFromJsonLd } from './source-bridge';
+
+const FORMAT_SET: ReadonlySet<string> = new Set(['html', 'markdown', 'asciidoc']);
+
+function isLocalizedObj(v: unknown): v is Record<string, string> {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return false;
+  return Object.values(v).every(x => typeof x === 'string');
+}
+
+function contentFromJsonLd(raw: unknown): TableContent | null {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  const c = raw as Record<string, unknown>;
+  const typeRaw = (pickField<string>(c, 'type') ?? '').toLowerCase();
+
+  if (typeRaw === 'markup') {
+    const markup = localized(c, 'markup');
+    if (!markup) return null;
+    return { kind: 'markup', markup };
+  }
+
+  if (typeRaw === 'structured' || !typeRaw) {
+    const headersRaw = pickField<unknown[]>(c, 'headers');
+    const rowsRaw = pickField<unknown[]>(c, 'rows');
+    if (!Array.isArray(headersRaw) || !Array.isArray(rowsRaw)) return null;
+
+    const headers: Record<string, string>[] = [];
+    for (const h of headersRaw) {
+      if (isLocalizedObj(h)) headers.push(h);
+    }
+    if (headers.length === 0) return null;
+
+    const rows: Record<string, string>[][] = [];
+    for (const r of rowsRaw) {
+      if (!Array.isArray(r)) continue;
+      const cells: Record<string, string>[] = [];
+      for (const cell of r) {
+        if (isLocalizedObj(cell)) cells.push(cell);
+      }
+      if (cells.length) rows.push(cells);
+    }
+    if (rows.length === 0) return null;
+
+    return { kind: 'structured', headers, rows };
+  }
+
+  return null;
+}
+
+export function tableFromJsonLd(doc: Record<string, unknown>): Table | null {
+  if (!isType(doc, 'Table')) return null;
+
+  const id = pickField<string>(doc, 'id') ?? '';
+  if (!id) return null;
+
+  const identifier = pickField<string>(doc, 'identifier');
+  const caption = localized(doc, 'caption');
+  const description = localized(doc, 'description');
+  const content = contentFromJsonLd(pickField(doc, 'content'));
+  if (!content) return null;
+
+  const formatRaw = (pickField<string>(doc, 'format') ?? '').toLowerCase();
+  const format = FORMAT_SET.has(formatRaw) ? (formatRaw as TableFormat) : undefined;
+
+  const sources = sourcesFromJsonLd(pickField(doc, 'source'));
+
+  const t: Table = { kind: 'table', id, content };
+  if (identifier) t.identifier = identifier;
+  if (caption) t.caption = caption;
+  if (description) t.description = description;
+  if (format) t.format = format;
+  if (sources.length) t.sources = sources;
+
+  return t;
+}