@glossarist/concept-browser 0.7.65 → 0.7.67

package/src/components/concept-rdf/image-variant-emitter.ts

@@ -1,46 +0,0 @@
-import { FOAF, DCTERMS, DCAT, XSD } from './predicates';
-import { RdfGraph } from './rdf-graph';
-
-export interface ImageVariantInput {
-  readonly registerId: string;
-  readonly figureId: string;
-  readonly lang?: string;
-  readonly format: 'svg' | 'png' | 'webp' | 'jpg' | 'gif';
-  readonly byteSize?: number;
-  readonly downloadUrl: string;
-}
-
-export function imageVariantIri(input: ImageVariantInput, baseUri = 'https://glossarist.org'): string {
-  const ext = input.format;
-  const langSuffix = input.lang ? `${input.lang}.` : '';
-  return `${baseUri}/${input.registerId}/image/${input.figureId}/${langSuffix}${ext}`;
-}
-
-export function emitImageVariantGraph(input: ImageVariantInput, baseUri = 'https://glossarist.org'): RdfGraph {
-  const graph = new RdfGraph();
-  const iri = imageVariantIri(input, baseUri);
-  const mimeType = mimeForFormat(input.format);
-  const w = graph.declare(iri, {
-    types: [FOAF.Image],
-    label: `${input.figureId} (${input.format}${input.lang ? `/${input.lang}` : ''})`,
-    classLabel: 'Image',
-    classId: FOAF.Image,
-  });
-  w.literal(DCTERMS.format, mimeType);
-  if (input.lang) w.literal(DCTERMS.language, input.lang);
-  if (input.byteSize != null) {
-    w.literal(DCAT.byteSize, String(input.byteSize), { datatype: XSD.integer });
-  }
-  w.iri(DCAT.downloadURL, input.downloadUrl);
-  return graph;
-}
-
-function mimeForFormat(format: ImageVariantInput['format']): string {
-  switch (format) {
-    case 'svg':  return 'image/svg+xml';
-    case 'png':  return 'image/png';
-    case 'webp': return 'image/webp';
-    case 'jpg':  return 'image/jpeg';
-    case 'gif':  return 'image/gif';
-  }
-}

package/src/components/concept-rdf/jsonld-writer.ts

@@ -1,82 +0,0 @@
-import { RDF_PREFIXES } from './rdf-prefixes';
-import { RDF } from './predicates';
-import type { RdfGraph, RdfResource, RdfTerm, RdfTriple } from './rdf-graph';
-
-export function writeJsonLd(graph: RdfGraph): string {
-  const context: Record<string, string> = {};
-  for (const p of RDF_PREFIXES) {
-    context[p.prefix] = p.iri;
-  }
-
-  const nodes: JsonLdNode[] = [];
-  for (const r of graph.resources()) {
-    nodes.push(resourceToNode(r));
-  }
-
-  const doc = {
-    '@context': context,
-    '@graph': nodes,
-  };
-
-  return JSON.stringify(doc, null, 2);
-}
-
-interface JsonLdNode {
-  [key: string]: unknown;
-}
-
-function resourceToNode(r: RdfResource): JsonLdNode {
-  const node: JsonLdNode = {
-    '@id': r.subject,
-    '@type': [...r.types],
-  };
-  mergeTriplesInto(node, r.triples);
-  return node;
-}
-
-function blankNodeToNode(triples: readonly RdfTriple[]): JsonLdNode {
-  const node: JsonLdNode = {};
-  mergeTriplesInto(node, triples);
-  return node;
-}
-
-function mergeTriplesInto(node: JsonLdNode, triples: readonly RdfTriple[]): void {
-  const grouped = new Map<string, RdfTerm[]>();
-  for (const t of triples) {
-    const arr = grouped.get(t.predicate) ?? [];
-    arr.push(t.object);
-    grouped.set(t.predicate, arr);
-  }
-
-  const typeTerms = grouped.get(RDF.type);
-  if (typeTerms && typeTerms.length > 0) {
-    const typeIris = typeTerms
-      .filter((t): t is Extract<RdfTerm, { kind: 'iri' }> => t.kind === 'iri')
-      .map(t => t.value);
-    if (typeIris.length === 1) {
-      node['@type'] = typeIris[0];
-    } else if (typeIris.length > 1) {
-      node['@type'] = typeIris;
-    }
-    grouped.delete(RDF.type);
-  }
-
-  for (const [pred, terms] of grouped) {
-    node[pred] = terms.length === 1
-      ? termToJson(terms[0])
-      : terms.map(termToJson);
-  }
-}
-
-function termToJson(term: RdfTerm): unknown {
-  switch (term.kind) {
-    case 'iri':
-      return { '@id': term.value };
-    case 'literal':
-      if (term.lang) return { '@value': term.value, '@language': term.lang };
-      if (term.datatype) return { '@value': term.value, '@type': term.datatype };
-      return term.value;
-    case 'blank':
-      return blankNodeToNode(term.triples);
-  }
-}

package/src/components/concept-rdf/predicates.ts

@@ -1,261 +0,0 @@
-export const GLOSS = {
-  // Classes
-  Concept: 'gloss:Concept',
-  LocalizedConcept: 'gloss:LocalizedConcept',
-  Designation: 'gloss:Designation',
-  Expression: 'gloss:Expression',
-  Abbreviation: 'gloss:Abbreviation',
-  Symbol: 'gloss:Symbol',
-  LetterSymbol: 'gloss:LetterSymbol',
-  GraphicalSymbol: 'gloss:GraphicalSymbol',
-
-  DetailedDefinition: 'gloss:DetailedDefinition',
-  ConceptDate: 'gloss:ConceptDate',
-  ConceptSource: 'gloss:ConceptSource',
-  ConceptRef: 'gloss:ConceptRef',
-  NonVerbalEntity: 'gloss:NonVerbalEntity',
-  NonVerbalRep: 'gloss:NonVerbalRep',
-  NonVerbalRepresentation: 'gloss:NonVerbalRepresentation',
-  Figure: 'gloss:Figure',
-  Table: 'gloss:Table',
-  Formula: 'gloss:Formula',
-  RelatedConcept: 'gloss:RelatedConcept',
-  Citation: 'gloss:Citation',
-  CitationRef: 'gloss:CitationRef',
-  Locality: 'gloss:Locality',
-  CustomLocality: 'gloss:CustomLocality',
-  Reference: 'gloss:Reference',
-  ConceptCollection: 'gloss:ConceptCollection',
-
-  // Concept predicates
-  identifier: 'gloss:identifier',
-  uri: 'gloss:uri',
-  hasStatus: 'gloss:hasStatus',
-  hasEntryStatus: 'gloss:hasEntryStatus',
-  hasLocalization: 'gloss:hasLocalization',
-  isLocalizationOf: 'gloss:isLocalizationOf',
-  hasDomain: 'gloss:hasDomain',
-  domain: 'gloss:domain',
-  hasSource: 'gloss:hasSource',
-  hasDate: 'gloss:hasDate',
-  hasRelatedConcept: 'gloss:hasRelatedConcept',
-  hasDesignation: 'gloss:hasDesignation',
-  hasDefinition: 'gloss:hasDefinition',
-  hasNote: 'gloss:hasNote',
-  hasExample: 'gloss:hasExample',
-  hasAnnotation: 'gloss:hasAnnotation',
-  hasNonVerbalRep: 'gloss:hasNonVerbalRep',
-  hasReference: 'gloss:hasReference',
-  hasPronunciation: 'gloss:hasPronunciation',
-  hasGrammarInfo: 'gloss:hasGrammarInfo',
-  hasTermType: 'gloss:hasTermType',
-  tag: 'gloss:tag',
-  register: 'gloss:register',
-
-  // Lifecycle / review
-  reviewDate: 'gloss:reviewDate',
-  reviewDecisionDate: 'gloss:reviewDecisionDate',
-  reviewDecisionEvent: 'gloss:reviewDecisionEvent',
-  reviewStatus: 'gloss:reviewStatus',
-  reviewDecision: 'gloss:reviewDecision',
-  reviewDecisionNotes: 'gloss:reviewDecisionNotes',
-  reviewType: 'gloss:reviewType',
-  lineageSourceSimilarity: 'gloss:lineageSimilarity',
-  lineageSimilarity: 'gloss:lineageSimilarity',
-  release: 'gloss:release',
-  classification: 'gloss:classification',
-  script: 'gloss:script',
-  system: 'gloss:conversionSystem',
-  conversionSystem: 'gloss:conversionSystem',
-  language: 'gloss:language',
-
-  // Non-verbal
-  nonVerbalType: 'gloss:representationType',
-  representationType: 'gloss:representationType',
-  representationRef: 'gloss:representationRef',
-  hasNonVerbalRepresentation: 'gloss:hasNonVerbalRepresentation',
-  expression: 'gloss:expression',
-  latexForm: 'gloss:latexForm',
-  content: 'gloss:content',
-  hasHeader: 'gloss:hasHeader',
-  hasRow: 'gloss:hasRow',
-  image: 'gloss:image',
-  caption: 'gloss:caption',
-  altText: 'gloss:altText',
-
-  // Designation
-  normativeStatus: 'gloss:normativeStatus',
-  geographicalArea: 'gloss:geographicalArea',
-  fieldOfApplication: 'gloss:fieldOfApplication',
-  prefix: 'gloss:prefix',
-  usageInfo: 'gloss:usageInfo',
-  text: 'gloss:text',
-  isInternational: 'gloss:isInternational',
-  isAbsent: 'gloss:isAbsent',
-  isAcronym: 'gloss:isAcronym',
-  isInitialism: 'gloss:isInitialism',
-  isTruncation: 'gloss:isTruncation',
-
-  // Related concept / ConceptRef
-  relationshipType: 'gloss:relationshipType',
-  relationshipContent: 'gloss:relationshipContent',
-  relationshipRef: 'gloss:relationshipRef',
-  conceptRefSource: 'gloss:conceptRefSource',
-  conceptRefId: 'gloss:conceptRefId',
-
-  // ConceptDate
-  dateType: 'gloss:dateType',
-  dateValue: 'gloss:dateValue',
-  eventDescription: 'gloss:eventDescription',
-
-  // ConceptSource
-  sourceStatus: 'gloss:sourceStatus',
-  sourceType: 'gloss:sourceType',
-  sourceOrigin: 'gloss:sourceOrigin',
-  modification: 'gloss:modification',
-
-  // Citation
-  hasCitationRef: 'gloss:hasCitationRef',
-  hasCitationLocality: 'gloss:hasCitationLocality',
-  citationLink: 'gloss:citationLink',
-  citationOriginal: 'gloss:citationOriginal',
-  hasCustomLocality: 'gloss:hasCustomLocality',
-  bibliographicCitation: 'gloss:bibliographicCitation',
-
-  // CitationRef
-  citationRefSource: 'gloss:citationRefSource',
-  citationRefId: 'gloss:citationRefId',
-  citationRefVersion: 'gloss:citationRefVersion',
-
-  // Reference
-  refSource: 'gloss:source',
-  refId: 'gloss:refId',
-  refVersion: 'gloss:refVersion',
-  refLink: 'gloss:refLink',
-  refType: 'gloss:refType',
-  urn: 'gloss:urn',
-  term: 'gloss:term',
-  hasLocality: 'gloss:hasLocality',
-
-  // Locality
-  localityType: 'gloss:localityType',
-  referenceFrom: 'gloss:referenceFrom',
-  referenceTo: 'gloss:referenceTo',
-  customLocalityName: 'gloss:customLocalityName',
-  customLocalityValue: 'gloss:customLocalityValue',
-} as const;
-
-export const SKOS = {
-  Concept: 'skos:Concept',
-  Collection: 'skos:Collection',
-  ConceptScheme: 'skos:ConceptScheme',
-  prefLabel: 'skos:prefLabel',
-  altLabel: 'skos:altLabel',
-  definition: 'skos:definition',
-  scopeNote: 'skos:scopeNote',
-  notation: 'skos:notation',
-  member: 'skos:member',
-  hasTopConcept: 'skos:hasTopConcept',
-  inScheme: 'skos:inScheme',
-} as const;
-
-export const SKOSXL = {
-  Label: 'skosxl:Label',
-  prefLabel: 'skosxl:prefLabel',
-  altLabel: 'skosxl:altLabel',
-  literalForm: 'skosxl:literalForm',
-} as const;
-
-export const DCTERMS = {
-  language: 'dcterms:language',
-  source: 'dcterms:source',
-  title: 'dcterms:title',
-  description: 'dcterms:description',
-  created: 'dcterms:created',
-  modified: 'dcterms:modified',
-  identifier: 'dcterms:identifier',
-  date: 'dcterms:date',
-  type: 'dcterms:type',
-  isVersionOf: 'dcterms:isVersionOf',
-  isPartOf: 'dcterms:isPartOf',
-  replaces: 'dcterms:replaces',
-  isReplacedBy: 'dcterms:isReplacedBy',
-  bibliographicCitation: 'dcterms:bibliographicCitation',
-  subject: 'dcterms:subject',
-  format: 'dcterms:format',
-  publisher: 'dcterms:publisher',
-  contactPoint: 'dcterms:contactPoint',
-  BibliographicResource: 'dcterms:BibliographicResource',
-} as const;
-
-export const RDF = {
-  type: 'rdf:type',
-  value: 'rdf:value',
-} as const;
-
-export const OWL = {
-  Thing: 'owl:Thing',
-  sameAs: 'owl:sameAs',
-  deprecated: 'owl:deprecated',
-} as const;
-
-export const RDFS = {
-  seeAlso: 'rdfs:seeAlso',
-  label: 'rdfs:label',
-  comment: 'rdfs:comment',
-} as const;
-
-export const PROV = {
-  wasGeneratedBy: 'prov:wasGeneratedBy',
-  generatedAtTime: 'prov:generatedAtTime',
-  wasDerivedFrom: 'prov:wasDerivedFrom',
-  wasAttributedTo: 'prov:wasAttributedTo',
-  invalidatedAtTime: 'prov:invalidatedAtTime',
-  wasInvalidatedBy: 'prov:wasInvalidatedBy',
-  wasAssociatedWith: 'prov:wasAssociatedWith',
-  wasRevisionOf: 'prov:wasRevisionOf',
-  used: 'prov:used',
-  actedOnBehalfOf: 'prov:actedOnBehalfOf',
-  Activity: 'prov:Activity',
-  Entity: 'prov:Entity',
-  Agent: 'prov:Agent',
-  Organization: 'prov:Organization',
-  Person: 'prov:Person',
-} as const;
-
-export const DCAT = {
-  Dataset: 'dcat:Dataset',
-  DatasetSeries: 'dcat:DatasetSeries',
-  Catalog: 'dcat:Catalog',
-  Distribution: 'dcat:Distribution',
-  distribution: 'dcat:distribution',
-  dataset: 'dcat:dataset',
-  hasVersion: 'dcat:hasVersion',
-  isVersionOf: 'dcat:isVersionOf',
-  hasCurrentVersion: 'gloss:hasCurrentVersion',
-  isCurrentVersionOf: 'gloss:isCurrentVersionOf',
-  downloadURL: 'dcat:downloadURL',
-  mediaType: 'dcat:mediaType',
-  byteSize: 'dcat:byteSize',
-  contactPoint: 'dcat:contactPoint',
-  theme: 'dcat:theme',
-  keyword: 'dcat:keyword',
-} as const;
-
-export const FOAF = {
-  Person: 'foaf:Person',
-  Organization: 'foaf:Organization',
-  name: 'foaf:name',
-  mbox: 'foaf:mbox',
-  page: 'foaf:page',
-  Image: 'foaf:Image',
-} as const;
-
-export const XSD = {
-  dateTime: 'xsd:dateTime',
-  date: 'xsd:date',
-  boolean: 'xsd:boolean',
-  integer: 'xsd:integer',
-  string: 'xsd:string',
-  anyURI: 'xsd:anyURI',
-} as const;

package/src/components/concept-rdf/provenance.ts

@@ -1,80 +0,0 @@
-import type { RdfGraph } from './rdf-graph';
-import { PROV, DCTERMS, XSD } from './predicates';
-
-/**
- * Provenance information attached to every emitted concept graph.
- *
- * The `toolId` and `toolVersion` identify the serializer that produced
- * the document; together they form the PROV-O activity IRI
- * (`<activity/serializers/{toolId}/{version}>`). The `generatedAt`
- * timestamp is when this document came into existence — at build
- * time for static dumps, at view time for client-side emission.
- *
- * `canonicalUri` is the unversioned concept URI; `dcterms:isVersionOf`
- * points there from the versioned concept resource.
- */
-export interface ProvenanceOptions {
-  readonly toolId: string;
-  readonly toolVersion: string;
-  readonly generatedAt: string;
-  readonly canonicalUri?: string;
-}
-
-export const SERIALIZER_TOOL_ID = 'concept-browser';
-
-/**
- * Compose the PROV-O activity IRI for a given tool + version. Format:
- * `activity/serializers/{toolId}/{version}`. This is a relative IRI;
- * under the document base it resolves to a per-tool activity resource.
- */
-export function activityUri(opts: ProvenanceOptions): string {
-  return `activity/serializers/${opts.toolId}/${opts.toolVersion}`;
-}
-
-/**
- * Attach provenance triples to the concept resource identified by
- * `subjectUri` in `graph`. Idempotent — calling twice with the same
- * arguments produces the same single set of triples (the underlying
- * RdfGraph deduplicates).
- *
- * The decorator is invoked AFTER the base emitter has populated the
- * graph, keeping domain emission (concept-emitter.ts) decoupled from
- * build/render context (timestamp, tool version). See ADR 0001 for
- * the rationale.
- */
-export function decorateWithProvenance(
-  graph: RdfGraph,
-  subjectUri: string,
-  opts: ProvenanceOptions,
-): void {
-  const w = graph.declare(subjectUri, {});
-  w.iri(PROV.wasGeneratedBy, activityUri(opts));
-  w.literal(PROV.generatedAtTime, opts.generatedAt, { datatype: XSD.dateTime });
-  if (opts.canonicalUri && opts.canonicalUri !== subjectUri) {
-    w.iri(DCTERMS.isVersionOf, opts.canonicalUri);
-  }
-
-  graph.declare(activityUri(opts), {
-    types: [PROV.Activity],
-    label: `${opts.toolId} ${opts.toolVersion}`,
-  });
-}
-
-/**
- * Build ProvenanceOptions for runtime emission in the browser. Uses
- * the current wall-clock time as `generatedAt`. Callers that want a
- * deterministic timestamp (e.g., build scripts, snapshot tests)
- * should construct the options directly.
- */
-export function runtimeProvenance(
-  toolVersion: string,
-  canonicalUri?: string,
-  now: () => Date = () => new Date(),
-): ProvenanceOptions {
-  return {
-    toolId: SERIALIZER_TOOL_ID,
-    toolVersion,
-    generatedAt: now().toISOString(),
-    canonicalUri,
-  };
-}

package/src/components/concept-rdf/rdf-graph.ts

@@ -1,211 +0,0 @@
-/**
- * RDF intermediate representation — a subject-grouped triple graph.
- *
- * The graph is the single source of truth for all RDF emission. The
- * ConceptEmitter walks the Concept model and populates an RdfGraph; the
- * Turtle/JSON-LD writers and the UI sections builder all consume the
- * same graph. Adding a new field touches exactly one site (the emitter),
- * not three.
- *
- * Terms use prefixed names (`gloss:Concept`) or absolute IRIs
- * (`https://glossarist.org/...`). Writers decide how to render each.
- */
-
-export type RdfTerm = RdfIri | RdfLiteral | RdfBlankNode;
-
-export interface RdfIri {
-  readonly kind: 'iri';
-  readonly value: string;
-}
-
-export interface RdfLiteral {
-  readonly kind: 'literal';
-  readonly value: string;
-  readonly lang?: string;
-  readonly datatype?: string;
-}
-
-export interface RdfBlankNode {
-  readonly kind: 'blank';
-  readonly triples: RdfTriple[];
-}
-
-export interface RdfTriple {
-  readonly predicate: string;
-  readonly object: RdfTerm;
-}
-
-export interface RdfResource {
-  readonly subject: string;
-  readonly types: readonly string[];
-  readonly triples: readonly RdfTriple[];
-  readonly label: string;
-  readonly classLabel: string;
-  readonly classId: string;
-}
-
-interface MutableResource {
-  readonly subject: string;
-  readonly types: string[];
-  readonly triples: RdfTriple[];
-  label: string;
-  classLabel: string;
-  classId: string;
-}
-
-export interface ResourceInit {
-  readonly types?: readonly string[];
-  readonly label?: string;
-  readonly classLabel?: string;
-  readonly classId?: string;
-}
-
-export function lit(value: string, opts: { lang?: string; datatype?: string } = {}): RdfLiteral {
-  return { kind: 'literal', value, lang: opts.lang, datatype: opts.datatype };
-}
-
-export function iri(value: string): RdfIri {
-  return { kind: 'iri', value };
-}
-
-export function blank(...triples: RdfTriple[]): RdfBlankNode {
-  return { kind: 'blank', triples };
-}
-
-export function triple(predicate: string, object: RdfTerm): RdfTriple {
-  return { predicate, object };
-}
-
-export function termEquals(a: RdfTerm, b: RdfTerm): boolean {
-  if (a.kind !== b.kind) return false;
-  switch (a.kind) {
-    case 'iri':
-      return a.value === (b as RdfIri).value;
-    case 'literal': {
-      const o = b as RdfLiteral;
-      return a.value === o.value && a.lang === o.lang && a.datatype === o.datatype;
-    }
-    case 'blank': {
-      const o = b as RdfBlankNode;
-      if (a.triples.length !== o.triples.length) return false;
-      return a.triples.every((t, i) => {
-        const u = o.triples[i];
-        return t.predicate === u.predicate && termEquals(t.object, u.object);
-      });
-    }
-  }
-}
-
-export class RdfGraph {
-  private readonly _resources = new Map<string, MutableResource>();
-  private readonly _order: string[] = [];
-
-  declare(subject: string, init: ResourceInit = {}): ResourceWriter {
-    let r = this._resources.get(subject);
-    if (!r) {
-      r = {
-        subject,
-        types: [...(init.types ?? [])],
-        triples: [],
-        label: init.label ?? subject,
-        classLabel: init.classLabel ?? '',
-        classId: init.classId ?? '',
-      };
-      this._resources.set(subject, r);
-      this._order.push(subject);
-    } else {
-      if (init.types) {
-        for (const t of init.types) {
-          if (!r.types.includes(t)) r.types.push(t);
-        }
-      }
-      if (init.label !== undefined && r.label === subject) r.label = init.label;
-      if (init.classLabel && !r.classLabel) r.classLabel = init.classLabel;
-      if (init.classId && !r.classId) r.classId = init.classId;
-    }
-    return new ResourceWriter(r.triples);
-  }
-
-  has(subject: string): boolean {
-    return this._resources.has(subject);
-  }
-
-  get(subject: string): RdfResource | undefined {
-    return this._resources.get(subject);
-  }
-
-  get size(): number {
-    return this._order.length;
-  }
-
-  *resources(): Iterable<RdfResource> {
-    for (const s of this._order) {
-      yield this._resources.get(s)!;
-    }
-  }
-
-  toArray(): RdfResource[] {
-    return Array.from(this.resources());
-  }
-
-  merge(other: RdfGraph): this {
-    for (const r of other.resources()) {
-      const w = this.declare(r.subject, {
-        types: [...r.types],
-        label: r.label,
-        classLabel: r.classLabel,
-        classId: r.classId,
-      });
-      for (const t of r.triples) {
-        if (t.object.kind === 'iri') w.iri(t.predicate, t.object.value);
-        else if (t.object.kind === 'literal') {
-          w.literal(t.predicate, t.object.value, { lang: t.object.lang, datatype: t.object.datatype });
-        } else {
-          w.blank(t.predicate, t.object.triples);
-        }
-      }
-    }
-    return this;
-  }
-}
-
-export class ResourceWriter {
-  constructor(private readonly triples: RdfTriple[]) {}
-
-  add(predicate: string, object: RdfTerm): this {
-    if (object.kind === 'literal' && object.value === '') return this;
-    if (object.kind === 'iri' && object.value === '') return this;
-    if (!this.triples.some(t => t.predicate === predicate && termEquals(t.object, object))) {
-      this.triples.push({ predicate, object });
-    }
-    return this;
-  }
-
-  literal(predicate: string, value: string, opts: { lang?: string; datatype?: string } = {}): this {
-    if (!value) return this;
-    return this.add(predicate, { kind: 'literal', value, lang: opts.lang, datatype: opts.datatype });
-  }
-
-  iri(predicate: string, value: string): this {
-    if (!value) return this;
-    return this.add(predicate, { kind: 'iri', value });
-  }
-
-  blank(predicate: string, triples: readonly RdfTriple[]): this {
-    if (triples.length === 0) return this;
-    return this.add(predicate, { kind: 'blank', triples: [...triples] });
-  }
-
-  addTriple(t: RdfTriple): this {
-    return this.add(t.predicate, t.object);
-  }
-
-  addTriples(triples: readonly RdfTriple[]): this {
-    for (const t of triples) this.addTriple(t);
-    return this;
-  }
-}
-
-export function isAbsoluteIri(s: string): boolean {
-  return /^[a-z][a-z0-9+.-]*:\/\//i.test(s) || s.startsWith('urn:');
-}