@robosystems/report-components 0.1.4 → 0.2.1

package/dist/chunk-DGP4KRWF.js

@@ -0,0 +1,721 @@
+import { DataFactory, Store, Parser } from 'n3';
+import jsonld from 'jsonld';
+
+// src/constants.ts
+var NS = {
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  rs: "https://robosystems.ai/vocab/",
+  rsgaap: "https://robosystems.ai/taxonomy/rs-gaap/v1/",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  xlink: "http://www.w3.org/1999/xlink#",
+  xbrli: "http://www.xbrl.org/2003/instance#",
+  link: "http://www.xbrl.org/2003/linkbase#",
+  iso4217: "http://www.xbrl.org/2003/iso4217#"
+};
+var IRI = {
+  type: NS.rdf + "type",
+  // rs: classes
+  Report: NS.rs + "Report",
+  Fact: NS.rs + "Fact",
+  InformationBlock: NS.rs + "InformationBlock",
+  Structure: NS.rs + "Structure",
+  Association: NS.rs + "Association",
+  Element: NS.rs + "Element",
+  Period: NS.rs + "Period",
+  Unit: NS.rs + "Unit",
+  Entity: NS.rs + "Entity",
+  // rs: predicates
+  element: NS.rs + "element",
+  period: NS.rs + "period",
+  unit: NS.rs + "unit",
+  entity: NS.rs + "entity",
+  factSet: NS.rs + "factSet",
+  numericValue: NS.rs + "numericValue",
+  decimals: NS.rs + "decimals",
+  blockType: NS.rs + "blockType",
+  associationType: NS.rs + "associationType",
+  hasAssociation: NS.rs + "hasAssociation",
+  roleUri: NS.rs + "roleUri",
+  structureName: NS.rs + "structureName",
+  abstract: NS.rs + "abstract",
+  monetary: NS.rs + "monetary",
+  legalName: NS.rs + "legalName",
+  country: NS.rs + "country",
+  // skos:
+  prefLabel: NS.skos + "prefLabel",
+  // xlink:
+  from: NS.xlink + "from",
+  to: NS.xlink + "to",
+  role: NS.xlink + "role",
+  // xbrli:
+  instant: NS.xbrli + "instant",
+  startDate: NS.xbrli + "startDate",
+  endDate: NS.xbrli + "endDate",
+  periodType: NS.xbrli + "periodType",
+  balance: NS.xbrli + "balance",
+  measure: NS.xbrli + "measure",
+  // link:
+  order: NS.link + "order",
+  weight: NS.link + "weight"
+};
+var PREFIXES = [
+  ["rs-gaap", NS.rsgaap],
+  ["disclosures", "https://robosystems.ai/taxonomy/rs-gaap/disclosures/v1/"],
+  ["us-gaap", "http://fasb.org/us-gaap/"],
+  ["dei", "http://xbrl.sec.gov/dei/"],
+  ["rs", NS.rs],
+  ["skos", NS.skos],
+  ["xbrli", NS.xbrli],
+  ["xlink", NS.xlink],
+  ["link", NS.link],
+  ["iso4217", NS.iso4217]
+];
+function qname(iri) {
+  for (const [prefix, ns] of PREFIXES) {
+    if (iri.startsWith(ns)) {
+      return `${prefix}:${iri.slice(ns.length)}`;
+    }
+  }
+  const slash = iri.lastIndexOf("/");
+  const hash = iri.lastIndexOf("#");
+  return iri.slice(Math.max(slash, hash) + 1);
+}
+function humanize(iri) {
+  const local = qname(iri).split(":").pop() ?? iri;
+  return local.replace(/(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g, " ");
+}
+function isExternalFactUrl(value) {
+  return !!value && /^https?:\/\/\S+\/fact_[0-9a-f]+\.(html|txt)$/i.test(value);
+}
+var BLOCK_ORDER = {
+  balance_sheet: 0,
+  income_statement: 1,
+  cash_flow_statement: 2,
+  equity_statement: 3
+};
+var BLOCK_TITLES = {
+  balance_sheet: "Balance Sheet",
+  income_statement: "Income Statement",
+  cash_flow_statement: "Cash Flow Statement",
+  equity_statement: "Statement of Changes in Equity"
+};
+
+// src/format.ts
+function formatMoney(value, opts = {}) {
+  if (value === null || value === void 0 || Number.isNaN(value)) return "\u2014";
+  const symbol = opts.currencySymbol ?? "$";
+  const abs = Math.abs(value).toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+  return value < 0 ? `${symbol}(${abs})` : `${symbol}${abs}`;
+}
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function formatDate(iso) {
+  if (!iso) return "";
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
+  if (!m) return iso;
+  const [, year, month, day] = m;
+  const idx = Number(month) - 1;
+  return `${MONTHS[idx] ?? month} ${Number(day)}, ${year}`;
+}
+function humanizeDuration(value) {
+  if (!value) return null;
+  const m = /^(-)?P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/.exec(
+    value.trim()
+  );
+  if (!m) return null;
+  const [, sign, y, mo, w, d, h, min, s] = m;
+  const parts = [];
+  const push = (n, unit) => {
+    if (n) parts.push(`${n} ${unit}${Number(n) === 1 ? "" : "s"}`);
+  };
+  push(y, "year");
+  push(mo, "month");
+  push(w, "week");
+  push(d, "day");
+  push(h, "hour");
+  push(min, "minute");
+  push(s, "second");
+  if (!parts.length) return null;
+  return `${sign ?? ""}${parts.join(" ")}`;
+}
+function formatPeriod(period) {
+  if (period.type === "instant") {
+    return `As of ${formatDate(period.instant ?? period.end)}`;
+  }
+  return `${formatDate(period.startDate)} \u2013 ${formatDate(period.endDate ?? period.end)}`;
+}
+function numericKindOf(el) {
+  return el.numericKind ?? (el.monetary ? "monetary" : "other");
+}
+var CURRENCY_SYMBOLS = {
+  USD: "$",
+  EUR: "\u20AC",
+  GBP: "\xA3",
+  JPY: "\xA5",
+  CNY: "\xA5",
+  CHF: "CHF ",
+  CAD: "CA$",
+  AUD: "A$",
+  HKD: "HK$",
+  INR: "\u20B9",
+  KRW: "\u20A9"
+};
+function currencySymbolFor(measure) {
+  if (!measure) return null;
+  const code = (measure.includes(":") ? measure.split(":").pop() : measure).toUpperCase();
+  if (CURRENCY_SYMBOLS[code]) return CURRENCY_SYMBOLS[code];
+  return /^[A-Z]{3}$/.test(code) ? `${code} ` : null;
+}
+function formatValue(value, fmt = {}) {
+  if (value === null || value === void 0 || Number.isNaN(value)) return "\u2014";
+  const kind = fmt.numericKind ?? "monetary";
+  const scale = kind === "monetary" ? fmt.scaleFactor ?? 1 : 1;
+  const scaled = kind === "percent" ? value * 100 : value / scale;
+  let minFrac = 0;
+  let maxFrac = 0;
+  if (kind === "perShare") {
+    minFrac = maxFrac = 2;
+  } else if (kind === "monetary") {
+    minFrac = maxFrac = scale > 1 ? 0 : 2;
+  } else if (kind === "percent") {
+    maxFrac = 2;
+  } else if (kind === "pure") {
+    maxFrac = 4;
+  }
+  const abs = Math.abs(scaled).toLocaleString("en-US", {
+    minimumFractionDigits: minFrac,
+    maximumFractionDigits: maxFrac
+  });
+  const symbol = kind === "monetary" || kind === "perShare" ? fmt.symbol ?? "" : "";
+  const suffix = kind === "percent" ? "%" : "";
+  return scaled < 0 ? `${symbol}(${abs}${suffix})` : `${symbol}${abs}${suffix}`;
+}
+
+// src/adapters/sec.ts
+var ENTITY_META_Q = `
+MATCH (ent:Entity)-[:ENTITY_HAS_REPORT]->(r:Report {identifier: $rid})
+RETURN ent.identifier AS entity_id, ent.name AS entity_name,
+       ent.legal_name AS legal_name, ent.cik AS cik, ent.ticker AS ticker,
+       r.form AS form, r.report_date AS report_date`;
+var SECTIONS_Q = `
+MATCH (r:Report {identifier: $rid})-[:REPORT_HAS_FACT]->(f:Fact)<-[:FACT_SET_CONTAINS_FACT]-(fs:FactSet)<-[:STRUCTURE_HAS_FACT_SET]-(s:Structure)
+RETURN s.identifier AS sid, s.canonical_type AS canonical_type,
+       s.definition AS definition, s.number AS number,
+       collect(DISTINCT fs.identifier) AS factsets
+ORDER BY number`;
+var FACTS_Q = `
+MATCH (fs:FactSet {identifier: $fsid})-[:FACT_SET_CONTAINS_FACT]->(f:Fact)-[:FACT_HAS_ELEMENT]->(e:Element),
+      (f)-[:FACT_HAS_PERIOD]->(p:Period)
+WHERE f.value IS NOT NULL
+RETURN f.identifier AS fid, e.qname AS qname, e.name AS ename, e.balance AS balance,
+       e.period_type AS e_period_type, e.is_abstract AS is_abstract, e.is_numeric AS is_numeric,
+       e.item_type AS item_type, e.is_shares AS is_shares,
+       f.numeric_value AS numeric_value, f.value AS raw_value, f.decimals AS decimals,
+       p.identifier AS pid, p.period_type AS period_type,
+       p.start_date AS start_date, p.end_date AS end_date
+LIMIT 2000`;
+var UNITS_Q = `
+MATCH (fs:FactSet {identifier: $fsid})-[:FACT_SET_CONTAINS_FACT]->(f:Fact)-[:FACT_HAS_UNIT]->(u:Unit)
+WHERE f.value IS NOT NULL
+RETURN f.identifier AS fid, u.measure AS unit
+LIMIT 2000`;
+var DIMS_Q = `
+MATCH (fs:FactSet {identifier: $fsid})-[:FACT_SET_CONTAINS_FACT]->(f:Fact)-[:FACT_HAS_DIMENSION]->(d:Dimension)
+WHERE f.value IS NOT NULL
+RETURN f.identifier AS fid, d.axis AS axis, d.member AS member,
+       d.axis_uri AS axis_uri, d.member_uri AS member_uri,
+       d.is_explicit AS is_explicit, d.is_typed AS is_typed
+LIMIT 4000`;
+var ASSOC_Q = `
+MATCH (s:Structure {identifier: $sid})-[:STRUCTURE_HAS_ASSOCIATION]->(a:Association),
+      (a)-[:ASSOCIATION_HAS_FROM_ELEMENT]->(pe:Element),
+      (a)-[:ASSOCIATION_HAS_TO_ELEMENT]->(ce:Element)
+RETURN a.association_type AS association_type, a.order_value AS order_value, a.weight AS weight,
+       pe.qname AS parent, pe.name AS parent_name, pe.is_abstract AS parent_abstract,
+       ce.qname AS child, ce.name AS child_name, ce.is_abstract AS child_abstract`;
+function str(row, key) {
+  const v = row[key];
+  return typeof v === "string" && v !== "" ? v : v == null ? null : String(v);
+}
+function num(row, key) {
+  const v = row[key];
+  if (v === null || v === void 0 || v === "") return null;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isNaN(n) ? null : n;
+}
+function bool(row, key) {
+  const v = row[key];
+  return v === true || v === "true";
+}
+function periodType(raw) {
+  return raw === "instant" || raw === "duration" ? raw : null;
+}
+function xbrlQname(uri, local) {
+  if (local) {
+    const ns = (uri ?? "").split("#")[0];
+    if (/fasb\.org\/us-gaap/.test(ns)) return `us-gaap:${local}`;
+    if (/fasb\.org\/srt/.test(ns)) return `srt:${local}`;
+    if (/xbrl\.sec\.gov\/dei/.test(ns)) return `dei:${local}`;
+    if (/robosystems\.ai\/taxonomy\/rs-gaap/.test(ns)) return `rs-gaap:${local}`;
+    return local;
+  }
+  return uri ? qname(uri) : "";
+}
+function dimLabel(local) {
+  if (!local) return "";
+  return humanize(local.replace(/(Axis|Member|Domain)$/, "")) || humanize(local);
+}
+function deriveNumericKind(row) {
+  const itemType = str(row, "item_type") ?? "";
+  if (/perShareItemType/i.test(itemType)) return "perShare";
+  if (/sharesItemType/i.test(itemType) || bool(row, "is_shares")) return "shares";
+  if (/percentItemType/i.test(itemType)) return "percent";
+  if (/pureItemType/i.test(itemType)) return "pure";
+  if (/monetaryItemType/i.test(itemType)) return "monetary";
+  if (/integerItemType/i.test(itemType)) return "integer";
+  if (!bool(row, "is_numeric")) return void 0;
+  const balance = str(row, "balance");
+  return balance === "debit" || balance === "credit" ? "monetary" : "other";
+}
+var CORE_STATEMENT_TYPES = /* @__PURE__ */ new Set([
+  "balance_sheet",
+  "income_statement",
+  "cash_flow_statement",
+  "equity_statement",
+  "comprehensive_income"
+]);
+function parseStructureDefinition(definition, canonicalType) {
+  const raw = (definition ?? "").trim();
+  const parts = raw.split(" - ");
+  let type = "";
+  let title = raw;
+  if (parts.length >= 3) {
+    type = parts[1].trim();
+    title = parts.slice(2).join(" - ").trim();
+  } else if (parts.length === 2) {
+    title = parts[1].trim();
+  }
+  let kind = "Other";
+  if (/cover/i.test(title)) kind = "Cover";
+  else if (type === "Statement") kind = "Statement";
+  else if (type === "Disclosure") kind = "Disclosure";
+  else if (type === "Document") kind = "Document";
+  if (canonicalType && CORE_STATEMENT_TYPES.has(canonicalType)) kind = "Statement";
+  return { title: title || raw || canonicalType || "Section", kind };
+}
+function mapEntity(row) {
+  if (!row) return null;
+  const id = str(row, "entity_id");
+  if (!id) return null;
+  return {
+    id,
+    name: str(row, "entity_name") ?? str(row, "legal_name") ?? "Entity",
+    legalName: str(row, "legal_name"),
+    country: null
+  };
+}
+async function fetchSecReportShell(query, reportId) {
+  const [entityRows, sectionRows] = await Promise.all([
+    query(ENTITY_META_Q, { rid: reportId }),
+    query(SECTIONS_Q, { rid: reportId })
+  ]);
+  const sections = sectionRows.map((row, order) => {
+    const { title, kind } = parseStructureDefinition(
+      str(row, "definition"),
+      str(row, "canonical_type")
+    );
+    const factsets = Array.isArray(row.factsets) ? row.factsets.filter((v) => typeof v === "string") : [];
+    return {
+      id: str(row, "sid") ?? "",
+      title,
+      kind,
+      canonicalType: str(row, "canonical_type"),
+      order,
+      factsetIds: factsets
+    };
+  }).filter((s) => s.id && s.factsetIds.length > 0);
+  return { reportId, entity: mapEntity(entityRows[0]), sections };
+}
+function accumulateElement(elements, row) {
+  const q = str(row, "qname");
+  if (!q || elements[q]) return;
+  const balance = str(row, "balance");
+  elements[q] = {
+    id: q,
+    qname: q,
+    label: str(row, "ename") ? humanize(str(row, "ename")) : humanize(q),
+    balance: balance === "debit" || balance === "credit" ? balance : null,
+    periodType: periodType(str(row, "e_period_type")),
+    abstract: bool(row, "is_abstract"),
+    monetary: bool(row, "is_numeric"),
+    numericKind: deriveNumericKind(row)
+  };
+}
+function registerPresentationElement(elements, qname2, name, isAbstract) {
+  if (!qname2 || elements[qname2]) return;
+  elements[qname2] = {
+    id: qname2,
+    qname: qname2,
+    label: name ? humanize(isAbstract ? name.replace(/Abstract$/, "") : name) : humanize(qname2),
+    balance: null,
+    periodType: null,
+    abstract: isAbstract,
+    monetary: false
+  };
+}
+function accumulatePeriod(periods, row) {
+  const id = str(row, "pid");
+  if (!id || periods[id]) return;
+  const type = periodType(str(row, "period_type")) ?? "duration";
+  const startDate = str(row, "start_date");
+  const endDate = str(row, "end_date");
+  periods[id] = {
+    id,
+    type,
+    instant: type === "instant" ? endDate : null,
+    startDate,
+    endDate,
+    end: endDate ?? ""
+  };
+}
+async function fetchSecSection(query, shell, section) {
+  const [factRowGroups, unitRowGroups, dimRowGroups, assocRows] = await Promise.all([
+    Promise.all(section.factsetIds.map((fsid) => query(FACTS_Q, { fsid }))),
+    Promise.all(section.factsetIds.map((fsid) => query(UNITS_Q, { fsid }))),
+    Promise.all(section.factsetIds.map((fsid) => query(DIMS_Q, { fsid }))),
+    query(ASSOC_Q, { sid: section.id })
+  ]);
+  const unitByFid = /* @__PURE__ */ new Map();
+  for (const row of unitRowGroups.flat()) {
+    const fid = str(row, "fid");
+    const measure = str(row, "unit");
+    if (fid && measure) unitByFid.set(fid, measure);
+  }
+  const dimsByFid = /* @__PURE__ */ new Map();
+  for (const row of dimRowGroups.flat()) {
+    const fid = str(row, "fid");
+    if (!fid) continue;
+    const memberLocal = str(row, "member");
+    const qual = {
+      axis: xbrlQname(str(row, "axis_uri"), str(row, "axis")),
+      member: memberLocal ? xbrlQname(str(row, "member_uri"), memberLocal) : null,
+      axisLabel: dimLabel(str(row, "axis")),
+      memberLabel: dimLabel(memberLocal),
+      explicit: bool(row, "is_explicit"),
+      typedValue: bool(row, "is_typed") ? str(row, "member") : null
+    };
+    const list = dimsByFid.get(fid) ?? [];
+    list.push(qual);
+    dimsByFid.set(fid, list);
+  }
+  for (const list of dimsByFid.values()) list.sort((a, b) => a.axis.localeCompare(b.axis));
+  const elements = {};
+  const periods = {};
+  const units = {};
+  const facts = [];
+  const seenFacts = /* @__PURE__ */ new Set();
+  for (const row of factRowGroups.flat()) {
+    const fid = str(row, "fid");
+    const element = str(row, "qname");
+    const period = str(row, "pid");
+    if (!fid || !element || !period || seenFacts.has(fid)) continue;
+    seenFacts.add(fid);
+    accumulateElement(elements, row);
+    accumulatePeriod(periods, row);
+    const measure = unitByFid.get(fid) ?? null;
+    if (measure && !units[measure]) {
+      const compact = qname(measure);
+      units[measure] = {
+        id: measure,
+        measure: compact,
+        label: compact.includes(":") ? compact.split(":").pop() : compact,
+        symbol: currencySymbolFor(compact)
+      };
+    }
+    const value = num(row, "numeric_value");
+    facts.push({
+      id: fid,
+      element,
+      period,
+      unit: measure,
+      entity: shell.entity?.id ?? null,
+      factSet: section.id,
+      value,
+      decimals: str(row, "decimals"),
+      textValue: value === null ? str(row, "raw_value") : null,
+      dimensions: dimsByFid.get(fid)
+    });
+  }
+  const calcAssociations = [];
+  const presAssociations = [];
+  for (const row of assocRows) {
+    const parent = str(row, "parent");
+    const child = str(row, "child");
+    if (!parent || !child) continue;
+    registerPresentationElement(
+      elements,
+      parent,
+      str(row, "parent_name"),
+      bool(row, "parent_abstract")
+    );
+    registerPresentationElement(
+      elements,
+      child,
+      str(row, "child_name"),
+      bool(row, "child_abstract")
+    );
+    const order = num(row, "order_value") ?? 0;
+    const type = str(row, "association_type")?.toLowerCase();
+    if (type === "calculation") {
+      calcAssociations.push({
+        parent,
+        child,
+        weight: num(row, "weight") ?? 1,
+        order,
+        role: null,
+        structure: section.id
+      });
+    } else if (type === "presentation") {
+      presAssociations.push({ parent, child, order, role: null, structure: section.id });
+    }
+  }
+  const informationBlock = {
+    id: section.id,
+    blockType: section.canonicalType ?? "",
+    factSet: section.id,
+    label: section.title,
+    structureId: section.id
+  };
+  const structure = {
+    id: section.id,
+    blockType: section.canonicalType ?? "",
+    roleUri: null,
+    structureName: section.title,
+    order: section.order
+  };
+  return {
+    reportId: shell.reportId,
+    reportIri: null,
+    entity: shell.entity,
+    informationBlocks: [informationBlock],
+    structures: [structure],
+    facts,
+    elements,
+    periods,
+    units,
+    calcAssociations,
+    presAssociations
+  };
+}
+function mergeSecSections(shell, sections) {
+  const elements = {};
+  const periods = {};
+  const units = {};
+  const informationBlocks = [];
+  const structures = [];
+  const facts = [];
+  const calcAssociations = [];
+  const presAssociations = [];
+  for (const part of sections) {
+    Object.assign(elements, part.elements);
+    Object.assign(periods, part.periods);
+    Object.assign(units, part.units);
+    informationBlocks.push(...part.informationBlocks);
+    structures.push(...part.structures);
+    facts.push(...part.facts);
+    calcAssociations.push(...part.calcAssociations);
+    presAssociations.push(...part.presAssociations);
+  }
+  return {
+    reportId: shell.reportId,
+    reportIri: null,
+    entity: shell.entity,
+    informationBlocks,
+    structures,
+    facts,
+    elements,
+    periods,
+    units,
+    calcAssociations,
+    presAssociations
+  };
+}
+
+// src/adapters/cypher.ts
+function cypherAdapter(config) {
+  return {
+    source: `sec:${config.reportId}`,
+    load: async () => {
+      const shell = await fetchSecReportShell(config.query, config.reportId);
+      const sections = await Promise.all(
+        shell.sections.map((section) => fetchSecSection(config.query, shell, section))
+      );
+      return mergeSecSections(shell, sections);
+    }
+  };
+}
+var { namedNode } = DataFactory;
+function makeReaders(store) {
+  const objects = (s, p) => store.getObjects(namedNode(s), namedNode(p), null);
+  const firstValue = (s, p) => {
+    const os = objects(s, p);
+    return os.length ? os[0].value : null;
+  };
+  const subjectsOfType = (type) => store.getSubjects(namedNode(IRI.type), namedNode(type), null).map((t) => t.value);
+  return { objects, firstValue, subjectsOfType };
+}
+function toNumber(raw) {
+  if (raw === null || raw === "") return null;
+  const n = Number(raw);
+  return Number.isNaN(n) ? null : n;
+}
+function parseStore(store) {
+  const { objects, firstValue, subjectsOfType } = makeReaders(store);
+  const elements = {};
+  for (const id of subjectsOfType(IRI.Element)) {
+    const balance = firstValue(id, IRI.balance);
+    const periodType2 = firstValue(id, IRI.periodType);
+    elements[id] = {
+      id,
+      qname: qname(id),
+      label: firstValue(id, IRI.prefLabel) ?? humanize(id),
+      balance: balance === "debit" || balance === "credit" ? balance : null,
+      periodType: periodType2 === "instant" || periodType2 === "duration" ? periodType2 : null,
+      abstract: firstValue(id, IRI.abstract) === "true",
+      monetary: firstValue(id, IRI.monetary) === "true"
+    };
+  }
+  const periods = {};
+  for (const id of subjectsOfType(IRI.Period)) {
+    const declared = firstValue(id, IRI.periodType);
+    const instant = firstValue(id, IRI.instant);
+    const startDate = firstValue(id, IRI.startDate);
+    const endDate = firstValue(id, IRI.endDate);
+    const type = declared === "instant" ? "instant" : declared === "duration" ? "duration" : instant ? "instant" : "duration";
+    const end = (type === "instant" ? instant : endDate) ?? instant ?? endDate ?? "";
+    periods[id] = { id, type, instant, startDate, endDate, end };
+  }
+  const units = {};
+  for (const id of subjectsOfType(IRI.Unit)) {
+    const measureTerm = objects(id, IRI.measure)[0];
+    const measure = measureTerm ? qname(measureTerm.value) : "unknown";
+    units[id] = {
+      id,
+      measure,
+      label: measure.includes(":") ? measure.split(":").pop() : measure
+    };
+  }
+  let entity = null;
+  const entityIds = subjectsOfType(IRI.Entity);
+  if (entityIds.length) {
+    const id = entityIds[0];
+    entity = {
+      id,
+      name: firstValue(id, IRI.prefLabel) ?? firstValue(id, IRI.legalName) ?? "Entity",
+      legalName: firstValue(id, IRI.legalName),
+      country: firstValue(id, IRI.country)
+    };
+  }
+  const facts = [];
+  for (const id of subjectsOfType(IRI.Fact)) {
+    facts.push({
+      id,
+      element: firstValue(id, IRI.element) ?? "",
+      period: firstValue(id, IRI.period) ?? "",
+      unit: firstValue(id, IRI.unit),
+      entity: firstValue(id, IRI.entity),
+      factSet: firstValue(id, IRI.factSet),
+      value: toNumber(firstValue(id, IRI.numericValue)),
+      decimals: firstValue(id, IRI.decimals)
+    });
+  }
+  const informationBlocks = [];
+  for (const id of subjectsOfType(IRI.InformationBlock)) {
+    informationBlocks.push({
+      id,
+      blockType: firstValue(id, IRI.blockType) ?? "",
+      factSet: firstValue(id, IRI.factSet),
+      label: firstValue(id, IRI.prefLabel)
+    });
+  }
+  const structures = [];
+  const assocStructure = /* @__PURE__ */ new Map();
+  for (const id of subjectsOfType(IRI.Structure)) {
+    structures.push({
+      id,
+      blockType: firstValue(id, IRI.blockType) ?? "",
+      roleUri: firstValue(id, IRI.roleUri),
+      structureName: firstValue(id, IRI.structureName)
+    });
+    for (const assoc of objects(id, IRI.hasAssociation)) {
+      assocStructure.set(assoc.value, id);
+    }
+  }
+  const calcAssociations = [];
+  const presAssociations = [];
+  for (const id of subjectsOfType(IRI.Association)) {
+    const parent = firstValue(id, IRI.from);
+    const child = firstValue(id, IRI.to);
+    if (!parent || !child) continue;
+    const type = firstValue(id, IRI.associationType);
+    const order = toNumber(firstValue(id, IRI.order)) ?? 0;
+    const role = firstValue(id, IRI.role);
+    const structure = assocStructure.get(id) ?? null;
+    if (type === "calculation") {
+      calcAssociations.push({
+        parent,
+        child,
+        weight: toNumber(firstValue(id, IRI.weight)) ?? 1,
+        order,
+        role,
+        structure
+      });
+    } else if (type === "presentation") {
+      presAssociations.push({ parent, child, order, role, structure });
+    }
+  }
+  let reportIri = null;
+  for (const graph of store.getGraphs(null, null, null)) {
+    const hash = graph.value.indexOf("#");
+    if (hash > 0) {
+      reportIri = graph.value.slice(0, hash);
+      break;
+    }
+  }
+  if (!reportIri) {
+    const reports = subjectsOfType(IRI.Report);
+    reportIri = reports.length ? reports[0] : null;
+  }
+  const reportId = reportIri ? reportIri.split("/").pop() ?? null : null;
+  return {
+    reportId,
+    reportIri,
+    entity,
+    informationBlocks,
+    structures,
+    facts,
+    elements,
+    periods,
+    units,
+    calcAssociations,
+    presAssociations
+  };
+}
+async function parseJsonld(doc) {
+  const json = typeof doc === "string" ? JSON.parse(doc) : doc;
+  const nquads = await jsonld.toRDF(json, { format: "application/n-quads" });
+  const store = new Store(new Parser({ format: "application/n-quads" }).parse(nquads));
+  return parseStore(store);
+}
+function jsonldFileAdapter(doc, source = "holon.jsonld") {
+  return {
+    source,
+    load: () => parseJsonld(doc)
+  };
+}
+
+export { BLOCK_ORDER, BLOCK_TITLES, NS, currencySymbolFor, cypherAdapter, fetchSecReportShell, fetchSecSection, formatDate, formatMoney, formatPeriod, formatValue, humanize, humanizeDuration, isExternalFactUrl, jsonldFileAdapter, mergeSecSections, numericKindOf, parseJsonld, parseStore, parseStructureDefinition, qname };
+//# sourceMappingURL=chunk-DGP4KRWF.js.map
+//# sourceMappingURL=chunk-DGP4KRWF.js.map