@dialecte/scl 0.1.19 → 0.1.20

package/dist/{index-ChFpcq4k.js → index-uvKv9uth.js}

@@ -21445,14 +21445,14 @@ 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();
+      const u = e[n.resolution] ??= /* @__PURE__ */ new Map();
       for (const r of n.target) {
-        const u = s.get(r) ?? [];
-        u.push({
+        const s = u.get(r) ?? [];
+        s.push({
           refTagName: t,
           uuidAttr: n.attribute.uuid,
           pathAttr: n.attribute.path
-        }), s.set(r, u);
+        }), u.set(r, s);
       }
     }
   return e;
@@ -21510,8 +21510,8 @@ const te = /* @__PURE__ */ new Set(["SourceRef", "ControlRef", "DOS", "SDS", "DA
   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: "." },
+  SourceRef: { type: "sourceRef" },
+  ControlRef: { type: "controlRef" },
   // Process section - data specifications (6-100, dot-separated)
   DOS: { type: "name", separator: "." },
   DAS: { type: "name", separator: "." },
@@ -21558,6 +21558,10 @@ const te = /* @__PURE__ */ new Set(["SourceRef", "ControlRef", "DOS", "SDS", "DA
         return [...ae];
       case "attribute":
         return [a.attr];
+      case "sourceRef":
+        return ["input", "inputInst", "pDA"];
+      case "controlRef":
+        return ["output", "outputInst"];
     }
   })
 );
@@ -21568,41 +21572,59 @@ function ne(a) {
     case "name": {
       const e = a.separator ?? "/";
       return (t) => {
-        const i = P(t, "name");
+        const i = b(t, "name");
         return i ? { segment: i, separator: e } : null;
       };
     }
     case "lnClass":
       return (e) => {
-        const t = P(e, "lnClass");
+        const t = b(e, "lnClass");
         if (!t) return null;
-        const i = P(e, "prefix") ?? "", n = P(e, "inst") ?? P(e, "lnInst") ?? "";
+        const i = b(e, "prefix") ?? "", n = b(e, "inst") ?? b(e, "lnInst") ?? "";
         return { segment: `${i}${t}${n}`, separator: "/" };
       };
     case "attribute":
       return (e) => {
-        const t = P(e, a.attr);
+        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 R(a) {
+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 s of t) {
-    const r = R(s);
-    r && i.push({ ...r, ref: { tagName: s.tagName, id: s.id } });
+  for (const u of t) {
+    const r = L(u);
+    r && i.push({ ...r, ref: { tagName: u.tagName, id: u.id } });
   }
-  const n = R(e);
+  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 P(a, e) {
+function b(a, e) {
   return a.attributes.find((t) => t.name === e)?.value;
 }
 function O(a) {
@@ -21623,24 +21645,24 @@ async function E(a, e) {
 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 u = n.resolution;
+  if (u === f.unsupported) return null;
+  if (u === f.behaviorDescription) {
     const c = await a.getRecord(i);
-    return c ? R(d(c))?.segment ?? null : null;
+    return c ? L(d(c))?.segment ?? null : null;
   }
   const r = await E(a, i);
   if (!r) return null;
-  const u = r.path;
-  if (s === f.lnode) {
+  const s = r.path;
+  if (u === f.lnode) {
     const c = await a.getRecord(t);
-    if (!c) return u;
+    if (!c) return s;
     const l = c.attributes.find((p) => p.name === n.attribute.path)?.value;
-    if (!l) return u;
+    if (!l) return s;
     const { qualifier: o } = G(l);
-    return o ? `${u}.${o}` : u;
+    return o ? `${s}.${o}` : s;
   }
-  return u;
+  return s;
 }
 function ue(a, e) {
   const t = m[a];
@@ -21651,18 +21673,18 @@ async function se(a, e, 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)));
+  let u;
+  (i.resolution === f.behaviorDescription || i.resolution === f.iedAddress) && (u = (await a.findAncestors(e, { order: "top-down" })).map((R) => d(R)));
   const r = B(
     i.resolution,
     t,
     n,
-    s
+    u
   );
   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({
+  const s = M(r.lookupKey);
+  if (s.length === 0) return;
+  const c = s[s.length - 1], l = s.slice(0, -1), o = await pe({
     query: a,
     targets: i.target,
     segment: c,
@@ -21697,57 +21719,57 @@ function de(a) {
 }
 async function pe(a) {
   const { query: e, targets: t, segment: i, expectedAncestry: n } = a;
-  for (const s of t) {
-    const r = le[s];
+  for (const u of t) {
+    const r = le[u];
     if (r) {
-      const u = await Se({
+      const s = await Se({
         query: e,
-        tagName: s,
+        tagName: u,
         segment: i,
         instAttr: r,
         expectedAncestry: n
       });
-      if (u) return u;
+      if (s) return s;
     } else {
-      const u = await fe({
+      const s = await fe({
         query: e,
-        tagName: s,
+        tagName: u,
         segment: i,
         expectedAncestry: n
       });
-      if (u) return u;
+      if (s) return s;
     }
   }
 }
 async function Se(a) {
-  const { query: e, tagName: t, segment: i, instAttr: n, expectedAncestry: s } = a, r = de(i.segment);
+  const { query: e, tagName: t, segment: i, instAttr: n, expectedAncestry: u } = a, r = de(i.segment);
   if (!r) return;
-  const u = await e.findByAttributes({
+  const s = await e.findByAttributes({
     tagName: t,
     attributes: { lnClass: r.lnClass }
   });
-  for (const c of u) {
+  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 V(e, c, s))
+    if (!(l !== r.prefix || o !== r.inst) && await V(e, c, u))
       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))
+  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 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]));
+  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((s, r) => s.segment === t[r].segment);
+  return n.length !== t.length ? !1 : n.every((u, r) => u.segment === t[r].segment);
 }
 async function me(a, e) {
   const t = M(e);
@@ -21763,41 +21785,41 @@ async function me(a, e) {
 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];
+  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 = R(d(c));
+    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 === u.segment && l.separator === u.separator)
+    if (l.segment === s.segment && l.separator === s.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 u = n.attributes.find((c) => c.name === "uuid")?.value;
+  if (!u) return [];
   const r = Re(n.tagName);
   if (r.length === 0) return [];
-  const u = [];
+  const s = [];
   for (const c of r) {
-    if (!T(c.refTagName, L)) continue;
+    if (!T(c.refTagName, P)) continue;
     const l = await a.findByAttributes({
       tagName: c.refTagName,
-      attributes: { [c.uuidAttr]: s }
+      attributes: { [c.uuidAttr]: u }
     });
     for (const o of l) {
       const p = i ? await Le(a, o, i) : void 0;
-      u.push({ ref: o, container: p });
+      s.push({ ref: o, container: p });
     }
   }
-  return u;
+  return s;
 }
 function Re(a) {
   const e = [];
@@ -21831,8 +21853,8 @@ function M(a) {
 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 };
+  const n = t.substring(0, i), u = t.substring(i + 1);
+  return { path: [...e.slice(0, -1), n].join("/"), qualifier: u || 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;
@@ -21871,7 +21893,7 @@ function ve(a) {
   if (e === -1) return null;
   const t = [];
   for (let i = 0; i < e; i++) {
-    const n = R(a[i]);
+    const n = L(a[i]);
     n && t.push(n);
   }
   return t.length === 0 ? null : O(t);
@@ -21889,22 +21911,22 @@ function he(a) {
 function Ne() {
   const a = /* @__PURE__ */ new Map(), e = [], t = [];
   return {
-    beforeImportRecord: (s) => {
-      const { record: r, ancestry: u } = s, { tagName: c } = r, l = Fe(r);
+    beforeImportRecord: (u) => {
+      const { record: r, ancestry: s } = u, { tagName: c } = r, l = Fe(r);
       if (l && De.has(c)) {
-        const S = x({ record: r, ancestry: u });
+        const S = x({ record: r, ancestry: s });
         S && a.set(S.path, l);
       }
       if (!we.has(c)) return;
-      const b = m[c];
-      for (const S of b) {
+      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 = B(S.resolution, S.attribute.path, C, u);
+        const A = B(S.resolution, S.attribute.path, C, s);
         if (!A) {
           S.resolution === f.unsupported && t.push({
             type: "unsupported-xpath-reference",
@@ -21929,29 +21951,29 @@ function Ne() {
       }
     },
     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);
+      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: u.recordId,
+            recordId: s.recordId,
             details: {
-              elementTag: u.elementTag,
-              uuidAttribute: u.uuidAttributeName,
-              pathValue: u.pathValue,
-              triedKeys: u.fallbackLookupKey ? [u.lookupKey, u.fallbackLookupKey] : [u.lookupKey]
+              elementTag: s.elementTag,
+              uuidAttribute: s.uuidAttributeName,
+              pathValue: s.pathValue,
+              triedKeys: s.fallbackLookupKey ? [s.lookupKey, s.fallbackLookupKey] : [s.lookupKey]
             }
           });
           continue;
         }
-        s.push({
-          recordId: u.recordId,
-          attributes: [{ name: u.uuidAttributeName, value: c }]
+        u.push({
+          recordId: s.recordId,
+          attributes: [{ name: s.uuidAttributeName, value: c }]
         });
       }
       return a.clear(), e.length = 0, t.length = 0, {
-        updates: s,
+        updates: u,
         warnings: r.length > 0 ? r : void 0
       };
     }
@@ -21990,9 +22012,10 @@ const qe = {
     uri: "http://www.iec.ch/61850/2019/SCL/6-100",
     prefix: "eIEC61850-6-100"
   }
-}, L = {
+}, P = {
   rootElementName: Y,
   singletonElements: j,
+  transparentElements: ["Private"],
   elements: H,
   namespaces: xe,
   attributes: w,
@@ -22006,38 +22029,38 @@ const qe = {
 };
 async function Oe(a) {
   const { childRecord: e, parentRecord: t, query: i } = a;
-  if (e.namespace.prefix === L.namespaces.default.prefix)
+  if (e.namespace.prefix === P.namespaces.default.prefix)
     return [];
-  const n = t.tagName === "Private", s = t.namespace.prefix === L.namespaces.default.prefix;
-  if (!n && !s)
+  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"), u = {
+  const r = t.children.find((o) => o.tagName === "Private"), s = {
     ...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,
+    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
     )
-  ) ? [] : Ve({ parentRecord: t, updatedParentRecord: u, childRecord: e });
+  ) ? [] : Ve({ parentRecord: t, updatedParentRecord: s, 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, {
+  const u = await U({ privateId: n.id, query: i });
+  I(u, {
     detail: "Latest private record not found",
     key: "ELEMENT_NOT_FOUND"
   });
-  const { childRecord: r, privateRecord: u } = z({
-    privateRecord: s,
+  const { childRecord: r, privateRecord: s } = z({
+    privateRecord: u,
     childRecord: t
   });
   return [
@@ -22048,15 +22071,15 @@ async function Ee(a) {
     },
     {
       status: "updated",
-      oldRecord: d(s),
-      newRecord: d(u)
+      oldRecord: d(u),
+      newRecord: d(s)
     }
   ];
 }
 async function ke(a) {
-  const { existingPrivateRef: e, parentRecord: t, updatedParentRecord: i, childRecord: n, query: s } = a, r = await U({
+  const { existingPrivateRef: e, parentRecord: t, updatedParentRecord: i, childRecord: n, query: u } = a, r = await U({
     privateId: e.id,
-    query: s
+    query: u
   });
   if (I(r, {
     detail: "Latest private record not found",
@@ -22090,12 +22113,12 @@ function Ve(a) {
   const { parentRecord: e, updatedParentRecord: t, childRecord: i } = a, n = {
     id: crypto.randomUUID(),
     tagName: "Private",
-    namespace: L.namespaces.default,
+    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 }]
-  }, s = {
+  }, u = {
     ...i,
     parent: { id: n.id, tagName: "Private" }
   }, r = {
@@ -22107,7 +22130,7 @@ function Ve(a) {
     {
       status: "updated",
       oldRecord: d(i),
-      newRecord: d(s)
+      newRecord: d(u)
     },
     {
       status: "updated",
@@ -22132,23 +22155,23 @@ function z(a) {
 }
 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;
@@ -22169,8 +22192,8 @@ async function Me(a) {
   const { childRecord: e, query: t } = a, i = ee.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 Ge({ childRecord: e, pair: u, query: t });
     r && n.push(r);
   }
   return n;
@@ -22178,13 +22201,13 @@ async function Me(a) {
 async function Ge(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 Be({
     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 k(i, { reference: r, target: s });
   if (!c) return null;
   const l = e.attributes.map(
     (o) => o.name === t.pathAttr ? { ...o, value: c } : o
@@ -22201,63 +22224,63 @@ async function Ge(a) {
 async function Be(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;
+  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];
+  const { childRecord: e, parentRecord: t, query: i } = a, n = await Oe({ childRecord: e, parentRecord: t, query: i }), u = await Ze({ 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);
   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 Ke({ target: r, uuidMap: i, uuidToRef: n, query: t });
+    s && u.push(s);
   }
-  return s;
+  return u;
 }
 async function He(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 We({ 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);
+  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;
+  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) {
+  for (const o of s) {
     const p = await Xe({
       pair: o,
-      tagName: s,
+      tagName: u,
       refId: r.id,
       updatedAttributes: c,
       uuidMap: t,
@@ -22273,34 +22296,34 @@ async function Ke(a) {
   } : 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;
+  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 = Qe(s, e.attribute.uuid, c, l);
+  p && (s = p, o = !0);
+  const R = await Ye({
+    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) {
   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);
+  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);
@@ -22309,7 +22332,7 @@ async function je(a) {
   return _e(a);
 }
 function $e(a) {
-  const { record: e } = a, { tagName: t, attributes: i } = e, n = L.definition[t];
+  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 {
@@ -22328,11 +22351,11 @@ function Je(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 };
+  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);
     }
   }
@@ -22344,27 +22367,27 @@ async function et(a) {
 }
 function tt(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 = [];
+  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);
@@ -22387,36 +22410,36 @@ function nt(a) {
 async function rt(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 ut({ 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 = [];
+  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 st({ 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);
+  const { refTagName: e, refRecord: t, refPairs: i, subtreeUuids: n, query: u } = a, r = ct({ refPairs: i, refRecord: t, subtreeUuids: n });
+  return r.size === 0 ? [] : te.has(e) ? [ot(t, r)] : lt(t, u);
 }
 function ct(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;
@@ -22440,7 +22463,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,11 +22477,11 @@ 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) {
@@ -22477,7 +22500,7 @@ export {
   bt as H,
   te as K,
   mt as R,
-  L as S,
+  P as S,
   m as U,
   X as a,
   ye as b,

package/dist/v2019C1/config/dialecte.config.d.ts

@@ -28,6 +28,7 @@ export declare const SCL_NAMESPACES: {
 export declare const SCL_DIALECTE_CONFIG: {
     readonly rootElementName: "SCL";
     readonly singletonElements: readonly ["Communication", "DataTypeTemplates", "Header", "History", "SCL"];
+    readonly transparentElements: readonly ["Private"];
     readonly elements: readonly ["AccessControl", "AccessPoint", "Address", "AllocationRole", "AllocationRoleRef", "AnalogueWiringParameters", "AnalogueWiringParametersRef", "Application", "ApplicationSclRef", "Association", "Authentication", "BDA", "Bay", "BayType", "BehaviorDescription", "BehaviorDescriptionRef", "BehaviorReference", "BinaryWiringParameters", "BinaryWiringParametersRef", "BitRate", "CheckoutID", "ClientLN", "ClientServices", "CommProt", "Communication", "CommunicationServiceSpecifications", "ConductingEquipment", "ConfDataSet", "ConfLNs", "ConfLdName", "ConfLogControl", "ConfReportControl", "ConfSG", "ConfSigRef", "ConnectedAP", "ConnectivityNode", "ControlRef", "ControllingLNode", "DA", "DAI", "DAS", "DAType", "DO", "DOI", "DOS", "DOType", "DataObjectDirectory", "DataSet", "DataSetDirectory", "DataTypeTemplates", "DynAssociation", "DynDataSet", "EnumType", "EnumVal", "EqFunction", "EqSubFunction", "ExtCtrl", "ExtRef", "FCDA", "FileHandling", "Function", "FunctionCatRef", "FunctionCategory", "FunctionCategoryRef", "FunctionRef", "FunctionRole", "FunctionRoleContent", "FunctionSclRef", "FunctionTemplate", "FunctionalSubVariant", "FunctionalVariant", "FunctionalVariantGroup", "FunctionalVariantRef", "GOOSE", "GOOSEMcSecurity", "GOOSESecurity", "GSE", "GSEControl", "GSEDir", "GSESettings", "GSSE", "GeneralEquipment", "GetCBValues", "GetDataObjectDefinition", "GetDataSetValue", "GetDirectory", "GooseParameters", "GooseParametersRef", "Header", "History", "Hitem", "IED", "IEDName", "IEDSourceFiles", "InputVar", "InputVarRef", "Inputs", "IssuerName", "KDC", "L2CommParameters", "L3IPv4CommParameters", "L3IPv6CommParameters", "LDevice", "LN", "LN0", "LNode", "LNodeDataRef", "LNodeInputRef", "LNodeInputs", "LNodeOutputRef", "LNodeOutputs", "LNodeSpecNaming", "LNodeType", "Label", "Labels", "Line", "Log", "LogControl", "LogParameters", "LogParametersRef", "LogSettings", "MaxTime", "McSecurity", "MinRequestedSCDFile", "MinRequestedSCDFiles", "MinTime", "MultiAPPerSubNet", "NeutralPoint", "OptFields", "OutputVar", "OutputVarRef", "Outputs", "P", "PhysConn", "PowerSystemRelation", "PowerSystemRelationRef", "PowerSystemRelations", "PowerTransformer", "Private", "Process", "ProcessEcho", "ProcessResource", "ProcessResourceRef", "ProcessResources", "Project", "ProjectProcessReference", "ProtNs", "Protocol", "ReadWrite", "RedProt", "ReportControl", "ReportParameters", "ReportParametersRef", "ReportSettings", "Resource", "RptEnabled", "SCL", "SCSM", "SDI", "SDO", "SDS", "SGEdit", "SMV", "SMVParameters", "SMVParametersRef", "SMVSecurity", "SMVSettings", "SMVsc", "SVMcSecurity", "SampledValueControl", "SamplesPerSec", "SclFileReference", "SecPerSamples", "Security", "Server", "ServerAt", "ServiceSpecifications", "Services", "SetDataSetValue", "SettingControl", "SettingGroups", "SignalRole", "SmpRate", "SmvOpts", "SourceFiles", "SourceRef", "SubCategory", "SubCheckoutID", "SubEquipment", "SubFunction", "SubFunctionTemplate", "SubNetwork", "Subject", "SubscriberLNode", "Substation", "SupSubscription", "TapChanger", "Terminal", "Text", "TimeSyncProt", "TimerActivatedControl", "TransformerWinding", "TrgOps", "Val", "ValueHandling", "Variable", "VariableApplyTo", "VariableRef", "Voltage", "VoltageLevel"];
     readonly namespaces: {
         readonly default: {

package/dist/v2019C1/config/dialecte.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dialecte.config.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/config/dialecte.config.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,aAAa;;;CAGN,CAAA;AAGpB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;CAaG,CAAA;AAEnC,eAAO,MAAM,cAAc;;;;;;;;;CAMjB,CAAA;AAEV,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaM,CAAA;AAEtC,MAAM,WAAW,MAAO,SAAQ,QAAQ,CAAC,OAAO,mBAAmB,CAAC;CAAG"}
+{"version":3,"file":"dialecte.config.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/config/dialecte.config.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,aAAa;;;CAGN,CAAA;AAGpB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;CAaG,CAAA;AAEnC,eAAO,MAAM,cAAc;;;;;;;;;CAMjB,CAAA;AAEV,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcM,CAAA;AAEtC,MAAM,WAAW,MAAO,SAAQ,QAAQ,CAAC,OAAO,mBAAmB,CAAC;CAAG"}

package/dist/v2019C1/extensions/reference/constants/path-extraction.d.ts

@@ -15,6 +15,10 @@ export type ExtractionStrategy = {
     type: 'attribute';
     attr: string;
     separator: '/' | '.';
+} | {
+    type: 'sourceRef';
+} | {
+    type: 'controlRef';
 };
 export declare const PATH_EXTRACTION_CONFIG: Record<string, ExtractionStrategy>;
 /**

package/dist/v2019C1/extensions/reference/constants/path-extraction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-extraction.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/reference/constants/path-extraction.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,kBAAkB,GAC3B;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,CAAA;AAE5D,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAiErE,CAAA;AAID;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,WAAW,CAAC,MAAM,CAa5D,CAAA"}
+{"version":3,"file":"path-extraction.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/reference/constants/path-extraction.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,kBAAkB,GAC3B;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAA;AAEzB,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAiErE,CAAA;AAID;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,WAAW,CAAC,MAAM,CAiB5D,CAAA"}

package/dist/v2019C1/extensions/reference/query/build/path-segment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-segment.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/reference/query/build/path-segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EACX,WAAW,EAEX,WAAW,EAEX,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAqClD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW,GAAG,IAAI,CAIvE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC7C,MAAM,EAAE,YAAY,CAAA;IACpB,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAA;CACjC,GAAG,WAAW,GAAG,IAAI,CAcrB;AAQD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAMnE"}
+{"version":3,"file":"path-segment.d.ts","sourceRoot":"","sources":["../../../../../../src/v2019C1/extensions/reference/query/build/path-segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EACX,WAAW,EAEX,WAAW,EAEX,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAyDlD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW,GAAG,IAAI,CAIvE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC7C,MAAM,EAAE,YAAY,CAAA;IACpB,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAA;CACjC,GAAG,WAAW,GAAG,IAAI,CAcrB;AAQD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAMnE"}

package/dist/v2019C1/index.js

@@ -1,5 +1,5 @@
-import { R as q, U as w, K as Z, D as J, r as _, a as x, H, S as R } from "../index-ChFpcq4k.js";
-import { b as Xt, c as Yt, d as Wt } from "../index-ChFpcq4k.js";
+import { R as q, U as w, K as Z, D as J, r as _, a as x, H, S as R } from "../index-uvKv9uth.js";
+import { b as Xt, c as Yt, d as Wt } from "../index-uvKv9uth.js";
 import { isChildOf as b, stripAttributes as tt } from "@dialecte/core/helpers";
 import { invariant as U } from "@dialecte/core/utils";
 import { createDialecteDocument as et, openDialecteDocument as nt, importXmlFiles as at, exportXmlFile as ot } from "@dialecte/core";

package/dist/v2019C1/test.js

@@ -1,6 +1,6 @@
 import { CUSTOM_RECORD_ID_ATTRIBUTE as R, CUSTOM_RECORD_ID_ATTRIBUTE_NAME as D } from "@dialecte/core/helpers";
 import { createTestRunner as r, createTestRecordFactory as n, createXmlAssertions as a, XMLNS_DEV_NAMESPACE as o, createTestDialecte as S } from "@dialecte/core/test";
-import { S as e, H as t } from "../index-ChFpcq4k.js";
+import { S as e, H as t } from "../index-uvKv9uth.js";
 const E = 'xmlns="http://www.iec.ch/61850/2003/SCL"', _ = 'xmlns:eIEC61850-6-100="http://www.iec.ch/61850/2019/SCL/6-100"', i = `${E} ${_} ${o}`, A = r(e, t);
 async function m(s) {
   const { xmlString: c } = s;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dialecte/scl",
-	"version": "0.1.19",
+	"version": "0.1.20",
 	"description": "Dialecte - SCL (Substation Configuration Language) sdk",
 	"license": "MIT",
 	"repository": {
@@ -47,7 +47,7 @@
 		"prepare": "husky"
 	},
 	"dependencies": {
-		"@dialecte/core": "0.1.21",
+		"@dialecte/core": "0.1.22",
 		"dexie": "4.2.0"
 	},
 	"devDependencies": {