@nfdi4plants/arctrl 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/ts/ts/ROCrate/Generic/Sample.js

@@ -0,0 +1,131 @@
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { LDPropertyValue } from './PropertyValue.js';
+import { clean } from '../Helper.js';
+import { contains } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { stringHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+
+class LDSample {
+  constructor() {
+  }
+  static get schemaType() {
+    return "https://bioschemas.org/Sample";
+  }
+  static get name() {
+    return "http://schema.org/name";
+  }
+  static get additionalProperty() {
+    return "http://schema.org/additionalProperty";
+  }
+  static tryGetNameAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDSample.name, unwrap(context));
+    let matchResult, n;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  static getNameAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDSample.name, unwrap(context));
+    let matchResult, n;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        throw new Error(`Could not access property \`name\` of object with @id \`${s.Id}\``);
+    }
+  }
+  static setNameAsString(s, n) {
+    s.SetProperty(LDSample.name, n);
+  }
+  static getAdditionalProperties(s, graph, context) {
+    return s.GetPropertyNodes(LDSample.additionalProperty, (ldObject, context_1) => LDPropertyValue.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setAdditionalProperties(s, additionalProperties, context) {
+    return s.SetProperty(LDSample.additionalProperty, additionalProperties, unwrap(context));
+  }
+  static getCharacteristics(s, graph, context) {
+    return s.GetPropertyNodes(LDSample.additionalProperty, (ldObject, context_1) => LDPropertyValue.validateCharacteristicValue(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static getFactors(s, graph, context) {
+    return s.GetPropertyNodes(LDSample.additionalProperty, (ldObject, context_1) => LDPropertyValue.validateFactorValue(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static validate(s, context) {
+    return s.HasType(LDSample.schemaType, unwrap(context)) && s.HasProperty(LDSample.name, unwrap(context));
+  }
+  static genIDSample(name) {
+    return clean(`#Sample_${name}`);
+  }
+  static genIDSource(name) {
+    return clean(`#Source_${name}`);
+  }
+  static genIDMaterial(name) {
+    return clean(`#Material_${name}`);
+  }
+  static validateSample(s, context) {
+    return LDSample.validate(s, unwrap(context)) && contains("Sample", s.AdditionalType, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static validateSource(s, context) {
+    return LDSample.validate(s, unwrap(context)) && contains("Source", s.AdditionalType, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static validateMaterial(s, context) {
+    return LDSample.validate(s, unwrap(context)) && contains("Material", s.AdditionalType, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static create(id, name, additionalProperties, context) {
+    const s = new LDNode(id, [LDSample.schemaType], void 0, unwrap(context));
+    s.SetProperty(LDSample.name, name, unwrap(context));
+    s.SetOptionalProperty(LDSample.additionalProperty, additionalProperties, unwrap(context));
+    return s;
+  }
+  static createSample(name, id, additionalProperties, context) {
+    const id_2 = id == null ? LDSample.genIDSample(name) : value(id);
+    const s = LDSample.create(id_2, name, unwrap(additionalProperties), unwrap(context));
+    s.AdditionalType = ["Sample"];
+    return s;
+  }
+  static createSource(name, id, additionalProperties, context) {
+    const id_2 = id == null ? LDSample.genIDSource(name) : value(id);
+    const s = LDSample.create(id_2, name, unwrap(additionalProperties), unwrap(context));
+    s.AdditionalType = ["Source"];
+    return s;
+  }
+  static createMaterial(name, id, additionalProperties, context) {
+    const id_2 = id == null ? LDSample.genIDMaterial(name) : value(id);
+    const s = LDSample.create(id_2, name, unwrap(additionalProperties), unwrap(context));
+    s.AdditionalType = ["Material"];
+    return s;
+  }
+}
+
+export { LDSample };

package/dist/ts/ts/ROCrate/Generic/ScholarlyArticle.js

@@ -0,0 +1,173 @@
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { LDPropertyValue } from './PropertyValue.js';
+import { LDPerson } from './Person.js';
+import { LDDefinedTerm } from './DefinedTerm.js';
+import { LDComment } from './Comment.js';
+import { clean } from '../Helper.js';
+
+class LDScholarlyArticle {
+  constructor() {
+  }
+  static get schemaType() {
+    return "http://schema.org/ScholarlyArticle";
+  }
+  static get headline() {
+    return "http://schema.org/headline";
+  }
+  static get identifier() {
+    return "http://schema.org/identifier";
+  }
+  static get author() {
+    return "http://schema.org/author";
+  }
+  static get url() {
+    return "http://schema.org/url";
+  }
+  static get sameAs() {
+    return "http://schema.org/sameAs";
+  }
+  static get creativeWorkStatus() {
+    return "http://schema.org/creativeWorkStatus";
+  }
+  static get comment() {
+    return "http://schema.org/comment";
+  }
+  static tryGetHeadlineAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDScholarlyArticle.headline, unwrap(context));
+    let matchResult, n;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  static getHeadlineAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDScholarlyArticle.headline, unwrap(context));
+    if (matchValue == null) {
+      throw new Error(`Could not access property \`headline\` of object with @id \`${s.Id}\``);
+    } else if (typeof value(matchValue) === "string") {
+      const n = value(matchValue);
+      return n;
+    } else {
+      throw new Error(`Value of property \`headline\` of object with @id \`${s.Id}\` should have been a string`);
+    }
+  }
+  static setHeadlineAsString(s, n) {
+    s.SetProperty(LDScholarlyArticle.headline, n);
+  }
+  static getIdentifiers(s, context) {
+    return s.GetPropertyValues(LDScholarlyArticle.identifier, void 0, unwrap(context));
+  }
+  static getIdentifiersAsPropertyValue(s, graph, context) {
+    return s.GetPropertyNodes(LDScholarlyArticle.identifier, (ldObject, context_1) => LDPropertyValue.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setIdentifiers(s, identifiers) {
+    s.SetProperty(LDScholarlyArticle.identifier, identifiers);
+  }
+  static getAuthors(s, graph, context) {
+    return s.GetPropertyNodes(LDScholarlyArticle.author, (ldObject, context_1) => LDPerson.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setAuthors(s, authors, context) {
+    return s.SetProperty(LDScholarlyArticle.author, authors, unwrap(context));
+  }
+  static tryGetUrlAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDScholarlyArticle.url, unwrap(context));
+    let matchResult, u;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        u = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return u;
+      default:
+        return void 0;
+    }
+  }
+  static tryGetSameAsAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDScholarlyArticle.sameAs, unwrap(context));
+    let matchResult, sa;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        sa = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return sa;
+      default:
+        return void 0;
+    }
+  }
+  static tryGetCreativeWorkStatus(s, graph, context) {
+    let cws;
+    const matchValue = s.TryGetPropertyAsSingleNode(LDScholarlyArticle.creativeWorkStatus, unwrap(graph), unwrap(context));
+    let matchResult, cws_1;
+    if (matchValue != null) {
+      if (cws = value(matchValue), LDDefinedTerm.validate(cws, unwrap(context))) {
+        matchResult = 0;
+        cws_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return cws_1;
+      default:
+        return void 0;
+    }
+  }
+  static setCreativeWorkStatus(s, cws, context) {
+    return s.SetProperty(LDScholarlyArticle.creativeWorkStatus, cws, unwrap(context));
+  }
+  static getComments(s, graph, context) {
+    return s.GetPropertyNodes(LDScholarlyArticle.comment, (ldObject, context_1) => LDComment.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setcomments(s, comments, context) {
+    return s.SetProperty(LDScholarlyArticle.comment, comments, unwrap(context));
+  }
+  static genID(headline, url) {
+    return clean(url == null ? `#${headline}` : value(url));
+  }
+  static validate(s, context) {
+    return s.HasType(LDScholarlyArticle.schemaType, unwrap(context)) && s.HasProperty(LDScholarlyArticle.headline, unwrap(context));
+  }
+  static create(headline, identifiers, id, authors, url, creativeWorkStatus, comments, context) {
+    const s = new LDNode(id == null ? LDScholarlyArticle.genID(headline, unwrap(url)) : value(id), [LDScholarlyArticle.schemaType], void 0, unwrap(context));
+    s.SetProperty(LDScholarlyArticle.headline, headline, unwrap(context));
+    s.SetProperty(LDScholarlyArticle.identifier, identifiers, unwrap(context));
+    s.SetOptionalProperty(LDScholarlyArticle.author, authors, unwrap(context));
+    s.SetOptionalProperty(LDScholarlyArticle.url, url, unwrap(context));
+    s.SetOptionalProperty(LDScholarlyArticle.creativeWorkStatus, creativeWorkStatus, unwrap(context));
+    s.SetOptionalProperty(LDScholarlyArticle.comment, comments, unwrap(context));
+    return s;
+  }
+}
+
+export { LDScholarlyArticle };

package/dist/ts/ts/ROCrate/Helper.js

@@ -0,0 +1,7 @@
+import { replace } from '../../node_modules/@fable-org/fable-library-js/String.js';
+
+function clean(id) {
+  return replace(id, " ", "_");
+}
+
+export { clean };

package/dist/ts/ts/ROCrate/LDContext.js

@@ -0,0 +1,288 @@
+import { ActivePatterns_$007CRegex$007C_$007C } from '../Core/Helper/Regex.js';
+import { defaultArg, value, unwrap } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { FSharpRef, toString } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { Uri } from '../../node_modules/@fable-org/fable-library-js/Uri.js';
+import { getEnumerator, disposeSafe, safeHash, stringHash, defaultOf, comparePrimitives } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { addToDict, getItemFromDict, tryGetValue } from '../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { reduce, map, sort, tryPick } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { StringDictionary_ofSeq } from '../Core/Helper/Collections.js';
+import { boxHashSeq, mergeHashes, hash } from '../Core/Helper/HashCodes.js';
+
+const IRIHelper_compactIRIRegex = "(?<prefix>.*):(?<suffix>[^\\/][^\\/].*)";
+function IRIHelper_$007CCompactIri$007C_$007C(termDefition) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C(IRIHelper_compactIRIRegex, termDefition);
+  if (activePatternResult != null) {
+    const result = value(activePatternResult);
+    return [result.groups && result.groups.prefix || "", result.groups && result.groups.suffix || ""];
+  } else {
+    return void 0;
+  }
+}
+function IRIHelper_combine(baseIRI, relative) {
+  if (relative.startsWith("http://") ? true : relative.startsWith("https://")) {
+    return relative;
+  } else {
+    return toString(Uri.create(Uri.create(baseIRI), relative));
+  }
+}
+function IRIHelper_combineOptional(baseIRI, relative) {
+  if (baseIRI == null) {
+    if (relative != null) {
+      const r_1 = value(relative);
+      return r_1;
+    } else {
+      return void 0;
+    }
+  } else if (relative == null) {
+    const b_1 = value(baseIRI);
+    return b_1;
+  } else {
+    const b = value(baseIRI);
+    const r = value(relative);
+    return IRIHelper_combine(b, r);
+  }
+}
+class LDContext {
+  constructor(mappings, baseContexts) {
+    this["baseContexts@41"] = defaultArg(baseContexts, []);
+    this.name = void 0;
+    this["mappings@45"] = mappings == null ? /* @__PURE__ */ new Map([]) : value(mappings);
+    this.reverseMappings = /* @__PURE__ */ new Map([]);
+    this.compactReverseMappings = /* @__PURE__ */ new Map([]);
+    let enumerator = getEnumerator(this["mappings@45"]);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const kvp = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        this.addReverseMapping(kvp[0], kvp[1]);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+  }
+  get Mappings() {
+    const this$ = this;
+    return this$["mappings@45"];
+  }
+  get BaseContexts() {
+    const this$ = this;
+    return this$["baseContexts@41"];
+  }
+  set BaseContexts(value) {
+    const this$ = this;
+    this$["baseContexts@41"] = value;
+  }
+  get Name() {
+    const this$ = this;
+    return unwrap(this$.name);
+  }
+  set Name(value) {
+    const this$ = this;
+    this$.name = value;
+  }
+  AddMapping(term, definition) {
+    const this$ = this;
+    const key = term;
+    const value = definition;
+    const dict = this$["mappings@45"];
+    if (dict.has(key)) {
+      dict.set(key, value);
+    } else {
+      addToDict(dict, key, value);
+    }
+    this$.addReverseMapping(term, definition);
+  }
+  TryResolveTerm(term) {
+    const this$ = this;
+    return term.indexOf(":") >= 0 ? reduce(IRIHelper_combineOptional, map((term_1) => this$.tryFindTerm(term_1), term.split(":"))) : this$.tryFindTerm(term);
+  }
+  TryGetTerm(iri) {
+    const this$ = this;
+    return this$.tryFindIri(iri);
+  }
+  PropertyNamesMatch(p1, p2) {
+    let p2Def_2, p1Def_2, p1Def_1, p2Def_1;
+    const this$ = this;
+    if (p1 === p2) {
+      return true;
+    } else {
+      const p1Def = this$.TryResolveTerm(p1);
+      const p2Def = this$.TryResolveTerm(p2);
+      return p1Def == null ? p2Def != null && (p2Def_2 = value(p2Def), p1 === p2Def_2) : p2Def == null ? (p1Def_2 = value(p1Def), p1Def_2 === p2) : (p1Def_1 = value(p1Def), p2Def_1 = value(p2Def), p1Def_1 === p2Def_1);
+    }
+  }
+  static fromMappingSeq(mappings) {
+    return new LDContext(StringDictionary_ofSeq(mappings));
+  }
+  static combine_InPlace(baseContext, specificContext) {
+    void specificContext.BaseContexts.push(baseContext);
+    return specificContext;
+  }
+  static combine(baseContext, specificContext) {
+    return new LDContext(void 0, [specificContext, baseContext]);
+  }
+  static tryCombineOptional(baseContext, specificContext) {
+    let s_1, f_1, f, s;
+    return baseContext == null ? specificContext != null ? (s_1 = value(specificContext), s_1) : void 0 : specificContext == null ? (f_1 = value(baseContext), f_1) : (f = value(baseContext), s = value(specificContext), LDContext.combine(f, s));
+  }
+  ShallowCopy() {
+    const this$ = this;
+    const newMappings = /* @__PURE__ */ new Map([]);
+    let enumerator = getEnumerator(this$["mappings@45"]);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const kvp = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        addToDict(newMappings, kvp[0], kvp[1]);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    return new LDContext(newMappings, this$["baseContexts@41"]);
+  }
+  DeepCopy() {
+    const this$ = this;
+    const newMappings = /* @__PURE__ */ new Map([]);
+    let enumerator = getEnumerator(this$["mappings@45"]);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const kvp = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        addToDict(newMappings, kvp[0], kvp[1]);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    const newBaseContexts = [];
+    let enumerator_1 = getEnumerator(this$["baseContexts@41"]);
+    try {
+      while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+        const ctx = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        void newBaseContexts.push(ctx.DeepCopy());
+      }
+    } finally {
+      disposeSafe(enumerator_1);
+    }
+    return new LDContext(newMappings, newBaseContexts);
+  }
+  StructurallyEquals(other) {
+    const this$ = this;
+    return safeHash(this$) === safeHash(other);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  Equals(other) {
+    let other_1;
+    const this$ = this;
+    return other instanceof LDContext && (other_1 = other, this$.StructurallyEquals(other_1));
+  }
+  GetHashCode() {
+    const this$ = this;
+    const mappingsHash = boxHashSeq(map((k) => mergeHashes(hash(k), hash(getItemFromDict(this$.Mappings, k))), sort(this$.Mappings.keys(), {
+      Compare: comparePrimitives
+    }))) | 0;
+    let nameHash;
+    const matchValue = this$.Name;
+    nameHash = matchValue == null ? 0 : stringHash(value(matchValue));
+    const baseContextsHash = (this$["baseContexts@41"].length === 0 ? 0 : reduce(mergeHashes, map(safeHash, this$["baseContexts@41"]))) | 0;
+    return mergeHashes(mergeHashes(mappingsHash, nameHash), baseContextsHash) | 0;
+  }
+  "System.ICloneable.Clone"() {
+    const this$ = this;
+    return this$.DeepCopy();
+  }
+  addReverseMapping(key, value$1) {
+    const this$ = this;
+    const key_1 = value$1;
+    const value_1 = key;
+    const dict = this$.reverseMappings;
+    if (dict.has(key_1)) {
+      dict.set(key_1, value_1);
+    } else {
+      addToDict(dict, key_1, value_1);
+    }
+    const activePatternResult = IRIHelper_$007CCompactIri$007C_$007C(value$1);
+    if (activePatternResult != null) {
+      const prefix = value(activePatternResult)[0];
+      const suffix = value(activePatternResult)[1];
+      const key_2 = prefix;
+      const value_2 = [suffix, key];
+      const dict_1 = this$.compactReverseMappings;
+      if (dict_1.has(key_2)) {
+        dict_1.set(key_2, value_2);
+      } else {
+        addToDict(dict_1, key_2, value_2);
+      }
+      let matchValue;
+      let patternInput;
+      let outArg = defaultOf();
+      patternInput = [tryGetValue(this$["mappings@45"], prefix, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      matchValue = patternInput[0] ? patternInput[1] : void 0;
+      if (matchValue == null) ; else {
+        const key_4 = IRIHelper_combine(value(matchValue), suffix);
+        const value_3 = key;
+        const dict_3 = this$.reverseMappings;
+        if (dict_3.has(key_4)) {
+          dict_3.set(key_4, value_3);
+        } else {
+          addToDict(dict_3, key_4, value_3);
+        }
+      }
+    } else {
+      let matchValue_1;
+      let patternInput_1;
+      let outArg_1 = defaultOf();
+      patternInput_1 = [tryGetValue(this$.compactReverseMappings, key, new FSharpRef(() => outArg_1, (v_2) => {
+        outArg_1 = v_2;
+      })), outArg_1];
+      matchValue_1 = patternInput_1[0] ? patternInput_1[1] : void 0;
+      if (matchValue_1 == null) ; else {
+        const term = value(matchValue_1)[1];
+        const key_6 = IRIHelper_combine(value$1, value(matchValue_1)[0]);
+        const value_4 = term;
+        const dict_5 = this$.reverseMappings;
+        if (dict_5.has(key_6)) {
+          dict_5.set(key_6, value_4);
+        } else {
+          addToDict(dict_5, key_6, value_4);
+        }
+      }
+    }
+  }
+  tryFindTerm(term) {
+    let prefix, suffix, d;
+    const this$ = this;
+    let definition;
+    let matchValue;
+    let patternInput;
+    let outArg = defaultOf();
+    patternInput = [tryGetValue(this$["mappings@45"], term, new FSharpRef(() => outArg, (v) => {
+      outArg = v;
+    })), outArg];
+    matchValue = patternInput[0] ? patternInput[1] : void 0;
+    definition = matchValue == null ? tryPick((ctx) => ctx.TryResolveTerm(term), this$["baseContexts@41"]) : value(matchValue);
+    if (definition == null) {
+      return void 0;
+    } else {
+      const activePatternResult = IRIHelper_$007CCompactIri$007C_$007C(value(definition));
+      return activePatternResult != null ? (prefix = value(activePatternResult)[0], suffix = value(activePatternResult)[1], IRIHelper_combine(prefix === term ? prefix : defaultArg(this$.tryFindTerm(prefix), prefix), suffix === term ? suffix : defaultArg(this$.tryFindTerm(suffix), suffix))) : (d = value(definition), d);
+    }
+  }
+  tryFindIri(iri) {
+    const this$ = this;
+    let matchValue;
+    let patternInput;
+    let outArg = defaultOf();
+    patternInput = [tryGetValue(this$.reverseMappings, iri, new FSharpRef(() => outArg, (v) => {
+      outArg = v;
+    })), outArg];
+    matchValue = patternInput[0] ? patternInput[1] : void 0;
+    return matchValue == null ? tryPick((ctx) => ctx.TryGetTerm(iri), this$["baseContexts@41"]) : value(matchValue);
+  }
+  tryCompactIRI(iri) {
+    throw new Error("TryCompactIRI is Not implemented yet");
+  }
+}
+
+export { IRIHelper_$007CCompactIri$007C_$007C, IRIHelper_combine, IRIHelper_combineOptional, IRIHelper_compactIRIRegex, LDContext };