@dialecte/scl 0.2.4 → 0.2.6

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

@@ -1,6 +1,6 @@
-import { toRawRecord as d, isElementOf as T } from "@dialecte/core/helpers";
-import { invariant as I } from "@dialecte/core/utils";
-const H = [
+import { toRawRecord as p, isElementOf as M, isChildOf as I, stripAttributes as Ce } from "@dialecte/core/helpers";
+import { invariant as F } from "@dialecte/core/utils";
+const ge = [
   "AccessControl",
   "AccessPoint",
   "Address",
@@ -211,7 +211,7 @@ const H = [
   "VariableRef",
   "Voltage",
   "VoltageLevel"
-], W = {
+], ve = {
   AccessControl: [],
   AccessPoint: [
     "Text",
@@ -779,7 +779,7 @@ const H = [
     "ProcessResources",
     "Variable"
   ]
-}, K = {
+}, Te = {
   AccessControl: ["LDevice"],
   AccessPoint: ["IED"],
   Address: ["ConnectedAP", "GSE", "SMV"],
@@ -3255,7 +3255,7 @@ const H = [
     "VariableRef",
     "Voltage"
   ]
-}, Q = {
+}, he = {
   AccessControl: ["AccessPoint", "IED", "LDevice", "SCL", "Server"],
   AccessPoint: ["IED", "SCL"],
   Address: ["Communication", "ConnectedAP", "GSE", "SCL", "SMV", "SubNetwork"],
@@ -4933,13 +4933,13 @@ const H = [
   ],
   Voltage: ["Line", "Process", "SCL", "Substation", "VoltageLevel"],
   VoltageLevel: ["Process", "SCL", "Substation"]
-}, Y = "SCL", j = [
+}, Ne = "SCL", Ie = [
   "Communication",
   "DataTypeTemplates",
   "Header",
   "History",
   "SCL"
-], w = {
+], Q = {
   AccessControl: {},
   AccessPoint: {
     clock: "",
@@ -6256,7 +6256,7 @@ const H = [
     templateUuid: "",
     uuid: ""
   }
-}, D = {
+}, G = {
   AccessControl: {
     tag: "AccessControl",
     namespace: { prefix: "", uri: "http://www.iec.ch/61850/2003/SCL" },
@@ -21145,133 +21145,133 @@ const H = [
     ]
   }
 };
-async function $(a) {
-  const { childRecord: e, parentRecord: t, query: i } = a;
-  if (e.namespace.prefix === P.namespaces.default.prefix)
+async function we(e) {
+  const { childRecord: a, parentRecord: t, query: i } = e;
+  if (a.namespace.prefix === P.namespaces.default.prefix)
     return [];
-  const n = t.tagName === "Private", u = t.namespace.prefix === P.namespaces.default.prefix;
-  if (!n && !u)
+  const n = t.tagName === "Private", r = t.namespace.prefix === P.namespaces.default.prefix;
+  if (!n && !r)
     return [];
-  const r = t.children.find((o) => o.tagName === "Private"), s = {
+  const s = t.children.find((l) => l.tagName === "Private"), u = {
     ...t,
-    children: t.children.filter((o) => o.id !== e.id)
+    children: t.children.filter((l) => l.id !== a.id)
   };
-  return n ? J({ parentRecord: t, childRecord: e, query: i }) : r ? ee({
-    existingPrivateRef: r,
+  return n ? De({ parentRecord: t, childRecord: a, query: i }) : s ? Fe({
+    existingPrivateRef: s,
     parentRecord: t,
-    updatedParentRecord: s,
-    childRecord: e,
+    updatedParentRecord: u,
+    childRecord: a,
     query: i
   }) : (await i.findAncestors(t)).some(
-    (o) => o.tagName === "Private" && o.attributes.some(
-      (p) => p.name === "type" && p.value === e.namespace.prefix
+    (l) => l.tagName === "Private" && l.attributes.some(
+      (d) => d.name === "type" && d.value === a.namespace.prefix
     )
-  ) ? [] : te({ parentRecord: t, updatedParentRecord: s, childRecord: e });
+  ) ? [] : ye({ parentRecord: t, updatedParentRecord: u, childRecord: a });
 }
-async function J(a) {
-  const { parentRecord: e, childRecord: t, query: i } = a, n = e;
+async function De(e) {
+  const { parentRecord: a, childRecord: t, query: i } = e, n = a;
   if (t.parent?.id === n.id && t.parent?.tagName === "Private")
     return [];
-  const u = await F({ privateId: n.id, query: i });
-  I(u, {
+  const r = await Y({ privateId: n.id, query: i });
+  F(r, {
     detail: "Latest private record not found",
     key: "ELEMENT_NOT_FOUND"
   });
-  const { childRecord: r, privateRecord: s } = q({
-    privateRecord: u,
+  const { childRecord: s, privateRecord: u } = j({
+    privateRecord: r,
     childRecord: t
   });
   return [
     {
       status: "updated",
-      oldRecord: d(t),
-      newRecord: d(r)
+      oldRecord: p(t),
+      newRecord: p(s)
     },
     {
       status: "updated",
-      oldRecord: d(u),
-      newRecord: d(s)
+      oldRecord: p(r),
+      newRecord: p(u)
     }
   ];
 }
-async function ee(a) {
-  const { existingPrivateRef: e, parentRecord: t, updatedParentRecord: i, childRecord: n, query: u } = a, r = await F({
-    privateId: e.id,
-    query: u
+async function Fe(e) {
+  const { existingPrivateRef: a, parentRecord: t, updatedParentRecord: i, childRecord: n, query: r } = e, s = await Y({
+    privateId: a.id,
+    query: r
   });
-  if (I(r, {
+  if (F(s, {
     detail: "Latest private record not found",
     key: "ELEMENT_NOT_FOUND"
-  }), !r.attributes.some(
-    (o) => o.name === "type" && o.value === n.namespace.prefix
+  }), !s.attributes.some(
+    (l) => l.name === "type" && l.value === n.namespace.prefix
   )) return [];
-  const { childRecord: c, privateRecord: l } = q({
-    privateRecord: r,
+  const { childRecord: c, privateRecord: o } = j({
+    privateRecord: s,
     childRecord: n
   });
   return [
     {
       status: "updated",
-      oldRecord: d(n),
-      newRecord: d(c)
+      oldRecord: p(n),
+      newRecord: p(c)
     },
     {
       status: "updated",
-      oldRecord: d(r),
-      newRecord: d(l)
+      oldRecord: p(s),
+      newRecord: p(o)
     },
     {
       status: "updated",
-      oldRecord: d(t),
-      newRecord: d(i)
+      oldRecord: p(t),
+      newRecord: p(i)
     }
   ];
 }
-function te(a) {
-  const { parentRecord: e, updatedParentRecord: t, childRecord: i } = a, n = {
+function ye(e) {
+  const { parentRecord: a, updatedParentRecord: t, childRecord: i } = e, 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 },
+    parent: { id: a.id, tagName: a.tagName },
     children: [{ id: i.id, tagName: i.tagName }]
-  }, u = {
+  }, r = {
     ...i,
     parent: { id: n.id, tagName: "Private" }
-  }, r = {
+  }, s = {
     ...t,
     children: [...t.children, { id: n.id, tagName: "Private" }]
   };
   return [
-    { status: "created", oldRecord: void 0, newRecord: d(n) },
+    { status: "created", oldRecord: void 0, newRecord: p(n) },
     {
       status: "updated",
-      oldRecord: d(i),
-      newRecord: d(u)
+      oldRecord: p(i),
+      newRecord: p(r)
     },
     {
       status: "updated",
-      oldRecord: d(e),
-      newRecord: d(r)
+      oldRecord: p(a),
+      newRecord: p(s)
     }
   ];
 }
-async function F(a) {
-  const { privateId: e, query: t } = a;
-  return await t.getRecord({ id: e, tagName: "Private" });
+async function Y(e) {
+  const { privateId: a, query: t } = e;
+  return await t.getRecord({ id: a, tagName: "Private" });
 }
-function q(a) {
-  const { privateRecord: e, childRecord: t } = a, i = {
+function j(e) {
+  const { privateRecord: a, childRecord: t } = e, i = {
     ...t,
-    parent: { id: e.id, tagName: "Private" }
+    parent: { id: a.id, tagName: "Private" }
   }, n = {
-    ...e,
-    children: [...e.children, { id: t.id, tagName: t.tagName }]
+    ...a,
+    children: [...a.children, { id: t.id, tagName: t.tagName }]
   };
   return { childRecord: i, privateRecord: n };
 }
-const y = {
+const $ = {
   // Transparent - do not contribute a path segment
   AccessPoint: { type: "transparent" },
   Server: { type: "transparent" },
@@ -21329,17 +21329,17 @@ const y = {
   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) {
+}, qe = ["lnClass", "prefix", "inst", "lnInst"], xe = new Set(
+  Object.values($).flatMap((e) => {
+    switch (e.type) {
       case "transparent":
         return [];
       case "name":
         return ["name"];
       case "lnClass":
-        return [...ae];
+        return [...qe];
       case "attribute":
-        return [a.attr];
+        return [e.attr];
       case "sourceRef":
         return ["input", "inputInst", "pDA"];
       case "controlRef":
@@ -21347,308 +21347,308 @@ const y = {
     }
   })
 );
-function ne(a) {
-  switch (a.type) {
+function Oe(e) {
+  switch (e.type) {
     case "transparent":
       return () => null;
     case "name": {
-      const e = a.separator ?? "/";
+      const a = e.separator ?? "/";
       return (t) => {
-        const i = b(t, "name");
-        return i ? { segment: i, separator: e } : null;
+        const i = R(t, "name");
+        return i ? { segment: i, separator: a } : null;
       };
     }
     case "lnClass":
-      return (e) => {
-        const t = b(e, "lnClass");
+      return (a) => {
+        const t = R(a, "lnClass");
         if (!t) return null;
-        const i = b(e, "prefix") ?? "", n = b(e, "inst") ?? b(e, "lnInst") ?? "";
+        const i = R(a, "prefix") ?? "", n = R(a, "inst") ?? R(a, "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;
+      return (a) => {
+        const t = R(a, e.attr);
+        return t ? { segment: t, separator: e.separator } : null;
       };
     case "sourceRef":
-      return (e) => {
-        const t = b(e, "input");
+      return (a) => {
+        const t = R(a, "input");
         if (!t) return null;
         let i = t;
-        const n = b(e, "inputInst");
+        const n = R(a, "inputInst");
         n && n !== "1" && (i += `(${n})`);
-        const u = b(e, "pDA");
-        return u && (i += `.${u}`), { segment: i, separator: "." };
+        const r = R(a, "pDA");
+        return r && (i += `.${r}`), { segment: i, separator: "." };
       };
     case "controlRef":
-      return (e) => {
-        const t = b(e, "output");
+      return (a) => {
+        const t = R(a, "output");
         if (!t) return null;
         let i = t;
-        const n = b(e, "outputInst");
+        const n = R(a, "outputInst");
         return n && n !== "1" && (i += `(${n})`), { segment: i, separator: "." };
       };
   }
 }
-const re = Object.fromEntries(
-  Object.entries(y).map(([a, e]) => [a, ne(e)])
+const Ee = Object.fromEntries(
+  Object.entries($).map(([e, a]) => [e, Oe(a)])
 );
-function L(a) {
-  const e = re[a.tagName];
-  return e ? e(a) : null;
+function A(e) {
+  const a = Ee[e.tagName];
+  return a ? a(e) : 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 } });
+function J(e) {
+  const { record: a, ancestry: t } = e, i = [];
+  for (const r of t) {
+    const s = A(r);
+    s && i.push({ ...s, ref: { tagName: r.tagName, id: r.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 };
+  const n = A(a);
+  return n && i.push({ ...n, ref: { tagName: a.tagName, id: a.id } }), i.length === 0 ? null : { path: ee(i), segments: i };
 }
-function b(a, e) {
-  return a.attributes.find((t) => t.name === e)?.value;
+function R(e, a) {
+  return e.attributes.find((t) => t.name === a)?.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;
+function ee(e) {
+  let a = e[0].segment;
+  for (let t = 1; t < e.length; t++)
+    a += e[t].separator + e[t].segment;
+  return a;
 }
-async function E(a, e) {
-  const t = await a.getRecord(e);
+async function te(e, a) {
+  const t = await e.getRecord(a);
   if (!t) return null;
-  const i = await a.findAncestors(e, { order: "top-down" });
-  return x({
-    record: d(t),
-    ancestry: i.map(d)
+  const i = await e.findAncestors(a, { order: "top-down" });
+  return J({
+    record: p(t),
+    ancestry: i.map(p)
   });
 }
-function k(a) {
-  if (!a) return [];
-  const e = [];
+function ae(e) {
+  if (!e) return [];
+  const a = [];
   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;
+  for (const n of e)
+    n === "/" || n === "." ? (t && a.push({ segment: t, separator: i }), i = n, t = "") : t += n;
+  return t && a.push({ segment: t, separator: i }), a;
 }
-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 ie(e) {
+  const a = e.split("/"), t = a[a.length - 1], i = t.indexOf(".");
+  if (i === -1) return { path: e };
+  const n = t.substring(0, i), r = t.substring(i + 1);
+  return { path: [...a.slice(0, -1), n].join("/"), qualifier: r || 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 ne(e, a, t, i) {
+  return !e || e === b.unsupported ? null : e === b.direct ? { lookupKey: t } : e === b.iedAddress ? Ve(t, i) : e === b.lnode ? ke(t) : e === b.behaviorDescription ? Ze(a, t, i) : null;
 }
-function ue(a) {
-  const { path: e, qualifier: t } = V(a);
-  return { lookupKey: e, qualifier: t };
+function ke(e) {
+  const { path: a, qualifier: t } = ie(e);
+  return { lookupKey: a, qualifier: t };
 }
-function se(a, e) {
-  if (e) {
-    const t = de(e);
+function Ve(e, a) {
+  if (a) {
+    const t = Be(a);
     if (t)
-      return { lookupKey: a, fallbackLookupKey: `${t}/${a}` };
+      return { lookupKey: e, fallbackLookupKey: `${t}/${e}` };
   }
-  return { lookupKey: a };
+  return { lookupKey: e };
 }
-function ce(a, e, t) {
+function Ze(e, a, t) {
   if (!t) return null;
-  const i = oe(t);
+  const i = Me(t);
   if (!i) return null;
-  if (a === "dataName")
-    return { lookupKey: i, qualifier: e };
-  if (a === "inputName" || a === "outputName") {
-    const n = le(e);
+  if (e === "dataName")
+    return { lookupKey: i, qualifier: a };
+  if (e === "inputName" || e === "outputName") {
+    const n = Ge(a);
     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;
+function Me(e) {
+  let a = -1;
+  for (let i = e.length - 1; i >= 0; i--)
+    if (e[i].tagName === "BehaviorDescription") {
+      a = i;
       break;
     }
-  if (e === -1) return null;
+  if (a === -1) return null;
   const t = [];
-  for (let i = 0; i < e; i++) {
-    const n = L(a[i]);
+  for (let i = 0; i < a; i++) {
+    const n = A(e[i]);
     n && t.push(n);
   }
-  return t.length === 0 ? null : O(t);
+  return t.length === 0 ? null : ee(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 Ge(e) {
+  const a = e.indexOf("("), t = e.indexOf(".");
+  return a !== -1 ? e.substring(0, a) : t !== -1 ? e.substring(0, t) : e;
 }
-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;
+function Be(e) {
+  for (let a = e.length - 1; a >= 0; a--)
+    if (e[a].tagName === "LNode")
+      return e[a].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);
+async function re(e, a) {
+  const { reference: t, target: i } = a, n = Ue(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 = n.resolution;
+  if (r === b.unsupported) return null;
+  if (r === b.behaviorDescription) {
+    const c = await e.getRecord(i);
+    return c ? A(p(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;
+  const s = await te(e, i);
+  if (!s) return null;
+  const u = s.path;
+  if (r === b.lnode) {
+    const c = await e.getRecord(t);
+    if (!c) return u;
+    const o = c.attributes.find((d) => d.name === n.attribute.path)?.value;
+    if (!o) return u;
+    const { qualifier: l } = ie(o);
+    return l ? `${u}.${l}` : u;
   }
-  return s;
+  return u;
 }
-function pe(a, e) {
-  const t = m[a];
-  return t ? t.find((i) => i.target.includes(e)) ?? null : null;
+function Ue(e, a) {
+  const t = m[e];
+  return t ? t.find((i) => i.target.includes(a)) ?? null : null;
 }
-async function Se(a, e, t) {
-  const i = fe(e.tagName, t);
+async function ze(e, a, t) {
+  const i = _e(a.tagName, t);
   if (!i) return;
-  const n = e.attributes.find((p) => p.name === t)?.value;
+  const n = a.attributes.find((d) => d.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(
+  let r;
+  (i.resolution === b.behaviorDescription || i.resolution === b.iedAddress) && (r = (await e.findAncestors(a, { order: "top-down" })).map((f) => p(f)));
+  const s = ne(
     i.resolution,
     t,
     n,
-    u
+    r
   );
-  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,
+  if (!s) return;
+  const u = ae(s.lookupKey);
+  if (u.length === 0) return;
+  const c = u[u.length - 1], o = u.slice(0, -1), l = await Xe({
+    query: e,
     targets: i.target,
     segment: c,
-    expectedAncestry: l
+    expectedAncestry: o
   });
-  if (o)
-    return { record: o, qualifier: r.qualifier };
+  if (l)
+    return { record: l, qualifier: s.qualifier };
 }
-function fe(a, e) {
-  const t = m[a];
+function _e(e, a) {
+  const t = m[e];
   if (t)
-    return t.find((i) => i.attribute.path === e);
+    return t.find((i) => i.attribute.path === a);
 }
-const me = new Set(
-  D.LNode.attributes.details.lnClass.facets.enumeration
-), be = {
+const He = new Set(
+  G.LNode.attributes.details.lnClass.facets.enumeration
+), We = {
   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))
+function Ke(e) {
+  for (let a = 0; a <= e.length - 4; a++) {
+    const t = e.substring(a, a + 4);
+    if (He.has(t))
       return {
-        prefix: a.substring(0, e),
+        prefix: e.substring(0, a),
         lnClass: t,
-        inst: a.substring(e + 4)
+        inst: e.substring(a + 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,
+async function Xe(e) {
+  const { query: a, targets: t, segment: i, expectedAncestry: n } = e;
+  for (const r of t) {
+    const s = We[r];
+    if (s) {
+      const u = await Qe({
+        query: a,
+        tagName: r,
         segment: i,
-        instAttr: r,
+        instAttr: s,
         expectedAncestry: n
       });
-      if (s) return s;
+      if (u) return u;
     } else {
-      const s = await Ce({
-        query: e,
-        tagName: u,
+      const u = await Ye({
+        query: a,
+        tagName: r,
         segment: i,
         expectedAncestry: n
       });
-      if (s) return s;
+      if (u) return u;
     }
   }
 }
-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({
+async function Qe(e) {
+  const { query: a, tagName: t, segment: i, instAttr: n, expectedAncestry: r } = e, s = Ke(i.segment);
+  if (!s) return;
+  const u = await a.findByAttributes({
     tagName: t,
-    attributes: { lnClass: r.lnClass }
+    attributes: { lnClass: s.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))
+  for (const c of u) {
+    const o = c.attributes.find((d) => d.name === "prefix")?.value ?? "", l = c.attributes.find((d) => d.name === n)?.value ?? "";
+    if (!(o !== s.prefix || l !== s.inst) && await se(a, c, r))
       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 Ye(e) {
+  const { query: a, tagName: t, segment: i, expectedAncestry: n } = e, r = await a.getRecordsByTagName(t);
+  for (const s of r) {
+    const u = A(p(s));
+    if (!(!u || u.segment !== i.segment) && await se(a, s, n))
+      return s;
   }
 }
-async function G(a, e, t) {
+async function se(e, a, 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);
+  const i = await e.findAncestors(a), n = [];
+  for (let r = i.length - 1; r >= 0; r--) {
+    const s = A(p(i[r]));
+    s && n.push(s);
   }
-  return n.length !== t.length ? !1 : n.every((u, r) => u.segment === t[r].segment);
+  return n.length !== t.length ? !1 : n.every((r, s) => r.segment === t[s].segment);
 }
-async function Ae(a, e) {
-  const t = k(e);
+async function je(e, a) {
+  const t = ae(a);
   if (t.length === 0) return;
-  const i = await a.getRoot();
-  return v({
-    query: a,
+  const i = await e.getRoot();
+  return k({
+    query: e,
     current: i,
     segments: t,
     index: 0
   });
 }
-async function v(a) {
-  const { query: e, current: t, segments: i, index: n } = a;
+async function k(e) {
+  const { query: a, current: t, segments: i, index: n } = e;
   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) {
+  const r = t.children ?? [];
+  if (r.length === 0) return;
+  const s = await a.getRecords(r), u = i[n];
+  for (const c of s) {
     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;
+    const o = A(p(c));
+    if (!o) {
+      const l = await k({ query: a, current: c, segments: i, index: n });
+      if (l) return l;
       continue;
     }
-    if (l.segment === s.segment && l.separator === s.separator)
-      return v({ query: e, current: c, segments: i, index: n + 1 });
+    if (o.segment === u.segment && o.separator === u.separator)
+      return k({ query: a, current: c, segments: i, index: n + 1 });
   }
 }
-const f = {
+const b = {
   direct: "direct",
   lnode: "lnode",
   iedAddress: "ied-address",
@@ -21945,26 +21945,26 @@ const f = {
     }
   ]
 };
-function ge(a) {
-  const e = {};
-  for (const [t, i] of Object.entries(a))
+function $e(e) {
+  const a = {};
+  for (const [t, i] of Object.entries(e))
     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({
+      const r = a[n.resolution] ??= /* @__PURE__ */ new Map();
+      for (const s of n.target) {
+        const u = r.get(s) ?? [];
+        u.push({
           refTagName: t,
           uuidAttr: n.attribute.uuid,
           pathAttr: n.attribute.path
-        }), u.set(r, s);
+        }), r.set(s, u);
       }
     }
-  return e;
+  return a;
 }
-function ve(a) {
-  const e = /* @__PURE__ */ new Map();
-  for (const [t, i] of Object.entries(a))
-    e.set(
+function Je(e) {
+  const a = /* @__PURE__ */ new Map();
+  for (const [t, i] of Object.entries(e))
+    a.set(
       t,
       i.map((n) => ({
         uuidAttr: n.attribute.uuid,
@@ -21973,255 +21973,255 @@ function ve(a) {
         targetTagNames: n.target
       }))
     );
-  return e;
+  return a;
 }
-const B = ge(m), U = [
-  f.direct,
-  f.lnode,
-  f.iedAddress,
-  f.behaviorDescription
-], Te = ve(m);
+const ue = $e(m), ce = [
+  b.direct,
+  b.lnode,
+  b.iedAddress,
+  b.behaviorDescription
+], et = Je(m);
 [
   ...new Set(
     Object.values(m).flatMap(
-      (a) => a.map((e) => e.attribute.uuid)
+      (e) => e.map((a) => a.attribute.uuid)
     )
   )
 ];
-const he = /* @__PURE__ */ new Set(["SourceRef", "ControlRef", "DOS", "SDS", "DAS", "InputVar", "OutputVar", "ProcessEcho"]), bt = {
+const oe = /* @__PURE__ */ new Set(["SourceRef", "ControlRef", "DOS", "SDS", "DAS", "InputVar", "OutputVar", "ProcessEcho"]), tt = {
   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);
+async function at(e, a) {
+  const { target: t, containerTagName: i } = a, n = await e.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({
+  const r = n.attributes.find((c) => c.name === "uuid")?.value;
+  if (!r) return [];
+  const s = it(n.tagName);
+  if (s.length === 0) return [];
+  const u = [];
+  for (const c of s) {
+    if (!M(c.refTagName, P)) continue;
+    const o = await e.findByAttributes({
       tagName: c.refTagName,
-      attributes: { [c.uuidAttr]: u }
+      attributes: { [c.uuidAttr]: r }
     });
-    for (const o of l) {
-      const p = i ? await we(a, o, i) : void 0;
-      s.push({ ref: o, container: p });
+    for (const l of o) {
+      const d = i ? await nt(e, l, i) : void 0;
+      u.push({ ref: l, container: d });
     }
   }
-  return s;
+  return u;
 }
-function Ie(a) {
-  const e = [];
-  for (const t of U) {
-    const i = B[t].get(a);
-    i && e.push(...i);
+function it(e) {
+  const a = [];
+  for (const t of ce) {
+    const i = ue[t].get(e);
+    i && a.push(...i);
   }
-  return e;
+  return a;
 }
-async function we(a, e, t) {
-  return (await a.findAncestors(e, { stopAtTagName: t })).find((n) => n.tagName === t);
+async function nt(e, a, t) {
+  return (await e.findAncestors(a, { stopAtTagName: t })).find((n) => n.tagName === t);
 }
-const De = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const rt = /* @__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
+  buildElementPath: te,
+  buildReferencePath: re,
+  findRefsPointingTo: at,
+  resolveElementPath: je,
+  resolveReferencePath: ze
+}, Symbol.toStringTag, { value: "Module" })), T = {
+  query: rt
 };
-async function h(a) {
-  const { uuid: e, entry: t, target: i, query: n } = a;
-  if (!T(t.refTagName, P)) return [];
-  const u = await n.getRecordsByTagName(t.refTagName), r = [];
-  for (const s of u) {
-    if (s.attributes.find(
+async function B(e) {
+  const { uuid: a, entry: t, target: i, query: n } = e;
+  if (!M(t.refTagName, P)) return [];
+  const r = await n.getRecordsByTagName(t.refTagName), s = [];
+  for (const u of r) {
+    if (u.attributes.find(
       (S) => S.name === t.uuidAttr
-    )?.value !== e) continue;
-    const l = { tagName: s.tagName, id: s.id }, o = await z.query.buildReferencePath(n, { reference: l, target: i });
-    if (!o || s.attributes.find(
+    )?.value !== a) continue;
+    const o = { tagName: u.tagName, id: u.id }, l = await T.query.buildReferencePath(n, { reference: o, target: i });
+    if (!l || u.attributes.find(
       (S) => S.name === t.pathAttr
-    )?.value === o) continue;
-    const R = s.attributes.map(
-      (S) => S.name === t.pathAttr ? { ...S, value: o } : S
+    )?.value === l) continue;
+    const f = u.attributes.map(
+      (S) => S.name === t.pathAttr ? { ...S, value: l } : S
     );
-    r.push({
+    s.push({
       status: "updated",
-      oldRecord: d(s),
-      newRecord: d({ ...s, attributes: R })
+      oldRecord: p(u),
+      newRecord: p({ ...u, attributes: f })
     });
   }
-  return r;
+  return s;
 }
-function N(a) {
-  const e = [];
-  for (const t of U) {
-    const i = B[t].get(a);
-    i && e.push(...i);
+function U(e) {
+  const a = [];
+  for (const t of ce) {
+    const i = ue[t].get(e);
+    i && a.push(...i);
   }
-  return e;
+  return a;
 }
-async function Fe(a) {
-  const { childRecord: e, query: t } = a, i = await qe({ childRecord: e, query: t }), n = await Oe({ childRecord: e, query: t });
+async function st(e) {
+  const { childRecord: a, query: t } = e, i = await ut({ childRecord: a, query: t }), n = await lt({ childRecord: a, query: t });
   return [...i, ...n];
 }
-async function qe(a) {
-  const { childRecord: e, query: t } = a, i = Te.get(e.tagName);
+async function ut(e) {
+  const { childRecord: a, query: t } = e, i = et.get(a.tagName);
   if (!i?.length) return [];
   const n = [];
-  for (const u of i) {
-    const r = await ye({ childRecord: e, pair: u, query: t });
-    r && n.push(r);
+  for (const r of i) {
+    const s = await ct({ childRecord: a, pair: r, query: t });
+    s && n.push(s);
   }
   return n;
 }
-async function ye(a) {
-  const { childRecord: e, pair: t, query: i } = a, n = e.attributes.find((o) => o.name === t.uuidAttr)?.value;
+async function ct(e) {
+  const { childRecord: a, pair: t, query: i } = e, n = a.attributes.find((l) => l.name === t.uuidAttr)?.value;
   if (!n) return null;
-  const u = await xe({
+  const r = await ot({
     uuidValue: n,
     targetTagNames: t.targetTagNames,
     query: i
   });
-  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 (!r) return null;
+  const s = { tagName: a.tagName, id: a.id }, u = { tagName: r.tagName, id: r.id }, c = await re(i, { reference: s, target: u });
   if (!c) return null;
-  const l = e.attributes.map(
-    (o) => o.name === t.pathAttr ? { ...o, value: c } : o
+  const o = a.attributes.map(
+    (l) => l.name === t.pathAttr ? { ...l, value: c } : l
   );
   return {
     status: "updated",
-    oldRecord: e,
+    oldRecord: a,
     newRecord: {
-      ...e,
-      attributes: l
+      ...a,
+      attributes: o
     }
   };
 }
-async function xe(a) {
-  const { uuidValue: e, targetTagNames: t, query: i } = a;
+async function ot(e) {
+  const { uuidValue: a, targetTagNames: t, query: i } = e;
   for (const n of t) {
-    if (!T(n, P)) continue;
-    const r = (await i.getRecordsByTagName(n)).find(
-      (s) => s.attributes.find((c) => c.name === "uuid")?.value === e
+    if (!M(n, P)) continue;
+    const s = (await i.getRecordsByTagName(n)).find(
+      (u) => u.attributes.find((c) => c.name === "uuid")?.value === a
     );
-    if (r) return { tagName: r.tagName, id: r.id };
+    if (s) return { tagName: s.tagName, id: s.id };
   }
   return null;
 }
-async function Oe(a) {
-  const { childRecord: e, query: t } = a, i = e.attributes.find((s) => s.name === "uuid")?.value;
+async function lt(e) {
+  const { childRecord: a, query: t } = e, i = a.attributes.find((u) => u.name === "uuid")?.value;
   if (!i) return [];
-  const n = N(e.tagName);
+  const n = U(a.tagName);
   if (n.length === 0) return [];
-  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);
+  const r = { tagName: a.tagName, id: a.id }, s = [];
+  for (const u of n) {
+    const c = await B({ uuid: i, entry: u, target: r, query: t });
+    s.push(...c);
   }
-  return r;
+  return 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 dt(e) {
+  const { childRecord: a, parentRecord: t, query: i } = e, n = await we({ childRecord: a, parentRecord: t, query: i }), r = await st({ childRecord: a, query: i });
+  return [...n, ...r];
 }
-async function ke(a) {
-  const { cumulativeCloneMappings: e, query: t } = a, { uuidMap: i, uuidToRef: n } = await Ve(e, t);
+async function pt(e) {
+  const { cumulativeCloneMappings: a, query: t } = e, { uuidMap: i, uuidToRef: n } = await St(a, t);
   if (i.size === 0) return [];
-  const u = [];
-  for (const { target: r } of e) {
-    const s = await Me({ target: r, uuidMap: i, uuidToRef: n, query: t });
-    s && u.push(s);
+  const r = [];
+  for (const { target: s } of a) {
+    const u = await mt({ target: s, uuidMap: i, uuidToRef: n, query: t });
+    u && r.push(u);
   }
-  return u;
+  return r;
 }
-async function Ve(a, e) {
+async function St(e, a) {
   const t = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
-  for (const { source: n, target: u } of a)
-    await Ze({ source: n, target: u, query: e, uuidMap: t, uuidToRef: i });
+  for (const { source: n, target: r } of e)
+    await ft({ source: n, target: r, query: a, uuidMap: t, uuidToRef: i });
   return { uuidMap: t, uuidToRef: i };
 }
-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 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 ft(e) {
+  const { source: a, target: t, query: i, uuidMap: n, uuidToRef: r } = e, s = await i.getRecord(t);
+  if (!s) return;
+  const u = a.attributes.find((o) => o.name === "uuid")?.value, c = s.attributes.find((o) => o.name === "uuid")?.value;
+  !u || !c || (n.set(u, c), r.set(c, { tagName: s.tagName, id: s.id }));
 }
-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 s = m[u];
-  let c = [...r.attributes], l = !1;
-  for (const o of s) {
-    const p = await Ge({
-      pair: o,
-      tagName: u,
-      refId: r.id,
+async function mt(e) {
+  const { target: a, uuidMap: t, uuidToRef: i, query: n } = e, r = a.tagName;
+  if (!(r in m)) return null;
+  const s = await n.getRecord(a);
+  if (!s) return null;
+  const u = m[r];
+  let c = [...s.attributes], o = !1;
+  for (const l of u) {
+    const d = await bt({
+      pair: l,
+      tagName: r,
+      refId: s.id,
       updatedAttributes: c,
       uuidMap: t,
       uuidToRef: i,
       query: n
     });
-    p && (c = p, l = !0);
+    d && (c = d, o = !0);
   }
-  return l ? {
+  return o ? {
     status: "updated",
-    oldRecord: d(r),
-    newRecord: d({ ...r, attributes: c })
+    oldRecord: p(s),
+    newRecord: p({ ...s, attributes: c })
   } : null;
 }
-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;
+async function bt(e) {
+  const { pair: a, tagName: t, refId: i, uuidMap: n, uuidToRef: r, query: s } = e;
+  let u = [...e.updatedAttributes];
+  const c = u.find((S) => S.name === a.attribute.uuid)?.value;
   if (!c) return null;
-  const l = n.get(c);
-  if (!l) return null;
-  let o = !1;
-  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: u,
+  const o = n.get(c);
+  if (!o) return null;
+  let l = !1;
+  const d = Rt(u, a.attribute.uuid, c, o);
+  d && (u = d, l = !0);
+  const f = await Lt({
+    attributes: u,
+    pathAttrName: a.attribute.path,
+    newUuid: o,
+    uuidToRef: r,
     tagName: t,
     refId: i,
-    query: r
+    query: s
   });
-  return R && (s = R, o = !0), o ? s : null;
+  return f && (u = f, l = !0), l ? u : null;
 }
-function Be(a, e, t, i) {
-  return i === t ? null : a.map((n) => n.name === e ? { ...n, value: i } : n);
+function Rt(e, a, t, i) {
+  return i === t ? null : e.map((n) => n.name === a ? { ...n, value: i } : n);
 }
-async function Ue(a) {
-  const { attributes: e, pathAttrName: t, newUuid: i, uuidToRef: n, tagName: u, refId: r, query: s } = a, c = n.get(i);
+async function Lt(e) {
+  const { attributes: a, pathAttrName: t, newUuid: i, uuidToRef: n, tagName: r, refId: s, query: u } = e, c = n.get(i);
   if (!c) return null;
-  const l = await z.query.buildReferencePath(s, {
-    reference: { tagName: u, id: r },
+  const o = await T.query.buildReferencePath(u, {
+    reference: { tagName: r, id: s },
     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);
+  return !o || a.find((d) => d.name === t)?.value === o ? null : a.map((d) => d.name === t ? { ...d, value: o } : d);
 }
-async function ze(a) {
-  return ke(a);
+async function At(e) {
+  return pt(e);
 }
-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");
+function Pt(e) {
+  const { record: a } = e, { tagName: t, attributes: i } = a, n = P.definition[t];
+  if (!("uuid" in n.attributes.details) || i.find((l) => l.name === "uuid")?.value) return a;
+  const c = n.attributes.details.uuid?.namespace, o = i.filter((l) => l.name !== "uuid");
   return {
-    ...e,
+    ...a,
     attributes: [
-      ...l,
+      ...o,
       {
         name: "uuid",
         value: crypto.randomUUID(),
@@ -22230,240 +22230,240 @@ function _e(a) {
     ]
   };
 }
-function He(a) {
-  return _e(a);
+function Ct(e) {
+  return Pt(e);
 }
-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: u, entry: c, target: s, query: i });
-      n.push(...l);
+async function gt(e) {
+  const { oldRecord: a, newRecord: t, query: i } = e, n = [], r = t.attributes.find((s) => s.name === "uuid")?.value;
+  if (r) {
+    const s = U(t.tagName), u = { tagName: t.tagName, id: t.id };
+    for (const c of s) {
+      const o = await B({ uuid: r, entry: c, target: u, query: i });
+      n.push(...o);
     }
   }
-  if (Ke(e, t)) {
-    const r = await Xe({ newRecord: t, query: i });
-    n.push(...r);
+  if (vt(a, t)) {
+    const s = await Tt({ newRecord: t, query: i });
+    n.push(...s);
   }
   return n;
 }
-function Ke(a, e) {
-  for (const t of ie) {
-    const i = a.attributes.find((u) => u.name === t)?.value, n = e.attributes.find((u) => u.name === t)?.value;
+function vt(e, a) {
+  for (const t of xe) {
+    const i = e.attributes.find((r) => r.name === t)?.value, n = a.attributes.find((r) => r.name === t)?.value;
     if (i !== n) return !0;
   }
   return !1;
 }
-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 s of r) {
-      if (s.id === e.id) continue;
-      const c = await t.any.getAttribute(s, { name: "uuid" });
+async function Tt(e) {
+  const { newRecord: a, query: t } = e, i = { tagName: a.tagName, id: a.id }, n = await t.findDescendants(i), r = [];
+  for (const s of Object.values(n))
+    for (const u of s) {
+      if (u.id === a.id) continue;
+      const c = await t.any.getAttribute(u, { name: "uuid" });
       if (!c) continue;
-      const l = N(s.tagName);
-      if (l.length === 0) continue;
-      const o = { tagName: s.tagName, id: s.id };
-      for (const p of l) {
-        const R = await h({ uuid: c, entry: p, target: o, query: t });
-        u.push(...R);
+      const o = U(u.tagName);
+      if (o.length === 0) continue;
+      const l = { tagName: u.tagName, id: u.id };
+      for (const d of o) {
+        const f = await B({ uuid: c, entry: d, target: l, query: t });
+        r.push(...f);
       }
     }
-  return u;
+  return r;
 }
-async function Qe(a) {
-  return We(a);
+async function ht(e) {
+  return gt(e);
 }
-function Ye(a) {
-  const { record: e } = a;
+function Nt(e) {
+  const { record: a } = e;
   let t = !0;
-  e.tagName === "Private" && !e.tree.length && (t = !1);
-  const i = e.attributes.filter(
+  a.tagName === "Private" && !a.tree.length && (t = !1);
+  const i = a.attributes.filter(
     (n) => n.name !== "uuid"
   );
   return {
     shouldBeCloned: t,
     transformedRecord: {
-      ...e,
+      ...a,
       attributes: i
     }
   };
 }
-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 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);
+async function It(e) {
+  const { record: a, query: t } = e, i = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+  if (await le({ record: a, query: t, ids: i, uuids: n }), n.size === 0) return [];
+  const r = [], s = Object.keys(m);
+  for (const u of s) {
+    const c = await wt({ refTagName: u, subtreeIds: i, subtreeUuids: n, query: t });
+    r.push(...c);
   }
-  return u;
+  return r;
 }
-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) {
+async function wt(e) {
+  const { refTagName: a, subtreeIds: t, subtreeUuids: i, query: n } = e, r = m[a], s = await n.getRecordsByTagName(a), u = [];
+  for (const c of s) {
     if (t.has(c.id)) continue;
-    const l = await Je({ refTagName: e, refRecord: c, refPairs: u, subtreeUuids: i, query: n });
-    s.push(...l);
+    const o = await Dt({ refTagName: a, refRecord: c, refPairs: r, subtreeUuids: i, query: n });
+    u.push(...o);
   }
-  return s;
+  return u;
 }
-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);
+async function Dt(e) {
+  const { refTagName: a, refRecord: t, refPairs: i, subtreeUuids: n, query: r } = e, s = Ft({ refPairs: i, refRecord: t, subtreeUuids: n });
+  return s.size === 0 ? [] : oe.has(a) ? [yt(t, s)] : qt(t, r);
 }
-function et(a) {
-  const { refPairs: e, refRecord: t, subtreeUuids: i } = a, n = /* @__PURE__ */ new Set();
-  for (const u of e) {
-    const r = t.attributes.find(
-      (s) => s.name === u.attribute.uuid
+function Ft(e) {
+  const { refPairs: a, refRecord: t, subtreeUuids: i } = e, n = /* @__PURE__ */ new Set();
+  for (const r of a) {
+    const s = t.attributes.find(
+      (u) => u.name === r.attribute.uuid
     )?.value;
-    if (!(!r || !i.has(r))) {
-      n.add(u.attribute.uuid), n.add(u.attribute.path);
-      for (const s of u.companions)
-        n.add(s.name);
+    if (!(!s || !i.has(s))) {
+      n.add(r.attribute.uuid), n.add(r.attribute.path);
+      for (const u of r.companions)
+        n.add(u.name);
     }
   }
   return n;
 }
-function tt(a, e) {
-  const t = a.attributes.filter(
-    (i) => !e.has(i.name)
+function yt(e, a) {
+  const t = e.attributes.filter(
+    (i) => !a.has(i.name)
   );
   return {
     status: "updated",
-    oldRecord: d(a),
-    newRecord: d({ ...a, attributes: t })
+    oldRecord: p(e),
+    newRecord: p({ ...e, attributes: t })
   };
 }
-async function at(a, e) {
+async function qt(e, a) {
   const t = [
-    { status: "deleted", oldRecord: d(a), newRecord: void 0 }
+    { status: "deleted", oldRecord: p(e), newRecord: void 0 }
   ];
-  if (a.parent) {
-    const i = await e.getRecord(a.parent);
+  if (e.parent) {
+    const i = await a.getRecord(e.parent);
     if (i) {
       const n = {
         ...i,
-        children: i.children.filter((u) => u.id !== a.id)
+        children: i.children.filter((r) => r.id !== e.id)
       };
       t.push({
         status: "updated",
-        oldRecord: d(i),
-        newRecord: d(n)
+        oldRecord: p(i),
+        newRecord: p(n)
       });
     }
   }
   return t;
 }
-async function _(a) {
-  const { record: e, query: t, ids: i, uuids: n } = a;
-  i.add(e.id);
-  const u = e.attributes.find((r) => r.name === "uuid")?.value;
-  u && n.add(u);
-  for (const r of e.children) {
-    const s = await t.getRecord(r);
-    s && await _({ record: s, query: t, ids: i, uuids: n });
+async function le(e) {
+  const { record: a, query: t, ids: i, uuids: n } = e;
+  i.add(a.id);
+  const r = a.attributes.find((s) => s.name === "uuid")?.value;
+  r && n.add(r);
+  for (const s of a.children) {
+    const u = await t.getRecord(s);
+    u && await le({ record: u, query: t, ids: i, uuids: n });
   }
 }
-async function it(a) {
-  return je(a);
+async function xt(e) {
+  return It(e);
 }
-function nt() {
-  const a = /* @__PURE__ */ new Map(), e = [], t = [];
+function Ot() {
+  const e = /* @__PURE__ */ new Map(), a = [], 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
+    beforeImportRecord: (r) => {
+      const { record: s, ancestry: u } = r, { tagName: c } = s, o = Zt(s);
+      if (o && Vt.has(c)) {
+        const S = J({ record: s, ancestry: u });
+        S && e.set(S.path, o);
+      }
+      if (!kt.has(c)) return;
+      const f = m[c];
+      for (const S of f) {
+        const L = s.attributes.find(
+          (C) => C.name === S.attribute.path
         )?.value;
-        if (!C || r.attributes.find(
-          (g) => g.name === S.attribute.uuid
+        if (!L || s.attributes.find(
+          (C) => C.name === S.attribute.uuid
         )?.value) continue;
-        const A = Z(S.resolution, S.attribute.path, C, s);
-        if (!A) {
-          S.resolution === f.unsupported && t.push({
+        const N = ne(S.resolution, S.attribute.path, L, u);
+        if (!N) {
+          S.resolution === b.unsupported && t.push({
             type: "unsupported-xpath-reference",
-            recordId: r.id,
+            recordId: s.id,
             details: {
               elementTag: c,
               pathAttribute: S.attribute.path,
               uuidAttribute: S.attribute.uuid,
-              pathValue: C
+              pathValue: L
             }
           });
           continue;
         }
-        e.push({
-          recordId: r.id,
+        a.push({
+          recordId: s.id,
           elementTag: c,
           uuidAttributeName: S.attribute.uuid,
-          pathValue: C,
-          lookupKey: A.lookupKey,
-          fallbackLookupKey: A.fallbackLookupKey
+          pathValue: L,
+          lookupKey: N.lookupKey,
+          fallbackLookupKey: N.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);
+      const r = [], s = [...t];
+      for (const u of a) {
+        const c = e.get(u.lookupKey) ?? (u.fallbackLookupKey ? e.get(u.fallbackLookupKey) : void 0);
         if (!c) {
-          r.push({
+          s.push({
             type: "unresolved-reference",
-            recordId: s.recordId,
+            recordId: u.recordId,
             details: {
-              elementTag: s.elementTag,
-              uuidAttribute: s.uuidAttributeName,
-              pathValue: s.pathValue,
-              triedKeys: s.fallbackLookupKey ? [s.lookupKey, s.fallbackLookupKey] : [s.lookupKey]
+              elementTag: u.elementTag,
+              uuidAttribute: u.uuidAttributeName,
+              pathValue: u.pathValue,
+              triedKeys: u.fallbackLookupKey ? [u.lookupKey, u.fallbackLookupKey] : [u.lookupKey]
             }
           });
           continue;
         }
-        u.push({
-          recordId: s.recordId,
-          attributes: [{ name: s.uuidAttributeName, value: c }]
+        r.push({
+          recordId: u.recordId,
+          attributes: [{ name: u.uuidAttributeName, value: c }]
         });
       }
-      return a.clear(), e.length = 0, t.length = 0, {
-        updates: u,
-        warnings: r.length > 0 ? r : void 0
+      return e.clear(), a.length = 0, t.length = 0, {
+        updates: r,
+        warnings: s.length > 0 ? s : 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))
+const Et = new Set(
+  Object.entries(Q).filter(([, e]) => "uuid" in e).map(([e]) => e)
+), kt = new Set(Object.keys(m)), Vt = new Set(
+  Object.values(m).flatMap((e) => e.flatMap((a) => a.target))
 );
-function ct(a) {
-  if (!rt.has(a.tagName)) return;
-  const e = a.attributes.find((i) => i.name === "uuid");
-  if (e) return e.value;
+function Zt(e) {
+  if (!Et.has(e.tagName)) return;
+  const a = e.attributes.find((i) => i.name === "uuid");
+  if (a) return a.value;
   const t = crypto.randomUUID();
-  return a.attributes.push({ name: "uuid", value: t }), t;
+  return e.attributes.push({ name: "uuid", value: t }), t;
 }
-const Rt = {
-  beforeClone: Ye,
-  afterStandardizedRecord: He,
-  afterCreated: Ee,
-  afterDeepClone: ze,
-  afterUpdated: Qe,
-  beforeDelete: it
-}, ot = nt(), lt = {
+const ga = {
+  beforeClone: Nt,
+  afterStandardizedRecord: Ct,
+  afterCreated: dt,
+  afterDeepClone: At,
+  afterUpdated: ht,
+  beforeDelete: xt
+}, Mt = Ot(), Gt = {
   supportedFileExtensions: [".fsd", ".asd", ".ssd", ".scd", ".isd", ".xml"],
-  hooks: ot
-}, dt = {
+  hooks: Mt
+}, Bt = {
   recordSchema: {
     primaryKey: "id",
     indexes: ["tagName", "parent.id", "parent.tagName"],
@@ -22482,37 +22482,604 @@ const Rt = {
       }
     }
   }
-}, pt = {
+}, Ut = {
   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,
+  rootElementName: Ne,
+  singletonElements: Ie,
   transparentElements: ["Private"],
-  elements: H,
-  namespaces: pt,
-  attributes: w,
-  children: W,
-  parents: K,
+  elements: ge,
+  namespaces: Ut,
+  attributes: Q,
+  children: ve,
+  parents: Te,
   descendants: X,
-  ancestors: Q,
-  database: dt,
-  io: lt,
-  definition: D
+  ancestors: he,
+  database: Bt,
+  io: Gt,
+  definition: G
+};
+async function zt(e) {
+  const a = await e.getRecordsByTagName("LNode");
+  for (const t of a) {
+    const i = await e.getAttribute(t, { name: "iedName" });
+    if (!i || i === "None") continue;
+    const [n] = await e.findByAttributes({
+      tagName: "IED",
+      attributes: { name: i }
+    });
+    n || await _t(e, t);
+  }
+}
+async function _t(e, a) {
+  const t = await e.getChild(a, "LNodeSpecNaming");
+  if (t) {
+    const i = await e.getAttribute(t, { name: "sLnClass" }), n = await e.getAttribute(t, { name: "sLnInst" }), r = await e.getAttribute(t, { name: "sPrefix" });
+    await e.update(t, {
+      attributes: { sIedName: "None", sLdInst: void 0 }
+    }), await e.update(a, {
+      attributes: {
+        iedName: "None",
+        ldInst: void 0,
+        lnUuid: void 0,
+        templateUuid: void 0,
+        lnClass: i || void 0,
+        lnInst: n || void 0,
+        prefix: r || void 0
+      }
+    });
+  } else
+    await e.update(a, {
+      attributes: {
+        iedName: "None",
+        ldInst: void 0,
+        lnUuid: void 0,
+        templateUuid: void 0,
+        lnClass: void 0,
+        lnInst: void 0,
+        prefix: void 0
+      }
+    });
+}
+async function Ht(e) {
+  const a = [...Object.values(tt).flat(), "Private"];
+  for (const t of a) {
+    const i = await e.getRecordsByTagName(t);
+    for (const n of i)
+      n.children.length === 0 && await e.delete(n);
+  }
+}
+async function Wt(e) {
+  const a = Object.keys(m);
+  for (const t of a) {
+    const i = m[t], n = await e.getRecordsByTagName(t);
+    for (const r of n) {
+      let s = !1, u = !1;
+      const c = {};
+      for (const d of i) {
+        const f = await e.getAttribute(r, {
+          name: d.attribute.uuid
+        });
+        if (!f) continue;
+        if (s = !0, await Kt(e, f, d.target))
+          u = !0;
+        else {
+          c[d.attribute.uuid] = void 0, c[d.attribute.path] = void 0;
+          for (const L of d.companions)
+            c[L.name] = void 0;
+        }
+      }
+      Object.keys(c).length > 0 && await e.update(r, { attributes: c });
+      const o = oe.has(t);
+      s && !u && !o && await e.delete(r);
+    }
+  }
+}
+async function Kt(e, a, t) {
+  for (const i of t) {
+    const [n] = await e.findByAttributes({
+      tagName: i,
+      attributes: { uuid: a }
+    });
+    if (n) return !0;
+  }
+  return !1;
+}
+const Xt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  orphanUuidRefs: Wt,
+  pruneEmptyContainers: Ht,
+  resetLNode: zt
+}, Symbol.toStringTag, { value: "Module" })), w = {
+  transaction: Xt
+};
+async function de(e, a) {
+  const { records: t } = a, i = {
+    lnodeTypes: /* @__PURE__ */ new Map(),
+    doTypes: /* @__PURE__ */ new Map(),
+    daTypes: /* @__PURE__ */ new Map(),
+    enumTypes: /* @__PURE__ */ new Map()
+  };
+  for (const n of t) {
+    const r = await e.getAttribute(n, { name: "lnType" });
+    if (!r) continue;
+    const [s] = await e.findByAttributes({
+      tagName: "LNodeType",
+      attributes: { id: r }
+    });
+    if (F(s, {
+      key: "ELEMENT_NOT_FOUND",
+      detail: `LNodeType not found for lnType="${r}"`
+    }), !v(i.lnodeTypes, r, s)) continue;
+    const u = s.children.filter((o) => I(o, "DO")), c = await e.getRecords(u);
+    for (const o of c) {
+      if (!o) continue;
+      const l = await e.getAttribute(o, { name: "type" });
+      if (!l) continue;
+      const [d] = await e.findByAttributes({
+        tagName: "DOType",
+        attributes: { id: l }
+      });
+      d && v(i.doTypes, l, d) && await V({ query: e, parent: d, dataModelMap: i });
+    }
+  }
+  return {
+    lnodeTypes: Array.from(i.lnodeTypes.values()),
+    doTypes: Array.from(i.doTypes.values()),
+    daTypes: Array.from(i.daTypes.values()),
+    enumTypes: Array.from(i.enumTypes.values())
+  };
+}
+function v(e, a, t) {
+  return e.has(a) ? !1 : (e.set(a, t), !0);
+}
+async function V(e) {
+  const { query: a, parent: t, dataModelMap: i } = e, n = t.tagName === "DOType" ? await a.getRecords(t.children.filter((r) => I(r, "DA"))) : await a.getRecords(t.children.filter((r) => I(r, "BDA")));
+  for (const r of n) {
+    if (!r) continue;
+    const s = await a.getAttribute(r, { name: "bType" }), u = await a.getAttribute(r, { name: "type" });
+    if (u) {
+      if (s === "Enum") {
+        const [c] = await a.findByAttributes({
+          tagName: "EnumType",
+          attributes: { id: u }
+        });
+        c && v(i.enumTypes, u, c);
+      } else if (s === "Struct") {
+        const [c] = await a.findByAttributes({
+          tagName: "DAType",
+          attributes: { id: u }
+        });
+        c && v(i.daTypes, u, c) && await V({ query: a, parent: c, dataModelMap: i });
+      }
+    }
+  }
+  if (t.tagName === "DOType") {
+    const r = t.children.filter((u) => I(u, "SDO")), s = await a.getRecords(r);
+    for (const u of s) {
+      const c = await a.getAttribute(u, { name: "type" });
+      if (!c) continue;
+      const [o] = await a.findByAttributes({
+        tagName: "DOType",
+        attributes: { id: c }
+      });
+      o && v(i.doTypes, c, o) && await V({ query: a, parent: o, dataModelMap: i });
+    }
+  }
+}
+const Qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  resolve: de
+}, Symbol.toStringTag, { value: "Module" }));
+async function Yt(e, a) {
+  const { sourceQuery: t, records: i } = a, n = await de(t, { records: i }), r = jt(n), s = await e.getRoot(), u = await e.ensureChild(s, {
+    tagName: "DataTypeTemplates",
+    attributes: {}
+  });
+  for (const c of r) {
+    const o = await t.getAttribute(c, { name: "id" });
+    if (!o) continue;
+    const [l] = await e.findByAttributes({
+      tagName: c.tagName,
+      attributes: { id: o }
+    });
+    if (l) continue;
+    const d = await t.getTree(c);
+    d && await e.deepClone(u, d);
+  }
+}
+function jt(e) {
+  return [...e.lnodeTypes, ...e.doTypes, ...e.daTypes, ...e.enumTypes];
+}
+const $t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  extract: Yt
+}, Symbol.toStringTag, { value: "Module" })), pe = {
+  query: Qt,
+  transaction: $t
+};
+async function Se(e) {
+  const a = await e.getRecord({ tagName: "History" });
+  if (!a) return [];
+  const { Hitem: t = [] } = await e.findDescendants(a, { collect: "Hitem" });
+  function i(r, s) {
+    return Number(r.attributes.find((u) => u.name === s)?.value || 0);
+  }
+  return [...t].sort((r, s) => {
+    const u = i(r, "version") - i(s, "version");
+    return u !== 0 ? u : i(r, "revision") - i(s, "revision");
+  });
+}
+async function fe(e) {
+  return (await Se(e)).at(-1);
+}
+const Jt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getLatestHitem: fe,
+  getSortedHitems: Se
+}, Symbol.toStringTag, { value: "Module" }));
+async function ea(e, a) {
+  const { filename: t, header: i, item: n } = a, { id: r, fileType: s, nameStructure: u, version: c, tool: o } = i, { who: l, what: d, why: f } = n, S = await e.getRoot(), h = await e.getRecord({ tagName: "Header" }) ?? await e.addChild(S, {
+    tagName: "Header",
+    attributes: {
+      id: r ?? t.replace(/\.[^.]+$/, "").toLowerCase().replace(/\s+/g, "_"),
+      toolID: o,
+      fileType: s,
+      ...u ? { nameStructure: u } : {},
+      version: "0",
+      revision: "1",
+      uuid: crypto.randomUUID()
+    }
+  }), C = await e.getRecord({ tagName: "History" }) ?? await e.addChild(h, { tagName: "History", attributes: {} }), H = await fe(e), q = H?.attributes.find((E) => E.name === "version")?.value, W = H?.attributes.find((E) => E.name === "revision")?.value, x = c === "keep" ? q ?? "0" : q ? String(Number(q) + 1) : "0", O = W ? String(Number(W) + 1) : "1";
+  await e.update(h, {
+    attributes: { version: x, revision: O }
+  });
+  const K = /* @__PURE__ */ new Date(), g = K.toString().split(" "), Ae = K.toLocaleString("en", { timeZoneName: "short" }).split(" ").pop(), Pe = `${g[0]} ${g[1]} ${g[2]} ${g[4]} ${Ae} ${g[3]}`;
+  await e.addChild(C, {
+    tagName: "Hitem",
+    attributes: {
+      version: x,
+      revision: O,
+      when: Pe,
+      who: l,
+      what: d,
+      why: f
+    }
+  }), await e.update(h, {
+    attributes: { version: x, revision: O }
+  });
+}
+const ta = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addEntry: ea
+}, Symbol.toStringTag, { value: "Module" })), z = {
+  query: Jt,
+  transaction: ta
+}, aa = {
+  LNode: ["prefix", "lnClass", "lnInst"],
+  LN: ["prefix", "lnClass", "inst"],
+  LN0: ["prefix", "lnClass", "inst"],
+  LDevice: ["inst"],
+  ConnectedAP: ["iedName", "apName"],
+  GSE: ["ldInst", "cbName"],
+  SMV: ["ldInst", "cbName"],
+  Private: ["type"],
+  EnumVal: ["ord"],
+  Association: ["associationID"],
+  ConnectivityNode: ["pathName"],
+  ControlRef: ["output", "outputInst"],
+  SourceRef: ["input", "inputInst"],
+  FunctionRoleContent: ["roleInst"],
+  Resource: ["resInst"],
+  Hitem: ["version", "revision"],
+  History: ["version", "revision"]
+}, ia = {
+  ConnectedAP: " / ",
+  GSE: "/",
+  SMV: "/",
+  Hitem: ".",
+  History: ".",
+  ControlRef: "/",
+  SourceRef: "/"
+};
+async function na(e, a) {
+  const t = await e.getRecord(a);
+  if (!t) return "";
+  const i = t.tagName, n = await e.any.getAttributes(t), r = aa[i];
+  if (r) {
+    const o = ia[i] ?? "", l = r.map((d) => n[d]).filter(Boolean);
+    return l.length > 0 ? l.join(o) : i;
+  }
+  const u = G[i]?.attributes?.identityFields, c = u?.find((o) => o === "name" || o === "id") ?? u?.[0];
+  return c ? n[c] || i : n.name || i;
+}
+const ra = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  extractElementTitle: na
+}, Symbol.toStringTag, { value: "Module" })), sa = {
+  query: ra
+};
+async function _(e) {
+  const a = await e.getRoot(), t = await e.ensureChild(a, {
+    tagName: "Substation",
+    attributes: { name: "TEMPLATE" }
+  }), i = await e.ensureChild(t, {
+    tagName: "VoltageLevel",
+    attributes: { name: "TEMPLATE" }
+  }), n = await e.ensureChild(i, {
+    tagName: "Bay",
+    attributes: { name: "TEMPLATE" }
+  });
+  return {
+    Substation: t,
+    VoltageLevel: i,
+    Bay: n
+  };
+}
+const ua = {
+  scope: "tree",
+  attributes: ["templateUuid", "originUuid"]
+};
+async function y(e, a) {
+  const { sourceQuery: t, ref: i, targetParent: n, omit: r, promoteRoot: s, strip: u = ua } = a, c = await t.getTree(i, { omit: r });
+  if (!c) return;
+  const o = s && c.tagName === s.from ? { ...c, tagName: s.to } : c;
+  let l = o;
+  u && (l = u.scope === "tree" ? Ce(o, u.attributes) : {
+    ...o,
+    attributes: o.attributes.filter((d) => !u.attributes.includes(d.name))
+  }), await e.deepClone(n, l);
+}
+async function ca(e, a) {
+  const { sourceQuery: t, scopeRef: i } = a, { LNode: n = [] } = await t.findDescendants(i, {
+    collect: "LNode"
+  });
+  n.length > 0 && await pe.transaction.extract(e, { sourceQuery: t, records: n });
+}
+async function Z(e, a, t) {
+  const n = (await e.findAncestors(a, { stopAtTagName: "Substation" })).find((s) => s.tagName in t);
+  F(n, {
+    key: "ELEMENT_NOT_FOUND",
+    detail: `No Substation/VoltageLevel/Bay ancestor found for ${a.tagName}`
+  });
+  const r = t[n.tagName];
+  return { tagName: r.tagName, id: r.id };
+}
+async function me(e, a) {
+  const { sourceQuery: t, functionRef: i, targetParentRef: n, omit: r, stripRootAttributes: s } = a, u = s?.length ? { scope: "root", attributes: [...s] } : !1;
+  await y(e, {
+    sourceQuery: t,
+    ref: i,
+    targetParent: n,
+    omit: r,
+    promoteRoot: { from: "SubFunction", to: "Function" },
+    strip: u
+  }), await ca(e, { sourceQuery: t, scopeRef: i });
+}
+async function be(e, a) {
+  const { sourceQuery: t, functionRef: i, structure: n, stripCategoriesUuid: r = !0 } = a, s = await oa(t, i);
+  for (const u of s) {
+    if (await da(e, t, u)) continue;
+    const o = { tagName: "FunctionCategory", id: u }, l = await Z(t, o, n);
+    await y(e, {
+      sourceQuery: t,
+      ref: o,
+      targetParent: l,
+      ...r ? {} : { strip: !1 }
+    });
+  }
+}
+async function oa(e, a) {
+  const t = await la(e, a), i = /* @__PURE__ */ new Set();
+  for (const { container: n } of t)
+    n && i.add(n.id);
+  return i;
+}
+async function la(e, a) {
+  const t = await T.query.findRefsPointingTo(e, {
+    target: a,
+    containerTagName: "FunctionCategory"
+  }), { SubFunction: i = [] } = await e.findDescendants(a, {
+    collect: "SubFunction"
+  });
+  for (const n of i) {
+    const r = await T.query.findRefsPointingTo(e, {
+      target: { tagName: "SubFunction", id: n.id },
+      containerTagName: "FunctionCategory"
+    });
+    t.push(...r);
+  }
+  return t;
+}
+async function da(e, a, t) {
+  const i = await a.getRecord({
+    tagName: "FunctionCategory",
+    id: t
+  });
+  if (!i) return !1;
+  const n = await a.getAttribute(i, { name: "name" });
+  if (!n) return !1;
+  const [r] = await e.findByAttributes({
+    tagName: "FunctionCategory",
+    attributes: { name: n }
+  });
+  return !!r;
+}
+async function Re(e, a) {
+  const { sourceQuery: t, scopeRef: i, refTagName: n, targetTagName: r } = a, s = m[n][0].attribute.uuid, u = await t.findDescendants(i, {
+    collect: n
+  }), { [n]: c = [] } = u, o = /* @__PURE__ */ new Set();
+  for (const d of c) {
+    const f = d.attributes.find(
+      (S) => S.name === s
+    )?.value;
+    f && o.add(f);
+  }
+  const l = [];
+  for (const d of o) {
+    const f = { uuid: d }, [S] = await e.findByAttributes({ tagName: r, attributes: f });
+    if (S) continue;
+    const [L] = await t.findByAttributes({
+      tagName: r,
+      attributes: f
+    });
+    L && l.push({ tagName: r, id: L.id });
+  }
+  return l;
+}
+async function pa(e, a) {
+  const { sourceQuery: t, scopeRef: i, refTagName: n, targetTagName: r, targetParent: s, omit: u } = a, c = await Re(e, {
+    sourceQuery: t,
+    scopeRef: i,
+    refTagName: n,
+    targetTagName: r
+  });
+  for (const o of c)
+    await y(e, { sourceQuery: t, ref: o, targetParent: s, omit: u });
+}
+async function Sa(e, a) {
+  const { sourceQuery: t, scopeTagName: i, scopeRef: n, targetParent: r, skip: s = /* @__PURE__ */ new Set(), omit: u } = a, c = X[i].filter(
+    (l) => l in m && !s.has(l)
+  ), o = pa;
+  for (const l of c)
+    for (const d of m[l])
+      for (const f of d.target)
+        await o(e, {
+          sourceQuery: t,
+          scopeRef: n,
+          refTagName: l,
+          targetTagName: f,
+          targetParent: r,
+          omit: u
+        });
+}
+const D = [
+  "FunctionSclRef",
+  "ApplicationSclRef",
+  "GeneralEquipment",
+  "ConductingEquipment"
+], fa = [
+  ...D,
+  "DOS",
+  "Labels",
+  "LNodeInputs",
+  "LNodeOutputs",
+  "ProcessResources",
+  "PowerSystemRelations",
+  "BehaviorDescription",
+  "Variable"
+];
+async function ma(e, a) {
+  const { sourceQuery: t, applicationRef: i, structure: n } = a, r = {
+    tagName: "Substation",
+    id: n.Substation.id
+  }, s = await Re(e, {
+    sourceQuery: t,
+    scopeRef: i,
+    refTagName: "FunctionRef",
+    targetTagName: "Function"
+  });
+  for (const o of s) {
+    const l = await Z(t, o, n);
+    await me(e, {
+      sourceQuery: t,
+      functionRef: o,
+      targetParentRef: l,
+      omit: D
+    });
+  }
+  for (const o of s)
+    await be(e, {
+      sourceQuery: t,
+      functionRef: o,
+      structure: n,
+      stripCategoriesUuid: !1
+    });
+  await Sa(e, {
+    sourceQuery: t,
+    scopeTagName: "Application",
+    scopeRef: i,
+    targetParent: r,
+    skip: /* @__PURE__ */ new Set(["FunctionRef", "FunctionCategoryRef"]),
+    omit: D
+  });
+  const c = await Z(t, i, n);
+  await y(e, { sourceQuery: t, ref: i, targetParent: c, omit: D });
+}
+async function Le(e) {
+  await w.transaction.orphanUuidRefs(e), await w.transaction.resetLNode(e), await w.transaction.pruneEmptyContainers(e);
+}
+async function ba(e, a) {
+  const { sourceQuery: t, applicationRef: i, tool: n, who: r, nameStructure: s } = a, u = await _(e), c = await e.getAttribute(i, { name: "name" }) || "Unnamed Application";
+  await z.transaction.addEntry(e, {
+    filename: `ASD_${c.replace(/\s+/g, "_")}`,
+    header: {
+      fileType: "ASD",
+      version: "keep",
+      tool: n,
+      ...s ? { nameStructure: s } : {}
+    },
+    item: {
+      who: r,
+      what: "ASD initialization",
+      why: "Application was extracted from a previous file"
+    }
+  }), await ma(e, { sourceQuery: t, applicationRef: i, structure: u }), await Le(e);
+}
+async function Ra(e, a) {
+  const { sourceQuery: t, functionRef: i, tool: n, who: r, nameStructure: s } = a, u = await _(e), c = {
+    tagName: u.Substation.tagName,
+    id: u.Substation.id
+  }, o = await t.getAttribute(i, { name: "name" }) || "Unnamed Function";
+  await z.transaction.addEntry(e, {
+    filename: `FSD_${o.replace(/\s+/g, "_")}`,
+    header: {
+      fileType: "FSD",
+      version: "keep",
+      tool: n,
+      ...s ? { nameStructure: s } : {}
+    },
+    item: {
+      who: r,
+      what: "FSD initialization",
+      why: "Function was extracted from a previous file"
+    }
+  }), await me(e, {
+    sourceQuery: t,
+    functionRef: i,
+    targetParentRef: c,
+    omit: fa,
+    stripRootAttributes: ["templateUuid"]
+  }), await be(e, {
+    sourceQuery: t,
+    functionRef: i,
+    structure: u
+  }), await Le(e);
+}
+const La = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ensureSubstationTemplateStructure: _,
+  extractToAsd: ba,
+  extractToFsd: Ra
+}, Symbol.toStringTag, { value: "Module" })), Aa = {
+  transaction: La
+}, va = {
+  cleanUp: w,
+  dataModel: pe,
+  history: z,
+  reference: T,
+  template: Aa,
+  presentation: sa
 };
 export {
-  D,
-  Rt as H,
-  he as K,
-  bt as R,
-  P as S,
-  m as U,
-  X as a,
-  dt as b,
-  lt as c,
-  pt as d,
-  z as r
+  ga as H,
+  Bt as S,
+  P as a,
+  va as b,
+  Gt as c,
+  Ut as d
 };