@dialecte/scl 0.1.19 → 0.2.0

package/dist/{index-ChFpcq4k.js → dialecte.config-BkqCz0VE.js}

@@ -21144,162 +21144,666 @@ const H = [
       }
     ]
   }
-}, f = {
-  direct: "direct",
-  lnode: "lnode",
-  iedAddress: "ied-address",
-  behaviorDescription: "behavior-description",
-  unsupported: "unsupported"
-}, m = {
-  AllocationRoleRef: [
-    {
-      attribute: { path: "allocationRole", uuid: "allocationRoleUuid" },
-      resolution: "direct",
-      target: ["AllocationRole"],
-      companions: []
-    }
-  ],
-  BehaviorDescriptionRef: [
-    {
-      attribute: { path: "behaviorDescription", uuid: "behaviorDescriptionUuid" },
-      resolution: "direct",
-      target: ["BehaviorDescription"],
-      companions: []
-    }
-  ],
-  BehaviorReference: [
+};
+async function $(a) {
+  const { childRecord: e, parentRecord: t, query: i } = a;
+  if (e.namespace.prefix === P.namespaces.default.prefix)
+    return [];
+  const n = t.tagName === "Private", u = t.namespace.prefix === P.namespaces.default.prefix;
+  if (!n && !u)
+    return [];
+  const r = t.children.find((o) => o.tagName === "Private"), s = {
+    ...t,
+    children: t.children.filter((o) => o.id !== e.id)
+  };
+  return n ? J({ parentRecord: t, childRecord: e, query: i }) : r ? ee({
+    existingPrivateRef: r,
+    parentRecord: t,
+    updatedParentRecord: s,
+    childRecord: e,
+    query: i
+  }) : (await i.findAncestors(t)).some(
+    (o) => o.tagName === "Private" && o.attributes.some(
+      (p) => p.name === "type" && p.value === e.namespace.prefix
+    )
+  ) ? [] : te({ parentRecord: t, updatedParentRecord: s, childRecord: e });
+}
+async function J(a) {
+  const { parentRecord: e, childRecord: t, query: i } = a, n = e;
+  if (t.parent?.id === n.id && t.parent?.tagName === "Private")
+    return [];
+  const u = await F({ privateId: n.id, query: i });
+  I(u, {
+    detail: "Latest private record not found",
+    key: "ELEMENT_NOT_FOUND"
+  });
+  const { childRecord: r, privateRecord: s } = q({
+    privateRecord: u,
+    childRecord: t
+  });
+  return [
     {
-      attribute: { path: "behaviorReference", uuid: "behaviorUuid" },
-      resolution: "direct",
-      target: ["BehaviorDescription"],
-      companions: []
-    }
-  ],
-  ControllingLNode: [
+      status: "updated",
+      oldRecord: d(t),
+      newRecord: d(r)
+    },
     {
-      attribute: { path: "resourceName", uuid: "resourceUuid" },
-      resolution: "direct",
-      target: ["ProcessResource"],
-      companions: []
+      status: "updated",
+      oldRecord: d(u),
+      newRecord: d(s)
     }
-  ],
-  ControlRef: [
+  ];
+}
+async function ee(a) {
+  const { existingPrivateRef: e, parentRecord: t, updatedParentRecord: i, childRecord: n, query: u } = a, r = await F({
+    privateId: e.id,
+    query: u
+  });
+  if (I(r, {
+    detail: "Latest private record not found",
+    key: "ELEMENT_NOT_FOUND"
+  }), !r.attributes.some(
+    (o) => o.name === "type" && o.value === n.namespace.prefix
+  )) return [];
+  const { childRecord: c, privateRecord: l } = q({
+    privateRecord: r,
+    childRecord: n
+  });
+  return [
     {
-      attribute: { path: "controlled", uuid: "controlledLNodeUuid" },
-      resolution: "lnode",
-      target: ["LNode"],
-      companions: [{ name: "controlledDoName", required: !0 }]
+      status: "updated",
+      oldRecord: d(n),
+      newRecord: d(c)
     },
     {
-      attribute: { path: "extCtrlAddr", uuid: "extCtrlUuid" },
-      resolution: "ied-address",
-      target: ["ExtCtrl"],
-      companions: []
+      status: "updated",
+      oldRecord: d(r),
+      newRecord: d(l)
     },
     {
-      attribute: { path: "resourceName", uuid: "resourceUuid" },
-      resolution: "direct",
-      target: ["ProcessResource"],
-      companions: []
-    }
-  ],
-  DAS: [
-    {
-      attribute: { path: "mappedDaName", uuid: "mappedLnUuid" },
-      resolution: "lnode",
-      target: ["LN", "LN0"],
-      companions: []
+      status: "updated",
+      oldRecord: d(t),
+      newRecord: d(i)
     }
-  ],
-  DOS: [
+  ];
+}
+function te(a) {
+  const { parentRecord: e, updatedParentRecord: t, childRecord: i } = a, n = {
+    id: crypto.randomUUID(),
+    tagName: "Private",
+    namespace: P.namespaces.default,
+    attributes: [{ name: "type", value: i.namespace.prefix }],
+    value: "",
+    parent: { id: e.id, tagName: e.tagName },
+    children: [{ id: i.id, tagName: i.tagName }]
+  }, u = {
+    ...i,
+    parent: { id: n.id, tagName: "Private" }
+  }, r = {
+    ...t,
+    children: [...t.children, { id: n.id, tagName: "Private" }]
+  };
+  return [
+    { status: "created", oldRecord: void 0, newRecord: d(n) },
     {
-      attribute: { path: "mappedDoName", uuid: "mappedLnUuid" },
-      resolution: "lnode",
-      target: ["LN", "LN0"],
-      companions: []
-    }
-  ],
-  FunctionCategoryRef: [
+      status: "updated",
+      oldRecord: d(i),
+      newRecord: d(u)
+    },
     {
-      attribute: { path: "functionCategory", uuid: "functionCategoryUuid" },
-      resolution: "direct",
-      target: ["FunctionCategory", "SubCategory"],
-      companions: []
+      status: "updated",
+      oldRecord: d(e),
+      newRecord: d(r)
     }
-  ],
-  FunctionCatRef: [
-    {
-      attribute: { path: "function", uuid: "functionUuid" },
-      resolution: "direct",
-      target: ["Function", "SubFunction"],
-      companions: []
+  ];
+}
+async function F(a) {
+  const { privateId: e, query: t } = a;
+  return await t.getRecord({ id: e, tagName: "Private" });
+}
+function q(a) {
+  const { privateRecord: e, childRecord: t } = a, i = {
+    ...t,
+    parent: { id: e.id, tagName: "Private" }
+  }, n = {
+    ...e,
+    children: [...e.children, { id: t.id, tagName: t.tagName }]
+  };
+  return { childRecord: i, privateRecord: n };
+}
+const y = {
+  // Transparent - do not contribute a path segment
+  AccessPoint: { type: "transparent" },
+  Server: { type: "transparent" },
+  Private: { type: "transparent" },
+  LNodeInputs: { type: "transparent" },
+  LNodeOutputs: { type: "transparent" },
+  // IED section - structural containers
+  LDevice: { type: "attribute", attr: "inst", separator: "/" },
+  IED: { type: "name" },
+  // IED section - logical nodes (targets of lnode resolution)
+  LN: { type: "lnClass" },
+  LN0: { type: "lnClass" },
+  // IED section - data instances (dot-separated)
+  DOI: { type: "name", separator: "." },
+  SDI: { type: "name", separator: "." },
+  DAI: { type: "name", separator: "." },
+  // IED section - data references
+  ExtRef: { type: "attribute", attr: "intAddr", separator: "." },
+  ExtCtrl: { type: "attribute", attr: "intAddr", separator: "." },
+  // Process section - named path contributors (targets of lnode / ied-address resolution)
+  SourceRef: { type: "sourceRef" },
+  ControlRef: { type: "controlRef" },
+  // Process section - data specifications (6-100, dot-separated)
+  DOS: { type: "name", separator: "." },
+  DAS: { type: "name", separator: "." },
+  SDS: { type: "name", separator: "." },
+  // Process section - targets of direct UUID resolution
+  Substation: { type: "name" },
+  VoltageLevel: { type: "name" },
+  Bay: { type: "name" },
+  Line: { type: "name" },
+  ConductingEquipment: { type: "name" },
+  ConnectivityNode: { type: "name" },
+  PowerTransformer: { type: "name" },
+  TransformerWinding: { type: "name" },
+  TapChanger: { type: "name" },
+  GeneralEquipment: { type: "name" },
+  SubEquipment: { type: "name" },
+  LNode: { type: "lnClass" },
+  Function: { type: "name" },
+  SubFunction: { type: "name" },
+  FunctionTemplate: { type: "name" },
+  SubFunctionTemplate: { type: "name" },
+  EqFunction: { type: "name" },
+  EqSubFunction: { type: "name" },
+  Application: { type: "name" },
+  AllocationRole: { type: "name" },
+  BehaviorDescription: { type: "name" },
+  FunctionCategory: { type: "name" },
+  SubCategory: { type: "name" },
+  FunctionalVariant: { type: "name" },
+  FunctionalSubVariant: { type: "name" },
+  FunctionalVariantGroup: { type: "name" },
+  ProcessResource: { type: "name" },
+  PowerSystemRelation: { type: "name" },
+  Variable: { type: "name" },
+  Process: { type: "name" }
+}, ae = ["lnClass", "prefix", "inst", "lnInst"], ie = new Set(
+  Object.values(y).flatMap((a) => {
+    switch (a.type) {
+      case "transparent":
+        return [];
+      case "name":
+        return ["name"];
+      case "lnClass":
+        return [...ae];
+      case "attribute":
+        return [a.attr];
+      case "sourceRef":
+        return ["input", "inputInst", "pDA"];
+      case "controlRef":
+        return ["output", "outputInst"];
     }
-  ],
-  FunctionRef: [
-    {
-      attribute: { path: "function", uuid: "functionUuid" },
-      resolution: "direct",
-      target: ["Function", "SubFunction", "EqFunction", "EqSubFunction"],
-      companions: []
+  })
+);
+function ne(a) {
+  switch (a.type) {
+    case "transparent":
+      return () => null;
+    case "name": {
+      const e = a.separator ?? "/";
+      return (t) => {
+        const i = b(t, "name");
+        return i ? { segment: i, separator: e } : null;
+      };
     }
-  ],
-  FunctionalVariantRef: [
-    {
-      attribute: { path: "functionalVariant", uuid: "functionalVariantUuid" },
-      resolution: "direct",
-      target: ["FunctionalVariant", "FunctionalSubVariant"],
-      companions: []
+    case "lnClass":
+      return (e) => {
+        const t = b(e, "lnClass");
+        if (!t) return null;
+        const i = b(e, "prefix") ?? "", n = b(e, "inst") ?? b(e, "lnInst") ?? "";
+        return { segment: `${i}${t}${n}`, separator: "/" };
+      };
+    case "attribute":
+      return (e) => {
+        const t = b(e, a.attr);
+        return t ? { segment: t, separator: a.separator } : null;
+      };
+    case "sourceRef":
+      return (e) => {
+        const t = b(e, "input");
+        if (!t) return null;
+        let i = t;
+        const n = b(e, "inputInst");
+        n && n !== "1" && (i += `(${n})`);
+        const u = b(e, "pDA");
+        return u && (i += `.${u}`), { segment: i, separator: "." };
+      };
+    case "controlRef":
+      return (e) => {
+        const t = b(e, "output");
+        if (!t) return null;
+        let i = t;
+        const n = b(e, "outputInst");
+        return n && n !== "1" && (i += `(${n})`), { segment: i, separator: "." };
+      };
+  }
+}
+const re = Object.fromEntries(
+  Object.entries(y).map(([a, e]) => [a, ne(e)])
+);
+function L(a) {
+  const e = re[a.tagName];
+  return e ? e(a) : null;
+}
+function x(a) {
+  const { record: e, ancestry: t } = a, i = [];
+  for (const u of t) {
+    const r = L(u);
+    r && i.push({ ...r, ref: { tagName: u.tagName, id: u.id } });
+  }
+  const n = L(e);
+  return n && i.push({ ...n, ref: { tagName: e.tagName, id: e.id } }), i.length === 0 ? null : { path: O(i), segments: i };
+}
+function b(a, e) {
+  return a.attributes.find((t) => t.name === e)?.value;
+}
+function O(a) {
+  let e = a[0].segment;
+  for (let t = 1; t < a.length; t++)
+    e += a[t].separator + a[t].segment;
+  return e;
+}
+async function E(a, e) {
+  const t = await a.getRecord(e);
+  if (!t) return null;
+  const i = await a.findAncestors(e, { order: "top-down" });
+  return x({
+    record: d(t),
+    ancestry: i.map(d)
+  });
+}
+function k(a) {
+  if (!a) return [];
+  const e = [];
+  let t = "", i = "/";
+  for (const n of a)
+    n === "/" || n === "." ? (t && e.push({ segment: t, separator: i }), i = n, t = "") : t += n;
+  return t && e.push({ segment: t, separator: i }), e;
+}
+function V(a) {
+  const e = a.split("/"), t = e[e.length - 1], i = t.indexOf(".");
+  if (i === -1) return { path: a };
+  const n = t.substring(0, i), u = t.substring(i + 1);
+  return { path: [...e.slice(0, -1), n].join("/"), qualifier: u || void 0 };
+}
+function Z(a, e, t, i) {
+  return !a || a === f.unsupported ? null : a === f.direct ? { lookupKey: t } : a === f.iedAddress ? se(t, i) : a === f.lnode ? ue(t) : a === f.behaviorDescription ? ce(e, t, i) : null;
+}
+function ue(a) {
+  const { path: e, qualifier: t } = V(a);
+  return { lookupKey: e, qualifier: t };
+}
+function se(a, e) {
+  if (e) {
+    const t = de(e);
+    if (t)
+      return { lookupKey: a, fallbackLookupKey: `${t}/${a}` };
+  }
+  return { lookupKey: a };
+}
+function ce(a, e, t) {
+  if (!t) return null;
+  const i = oe(t);
+  if (!i) return null;
+  if (a === "dataName")
+    return { lookupKey: i, qualifier: e };
+  if (a === "inputName" || a === "outputName") {
+    const n = le(e);
+    return { lookupKey: `${i}.${n}` };
+  }
+  return null;
+}
+function oe(a) {
+  let e = -1;
+  for (let i = a.length - 1; i >= 0; i--)
+    if (a[i].tagName === "BehaviorDescription") {
+      e = i;
+      break;
     }
-  ],
-  InputVar: [
-    {
-      attribute: { path: "dataName", uuid: "lnodeUuid" },
-      resolution: "behavior-description",
-      target: ["LNode"],
-      companions: [
-        { name: "doName", required: !0 },
-        { name: "daName", required: !1 }
-      ]
-    },
+  if (e === -1) return null;
+  const t = [];
+  for (let i = 0; i < e; i++) {
+    const n = L(a[i]);
+    n && t.push(n);
+  }
+  return t.length === 0 ? null : O(t);
+}
+function le(a) {
+  const e = a.indexOf("("), t = a.indexOf(".");
+  return e !== -1 ? a.substring(0, e) : t !== -1 ? a.substring(0, t) : a;
+}
+function de(a) {
+  for (let e = a.length - 1; e >= 0; e--)
+    if (a[e].tagName === "LNode")
+      return a[e].attributes.find((t) => t.name === "iedName")?.value ?? null;
+  return null;
+}
+async function M(a, e) {
+  const { reference: t, target: i } = e, n = pe(t.tagName, i.tagName);
+  if (!n) return null;
+  const u = n.resolution;
+  if (u === f.unsupported) return null;
+  if (u === f.behaviorDescription) {
+    const c = await a.getRecord(i);
+    return c ? L(d(c))?.segment ?? null : null;
+  }
+  const r = await E(a, i);
+  if (!r) return null;
+  const s = r.path;
+  if (u === f.lnode) {
+    const c = await a.getRecord(t);
+    if (!c) return s;
+    const l = c.attributes.find((p) => p.name === n.attribute.path)?.value;
+    if (!l) return s;
+    const { qualifier: o } = V(l);
+    return o ? `${s}.${o}` : s;
+  }
+  return s;
+}
+function pe(a, e) {
+  const t = m[a];
+  return t ? t.find((i) => i.target.includes(e)) ?? null : null;
+}
+async function Se(a, e, t) {
+  const i = fe(e.tagName, t);
+  if (!i) return;
+  const n = e.attributes.find((p) => p.name === t)?.value;
+  if (!n) return;
+  let u;
+  (i.resolution === f.behaviorDescription || i.resolution === f.iedAddress) && (u = (await a.findAncestors(e, { order: "top-down" })).map((R) => d(R)));
+  const r = Z(
+    i.resolution,
+    t,
+    n,
+    u
+  );
+  if (!r) return;
+  const s = k(r.lookupKey);
+  if (s.length === 0) return;
+  const c = s[s.length - 1], l = s.slice(0, -1), o = await Le({
+    query: a,
+    targets: i.target,
+    segment: c,
+    expectedAncestry: l
+  });
+  if (o)
+    return { record: o, qualifier: r.qualifier };
+}
+function fe(a, e) {
+  const t = m[a];
+  if (t)
+    return t.find((i) => i.attribute.path === e);
+}
+const me = new Set(
+  D.LNode.attributes.details.lnClass.facets.enumeration
+), be = {
+  LNode: "lnInst",
+  LN: "inst",
+  LN0: "inst"
+};
+function Re(a) {
+  for (let e = 0; e <= a.length - 4; e++) {
+    const t = a.substring(e, e + 4);
+    if (me.has(t))
+      return {
+        prefix: a.substring(0, e),
+        lnClass: t,
+        inst: a.substring(e + 4)
+      };
+  }
+  return null;
+}
+async function Le(a) {
+  const { query: e, targets: t, segment: i, expectedAncestry: n } = a;
+  for (const u of t) {
+    const r = be[u];
+    if (r) {
+      const s = await Pe({
+        query: e,
+        tagName: u,
+        segment: i,
+        instAttr: r,
+        expectedAncestry: n
+      });
+      if (s) return s;
+    } else {
+      const s = await Ce({
+        query: e,
+        tagName: u,
+        segment: i,
+        expectedAncestry: n
+      });
+      if (s) return s;
+    }
+  }
+}
+async function Pe(a) {
+  const { query: e, tagName: t, segment: i, instAttr: n, expectedAncestry: u } = a, r = Re(i.segment);
+  if (!r) return;
+  const s = await e.findByAttributes({
+    tagName: t,
+    attributes: { lnClass: r.lnClass }
+  });
+  for (const c of s) {
+    const l = c.attributes.find((p) => p.name === "prefix")?.value ?? "", o = c.attributes.find((p) => p.name === n)?.value ?? "";
+    if (!(l !== r.prefix || o !== r.inst) && await G(e, c, u))
+      return c;
+  }
+}
+async function Ce(a) {
+  const { query: e, tagName: t, segment: i, expectedAncestry: n } = a, u = await e.getRecordsByTagName(t);
+  for (const r of u) {
+    const s = L(d(r));
+    if (!(!s || s.segment !== i.segment) && await G(e, r, n))
+      return r;
+  }
+}
+async function G(a, e, t) {
+  if (t.length === 0) return !0;
+  const i = await a.findAncestors(e), n = [];
+  for (let u = i.length - 1; u >= 0; u--) {
+    const r = L(d(i[u]));
+    r && n.push(r);
+  }
+  return n.length !== t.length ? !1 : n.every((u, r) => u.segment === t[r].segment);
+}
+async function Ae(a, e) {
+  const t = k(e);
+  if (t.length === 0) return;
+  const i = await a.getRoot();
+  return v({
+    query: a,
+    current: i,
+    segments: t,
+    index: 0
+  });
+}
+async function v(a) {
+  const { query: e, current: t, segments: i, index: n } = a;
+  if (n >= i.length) return t;
+  const u = t.children ?? [];
+  if (u.length === 0) return;
+  const r = await e.getRecords(u), s = i[n];
+  for (const c of r) {
+    if (!c) continue;
+    const l = L(d(c));
+    if (!l) {
+      const o = await v({ query: e, current: c, segments: i, index: n });
+      if (o) return o;
+      continue;
+    }
+    if (l.segment === s.segment && l.separator === s.separator)
+      return v({ query: e, current: c, segments: i, index: n + 1 });
+  }
+}
+const f = {
+  direct: "direct",
+  lnode: "lnode",
+  iedAddress: "ied-address",
+  behaviorDescription: "behavior-description",
+  unsupported: "unsupported"
+}, m = {
+  AllocationRoleRef: [
     {
-      attribute: { path: "inputName", uuid: "inputUuid" },
-      resolution: "behavior-description",
-      target: ["SourceRef"],
+      attribute: { path: "allocationRole", uuid: "allocationRoleUuid" },
+      resolution: "direct",
+      target: ["AllocationRole"],
       companions: []
     }
   ],
-  LNodeDataRef: [
+  BehaviorDescriptionRef: [
     {
-      attribute: { path: "data", uuid: "lnodeUuid" },
-      resolution: "lnode",
-      target: ["LNode"],
-      companions: [
-        { name: "doName", required: !0 },
-        { name: "daName", required: !1 }
-      ]
+      attribute: { path: "behaviorDescription", uuid: "behaviorDescriptionUuid" },
+      resolution: "direct",
+      target: ["BehaviorDescription"],
+      companions: []
     }
   ],
-  LNodeInputRef: [
+  BehaviorReference: [
     {
-      attribute: { path: "sourceRef", uuid: "sourceRefUuid" },
+      attribute: { path: "behaviorReference", uuid: "behaviorUuid" },
       resolution: "direct",
-      target: ["SourceRef"],
+      target: ["BehaviorDescription"],
       companions: []
     }
   ],
-  LNodeOutputRef: [
+  ControllingLNode: [
     {
-      attribute: { path: "controlRef", uuid: "controlRefUuid" },
+      attribute: { path: "resourceName", uuid: "resourceUuid" },
       resolution: "direct",
-      target: ["ControlRef"],
+      target: ["ProcessResource"],
       companions: []
     }
   ],
-  OutputVar: [
+  ControlRef: [
     {
-      attribute: { path: "dataName", uuid: "lnodeUuid" },
-      resolution: "behavior-description",
-      target: ["LNode"],
+      attribute: { path: "controlled", uuid: "controlledLNodeUuid" },
+      resolution: "lnode",
+      target: ["LNode"],
+      companions: [{ name: "controlledDoName", required: !0 }]
+    },
+    {
+      attribute: { path: "extCtrlAddr", uuid: "extCtrlUuid" },
+      resolution: "ied-address",
+      target: ["ExtCtrl"],
+      companions: []
+    },
+    {
+      attribute: { path: "resourceName", uuid: "resourceUuid" },
+      resolution: "direct",
+      target: ["ProcessResource"],
+      companions: []
+    }
+  ],
+  DAS: [
+    {
+      attribute: { path: "mappedDaName", uuid: "mappedLnUuid" },
+      resolution: "lnode",
+      target: ["LN", "LN0"],
+      companions: []
+    }
+  ],
+  DOS: [
+    {
+      attribute: { path: "mappedDoName", uuid: "mappedLnUuid" },
+      resolution: "lnode",
+      target: ["LN", "LN0"],
+      companions: []
+    }
+  ],
+  FunctionCategoryRef: [
+    {
+      attribute: { path: "functionCategory", uuid: "functionCategoryUuid" },
+      resolution: "direct",
+      target: ["FunctionCategory", "SubCategory"],
+      companions: []
+    }
+  ],
+  FunctionCatRef: [
+    {
+      attribute: { path: "function", uuid: "functionUuid" },
+      resolution: "direct",
+      target: ["Function", "SubFunction"],
+      companions: []
+    }
+  ],
+  FunctionRef: [
+    {
+      attribute: { path: "function", uuid: "functionUuid" },
+      resolution: "direct",
+      target: ["Function", "SubFunction", "EqFunction", "EqSubFunction"],
+      companions: []
+    }
+  ],
+  FunctionalVariantRef: [
+    {
+      attribute: { path: "functionalVariant", uuid: "functionalVariantUuid" },
+      resolution: "direct",
+      target: ["FunctionalVariant", "FunctionalSubVariant"],
+      companions: []
+    }
+  ],
+  InputVar: [
+    {
+      attribute: { path: "dataName", uuid: "lnodeUuid" },
+      resolution: "behavior-description",
+      target: ["LNode"],
+      companions: [
+        { name: "doName", required: !0 },
+        { name: "daName", required: !1 }
+      ]
+    },
+    {
+      attribute: { path: "inputName", uuid: "inputUuid" },
+      resolution: "behavior-description",
+      target: ["SourceRef"],
+      companions: []
+    }
+  ],
+  LNodeDataRef: [
+    {
+      attribute: { path: "data", uuid: "lnodeUuid" },
+      resolution: "lnode",
+      target: ["LNode"],
+      companions: [
+        { name: "doName", required: !0 },
+        { name: "daName", required: !1 }
+      ]
+    }
+  ],
+  LNodeInputRef: [
+    {
+      attribute: { path: "sourceRef", uuid: "sourceRefUuid" },
+      resolution: "direct",
+      target: ["SourceRef"],
+      companions: []
+    }
+  ],
+  LNodeOutputRef: [
+    {
+      attribute: { path: "controlRef", uuid: "controlRefUuid" },
+      resolution: "direct",
+      target: ["ControlRef"],
+      companions: []
+    }
+  ],
+  OutputVar: [
+    {
+      attribute: { path: "dataName", uuid: "lnodeUuid" },
+      resolution: "behavior-description",
+      target: ["LNode"],
       companions: [
         { name: "doName", required: !0 },
         { name: "daName", required: !1 }
@@ -21403,788 +21907,190 @@ const H = [
     {
       attribute: { path: "extRefAddr", uuid: "extRefUuid" },
       resolution: "ied-address",
-      target: ["ExtRef"],
-      companions: []
-    },
-    {
-      attribute: { path: "resourceName", uuid: "resourceUuid" },
-      resolution: "direct",
-      target: ["ProcessResource"],
-      companions: []
-    }
-  ],
-  SubscriberLNode: [
-    {
-      attribute: { path: "resourceName", uuid: "resourceUuid" },
-      resolution: "direct",
-      target: ["ProcessResource"],
-      companions: []
-    }
-  ],
-  VariableApplyTo: [
-    {
-      attribute: { path: "element", uuid: "elementUuid" },
-      resolution: "unsupported",
-      target: ["LNode", "Function", "SubFunction", "EqFunction", "EqSubFunction"],
-      companions: [
-        { name: "doName", required: !1 },
-        { name: "daName", required: !1 }
-      ]
-    }
-  ],
-  VariableRef: [
-    {
-      attribute: { path: "variable", uuid: "variableUuid" },
-      resolution: "direct",
-      target: ["Variable"],
-      companions: []
-    }
-  ]
-};
-function $(a) {
-  const e = {};
-  for (const [t, i] of Object.entries(a))
-    for (const n of i) {
-      const s = e[n.resolution] ??= /* @__PURE__ */ new Map();
-      for (const r of n.target) {
-        const u = s.get(r) ?? [];
-        u.push({
-          refTagName: t,
-          uuidAttr: n.attribute.uuid,
-          pathAttr: n.attribute.path
-        }), s.set(r, u);
-      }
-    }
-  return e;
-}
-function J(a) {
-  const e = /* @__PURE__ */ new Map();
-  for (const [t, i] of Object.entries(a))
-    e.set(
-      t,
-      i.map((n) => ({
-        uuidAttr: n.attribute.uuid,
-        pathAttr: n.attribute.path,
-        resolution: n.resolution,
-        targetTagNames: n.target
-      }))
-    );
-  return e;
-}
-const F = $(m), q = [
-  f.direct,
-  f.lnode,
-  f.iedAddress,
-  f.behaviorDescription
-], ee = J(m);
-[
-  ...new Set(
-    Object.values(m).flatMap(
-      (a) => a.map((e) => e.attribute.uuid)
-    )
-  )
-];
-const te = /* @__PURE__ */ new Set(["SourceRef", "ControlRef", "DOS", "SDS", "DAS", "InputVar", "OutputVar", "ProcessEcho"]), mt = {
-  FunctionCatRef: ["SubCategory", "FunctionCategory"],
-  PowerSystemRelation: ["PowerSystemRelations"],
-  Resource: ["ProcessResource", "ProcessResources"],
-  VariableApplyTo: ["Variable"]
-}, y = {
-  // Transparent - do not contribute a path segment
-  AccessPoint: { type: "transparent" },
-  Server: { type: "transparent" },
-  Private: { type: "transparent" },
-  LNodeInputs: { type: "transparent" },
-  LNodeOutputs: { type: "transparent" },
-  // IED section - structural containers
-  LDevice: { type: "attribute", attr: "inst", separator: "/" },
-  IED: { type: "name" },
-  // IED section - logical nodes (targets of lnode resolution)
-  LN: { type: "lnClass" },
-  LN0: { type: "lnClass" },
-  // IED section - data instances (dot-separated)
-  DOI: { type: "name", separator: "." },
-  SDI: { type: "name", separator: "." },
-  DAI: { type: "name", separator: "." },
-  // IED section - data references
-  ExtRef: { type: "attribute", attr: "intAddr", separator: "." },
-  ExtCtrl: { type: "attribute", attr: "intAddr", separator: "." },
-  // Process section - named path contributors (targets of lnode / ied-address resolution)
-  SourceRef: { type: "attribute", attr: "input", separator: "." },
-  ControlRef: { type: "attribute", attr: "output", separator: "." },
-  // Process section - data specifications (6-100, dot-separated)
-  DOS: { type: "name", separator: "." },
-  DAS: { type: "name", separator: "." },
-  SDS: { type: "name", separator: "." },
-  // Process section - targets of direct UUID resolution
-  Substation: { type: "name" },
-  VoltageLevel: { type: "name" },
-  Bay: { type: "name" },
-  Line: { type: "name" },
-  ConductingEquipment: { type: "name" },
-  ConnectivityNode: { type: "name" },
-  PowerTransformer: { type: "name" },
-  TransformerWinding: { type: "name" },
-  TapChanger: { type: "name" },
-  GeneralEquipment: { type: "name" },
-  SubEquipment: { type: "name" },
-  LNode: { type: "lnClass" },
-  Function: { type: "name" },
-  SubFunction: { type: "name" },
-  FunctionTemplate: { type: "name" },
-  SubFunctionTemplate: { type: "name" },
-  EqFunction: { type: "name" },
-  EqSubFunction: { type: "name" },
-  Application: { type: "name" },
-  AllocationRole: { type: "name" },
-  BehaviorDescription: { type: "name" },
-  FunctionCategory: { type: "name" },
-  SubCategory: { type: "name" },
-  FunctionalVariant: { type: "name" },
-  FunctionalSubVariant: { type: "name" },
-  FunctionalVariantGroup: { type: "name" },
-  ProcessResource: { type: "name" },
-  PowerSystemRelation: { type: "name" },
-  Variable: { type: "name" },
-  Process: { type: "name" }
-}, ae = ["lnClass", "prefix", "inst", "lnInst"], ie = new Set(
-  Object.values(y).flatMap((a) => {
-    switch (a.type) {
-      case "transparent":
-        return [];
-      case "name":
-        return ["name"];
-      case "lnClass":
-        return [...ae];
-      case "attribute":
-        return [a.attr];
-    }
-  })
-);
-function ne(a) {
-  switch (a.type) {
-    case "transparent":
-      return () => null;
-    case "name": {
-      const e = a.separator ?? "/";
-      return (t) => {
-        const i = P(t, "name");
-        return i ? { segment: i, separator: e } : null;
-      };
-    }
-    case "lnClass":
-      return (e) => {
-        const t = P(e, "lnClass");
-        if (!t) return null;
-        const i = P(e, "prefix") ?? "", n = P(e, "inst") ?? P(e, "lnInst") ?? "";
-        return { segment: `${i}${t}${n}`, separator: "/" };
-      };
-    case "attribute":
-      return (e) => {
-        const t = P(e, a.attr);
-        return t ? { segment: t, separator: a.separator } : null;
-      };
-  }
-}
-const re = Object.fromEntries(
-  Object.entries(y).map(([a, e]) => [a, ne(e)])
-);
-function R(a) {
-  const e = re[a.tagName];
-  return e ? e(a) : null;
-}
-function x(a) {
-  const { record: e, ancestry: t } = a, i = [];
-  for (const s of t) {
-    const r = R(s);
-    r && i.push({ ...r, ref: { tagName: s.tagName, id: s.id } });
-  }
-  const n = R(e);
-  return n && i.push({ ...n, ref: { tagName: e.tagName, id: e.id } }), i.length === 0 ? null : { path: O(i), segments: i };
-}
-function P(a, e) {
-  return a.attributes.find((t) => t.name === e)?.value;
-}
-function O(a) {
-  let e = a[0].segment;
-  for (let t = 1; t < a.length; t++)
-    e += a[t].separator + a[t].segment;
-  return e;
-}
-async function E(a, e) {
-  const t = await a.getRecord(e);
-  if (!t) return null;
-  const i = await a.findAncestors(e, { order: "top-down" });
-  return x({
-    record: d(t),
-    ancestry: i.map(d)
-  });
-}
-async function k(a, e) {
-  const { reference: t, target: i } = e, n = ue(t.tagName, i.tagName);
-  if (!n) return null;
-  const s = n.resolution;
-  if (s === f.unsupported) return null;
-  if (s === f.behaviorDescription) {
-    const c = await a.getRecord(i);
-    return c ? R(d(c))?.segment ?? null : null;
-  }
-  const r = await E(a, i);
-  if (!r) return null;
-  const u = r.path;
-  if (s === f.lnode) {
-    const c = await a.getRecord(t);
-    if (!c) return u;
-    const l = c.attributes.find((p) => p.name === n.attribute.path)?.value;
-    if (!l) return u;
-    const { qualifier: o } = G(l);
-    return o ? `${u}.${o}` : u;
-  }
-  return u;
-}
-function ue(a, e) {
-  const t = m[a];
-  return t ? t.find((i) => i.target.includes(e)) ?? null : null;
-}
-async function se(a, e, t) {
-  const i = ce(e.tagName, t);
-  if (!i) return;
-  const n = e.attributes.find((p) => p.name === t)?.value;
-  if (!n) return;
-  let s;
-  (i.resolution === f.behaviorDescription || i.resolution === f.iedAddress) && (s = (await a.findAncestors(e, { order: "top-down" })).map((b) => d(b)));
-  const r = B(
-    i.resolution,
-    t,
-    n,
-    s
-  );
-  if (!r) return;
-  const u = M(r.lookupKey);
-  if (u.length === 0) return;
-  const c = u[u.length - 1], l = u.slice(0, -1), o = await pe({
-    query: a,
-    targets: i.target,
-    segment: c,
-    expectedAncestry: l
-  });
-  if (o)
-    return { record: o, qualifier: r.qualifier };
-}
-function ce(a, e) {
-  const t = m[a];
-  if (t)
-    return t.find((i) => i.attribute.path === e);
-}
-const oe = new Set(
-  D.LNode.attributes.details.lnClass.facets.enumeration
-), le = {
-  LNode: "lnInst",
-  LN: "inst",
-  LN0: "inst"
-};
-function de(a) {
-  for (let e = 0; e <= a.length - 4; e++) {
-    const t = a.substring(e, e + 4);
-    if (oe.has(t))
-      return {
-        prefix: a.substring(0, e),
-        lnClass: t,
-        inst: a.substring(e + 4)
-      };
-  }
-  return null;
-}
-async function pe(a) {
-  const { query: e, targets: t, segment: i, expectedAncestry: n } = a;
-  for (const s of t) {
-    const r = le[s];
-    if (r) {
-      const u = await Se({
-        query: e,
-        tagName: s,
-        segment: i,
-        instAttr: r,
-        expectedAncestry: n
-      });
-      if (u) return u;
-    } else {
-      const u = await fe({
-        query: e,
-        tagName: s,
-        segment: i,
-        expectedAncestry: n
-      });
-      if (u) return u;
-    }
-  }
-}
-async function Se(a) {
-  const { query: e, tagName: t, segment: i, instAttr: n, expectedAncestry: s } = a, r = de(i.segment);
-  if (!r) return;
-  const u = await e.findByAttributes({
-    tagName: t,
-    attributes: { lnClass: r.lnClass }
-  });
-  for (const c of u) {
-    const l = c.attributes.find((p) => p.name === "prefix")?.value ?? "", o = c.attributes.find((p) => p.name === n)?.value ?? "";
-    if (!(l !== r.prefix || o !== r.inst) && await V(e, c, s))
-      return c;
-  }
-}
-async function fe(a) {
-  const { query: e, tagName: t, segment: i, expectedAncestry: n } = a, s = await e.getRecordsByTagName(t);
-  for (const r of s) {
-    const u = R(d(r));
-    if (!(!u || u.segment !== i.segment) && await V(e, r, n))
-      return r;
-  }
-}
-async function V(a, e, t) {
-  if (t.length === 0) return !0;
-  const i = await a.findAncestors(e), n = [];
-  for (let s = i.length - 1; s >= 0; s--) {
-    const r = R(d(i[s]));
-    r && n.push(r);
-  }
-  return n.length !== t.length ? !1 : n.every((s, r) => s.segment === t[r].segment);
-}
-async function me(a, e) {
-  const t = M(e);
-  if (t.length === 0) return;
-  const i = await a.getRoot();
-  return v({
-    query: a,
-    current: i,
-    segments: t,
-    index: 0
-  });
-}
-async function v(a) {
-  const { query: e, current: t, segments: i, index: n } = a;
-  if (n >= i.length) return t;
-  const s = t.children ?? [];
-  if (s.length === 0) return;
-  const r = await e.getRecords(s), u = i[n];
-  for (const c of r) {
-    if (!c) continue;
-    const l = R(d(c));
-    if (!l) {
-      const o = await v({ query: e, current: c, segments: i, index: n });
-      if (o) return o;
-      continue;
-    }
-    if (l.segment === u.segment && l.separator === u.separator)
-      return v({ query: e, current: c, segments: i, index: n + 1 });
-  }
-}
-async function be(a, e) {
-  const { target: t, containerTagName: i } = e, n = await a.getRecord(t);
-  if (!n) return [];
-  const s = n.attributes.find((c) => c.name === "uuid")?.value;
-  if (!s) return [];
-  const r = Re(n.tagName);
-  if (r.length === 0) return [];
-  const u = [];
-  for (const c of r) {
-    if (!T(c.refTagName, L)) continue;
-    const l = await a.findByAttributes({
-      tagName: c.refTagName,
-      attributes: { [c.uuidAttr]: s }
-    });
-    for (const o of l) {
-      const p = i ? await Le(a, o, i) : void 0;
-      u.push({ ref: o, container: p });
-    }
-  }
-  return u;
-}
-function Re(a) {
-  const e = [];
-  for (const t of q) {
-    const i = F[t].get(a);
-    i && e.push(...i);
-  }
-  return e;
-}
-async function Le(a, e, t) {
-  return (await a.findAncestors(e, { stopAtTagName: t })).find((n) => n.tagName === t);
-}
-const Pe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  buildElementPath: E,
-  buildReferencePath: k,
-  findRefsPointingTo: be,
-  resolveElementPath: me,
-  resolveReferencePath: se
-}, Symbol.toStringTag, { value: "Module" })), Z = {
-  query: Pe
-};
-function M(a) {
-  if (!a) return [];
-  const e = [];
-  let t = "", i = "/";
-  for (const n of a)
-    n === "/" || n === "." ? (t && e.push({ segment: t, separator: i }), i = n, t = "") : t += n;
-  return t && e.push({ segment: t, separator: i }), e;
-}
-function G(a) {
-  const e = a.split("/"), t = e[e.length - 1], i = t.indexOf(".");
-  if (i === -1) return { path: a };
-  const n = t.substring(0, i), s = t.substring(i + 1);
-  return { path: [...e.slice(0, -1), n].join("/"), qualifier: s || void 0 };
-}
-function B(a, e, t, i) {
-  return !a || a === f.unsupported ? null : a === f.direct ? { lookupKey: t } : a === f.iedAddress ? Ae(t, i) : a === f.lnode ? Ce(t) : a === f.behaviorDescription ? ge(e, t, i) : null;
-}
-function Ce(a) {
-  const { path: e, qualifier: t } = G(a);
-  return { lookupKey: e, qualifier: t };
-}
-function Ae(a, e) {
-  if (e) {
-    const t = he(e);
-    if (t)
-      return { lookupKey: a, fallbackLookupKey: `${t}/${a}` };
-  }
-  return { lookupKey: a };
-}
-function ge(a, e, t) {
-  if (!t) return null;
-  const i = ve(t);
-  if (!i) return null;
-  if (a === "dataName")
-    return { lookupKey: i, qualifier: e };
-  if (a === "inputName" || a === "outputName") {
-    const n = Te(e);
-    return { lookupKey: `${i}.${n}` };
-  }
-  return null;
-}
-function ve(a) {
-  let e = -1;
-  for (let i = a.length - 1; i >= 0; i--)
-    if (a[i].tagName === "BehaviorDescription") {
-      e = i;
-      break;
-    }
-  if (e === -1) return null;
-  const t = [];
-  for (let i = 0; i < e; i++) {
-    const n = R(a[i]);
-    n && t.push(n);
-  }
-  return t.length === 0 ? null : O(t);
-}
-function Te(a) {
-  const e = a.indexOf("("), t = a.indexOf(".");
-  return e !== -1 ? a.substring(0, e) : t !== -1 ? a.substring(0, t) : a;
-}
-function he(a) {
-  for (let e = a.length - 1; e >= 0; e--)
-    if (a[e].tagName === "LNode")
-      return a[e].attributes.find((t) => t.name === "iedName")?.value ?? null;
-  return null;
-}
-function Ne() {
-  const a = /* @__PURE__ */ new Map(), e = [], t = [];
-  return {
-    beforeImportRecord: (s) => {
-      const { record: r, ancestry: u } = s, { tagName: c } = r, l = Fe(r);
-      if (l && De.has(c)) {
-        const S = x({ record: r, ancestry: u });
-        S && a.set(S.path, l);
-      }
-      if (!we.has(c)) return;
-      const b = m[c];
-      for (const S of b) {
-        const C = r.attributes.find(
-          (g) => g.name === S.attribute.path
-        )?.value;
-        if (!C || r.attributes.find(
-          (g) => g.name === S.attribute.uuid
-        )?.value) continue;
-        const A = B(S.resolution, S.attribute.path, C, u);
-        if (!A) {
-          S.resolution === f.unsupported && t.push({
-            type: "unsupported-xpath-reference",
-            recordId: r.id,
-            details: {
-              elementTag: c,
-              pathAttribute: S.attribute.path,
-              uuidAttribute: S.attribute.uuid,
-              pathValue: C
-            }
-          });
-          continue;
-        }
-        e.push({
-          recordId: r.id,
-          elementTag: c,
-          uuidAttributeName: S.attribute.uuid,
-          pathValue: C,
-          lookupKey: A.lookupKey,
-          fallbackLookupKey: A.fallbackLookupKey
-        });
-      }
-    },
-    afterImport: async () => {
-      const s = [], r = [...t];
-      for (const u of e) {
-        const c = a.get(u.lookupKey) ?? (u.fallbackLookupKey ? a.get(u.fallbackLookupKey) : void 0);
-        if (!c) {
-          r.push({
-            type: "unresolved-reference",
-            recordId: u.recordId,
-            details: {
-              elementTag: u.elementTag,
-              uuidAttribute: u.uuidAttributeName,
-              pathValue: u.pathValue,
-              triedKeys: u.fallbackLookupKey ? [u.lookupKey, u.fallbackLookupKey] : [u.lookupKey]
-            }
-          });
-          continue;
-        }
-        s.push({
-          recordId: u.recordId,
-          attributes: [{ name: u.uuidAttributeName, value: c }]
-        });
-      }
-      return a.clear(), e.length = 0, t.length = 0, {
-        updates: s,
-        warnings: r.length > 0 ? r : void 0
-      };
-    }
-  };
-}
-const Ie = new Set(
-  Object.entries(w).filter(([, a]) => "uuid" in a).map(([a]) => a)
-), we = new Set(Object.keys(m)), De = new Set(
-  Object.values(m).flatMap((a) => a.flatMap((e) => e.target))
-);
-function Fe(a) {
-  if (!Ie.has(a.tagName)) return;
-  const e = a.attributes.find((i) => i.name === "uuid");
-  if (e) return e.value;
-  const t = crypto.randomUUID();
-  return a.attributes.push({ name: "uuid", value: t }), t;
-}
-const qe = {
-  supportedFileExtensions: [".fsd", ".asd", ".ssd", ".scd", ".isd", ".xml"],
-  hooks: Ne()
-}, ye = {
-  tables: {
-    xmlElements: {
-      name: "sclElements",
-      schema: "id, tagName, [id+tagName], parent.id, parent.tagName, *children.id, *children.tagName"
-    },
-    additionalTables: {
-      attachedFiles: {
-        schema: "id, filename, file"
-      }
-    }
-  }
-}, xe = {
-  default: { uri: "http://www.iec.ch/61850/2003/SCL", prefix: "" },
-  v2019C1: {
-    uri: "http://www.iec.ch/61850/2019/SCL/6-100",
-    prefix: "eIEC61850-6-100"
-  }
-}, L = {
-  rootElementName: Y,
-  singletonElements: j,
-  elements: H,
-  namespaces: xe,
-  attributes: w,
-  children: W,
-  parents: K,
-  descendants: X,
-  ancestors: Q,
-  database: ye,
-  io: qe,
-  definition: D
-};
-async function Oe(a) {
-  const { childRecord: e, parentRecord: t, query: i } = a;
-  if (e.namespace.prefix === L.namespaces.default.prefix)
-    return [];
-  const n = t.tagName === "Private", s = t.namespace.prefix === L.namespaces.default.prefix;
-  if (!n && !s)
-    return [];
-  const r = t.children.find((o) => o.tagName === "Private"), u = {
-    ...t,
-    children: t.children.filter((o) => o.id !== e.id)
-  };
-  return n ? Ee({ parentRecord: t, childRecord: e, query: i }) : r ? ke({
-    existingPrivateRef: r,
-    parentRecord: t,
-    updatedParentRecord: u,
-    childRecord: e,
-    query: i
-  }) : (await i.findAncestors(t)).some(
-    (o) => o.tagName === "Private" && o.attributes.some(
-      (p) => p.name === "type" && p.value === e.namespace.prefix
-    )
-  ) ? [] : Ve({ parentRecord: t, updatedParentRecord: u, childRecord: e });
-}
-async function Ee(a) {
-  const { parentRecord: e, childRecord: t, query: i } = a, n = e;
-  if (t.parent?.id === n.id && t.parent?.tagName === "Private")
-    return [];
-  const s = await U({ privateId: n.id, query: i });
-  I(s, {
-    detail: "Latest private record not found",
-    key: "ELEMENT_NOT_FOUND"
-  });
-  const { childRecord: r, privateRecord: u } = z({
-    privateRecord: s,
-    childRecord: t
-  });
-  return [
-    {
-      status: "updated",
-      oldRecord: d(t),
-      newRecord: d(r)
-    },
-    {
-      status: "updated",
-      oldRecord: d(s),
-      newRecord: d(u)
-    }
-  ];
-}
-async function ke(a) {
-  const { existingPrivateRef: e, parentRecord: t, updatedParentRecord: i, childRecord: n, query: s } = a, r = await U({
-    privateId: e.id,
-    query: s
-  });
-  if (I(r, {
-    detail: "Latest private record not found",
-    key: "ELEMENT_NOT_FOUND"
-  }), !r.attributes.some(
-    (o) => o.name === "type" && o.value === n.namespace.prefix
-  )) return [];
-  const { childRecord: c, privateRecord: l } = z({
-    privateRecord: r,
-    childRecord: n
-  });
-  return [
-    {
-      status: "updated",
-      oldRecord: d(n),
-      newRecord: d(c)
-    },
-    {
-      status: "updated",
-      oldRecord: d(r),
-      newRecord: d(l)
+      target: ["ExtRef"],
+      companions: []
     },
     {
-      status: "updated",
-      oldRecord: d(t),
-      newRecord: d(i)
+      attribute: { path: "resourceName", uuid: "resourceUuid" },
+      resolution: "direct",
+      target: ["ProcessResource"],
+      companions: []
     }
-  ];
-}
-function Ve(a) {
-  const { parentRecord: e, updatedParentRecord: t, childRecord: i } = a, n = {
-    id: crypto.randomUUID(),
-    tagName: "Private",
-    namespace: L.namespaces.default,
-    attributes: [{ name: "type", value: i.namespace.prefix }],
-    value: "",
-    parent: { id: e.id, tagName: e.tagName },
-    children: [{ id: i.id, tagName: i.tagName }]
-  }, s = {
-    ...i,
-    parent: { id: n.id, tagName: "Private" }
-  }, r = {
-    ...t,
-    children: [...t.children, { id: n.id, tagName: "Private" }]
-  };
-  return [
-    { status: "created", oldRecord: void 0, newRecord: d(n) },
+  ],
+  SubscriberLNode: [
     {
-      status: "updated",
-      oldRecord: d(i),
-      newRecord: d(s)
-    },
+      attribute: { path: "resourceName", uuid: "resourceUuid" },
+      resolution: "direct",
+      target: ["ProcessResource"],
+      companions: []
+    }
+  ],
+  VariableApplyTo: [
     {
-      status: "updated",
-      oldRecord: d(e),
-      newRecord: d(r)
+      attribute: { path: "element", uuid: "elementUuid" },
+      resolution: "unsupported",
+      target: ["LNode", "Function", "SubFunction", "EqFunction", "EqSubFunction"],
+      companions: [
+        { name: "doName", required: !1 },
+        { name: "daName", required: !1 }
+      ]
     }
-  ];
+  ],
+  VariableRef: [
+    {
+      attribute: { path: "variable", uuid: "variableUuid" },
+      resolution: "direct",
+      target: ["Variable"],
+      companions: []
+    }
+  ]
+};
+function ge(a) {
+  const e = {};
+  for (const [t, i] of Object.entries(a))
+    for (const n of i) {
+      const u = e[n.resolution] ??= /* @__PURE__ */ new Map();
+      for (const r of n.target) {
+        const s = u.get(r) ?? [];
+        s.push({
+          refTagName: t,
+          uuidAttr: n.attribute.uuid,
+          pathAttr: n.attribute.path
+        }), u.set(r, s);
+      }
+    }
+  return e;
 }
-async function U(a) {
-  const { privateId: e, query: t } = a;
-  return await t.getRecord({ id: e, tagName: "Private" });
+function ve(a) {
+  const e = /* @__PURE__ */ new Map();
+  for (const [t, i] of Object.entries(a))
+    e.set(
+      t,
+      i.map((n) => ({
+        uuidAttr: n.attribute.uuid,
+        pathAttr: n.attribute.path,
+        resolution: n.resolution,
+        targetTagNames: n.target
+      }))
+    );
+  return e;
 }
-function z(a) {
-  const { privateRecord: e, childRecord: t } = a, i = {
-    ...t,
-    parent: { id: e.id, tagName: "Private" }
-  }, n = {
-    ...e,
-    children: [...e.children, { id: t.id, tagName: t.tagName }]
-  };
-  return { childRecord: i, privateRecord: n };
+const B = ge(m), U = [
+  f.direct,
+  f.lnode,
+  f.iedAddress,
+  f.behaviorDescription
+], Te = ve(m);
+[
+  ...new Set(
+    Object.values(m).flatMap(
+      (a) => a.map((e) => e.attribute.uuid)
+    )
+  )
+];
+const he = /* @__PURE__ */ new Set(["SourceRef", "ControlRef", "DOS", "SDS", "DAS", "InputVar", "OutputVar", "ProcessEcho"]), bt = {
+  FunctionCatRef: ["SubCategory", "FunctionCategory"],
+  PowerSystemRelation: ["PowerSystemRelations"],
+  Resource: ["ProcessResource", "ProcessResources"],
+  VariableApplyTo: ["Variable"]
+};
+async function Ne(a, e) {
+  const { target: t, containerTagName: i } = e, n = await a.getRecord(t);
+  if (!n) return [];
+  const u = n.attributes.find((c) => c.name === "uuid")?.value;
+  if (!u) return [];
+  const r = Ie(n.tagName);
+  if (r.length === 0) return [];
+  const s = [];
+  for (const c of r) {
+    if (!T(c.refTagName, P)) continue;
+    const l = await a.findByAttributes({
+      tagName: c.refTagName,
+      attributes: { [c.uuidAttr]: u }
+    });
+    for (const o of l) {
+      const p = i ? await we(a, o, i) : void 0;
+      s.push({ ref: o, container: p });
+    }
+  }
+  return s;
+}
+function Ie(a) {
+  const e = [];
+  for (const t of U) {
+    const i = B[t].get(a);
+    i && e.push(...i);
+  }
+  return e;
+}
+async function we(a, e, t) {
+  return (await a.findAncestors(e, { stopAtTagName: t })).find((n) => n.tagName === t);
 }
+const De = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  buildElementPath: E,
+  buildReferencePath: M,
+  findRefsPointingTo: Ne,
+  resolveElementPath: Ae,
+  resolveReferencePath: Se
+}, Symbol.toStringTag, { value: "Module" })), z = {
+  query: De
+};
 async function h(a) {
   const { uuid: e, entry: t, target: i, query: n } = a;
-  if (!T(t.refTagName, L)) return [];
-  const s = await n.getRecordsByTagName(t.refTagName), r = [];
-  for (const u of s) {
-    if (u.attributes.find(
+  if (!T(t.refTagName, P)) return [];
+  const u = await n.getRecordsByTagName(t.refTagName), r = [];
+  for (const s of u) {
+    if (s.attributes.find(
       (S) => S.name === t.uuidAttr
     )?.value !== e) continue;
-    const l = { tagName: u.tagName, id: u.id }, o = await Z.query.buildReferencePath(n, { reference: l, target: i });
-    if (!o || u.attributes.find(
+    const l = { tagName: s.tagName, id: s.id }, o = await z.query.buildReferencePath(n, { reference: l, target: i });
+    if (!o || s.attributes.find(
       (S) => S.name === t.pathAttr
     )?.value === o) continue;
-    const b = u.attributes.map(
+    const R = s.attributes.map(
       (S) => S.name === t.pathAttr ? { ...S, value: o } : S
     );
     r.push({
       status: "updated",
-      oldRecord: d(u),
-      newRecord: d({ ...u, attributes: b })
+      oldRecord: d(s),
+      newRecord: d({ ...s, attributes: R })
     });
   }
   return r;
 }
 function N(a) {
   const e = [];
-  for (const t of q) {
-    const i = F[t].get(a);
+  for (const t of U) {
+    const i = B[t].get(a);
     i && e.push(...i);
   }
   return e;
 }
-async function Ze(a) {
-  const { childRecord: e, query: t } = a, i = await Me({ childRecord: e, query: t }), n = await Ue({ childRecord: e, query: t });
+async function Fe(a) {
+  const { childRecord: e, query: t } = a, i = await qe({ childRecord: e, query: t }), n = await Oe({ childRecord: e, query: t });
   return [...i, ...n];
 }
-async function Me(a) {
-  const { childRecord: e, query: t } = a, i = ee.get(e.tagName);
+async function qe(a) {
+  const { childRecord: e, query: t } = a, i = Te.get(e.tagName);
   if (!i?.length) return [];
   const n = [];
-  for (const s of i) {
-    const r = await Ge({ childRecord: e, pair: s, query: t });
+  for (const u of i) {
+    const r = await ye({ childRecord: e, pair: u, query: t });
     r && n.push(r);
   }
   return n;
 }
-async function Ge(a) {
+async function ye(a) {
   const { childRecord: e, pair: t, query: i } = a, n = e.attributes.find((o) => o.name === t.uuidAttr)?.value;
   if (!n) return null;
-  const s = await Be({
+  const u = await xe({
     uuidValue: n,
     targetTagNames: t.targetTagNames,
     query: i
   });
-  if (!s) return null;
-  const r = { tagName: e.tagName, id: e.id }, u = { tagName: s.tagName, id: s.id }, c = await k(i, { reference: r, target: u });
+  if (!u) return null;
+  const r = { tagName: e.tagName, id: e.id }, s = { tagName: u.tagName, id: u.id }, c = await M(i, { reference: r, target: s });
   if (!c) return null;
   const l = e.attributes.map(
     (o) => o.name === t.pathAttr ? { ...o, value: c } : o
@@ -22198,66 +22104,66 @@ async function Ge(a) {
     }
   };
 }
-async function Be(a) {
+async function xe(a) {
   const { uuidValue: e, targetTagNames: t, query: i } = a;
   for (const n of t) {
-    if (!T(n, L)) continue;
+    if (!T(n, P)) continue;
     const r = (await i.getRecordsByTagName(n)).find(
-      (u) => u.attributes.find((c) => c.name === "uuid")?.value === e
+      (s) => s.attributes.find((c) => c.name === "uuid")?.value === e
     );
     if (r) return { tagName: r.tagName, id: r.id };
   }
   return null;
 }
-async function Ue(a) {
-  const { childRecord: e, query: t } = a, i = e.attributes.find((u) => u.name === "uuid")?.value;
+async function Oe(a) {
+  const { childRecord: e, query: t } = a, i = e.attributes.find((s) => s.name === "uuid")?.value;
   if (!i) return [];
   const n = N(e.tagName);
   if (n.length === 0) return [];
-  const s = { tagName: e.tagName, id: e.id }, r = [];
-  for (const u of n) {
-    const c = await h({ uuid: i, entry: u, target: s, query: t });
+  const u = { tagName: e.tagName, id: e.id }, r = [];
+  for (const s of n) {
+    const c = await h({ uuid: i, entry: s, target: u, query: t });
     r.push(...c);
   }
   return r;
 }
-async function ze(a) {
-  const { childRecord: e, parentRecord: t, query: i } = a, n = await Oe({ childRecord: e, parentRecord: t, query: i }), s = await Ze({ childRecord: e, query: i });
-  return [...n, ...s];
+async function Ee(a) {
+  const { childRecord: e, parentRecord: t, query: i } = a, n = await $({ childRecord: e, parentRecord: t, query: i }), u = await Fe({ childRecord: e, query: i });
+  return [...n, ...u];
 }
-async function _e(a) {
-  const { cumulativeCloneMappings: e, query: t } = a, { uuidMap: i, uuidToRef: n } = await He(e, t);
+async function ke(a) {
+  const { cumulativeCloneMappings: e, query: t } = a, { uuidMap: i, uuidToRef: n } = await Ve(e, t);
   if (i.size === 0) return [];
-  const s = [];
+  const u = [];
   for (const { target: r } of e) {
-    const u = await Ke({ target: r, uuidMap: i, uuidToRef: n, query: t });
-    u && s.push(u);
+    const s = await Me({ target: r, uuidMap: i, uuidToRef: n, query: t });
+    s && u.push(s);
   }
-  return s;
+  return u;
 }
-async function He(a, e) {
+async function Ve(a, e) {
   const t = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
-  for (const { source: n, target: s } of a)
-    await We({ source: n, target: s, query: e, uuidMap: t, uuidToRef: i });
+  for (const { source: n, target: u } of a)
+    await Ze({ source: n, target: u, query: e, uuidMap: t, uuidToRef: i });
   return { uuidMap: t, uuidToRef: i };
 }
-async function We(a) {
-  const { source: e, target: t, query: i, uuidMap: n, uuidToRef: s } = a, r = await i.getRecord(t);
+async function Ze(a) {
+  const { source: e, target: t, query: i, uuidMap: n, uuidToRef: u } = a, r = await i.getRecord(t);
   if (!r) return;
-  const u = e.attributes.find((l) => l.name === "uuid")?.value, c = r.attributes.find((l) => l.name === "uuid")?.value;
-  !u || !c || (n.set(u, c), s.set(c, { tagName: r.tagName, id: r.id }));
+  const s = e.attributes.find((l) => l.name === "uuid")?.value, c = r.attributes.find((l) => l.name === "uuid")?.value;
+  !s || !c || (n.set(s, c), u.set(c, { tagName: r.tagName, id: r.id }));
 }
-async function Ke(a) {
-  const { target: e, uuidMap: t, uuidToRef: i, query: n } = a, s = e.tagName;
-  if (!(s in m)) return null;
+async function Me(a) {
+  const { target: e, uuidMap: t, uuidToRef: i, query: n } = a, u = e.tagName;
+  if (!(u in m)) return null;
   const r = await n.getRecord(e);
   if (!r) return null;
-  const u = m[s];
+  const s = m[u];
   let c = [...r.attributes], l = !1;
-  for (const o of u) {
-    const p = await Xe({
+  for (const o of s) {
+    const p = await Ge({
       pair: o,
-      tagName: s,
+      tagName: u,
       refId: r.id,
       updatedAttributes: c,
       uuidMap: t,
@@ -22272,44 +22178,44 @@ async function Ke(a) {
     newRecord: d({ ...r, attributes: c })
   } : null;
 }
-async function Xe(a) {
-  const { pair: e, tagName: t, refId: i, uuidMap: n, uuidToRef: s, query: r } = a;
-  let u = [...a.updatedAttributes];
-  const c = u.find((S) => S.name === e.attribute.uuid)?.value;
+async function Ge(a) {
+  const { pair: e, tagName: t, refId: i, uuidMap: n, uuidToRef: u, query: r } = a;
+  let s = [...a.updatedAttributes];
+  const c = s.find((S) => S.name === e.attribute.uuid)?.value;
   if (!c) return null;
   const l = n.get(c);
   if (!l) return null;
   let o = !1;
-  const p = Qe(u, e.attribute.uuid, c, l);
-  p && (u = p, o = !0);
-  const b = await Ye({
-    attributes: u,
+  const p = Be(s, e.attribute.uuid, c, l);
+  p && (s = p, o = !0);
+  const R = await Ue({
+    attributes: s,
     pathAttrName: e.attribute.path,
     newUuid: l,
-    uuidToRef: s,
+    uuidToRef: u,
     tagName: t,
     refId: i,
     query: r
   });
-  return b && (u = b, o = !0), o ? u : null;
+  return R && (s = R, o = !0), o ? s : null;
 }
-function Qe(a, e, t, i) {
+function Be(a, e, t, i) {
   return i === t ? null : a.map((n) => n.name === e ? { ...n, value: i } : n);
 }
-async function Ye(a) {
-  const { attributes: e, pathAttrName: t, newUuid: i, uuidToRef: n, tagName: s, refId: r, query: u } = a, c = n.get(i);
+async function Ue(a) {
+  const { attributes: e, pathAttrName: t, newUuid: i, uuidToRef: n, tagName: u, refId: r, query: s } = a, c = n.get(i);
   if (!c) return null;
-  const l = await Z.query.buildReferencePath(u, {
-    reference: { tagName: s, id: r },
+  const l = await z.query.buildReferencePath(s, {
+    reference: { tagName: u, id: r },
     target: { tagName: c.tagName, id: c.id }
   });
   return !l || e.find((p) => p.name === t)?.value === l ? null : e.map((p) => p.name === t ? { ...p, value: l } : p);
 }
-async function je(a) {
-  return _e(a);
+async function ze(a) {
+  return ke(a);
 }
-function $e(a) {
-  const { record: e } = a, { tagName: t, attributes: i } = e, n = L.definition[t];
+function _e(a) {
+  const { record: e } = a, { tagName: t, attributes: i } = e, n = P.definition[t];
   if (!("uuid" in n.attributes.details) || i.find((o) => o.name === "uuid")?.value) return e;
   const c = n.attributes.details.uuid?.namespace, l = i.filter((o) => o.name !== "uuid");
   return {
@@ -22324,52 +22230,52 @@ function $e(a) {
     ]
   };
 }
-function Je(a) {
-  return $e(a);
+function He(a) {
+  return _e(a);
 }
-async function et(a) {
-  const { oldRecord: e, newRecord: t, query: i } = a, n = [], s = t.attributes.find((r) => r.name === "uuid")?.value;
-  if (s) {
-    const r = N(t.tagName), u = { tagName: t.tagName, id: t.id };
+async function We(a) {
+  const { oldRecord: e, newRecord: t, query: i } = a, n = [], u = t.attributes.find((r) => r.name === "uuid")?.value;
+  if (u) {
+    const r = N(t.tagName), s = { tagName: t.tagName, id: t.id };
     for (const c of r) {
-      const l = await h({ uuid: s, entry: c, target: u, query: i });
+      const l = await h({ uuid: u, entry: c, target: s, query: i });
       n.push(...l);
     }
   }
-  if (tt(e, t)) {
-    const r = await at({ newRecord: t, query: i });
+  if (Ke(e, t)) {
+    const r = await Xe({ newRecord: t, query: i });
     n.push(...r);
   }
   return n;
 }
-function tt(a, e) {
+function Ke(a, e) {
   for (const t of ie) {
-    const i = a.attributes.find((s) => s.name === t)?.value, n = e.attributes.find((s) => s.name === t)?.value;
+    const i = a.attributes.find((u) => u.name === t)?.value, n = e.attributes.find((u) => u.name === t)?.value;
     if (i !== n) return !0;
   }
   return !1;
 }
-async function at(a) {
-  const { newRecord: e, query: t } = a, i = { tagName: e.tagName, id: e.id }, n = await t.findDescendants(i), s = [];
+async function Xe(a) {
+  const { newRecord: e, query: t } = a, i = { tagName: e.tagName, id: e.id }, n = await t.findDescendants(i), u = [];
   for (const r of Object.values(n))
-    for (const u of r) {
-      if (u.id === e.id) continue;
-      const c = await t.any.getAttribute(u, { name: "uuid" });
+    for (const s of r) {
+      if (s.id === e.id) continue;
+      const c = await t.any.getAttribute(s, { name: "uuid" });
       if (!c) continue;
-      const l = N(u.tagName);
+      const l = N(s.tagName);
       if (l.length === 0) continue;
-      const o = { tagName: u.tagName, id: u.id };
+      const o = { tagName: s.tagName, id: s.id };
       for (const p of l) {
-        const b = await h({ uuid: c, entry: p, target: o, query: t });
-        s.push(...b);
+        const R = await h({ uuid: c, entry: p, target: o, query: t });
+        u.push(...R);
       }
     }
-  return s;
+  return u;
 }
-async function it(a) {
-  return et(a);
+async function Qe(a) {
+  return We(a);
 }
-function nt(a) {
+function Ye(a) {
   const { record: e } = a;
   let t = !0;
   e.tagName === "Private" && !e.tree.length && (t = !1);
@@ -22384,44 +22290,44 @@ function nt(a) {
     }
   };
 }
-async function rt(a) {
+async function je(a) {
   const { record: e, query: t } = a, i = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
   if (await _({ record: e, query: t, ids: i, uuids: n }), n.size === 0) return [];
-  const s = [], r = Object.keys(m);
-  for (const u of r) {
-    const c = await ut({ refTagName: u, subtreeIds: i, subtreeUuids: n, query: t });
-    s.push(...c);
+  const u = [], r = Object.keys(m);
+  for (const s of r) {
+    const c = await $e({ refTagName: s, subtreeIds: i, subtreeUuids: n, query: t });
+    u.push(...c);
   }
-  return s;
+  return u;
 }
-async function ut(a) {
-  const { refTagName: e, subtreeIds: t, subtreeUuids: i, query: n } = a, s = m[e], r = await n.getRecordsByTagName(e), u = [];
+async function $e(a) {
+  const { refTagName: e, subtreeIds: t, subtreeUuids: i, query: n } = a, u = m[e], r = await n.getRecordsByTagName(e), s = [];
   for (const c of r) {
     if (t.has(c.id)) continue;
-    const l = await st({ refTagName: e, refRecord: c, refPairs: s, subtreeUuids: i, query: n });
-    u.push(...l);
+    const l = await Je({ refTagName: e, refRecord: c, refPairs: u, subtreeUuids: i, query: n });
+    s.push(...l);
   }
-  return u;
+  return s;
 }
-async function st(a) {
-  const { refTagName: e, refRecord: t, refPairs: i, subtreeUuids: n, query: s } = a, r = ct({ refPairs: i, refRecord: t, subtreeUuids: n });
-  return r.size === 0 ? [] : te.has(e) ? [ot(t, r)] : lt(t, s);
+async function Je(a) {
+  const { refTagName: e, refRecord: t, refPairs: i, subtreeUuids: n, query: u } = a, r = et({ refPairs: i, refRecord: t, subtreeUuids: n });
+  return r.size === 0 ? [] : he.has(e) ? [tt(t, r)] : at(t, u);
 }
-function ct(a) {
+function et(a) {
   const { refPairs: e, refRecord: t, subtreeUuids: i } = a, n = /* @__PURE__ */ new Set();
-  for (const s of e) {
+  for (const u of e) {
     const r = t.attributes.find(
-      (u) => u.name === s.attribute.uuid
+      (s) => s.name === u.attribute.uuid
     )?.value;
     if (!(!r || !i.has(r))) {
-      n.add(s.attribute.uuid), n.add(s.attribute.path);
-      for (const u of s.companions)
-        n.add(u.name);
+      n.add(u.attribute.uuid), n.add(u.attribute.path);
+      for (const s of u.companions)
+        n.add(s.name);
     }
   }
   return n;
 }
-function ot(a, e) {
+function tt(a, e) {
   const t = a.attributes.filter(
     (i) => !e.has(i.name)
   );
@@ -22431,7 +22337,7 @@ function ot(a, e) {
     newRecord: d({ ...a, attributes: t })
   };
 }
-async function lt(a, e) {
+async function at(a, e) {
   const t = [
     { status: "deleted", oldRecord: d(a), newRecord: void 0 }
   ];
@@ -22440,7 +22346,7 @@ async function lt(a, e) {
     if (i) {
       const n = {
         ...i,
-        children: i.children.filter((s) => s.id !== a.id)
+        children: i.children.filter((u) => u.id !== a.id)
       };
       t.push({
         status: "updated",
@@ -22454,34 +22360,159 @@ async function lt(a, e) {
 async function _(a) {
   const { record: e, query: t, ids: i, uuids: n } = a;
   i.add(e.id);
-  const s = e.attributes.find((r) => r.name === "uuid")?.value;
-  s && n.add(s);
+  const u = e.attributes.find((r) => r.name === "uuid")?.value;
+  u && n.add(u);
   for (const r of e.children) {
-    const u = await t.getRecord(r);
-    u && await _({ record: u, query: t, ids: i, uuids: n });
+    const s = await t.getRecord(r);
+    s && await _({ record: s, query: t, ids: i, uuids: n });
   }
 }
-async function dt(a) {
-  return rt(a);
+async function it(a) {
+  return je(a);
+}
+function nt() {
+  const a = /* @__PURE__ */ new Map(), e = [], t = [];
+  return {
+    beforeImportRecord: (u) => {
+      const { record: r, ancestry: s } = u, { tagName: c } = r, l = ct(r);
+      if (l && st.has(c)) {
+        const S = x({ record: r, ancestry: s });
+        S && a.set(S.path, l);
+      }
+      if (!ut.has(c)) return;
+      const R = m[c];
+      for (const S of R) {
+        const C = r.attributes.find(
+          (g) => g.name === S.attribute.path
+        )?.value;
+        if (!C || r.attributes.find(
+          (g) => g.name === S.attribute.uuid
+        )?.value) continue;
+        const A = Z(S.resolution, S.attribute.path, C, s);
+        if (!A) {
+          S.resolution === f.unsupported && t.push({
+            type: "unsupported-xpath-reference",
+            recordId: r.id,
+            details: {
+              elementTag: c,
+              pathAttribute: S.attribute.path,
+              uuidAttribute: S.attribute.uuid,
+              pathValue: C
+            }
+          });
+          continue;
+        }
+        e.push({
+          recordId: r.id,
+          elementTag: c,
+          uuidAttributeName: S.attribute.uuid,
+          pathValue: C,
+          lookupKey: A.lookupKey,
+          fallbackLookupKey: A.fallbackLookupKey
+        });
+      }
+    },
+    afterImport: async () => {
+      const u = [], r = [...t];
+      for (const s of e) {
+        const c = a.get(s.lookupKey) ?? (s.fallbackLookupKey ? a.get(s.fallbackLookupKey) : void 0);
+        if (!c) {
+          r.push({
+            type: "unresolved-reference",
+            recordId: s.recordId,
+            details: {
+              elementTag: s.elementTag,
+              uuidAttribute: s.uuidAttributeName,
+              pathValue: s.pathValue,
+              triedKeys: s.fallbackLookupKey ? [s.lookupKey, s.fallbackLookupKey] : [s.lookupKey]
+            }
+          });
+          continue;
+        }
+        u.push({
+          recordId: s.recordId,
+          attributes: [{ name: s.uuidAttributeName, value: c }]
+        });
+      }
+      return a.clear(), e.length = 0, t.length = 0, {
+        updates: u,
+        warnings: r.length > 0 ? r : void 0
+      };
+    }
+  };
+}
+const rt = new Set(
+  Object.entries(w).filter(([, a]) => "uuid" in a).map(([a]) => a)
+), ut = new Set(Object.keys(m)), st = new Set(
+  Object.values(m).flatMap((a) => a.flatMap((e) => e.target))
+);
+function ct(a) {
+  if (!rt.has(a.tagName)) return;
+  const e = a.attributes.find((i) => i.name === "uuid");
+  if (e) return e.value;
+  const t = crypto.randomUUID();
+  return a.attributes.push({ name: "uuid", value: t }), t;
 }
-const bt = {
-  beforeClone: nt,
-  afterStandardizedRecord: Je,
-  afterCreated: ze,
-  afterDeepClone: je,
-  afterUpdated: it,
-  beforeDelete: dt
+const Rt = {
+  beforeClone: Ye,
+  afterStandardizedRecord: He,
+  afterCreated: Ee,
+  afterDeepClone: ze,
+  afterUpdated: Qe,
+  beforeDelete: it
+}, ot = nt(), lt = {
+  supportedFileExtensions: [".fsd", ".asd", ".ssd", ".scd", ".isd", ".xml"],
+  hooks: ot
+}, dt = {
+  recordSchema: {
+    primaryKey: "id",
+    indexes: ["tagName", "parent.id", "parent.tagName"],
+    compoundIndexes: [["id", "tagName"]],
+    arrayIndexes: ["children.id", "children.tagName"]
+  },
+  /** @deprecated - kept for old io/ pipeline until Phase 5 removes it */
+  tables: {
+    xmlElements: {
+      name: "sclElements",
+      schema: "id, tagName, [id+tagName], parent.id, parent.tagName, *children.id, *children.tagName"
+    },
+    additionalTables: {
+      attachedFiles: {
+        schema: "id, filename, file"
+      }
+    }
+  }
+}, pt = {
+  default: { uri: "http://www.iec.ch/61850/2003/SCL", prefix: "" },
+  v2019C1: {
+    uri: "http://www.iec.ch/61850/2019/SCL/6-100",
+    prefix: "eIEC61850-6-100"
+  }
+}, P = {
+  rootElementName: Y,
+  singletonElements: j,
+  transparentElements: ["Private"],
+  elements: H,
+  namespaces: pt,
+  attributes: w,
+  children: W,
+  parents: K,
+  descendants: X,
+  ancestors: Q,
+  database: dt,
+  io: lt,
+  definition: D
 };
 export {
   D,
-  bt as H,
-  te as K,
-  mt as R,
-  L as S,
+  Rt as H,
+  he as K,
+  bt as R,
+  P as S,
   m as U,
   X as a,
-  ye as b,
-  qe as c,
-  xe as d,
-  Z as r
+  dt as b,
+  lt as c,
+  pt as d,
+  z as r
 };