glossarist 0.4.49 → 0.4.51

package/src/models/related-concept.ts

@@ -1,117 +0,0 @@
-import { GlossaristModel } from './base.js';
-import { ConceptRef } from './concept-ref.js';
-import type { ConceptRefJson } from './concept-ref.js';
-import type { LocalizedString } from './generic-member.js';
-
-export const RELATIONSHIP_TYPES: ReadonlyArray<string> = Object.freeze([
-  // Lifecycle (ISO 10241-1)
-  'deprecates', 'deprecated_by', 'supersedes', 'superseded_by',
-  'replaces', 'replaced_by', 'invalidates', 'invalidated_by',
-  'retires', 'retired_by',
-  // Hierarchical (SKOS)
-  'broader', 'narrower',
-  // ISO 25964 generic
-  'broader_generic', 'narrower_generic',
-  // ISO 25964 partitive
-  'broader_partitive', 'narrower_partitive',
-  // ISO 25964 instantial
-  'broader_instantial', 'narrower_instantial',
-  // ISO 19135 concept-to-concept
-  'has_concept', 'is_concept_of', 'instance_of', 'has_instance',
-  'has_definition', 'definition_of', 'has_part', 'is_part_of',
-  'inherits', 'inherited_by',
-  // ISO 19135 versioning
-  'has_version', 'version_of', 'current_version', 'current_version_of',
-  // SKOS mapping
-  'equivalent', 'close_match', 'broad_match', 'narrow_match', 'related_match',
-  // Associative (ISO 10241-1 / ISO 25964)
-  'see', 'related_concept', 'related_concept_broader', 'related_concept_narrower',
-  'references',
-  // ExternalConcept resolution (Glossarist extension). Direction: real
-  // concept `provides` substance for an external concept; external concept
-  // `provided_by` real concept. Stored on the ExternalConcept.
-  'provides', 'provided_by',
-  // Comparative (ISO 10241-1)
-  'compare', 'contrast',
-  // Spatiotemporal (ISO 25964 / TBX)
-  'sequentially_related_concept', 'spatially_related_concept', 'temporally_related_concept',
-  // Lexical (ISO 12620 / TBX)
-  'homograph', 'false_friend',
-]);
-
-export type RelationshipType = string;
-
-export interface RelatedConceptJson {
-  type?: RelationshipType;
-  content?: LocalizedString | string | null;
-  ref?: ConceptRefJson | ConceptRef | null;
-}
-
-export class RelatedConcept extends GlossaristModel {
-  readonly type: RelationshipType;
-  readonly content: LocalizedString | null;
-  readonly ref: ConceptRef | null;
-
-  constructor(data: RelatedConceptJson = {}) {
-    super();
-    this.type = data.type ?? 'see';
-    this.content = _normalizeContent(data.content);
-    this.ref = data.ref
-      ? data.ref instanceof ConceptRef
-        ? data.ref
-        : new ConceptRef(data.ref)
-      : null;
-  }
-
-  /**
-   * Convenience reader: returns the first available string value from
-   * the localized hash, or null if absent.
-   */
-  get contentString(): string | null {
-    if (!this.content) return null;
-    const values = Object.values(this.content);
-    return values.length > 0 ? (values[0] ?? null) : null;
-  }
-
-  override toJSON(): RelatedConceptJson {
-    const obj: RelatedConceptJson = { type: this.type };
-    if (this.content != null) obj.content = this.content;
-    if (this.ref != null) obj.ref = this.ref.toJSON();
-    return obj;
-  }
-
-  static identityOf(
-    value: {
-      type?: string;
-      ref?: { source?: string | null; id?: string | null } | null;
-    } | null | undefined,
-  ): string {
-    const v = value ?? {};
-    const ref = v.ref;
-    return `${v.type ?? ''}|${ref?.source ?? ''}|${ref?.id ?? ''}`;
-  }
-
-  override identity(): string {
-    return RelatedConcept.identityOf(this);
-  }
-
-  static override fromJSON(data: RelatedConceptJson): RelatedConcept {
-    return new RelatedConcept(data);
-  }
-}
-
-function _normalizeContent(
-  value: LocalizedString | string | null | undefined,
-): LocalizedString | null {
-  if (value == null) return null;
-  if (typeof value === 'string') return { default: value };
-  if (typeof value === 'object') {
-    const entries = Object.entries(value).filter(
-      ([, v]) => typeof v === 'string',
-    );
-    return entries.length > 0
-      ? (Object.fromEntries(entries) as LocalizedString)
-      : null;
-  }
-  return null;
-}

package/src/models/relation-categories.ts

@@ -1,167 +0,0 @@
-// Categorization SSOT for the 52 glossarist relationship types.
-
-import { RELATIONSHIP_TYPES } from './related-concept.js';
-
-export interface CategoryDefinition {
-  label: string;
-  description: string;
-  types: ReadonlyArray<string>;
-}
-
-type CategoryKey =
-  | 'lifecycle'
-  | 'hierarchical'
-  | 'associative'
-  | 'comparative'
-  | 'spatiotemporal'
-  | 'lexical'
-  | 'mapping'
-  | 'definitional';
-
-/**
- * Each type in RELATIONSHIP_TYPES belongs to exactly one category. The
- * categories mirror the concept-model taxonomy. Adding a new type
- * means adding a taxonomy entry — no code changes here.
- */
-export const RELATION_CATEGORIES: Readonly<Record<CategoryKey, CategoryDefinition>> = Object.freeze({
-  lifecycle: Object.freeze({
-    label: 'Lifecycle',
-    description: 'Concept lifecycle transitions: supersession, deprecation, replacement.',
-    types: Object.freeze([
-      'deprecates', 'deprecated_by',
-      'supersedes', 'superseded_by',
-      'replaces', 'replaced_by',
-      'invalidates', 'invalidated_by',
-      'retires', 'retired_by',
-    ]),
-  }) as CategoryDefinition,
-
-  hierarchical: Object.freeze({
-    label: 'Hierarchical',
-    description: 'Broader/narrower relations, including SKOS and ISO 25964 generic/partitive/instantial.',
-    types: Object.freeze([
-      'broader', 'narrower',
-      'broader_generic', 'narrower_generic',
-      'broader_partitive', 'narrower_partitive',
-      'broader_instantial', 'narrower_instantial',
-    ]),
-  }) as CategoryDefinition,
-
-  associative: Object.freeze({
-    label: 'Associative',
-    description: 'Generic see-also references between concepts.',
-    types: Object.freeze([
-      'see', 'related_concept',
-      'related_concept_broader', 'related_concept_narrower',
-      'references',
-    ]),
-  }) as CategoryDefinition,
-
-  comparative: Object.freeze({
-    label: 'Comparative',
-    description: 'Compare / contrast relations between concepts.',
-    types: Object.freeze(['compare', 'contrast']),
-  }) as CategoryDefinition,
-
-  spatiotemporal: Object.freeze({
-    label: 'Spatiotemporal',
-    description: 'Sequential, spatial, and temporal relations.',
-    types: Object.freeze([
-      'sequentially_related_concept',
-      'spatially_related_concept',
-      'temporally_related_concept',
-    ]),
-  }) as CategoryDefinition,
-
-  lexical: Object.freeze({
-    label: 'Lexical',
-    description: 'Lexical relations between designations across languages.',
-    types: Object.freeze(['homograph', 'false_friend']),
-  }) as CategoryDefinition,
-
-  mapping: Object.freeze({
-    label: 'Mapping',
-    description: 'SKOS mapping properties for cross-vocabulary alignment.',
-    types: Object.freeze([
-      'equivalent', 'close_match',
-      'broad_match', 'narrow_match', 'related_match',
-    ]),
-  }) as CategoryDefinition,
-
-  definitional: Object.freeze({
-    label: 'Definitional',
-    description: 'ISO 19135 concept-to-concept relations: definition, part, instance, inheritance, versioning.',
-    types: Object.freeze([
-      'has_concept', 'is_concept_of',
-      'instance_of', 'has_instance',
-      'has_definition', 'definition_of',
-      'has_part', 'is_part_of',
-      'inherits', 'inherited_by',
-      'has_version', 'version_of',
-      'current_version', 'current_version_of',
-      'provides', 'provided_by',
-    ]),
-  }) as CategoryDefinition,
-});
-
-const _CATEGORY_BY_TYPE: ReadonlyMap<string, string> = (() => {
-  const map = new Map<string, string>();
-  for (const [cat, def] of Object.entries(RELATION_CATEGORIES)) {
-    for (const t of def.types) map.set(t, cat);
-  }
-  return map;
-})();
-
-const _CATEGORY_ALIASES: Readonly<Record<string, string>> = {
-  conceptInstance: 'definitional',
-  versioning: 'definitional',
-};
-
-/**
- * Returns the category key for the given relationship type, or null
- * when the type is not categorized.
- */
-export function categoryOf(type: string): string | null {
-  return _CATEGORY_BY_TYPE.get(type) ?? null;
-}
-
-/**
- * Returns the category definition for the given category key.
- * Accepts both canonical names (definitional) and aliases from
- * earlier glossarist-js versions.
- */
-export function categoryDefinition(categoryKey: string): CategoryDefinition | null {
-  const canonical = _CATEGORY_ALIASES[categoryKey] ?? categoryKey;
-  return (RELATION_CATEGORIES as Readonly<Record<string, CategoryDefinition>>)[canonical] ?? null;
-}
-
-/**
- * MECE sanity check. Returns the list of relationship types that are
- * NOT categorized.
- */
-export function uncategorizedTypes(): string[] {
-  return RELATIONSHIP_TYPES.filter((t) => !_CATEGORY_BY_TYPE.has(t));
-}
-
-/**
- * MECE sanity check. Returns a list of { type, count } entries for any
- * type that appears in MORE than one category.
- */
-export function duplicatedTypes(): ReadonlyArray<{ type: string; count: number }> {
-  const counts = new Map<string, number>();
-  for (const def of Object.values(RELATION_CATEGORIES)) {
-    for (const t of def.types) {
-      counts.set(t, (counts.get(t) ?? 0) + 1);
-    }
-  }
-  const out: { type: string; count: number }[] = [];
-  for (const [type, count] of counts) {
-    if (count > 1) out.push({ type, count });
-  }
-  return out;
-}
-
-export {
-  RELATION_CATEGORIES as RELATION_CATEGORIES_READONLY,
-  type CategoryKey as RelationCategoryKey,
-};

package/src/models/relation-colors.ts

@@ -1,90 +0,0 @@
-// Default color palette for relation categories and individual types.
-//
-// The defaults mirror concept-browser/data/colors.json. Per-deployment
-// overrides pass through resolveRelationColor(type, { overrides, mode })
-// and take precedence over category defaults.
-
-import { categoryOf, categoryDefinition } from './relation-categories.js';
-
-export interface ColorPair {
-  light: string;
-  dark: string;
-}
-
-export interface RelationColorPalette {
-  byCategory: Readonly<Record<string, ColorPair>>;
-  byType: Readonly<Record<string, ColorPair>>;
-}
-
-export interface ResolveRelationColorOptions {
-  overrides?: Partial<RelationColorPalette>;
-  mode?: 'light' | 'dark';
-}
-
-/**
- * One { light, dark } pair per category. Keeping these in glossarist-js
- * lets the defaults ship with the library; consumers only need to
- * customize when they want to deviate.
- */
-export const RELATION_COLOR_DEFAULTS: RelationColorPalette = Object.freeze({
-  byCategory: Object.freeze({
-    lifecycle:      { light: '#B43A2E', dark: '#F87171' },
-    hierarchical:   { light: '#1F6FEB', dark: '#6EA8FE' },
-    associative:    { light: '#6B7280', dark: '#9CA3AF' },
-    comparative:    { light: '#A855F7', dark: '#C4B5FD' },
-    spatiotemporal: { light: '#0D9488', dark: '#5EEAD4' },
-    lexical:        { light: '#D97706', dark: '#FBBF24' },
-    mapping:        { light: '#2563EB', dark: '#93BBFD' },
-    definitional:   { light: '#65A30D', dark: '#A3E635' },
-  }) as Readonly<Record<string, ColorPair>>,
-  byType: Object.freeze({}) as Readonly<Record<string, ColorPair>>,
-});
-
-/**
- * Resolves the color for a relationship type. Resolution order:
- *   1. overrides.byType[type]
- *   2. RELATION_COLOR_DEFAULTS.byType[type]
- *   3. overrides.byCategory[category]
- *   4. RELATION_COLOR_DEFAULTS.byCategory[category]
- *   5. null (uncategorized or unrecognized type)
- */
-export function resolveRelationColor(
-  type: string,
-  options: ResolveRelationColorOptions = {},
-): string | null {
-  const mode = options.mode ?? 'light';
-  const overrides = options.overrides ?? {};
-  const typeOverride = overrides.byType?.[type] ?? RELATION_COLOR_DEFAULTS.byType[type];
-  if (typeOverride) return pickMode(typeOverride, mode);
-
-  const category = categoryOf(type);
-  if (!category) return null;
-
-  const categoryOverride =
-    overrides.byCategory?.[category] ?? RELATION_COLOR_DEFAULTS.byCategory[category];
-  if (!categoryOverride) return null;
-
-  return pickMode(categoryOverride, mode);
-}
-
-/**
- * Returns the { light, dark } pair for a category, merging overrides
- * over defaults. Useful for UIs that want to render a legend.
- */
-export function categoryColorPair(
-  categoryKey: string,
-  overrides: { byCategory?: Record<string, Partial<ColorPair>> } = {},
-): ColorPair | null {
-  const def = categoryDefinition(categoryKey);
-  if (!def) return null;
-  const fromOverride = overrides.byCategory?.[categoryKey];
-  const fromDefault = RELATION_COLOR_DEFAULTS.byCategory[categoryKey];
-  if (!fromDefault && !fromOverride) return null;
-  return { ...(fromDefault ?? { light: '', dark: '' }), ...(fromOverride ?? {}) } as ColorPair;
-}
-
-function pickMode(pair: ColorPair | string | null, mode: 'light' | 'dark'): string | null {
-  if (pair == null) return null;
-  if (typeof pair === 'string') return pair;
-  return pair[mode] ?? pair.light ?? pair.dark ?? null;
-}

package/src/models/relation-loader.ts

@@ -1,115 +0,0 @@
-// HyperedgeLoader — runtime loader for per-file hyperedge YAMLs.
-//
-// Walks a `relations/<comprehensive-id>/<slug>.yaml` directory and
-// dispatches each file to the appropriate class (PartitiveHyperedge,
-// GenericHyperedge, future leaves) based on its `type` field, via
-// HyperedgeRegistry.
-
-import { readdirSync, readFileSync, existsSync } from 'node:fs';
-import type { Dirent } from 'node:fs';
-import * as yaml from 'js-yaml';
-import { HyperedgeRegistry } from './hyperedge-registry.js';
-import type { HyperedgeClass } from './hyperedge-registry.js';
-import type { AbstractHyperedge } from './abstract-hyperedge.js';
-
-interface HyperedgeDocument {
-  type: string;
-  [key: string]: unknown;
-}
-
-interface HyperedgeClassWithFromJson extends HyperedgeClass {
-  fromJSON(data: unknown): AbstractHyperedge;
-}
-
-/**
- * Backward-compat: snapshot of registered classes keyed by typeTag.
- * Prefer HyperedgeRegistry.forTypeTag() for new code — this snapshot
- * is frozen at module load and won't pick up runtime registrations
- * from tests (the OCP test in Phase 11 registers a mock type after
- * import).
- */
-export const TYPE_TO_CLASS = new Proxy(
-  {} as Record<string, HyperedgeClass>,
-  {
-    get(_target: unknown, prop: string | symbol): HyperedgeClass | null {
-      return typeof prop === 'string' ? HyperedgeRegistry.forTypeTag(prop) : null;
-    },
-    ownKeys(): string[] {
-      return HyperedgeRegistry.allTypeTags();
-    },
-    getOwnPropertyDescriptor(): PropertyDescriptor {
-      return { enumerable: true, configurable: true };
-    },
-  },
-);
-
-/**
- * Thrown by `loadAll` when a relation file has an unknown `type`,
- * malformed structure, or a class that fails to instantiate.
- */
-export class RelationLoadError extends Error {
-  readonly path: string;
-  constructor(path: string, message: string) {
-    super(`relation-loader: ${path}: ${message}`);
-    this.path = path;
-  }
-}
-
-/**
- * Walk a `relations/` directory and load every relation file,
- * returning a Map keyed by comprehensive-id.
- *
- * Returns an empty Map if `relationsDir` doesn't exist or is empty.
- */
-export function loadAll(
-  relationsDir: string | null | undefined,
-): Map<string, AbstractHyperedge[]> {
-  const result = new Map<string, AbstractHyperedge[]>();
-  if (!relationsDir) return result;
-  if (!existsSync(relationsDir)) return result;
-
-  const entries = readdirSync(relationsDir, { withFileTypes: true });
-  for (const compEntry of entries as Dirent[]) {
-    if (!compEntry.isDirectory()) continue;
-    const compId = compEntry.name;
-    const compDir = `${relationsDir}/${compId}`;
-    if (!result.has(compId)) result.set(compId, []);
-    const files = readdirSync(compDir)
-      .filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
-      .sort();
-    for (const file of files) {
-      const path = `${compDir}/${file}`;
-      const rel = loadOne(path);
-      if (rel) result.get(compId)?.push(rel);
-    }
-  }
-  return result;
-}
-
-/**
- * Namespace bundle for the loader — callers import it as
- * `import { RelationLoader } from './relation-loader.js'` and call
- * `RelationLoader.loadAll(dir)`. The individual functions are also
- * exported directly for tree-shakeable single-call sites.
- */
-export const RelationLoader = Object.freeze({ loadAll, loadOne });
-
-/**
- * Load a single relation file. Returns null if the file is missing,
- * unreadable, or doesn't have a recognized `type` field. Throws
- * `RelationLoadError` on malformed content.
- */
-export function loadOne(path: string): AbstractHyperedge | null {
-  let doc: unknown;
-  try {
-    doc = yaml.load(readFileSync(path, 'utf8'));
-  } catch (e) {
-    throw new RelationLoadError(path, `YAML parse failed: ${(e as Error).message}`);
-  }
-  if (!doc || typeof doc !== 'object') return null;
-  const d = doc as HyperedgeDocument;
-  if (!d.type) return null;
-  const Cls = HyperedgeRegistry.forTypeTag(d.type) as HyperedgeClassWithFromJson | null;
-  if (!Cls) return null;
-  return Cls.fromJSON(d);
-}

package/src/models/section.ts

@@ -1,61 +0,0 @@
-import { GlossaristModel } from './base.js';
-import type { LocalizedString } from './generic-member.js';
-
-export const ORDERING_METHODS: ReadonlyArray<string> = Object.freeze([
-  'systematic',
-  'mixed',
-  'alphabetical',
-]);
-
-export type OrderingMethod = string;
-
-export interface SectionJson {
-  id?: string | null;
-  names?: LocalizedString;
-  ordering?: OrderingMethod | null;
-  children?: ReadonlyArray<SectionJson | Section>;
-}
-
-export class Section extends GlossaristModel {
-  readonly id: string | null;
-  readonly names: LocalizedString;
-  readonly ordering: OrderingMethod | null;
-  readonly children: ReadonlyArray<Section>;
-
-  constructor(data: SectionJson = {}) {
-    super();
-    this.id = data.id ?? null;
-    this.names = (data.names as LocalizedString) ?? {};
-    this.ordering = data.ordering ?? null;
-    this.children = (data.children ?? []).map((c) =>
-      c instanceof Section ? c : new Section(c as SectionJson),
-    );
-  }
-
-  name(lang: string): string | null {
-    return this.names[lang] ?? this.names['eng'] ?? null;
-  }
-
-  descendantById(id: string): Section | null {
-    for (const child of this.children) {
-      if (child.id === id) return child;
-      const found = child.descendantById(id);
-      if (found) return found;
-    }
-    return null;
-  }
-
-  override toJSON(): SectionJson {
-    const obj: SectionJson = { id: this.id };
-    if (Object.keys(this.names).length > 0) obj.names = { ...this.names };
-    if (this.ordering != null) obj.ordering = this.ordering;
-    if (this.children.length > 0) {
-      obj.children = this.children.map((c) => c.toJSON());
-    }
-    return obj;
-  }
-
-  static override fromJSON(data: SectionJson): Section {
-    return new Section(data);
-  }
-}

package/src/models/sequential-hyperedge.ts

@@ -1,70 +0,0 @@
-// SequentialHyperedge — an ISO 12620 A.6.3 / ISO 704:2022 §5.5.5
-// sequential relation connecting a comprehensive concept to two or
-// more subordinate concepts in an ORDERED sequence (temporal,
-// spatial, causal, developmental).
-//
-// Mirror of PartitiveHyperedge and GenericHyperedge. Member array
-// order IS significant — reversing the array reverses the sequence.
-// Use cases: manufacturing process steps, biological life cycles,
-// software release lifecycles, supply chain stages, geological eras.
-
-import { AbstractHyperedge } from './abstract-hyperedge.js';
-import type { AbstractHyperedgeJson } from './abstract-hyperedge.js';
-import { SequentialMember } from './sequential-member.js';
-import type { SequentialMemberJson } from './sequential-member.js';
-import { HyperedgeRegistry } from './hyperedge-registry.js';
-
-export interface SequentialHyperedgeJson extends AbstractHyperedgeJson {
-  members: ReadonlyArray<SequentialMemberJson | SequentialMember>;
-}
-
-export class SequentialHyperedge extends AbstractHyperedge {
-  // Per-class metadata block — the OCP contract.
-  static wireKey = 'sequential_relations' as const;
-  static typeTag = 'sequential_relation' as const;
-  static rdfType = 'gloss:SequentialRelation' as const;
-  static memberClass = SequentialMember;
-  static v1WireKeys: ReadonlyArray<string> = [];
-  static kindLabel = 'SEQ';
-
-  declare readonly members: ReadonlyArray<SequentialMember>;
-
-  constructor(data: Partial<SequentialHyperedgeJson> = {}) {
-    super({
-      comprehensive: data.comprehensive ?? {},
-      members: data.members ?? [],
-      completeness: data.completeness ?? 'complete',
-      criterion: data.criterion,
-      sources: data.sources,
-      notes: data.notes,
-      status: data.status,
-    });
-    this.members = (Array.isArray(data.members) ? data.members : []).map((m) =>
-      m instanceof SequentialMember ? m : new SequentialMember(m as SequentialMemberJson),
-    );
-  }
-
-  static identityOf(
-    value: {
-      comprehensive?: { source?: string | null; id?: string | null } | null;
-      members?: ReadonlyArray<{ ref?: { source?: string | null; id?: string | null } | null } | null>;
-    } | null | undefined,
-  ): string {
-    const v = value ?? {};
-    const c = v.comprehensive ?? {};
-    // For sequential, member order IS significant — do NOT sort.
-    const memberKeys = (v.members ?? []).map((m) => {
-      const r = m?.ref ?? (m as { source?: string; id?: string } | null) ?? {};
-      return `${r.source ?? ''}:${r.id ?? ''}`;
-    });
-    return `${c.source ?? ''}:${c.id ?? ''}|${memberKeys.join('|')}`;
-  }
-
-  static override fromJSON(data: SequentialHyperedgeJson): SequentialHyperedge {
-    return new SequentialHyperedge(data);
-  }
-}
-
-export default SequentialHyperedge;
-
-HyperedgeRegistry.register(SequentialHyperedge);

package/src/models/shared-non-verbal-entity.ts

@@ -1,36 +0,0 @@
-import { NonVerbalEntity } from './non-verbal-entity.js';
-import type { NonVerbalEntityJson } from './non-verbal-entity.js';
-
-export interface SharedNonVerbalEntityJson extends NonVerbalEntityJson {
-  id?: string | null;
-  identifier?: string | null;
-}
-
-export class SharedNonVerbalEntity extends NonVerbalEntity {
-  readonly id: string | null;
-  readonly identifier: string | null;
-
-  constructor(data: SharedNonVerbalEntityJson = {}) {
-    super(data);
-    this.id = data.id ?? null;
-    this.identifier = data.identifier ?? null;
-  }
-
-  override findById(targetId: string): this | null {
-    return this.id === targetId ? this : null;
-  }
-  override allIds(): string[] {
-    return this.id != null ? [this.id] : [];
-  }
-
-  override toJSON(): SharedNonVerbalEntityJson {
-    const obj = super.toJSON() as SharedNonVerbalEntityJson;
-    if (this.id != null) obj.id = this.id;
-    if (this.identifier != null) obj.identifier = this.identifier;
-    return obj;
-  }
-
-  static override fromJSON(data: SharedNonVerbalEntityJson): SharedNonVerbalEntity {
-    return SharedNonVerbalEntity.fromData(data);
-  }
-}

package/src/models/table.ts

@@ -1,36 +0,0 @@
-import { SharedNonVerbalEntity } from './shared-non-verbal-entity.js';
-import type { SharedNonVerbalEntityJson } from './shared-non-verbal-entity.js';
-import { NonVerbalEntity } from './non-verbal-entity.js';
-
-export interface TableJson extends SharedNonVerbalEntityJson {
-  content?: string | null;
-  format?: string | null;
-}
-
-export class Table extends SharedNonVerbalEntity {
-  readonly content: string | null;
-  readonly format: string | null;
-
-  constructor(data: TableJson = {}) {
-    super(data);
-    this.content = data.content ?? null;
-    this.format = data.format ?? null;
-  }
-
-  override rdfClass(): string {
-    return 'Table';
-  }
-
-  override toJSON(): TableJson {
-    const obj = super.toJSON() as TableJson;
-    if (this.content != null) obj.content = this.content;
-    if (this.format != null) obj.format = this.format;
-    return obj;
-  }
-
-  static override fromJSON(data: TableJson): Table {
-    return new Table(data);
-  }
-}
-
-NonVerbalEntity.register('table', Table);