glossarist 0.4.18 → 0.4.20

package/src/models/index.d.ts

@@ -100,6 +100,7 @@ export class Concept extends GlossaristModel {
   readonly localizations: Record<string, any>;
   readonly raw: Record<string, unknown> | null;
   readonly relatedConcepts: RelatedConcept[];
+  readonly partitiveHyperedges: PartitiveHyperedge[];
   readonly domains: ConceptReference[];
   readonly tags: string[];
   readonly dates: ConceptDate[];
@@ -257,6 +258,8 @@ export class ConceptSource extends GlossaristModel {
   readonly type: string | null;
   readonly origin: Citation | null;
   readonly modification: string | null;
+  readonly sourcedFrom: Citation[];
+  /** @deprecated use sourcedFrom */
   readonly sourced_from: Citation[];
 }
 
@@ -267,6 +270,64 @@ export class RelatedConcept extends GlossaristModel {
   readonly ref: ConceptRef | null;
 }
 
+export interface LocalizedContent {
+  readonly [language: string]: string;
+}
+
+export const PARTITIVE_ENUMERATION: Readonly<{
+  readonly CLOSED: 'closed';
+  readonly OPEN: 'open';
+}>;
+export const PARTITIVE_ENUMERATION_VALUES: readonly ['closed', 'open'];
+export function isValidPartitiveEnumeration(value: unknown): value is 'closed' | 'open';
+
+export const PLURALITY_MARKER: Readonly<{
+  readonly DOUBLE: 'double';
+  readonly DASHED: 'dashed';
+}>;
+export const PLURALITY_MARKER_VALUES: readonly ['double', 'dashed'];
+export function isValidPluralityMarker(value: unknown): value is 'double' | 'dashed';
+
+export function makeEnum<T extends string>(
+  name: string,
+  values: Record<string, T>,
+): Readonly<Record<string, T>> & {
+  readonly name: string;
+  readonly VALUES: readonly T[];
+  readonly isValid: (value: unknown) => value is T;
+};
+
+export interface HyperedgeColorPair {
+  readonly light: string;
+  readonly dark: string;
+  readonly pattern: 'dashed' | 'double' | null;
+}
+
+export function resolveHyperedgeColor(
+  hyperedge: { enumeration?: string; markers?: string[] } | null,
+  options?: {
+    category?: string;
+    overrides?: { byCategory?: Record<string, unknown> };
+  },
+): HyperedgeColorPair | null;
+
+export class PartitiveHyperedge extends GlossaristModel {
+  readonly comprehensive: ConceptRef;
+  readonly parts: ConceptRef[];
+  readonly enumeration: 'closed' | 'open';
+  readonly markers: ('double' | 'dashed')[];
+  readonly content: LocalizedContent | null;
+
+  readonly isMarked: boolean;
+  readonly contentString: string | null;
+
+  hasMarker(value: string): boolean;
+  hasEnumeration(value: string): boolean;
+  identity(): string;
+  toJSON(): Record<string, unknown>;
+  static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
+}
+
 export const DESIGNATION_RELATIONSHIP_TYPES: readonly string[];
 export class DesignationRelationship extends GlossaristModel {
   readonly type: string | null;

package/src/models/index.js

@@ -21,6 +21,45 @@ export { Citation } from './citation.js';
 export { ConceptRef } from './concept-ref.js';
 export { ConceptSource } from './concept-source.js';
 export { RelatedConcept, RELATIONSHIP_TYPES } from './related-concept.js';
+export { PartitiveHyperedge } from './partitive-hyperedge.js';
+export {
+  PARTITIVE_ENUMERATION,
+  PARTITIVE_ENUMERATION_VALUES,
+  isValidPartitiveEnumeration,
+} from './partitive-enumeration.js';
+export {
+  PLURALITY_MARKER,
+  PLURALITY_MARKER_VALUES,
+  isValidPluralityMarker,
+} from './plurality-marker.js';
+
+// v2 PartitiveRelation models (TODO.partitive-relation-v2). These
+// supersede the v1 hyperedge models above; the v1 models are kept for
+// backward-compat input. New code should use v2 exclusively.
+export { PartitiveRelation } from './partitive-relation.js';
+export { PartitiveMember } from './partitive-member.js';
+export { TypeSharedPlurality } from './type-shared-plurality.js';
+export {
+  COMPLETENESS,
+  COMPLETENESS_VALUES,
+  DEFAULT_COMPLETENESS,
+  isValidCompleteness,
+} from './completeness.js';
+export {
+  MEMBER_CERTAINTY,
+  MEMBER_CERTAINTY_VALUES,
+  DEFAULT_MEMBER_CERTAINTY,
+  isValidMemberCertainty,
+} from './member-certainty.js';
+
+// v1 → v2 migration helper. Pure function; idempotent.
+export {
+  migrateHyperedgeToRelation,
+  downgradeRelationToHyperedge,
+} from '../migration/partitive-relation-migrator.js';
+
+export { makeEnum } from './enum.js';
+export { resolveHyperedgeColor } from './hyperedge-colors.js';
 export { DesignationRelationship, DESIGNATION_RELATIONSHIP_TYPES } from './designation-relationship.js';
 export { ConceptReference } from './concept-reference.js';
 export { ConceptDate, DATE_TYPES } from './concept-date.js';

package/src/models/localized-concept.js

@@ -10,7 +10,36 @@ function wrapAs(Cls) {
   return item => item instanceof Cls ? item : new Cls(item);
 }
 
+const LOC_WIRE_NAMES = Object.freeze({
+  entryStatus: 'entry_status',
+  reviewType: 'review_type',
+  lineageSourceSimilarity: 'lineage_source_similarity',
+  reviewDate: 'review_date',
+  reviewDecisionDate: 'review_decision_date',
+  reviewDecisionEvent: 'review_decision_event',
+  reviewStatus: 'review_status',
+  reviewDecision: 'review_decision',
+  reviewDecisionNotes: 'review_decision_notes',
+});
+
 export class LocalizedConcept extends GlossaristModel {
+  // Scalar metadata fields the diff layer tracks per localization.
+  // Adding a new scalar field requires only appending its name here;
+  // diff/patch/similarity pick it up automatically.
+  // (Invariant N2 — TODO.hyperedges-v2/07.)
+  static get DIFF_FIELDS() {
+    return Object.freeze([
+      'entryStatus', 'classification', 'reviewType', 'domain', 'release',
+      'lineageSourceSimilarity', 'script', 'system',
+      'reviewDate', 'reviewDecisionDate', 'reviewDecisionEvent',
+      'reviewStatus', 'reviewDecision', 'reviewDecisionNotes',
+    ]);
+  }
+
+  static wireNameFor(field) {
+    return LOC_WIRE_NAMES[field] ?? field;
+  }
+
   constructor(data = {}) {
     super();
     this.languageCode = data.language_code ?? data.languageCode ?? null;

package/src/models/member-certainty.js

@@ -0,0 +1,21 @@
+// MemberCertainty — per-partitive certainty for a PartitiveMember.
+//
+// Glossarist extension beyond ISO 704 notation. ISO 704's broken-line
+// notation marks plurality-level uncertainty; per-member certainty
+// lets a relation assert "member b is confirmed, member d is possible"
+// at the member level.
+//
+// Defaults to `confirmed` when omitted (a member with no certainty
+// field is implicitly confirmed).
+
+import { makeEnum } from './enum.js';
+
+export const MEMBER_CERTAINTY = makeEnum('MEMBER_CERTAINTY', {
+  CONFIRMED: 'confirmed',
+  POSSIBLE: 'possible',
+});
+
+export const MEMBER_CERTAINTY_VALUES = MEMBER_CERTAINTY.VALUES;
+export const isValidMemberCertainty = MEMBER_CERTAINTY.isValid;
+
+export const DEFAULT_MEMBER_CERTAINTY = MEMBER_CERTAINTY.CONFIRMED;

package/src/models/partitive-enumeration.js

@@ -0,0 +1,23 @@
+// PartitiveEnumeration — allowed values for PartitiveHyperedge#enumeration.
+//
+//   closed — the encoded parts are ALL the parts of the comprehensive.
+//            Adding or removing a part would change the relationship.
+//   open   — the encoded parts are SOME of the parts; others may exist
+//            but are not encoded.
+//
+// See concept-model/TODO.hyperedge/00-design-overview.md for the design
+// rationale and the open/closed distinction.
+
+export const PARTITIVE_ENUMERATION = Object.freeze({
+  CLOSED: 'closed',
+  OPEN: 'open',
+});
+
+export const PARTITIVE_ENUMERATION_VALUES = Object.freeze([
+  PARTITIVE_ENUMERATION.CLOSED,
+  PARTITIVE_ENUMERATION.OPEN,
+]);
+
+export function isValidPartitiveEnumeration(value) {
+  return PARTITIVE_ENUMERATION_VALUES.includes(value);
+}

package/src/models/partitive-hyperedge.js

@@ -0,0 +1,175 @@
+// PartitiveHyperedge — a one-to-many partitive decomposition.
+//
+// One comprehensive concept (the whole) is related to one or more
+// parts as a SINGLE relationship. Captures invariants that binary
+// RelatedConcept edges cannot:
+//
+//   - which comprehensive owns which parts (set membership)
+//   - plurality markers from the source diagram (double / dashed)
+//   - enumeration completeness (closed: all parts listed; open:
+//     other parts may exist)
+//
+// See concept-model/TODO.hyperedge/00-design-overview.md for the
+// design rationale.
+//
+// Hyperedges coexist with binary `broader_partitive` /
+// `narrower_partitive` edges. Use a binary edge for pairwise
+// relationships without diagram metadata; use a hyperedge when the
+// relationship is one-to-many with enumeration/marker metadata.
+
+import { GlossaristModel } from './base.js';
+import { ConceptRef } from './concept-ref.js';
+import {
+  PARTITIVE_ENUMERATION,
+  PARTITIVE_ENUMERATION_VALUES,
+  isValidPartitiveEnumeration,
+} from './partitive-enumeration.js';
+import {
+  PLURALITY_MARKER_VALUES,
+  isValidPluralityMarker,
+} from './plurality-marker.js';
+
+const DEFAULT_ENUMERATION = PARTITIVE_ENUMERATION.CLOSED;
+
+export class PartitiveHyperedge extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.comprehensive = ensureConceptRef(data.comprehensive, 'comprehensive');
+    this.parts = ensureConceptRefArray(data.parts, 'parts');
+    this.enumeration = resolveEnumeration(data.enumeration);
+    this.markers = validateMarkers(data.markers ?? []);
+    this.content = normalizeContent(data.content);
+
+    assertNonEmptyParts(this.parts);
+    assertNoSelfLoop(this.comprehensive, this.parts);
+  }
+
+  get isClosed() { return this.enumeration === PARTITIVE_ENUMERATION.CLOSED; }
+  get isOpen() { return this.enumeration === PARTITIVE_ENUMERATION.OPEN; }
+  get isMarked() { return this.markers.length > 0; }
+
+  hasMarker(value) {
+    return this.markers.includes(value);
+  }
+
+  hasEnumeration(value) {
+    return this.enumeration === value;
+  }
+
+  get contentString() {
+    if (!this.content) return null;
+    const values = Object.values(this.content);
+    return values.length > 0 ? values[0] : null;
+  }
+
+  toJSON() {
+    const obj = {
+      comprehensive: this.comprehensive.toJSON(),
+      parts: this.parts.map(p => p.toJSON()),
+      enumeration: this.enumeration,
+    };
+    if (this.markers.length > 0) obj.markers = [...this.markers];
+    if (this.content != null) obj.content = this.content;
+    return obj;
+  }
+
+  static identityOf(value) {
+    const v = value ?? {};
+    const c = v.comprehensive ?? {};
+    const parts = Array.isArray(v.parts) ? v.parts : [];
+    const partsStr = parts
+      .map(p => `${p?.source ?? ''}:${p?.id ?? ''}`)
+      .sort();
+    return `${c.source ?? ''}:${c.id ?? ''}|${partsStr.join('|')}`;
+  }
+
+  identity() {
+    return PartitiveHyperedge.identityOf(this);
+  }
+
+  static fromJSON(data) {
+    return new PartitiveHyperedge(data);
+  }
+}
+
+function resolveEnumeration(value) {
+  if (value == null) return DEFAULT_ENUMERATION;
+  if (!isValidPartitiveEnumeration(value)) {
+    throw new Error(
+      `invalid enumeration ${JSON.stringify(value)}; ` +
+      `must be one of ${PARTITIVE_ENUMERATION_VALUES.join(', ')}`,
+    );
+  }
+  return value;
+}
+
+function validateMarkers(values) {
+  const arr = Array.isArray(values) ? values : [values];
+  const seen = new Set();
+  for (const m of arr) {
+    if (!isValidPluralityMarker(m)) {
+      throw new Error(
+        `invalid plurality marker ${JSON.stringify(m)}; ` +
+        `must be one of ${PLURALITY_MARKER_VALUES.join(', ')}`,
+      );
+    }
+    if (seen.has(m)) {
+      throw new Error(
+        `duplicate plurality marker ${JSON.stringify(m)} in partitive_hyperedge`,
+      );
+    }
+    seen.add(m);
+  }
+  return arr;
+}
+
+function ensureConceptRef(value, fieldName) {
+  const ref = value instanceof ConceptRef ? value : new ConceptRef(value ?? {});
+  if (!ref.source && !ref.id) {
+    throw new Error(
+      `PartitiveHyperedge#${fieldName} must be a non-empty ConceptRef ` +
+      `(source or id required)`,
+    );
+  }
+  return ref;
+}
+
+function ensureConceptRefArray(values, fieldName) {
+  if (!Array.isArray(values)) values = values == null ? [] : [values];
+  return values.map((v, i) => ensureConceptRef(v, `${fieldName}[${i}]`));
+}
+
+function assertNonEmptyParts(parts) {
+  if (!parts || parts.length === 0) {
+    throw new Error('PartitiveHyperedge requires at least one part');
+  }
+}
+
+function assertNoSelfLoop(comprehensive, parts) {
+  const cKey = `${comprehensive.source ?? ''}:${comprehensive.id ?? ''}`;
+  for (const p of parts) {
+    const pKey = `${p.source ?? ''}:${p.id ?? ''}`;
+    if (pKey === cKey) {
+      throw new Error('PartitiveHyperedge#parts cannot include the comprehensive');
+    }
+  }
+}
+
+// Content is a localized string (language -> text). Plain strings on
+// input are normalized to `{ default: '...' }` so callers always see
+// the same shape. `null` is preserved.
+//
+// Cross-repo symmetry: glossarist-ruby's `PartitiveHyperedge#content=`
+// (lib/glossarist/v3/partitive_hyperedge.rb) applies the same
+// normalization since commit c917846 (was previously a plain string;
+// aligned with invariant I7 in TODO.hyperedges round 1, item 29).
+// Datasets now round-trip identically across repos.
+function normalizeContent(value) {
+  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) : null;
+  }
+  return null;
+}

package/src/models/partitive-member.js

@@ -0,0 +1,79 @@
+// PartitiveMember — one member of a PartitiveRelation.
+//
+// A partitive member carries a ConceptRef (the subordinate concept
+// partitive) and optional certainty metadata. A PartitiveMember with
+// no certainty field is implicitly confirmed.
+//
+// Glossarist extension beyond ISO 704: ISO notation expresses
+// plurality-level uncertainty (broken line); per-member certainty
+// lets a relation assert "member b is confirmed, member d is possible"
+// at the member level.
+
+import { GlossaristModel } from './base.js';
+import { ConceptRef } from './concept-ref.js';
+import {
+  MEMBER_CERTAINTY,
+  DEFAULT_MEMBER_CERTAINTY,
+  isValidMemberCertainty,
+} from './member-certainty.js';
+
+export class PartitiveMember extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.ref = data.ref instanceof ConceptRef
+      ? data.ref
+      : new ConceptRef(data.ref ?? {});
+    this.certainty = _resolveCertainty(data.certainty);
+
+    _assertNonEmptyRef(this.ref);
+  }
+
+  get isConfirmed() {
+    return this.certainty === MEMBER_CERTAINTY.CONFIRMED;
+  }
+
+  get isPossible() {
+    return this.certainty === MEMBER_CERTAINTY.POSSIBLE;
+  }
+
+  identity() {
+    return PartitiveMember.identityOf(this);
+  }
+
+  toJSON() {
+    const obj = { ref: this.ref.toJSON() };
+    if (this.certainty !== DEFAULT_MEMBER_CERTAINTY) {
+      obj.certainty = this.certainty;
+    }
+    return obj;
+  }
+
+  static identityOf(value) {
+    const v = value ?? {};
+    const ref = v.ref ?? {};
+    return `${ref.source ?? ''}|${ref.id ?? ''}|${v.certainty ?? DEFAULT_MEMBER_CERTAINTY}`;
+  }
+
+  static fromJSON(data) {
+    return new PartitiveMember(data);
+  }
+}
+
+function _resolveCertainty(value) {
+  const cert = value ?? DEFAULT_MEMBER_CERTAINTY;
+  if (!isValidMemberCertainty(cert)) {
+    throw new Error(
+      `PartitiveMember.certainty has invalid value ${JSON.stringify(value)}; ` +
+      `must be one of: ${MEMBER_CERTAINTY.VALUES.join(', ')}`,
+    );
+  }
+  return cert;
+}
+
+function _assertNonEmptyRef(ref) {
+  if (!ref.source && !ref.id && !ref.text) {
+    throw new Error(
+      'PartitiveMember.ref must be non-empty (source, id, or text required)',
+    );
+  }
+}

package/src/models/partitive-relation.js

@@ -0,0 +1,158 @@
+// PartitiveRelation — a one-to-many partitive decomposition.
+//
+// Connects a comprehensive concept (superordinate concept partitive)
+// to two or more partitive concepts (subordinate concepts partitive)
+// which fitted together constitute the comprehensive.
+//
+// Renamed from the v1 `PartitiveHyperedge` per TODO.partitive-relation-v2
+// item 01. ISO 704 / 1087-1 / 12620 call this a *partitive relation*,
+// not a hyperedge.
+//
+// Field renames (v1 → v2):
+//   parts [1..*]              → partitives [2..*]  (as PartitiveMember)
+//   enumeration: closed|open  → completeness: complete|partial
+//   markers: [double, dashed] → plurality: TypeSharedPlurality (structured)
+//   content: LocalizedString  → (dropped — structural edges carry no prose)
+//
+// New field:
+//   criterion: LocalizedString [0..1]  (ISO 12620 coordinate-concept coherence)
+//
+// Distinguished from binary `has_part` / `is_part_of` edges, which
+// express pairwise part-of assertions without completeness, plurality,
+// or criterion claims. A single partitive should be expressed as a
+// binary edge, not a PartitiveRelation (ISO requires "two or more").
+
+import { GlossaristModel } from './base.js';
+import { ConceptRef } from './concept-ref.js';
+import { PartitiveMember } from './partitive-member.js';
+import { TypeSharedPlurality } from './type-shared-plurality.js';
+import {
+  COMPLETENESS,
+  COMPLETENESS_VALUES,
+  DEFAULT_COMPLETENESS,
+  isValidCompleteness,
+} from './completeness.js';
+
+export class PartitiveRelation extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.comprehensive = _ensureComprehensive(data.comprehensive);
+    this.partitives = _ensurePartitives(data.partitives);
+    this.completeness = _resolveCompleteness(data.completeness);
+    this.plurality = data.plurality == null
+      ? null
+      : (data.plurality instanceof TypeSharedPlurality
+          ? data.plurality
+          : new TypeSharedPlurality(data.plurality));
+    this.criterion = _normalizeCriterion(data.criterion);
+
+    _assertNoSelfLoop(this.comprehensive, this.partitives);
+  }
+
+  get isComplete() { return this.completeness === COMPLETENESS.COMPLETE; }
+  get isPartial() { return this.completeness === COMPLETENESS.PARTIAL; }
+
+  // ISO 12620 coordinate-concept predicate: a relation is "coordinate"
+  // when it has ≥2 partitives (all partitives within one relation are
+  // coordinate concepts by definition).
+  get isCoordinate() { return this.partitives.length >= 2; }
+
+  hasPlurality() { return this.plurality != null; }
+  hasCriterion() { return this.criterion != null; }
+
+  identity() {
+    return PartitiveRelation.identityOf(this);
+  }
+
+  toJSON() {
+    const obj = {
+      comprehensive: this.comprehensive.toJSON(),
+      partitives: this.partitives.map(p => p.toJSON()),
+      completeness: this.completeness,
+    };
+    if (this.plurality != null) obj.plurality = this.plurality.toJSON();
+    if (this.criterion != null) obj.criterion = { ...this.criterion };
+    return obj;
+  }
+
+  // Stable identity for diffing: same comprehensive + same partitive
+  // set (by ref identity) = same relation. Changes to completeness,
+  // plurality, or criterion produce "changed" entries rather than
+  // add+remove. Matches the v1 hyperedgeIdentity semantics.
+  static identityOf(value) {
+    const v = value ?? {};
+    const c = v.comprehensive ?? {};
+    const partitiveKeys = Array.isArray(v.partitives)
+      ? v.partitives.map(p => {
+          const r = p?.ref ?? p ?? {};
+          return `${r.source ?? ''}:${r.id ?? ''}`;
+        }).sort()
+      : [];
+    return `${c.source ?? ''}:${c.id ?? ''}|${partitiveKeys.join('|')}`;
+  }
+
+  static fromJSON(data) {
+    return new PartitiveRelation(data);
+  }
+}
+
+function _ensureComprehensive(value) {
+  const ref = value instanceof ConceptRef ? value : new ConceptRef(value ?? {});
+  if (!ref.source && !ref.id && !ref.text) {
+    throw new Error(
+      'PartitiveRelation.comprehensive must be a non-empty ConceptReference ' +
+      '(source, id, or text required)',
+    );
+  }
+  return ref;
+}
+
+function _ensurePartitives(values) {
+  if (!Array.isArray(values)) {
+    throw new Error(
+      `PartitiveRelation.partitives must be an array (got ${typeof values})`,
+    );
+  }
+  if (values.length < 2) {
+    throw new Error(
+      `PartitiveRelation requires ≥2 partitives (ISO 704); got ${values.length}`,
+    );
+  }
+  return values.map(v => v instanceof PartitiveMember ? v : new PartitiveMember(v));
+}
+
+function _resolveCompleteness(value) {
+  const c = value ?? DEFAULT_COMPLETENESS;
+  if (!isValidCompleteness(c)) {
+    throw new Error(
+      `PartitiveRelation.completeness has invalid value ${JSON.stringify(value)}; ` +
+      `must be one of: ${COMPLETENESS_VALUES.join(', ')}`,
+    );
+  }
+  return c;
+}
+
+function _normalizeCriterion(value) {
+  if (value == null) return null;
+  if (typeof value === 'string') {
+    return value.length > 0 ? { default: value } : null;
+  }
+  if (typeof value === 'object') {
+    const entries = Object.entries(value).filter(([, v]) => typeof v === 'string');
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+  }
+  return null;
+}
+
+function _assertNoSelfLoop(comprehensive, partitives) {
+  const cKey = `${comprehensive.source ?? ''}:${comprehensive.id ?? ''}`;
+  for (const p of partitives) {
+    const ref = p.ref;
+    const pKey = `${ref.source ?? ''}:${ref.id ?? ''}`;
+    if (pKey === cKey && (ref.source || ref.id)) {
+      throw new Error(
+        'PartitiveRelation.partitives cannot include the comprehensive (no self-loops)',
+      );
+    }
+  }
+}

package/src/models/plurality-marker.js

@@ -0,0 +1,24 @@
+// PluralityMarker — diagram notation flags from VIM concept-relationship
+// diagrams. Travels with a PartitiveHyperedge so the rendering layer
+// can reproduce the source diagram's notation.
+//
+//   double — close-set double line at the receiver end. Several
+//            partitive concepts of the same type are involved.
+//   dashed — broken/dashed line. Plurality is uncertain.
+//
+// Orthogonal to PartitiveEnumeration — both may be set on the same
+// hyperedge.
+
+export const PLURALITY_MARKER = Object.freeze({
+  DOUBLE: 'double',
+  DASHED: 'dashed',
+});
+
+export const PLURALITY_MARKER_VALUES = Object.freeze([
+  PLURALITY_MARKER.DOUBLE,
+  PLURALITY_MARKER.DASHED,
+]);
+
+export function isValidPluralityMarker(value) {
+  return PLURALITY_MARKER_VALUES.includes(value);
+}