@tricoteuses/tisseuse 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,63 +1,2551 @@
-function _(u, n) {
-  throw `Unexpected type ${u}: ${n}`;
+const vt = new Intl.DateTimeFormat("fr-FR", {
+  dateStyle: "long"
+});
+function Vi(e) {
+  return vt.format(new Date(e)).replace(/^1 /, "1er ");
 }
-const N = /^<\/?(!DOCTYPE|\?XML|[A-Z][A-Z0-9]*)/i;
-function H(u, n) {
-  return (t) => {
-    const s = [];
-    let e = t;
-    for (const i of n) {
-      const r = i(e);
-      (r.transformations !== void 0 || r.sourceMap.length !== 0) && (s.push(r), e = r.output);
+const mt = [
+  [],
+  ["un"],
+  ["du"],
+  // duo
+  ["ter"],
+  ["quater"],
+  ["quin"],
+  ["sex"],
+  ["sept"],
+  ["oct"],
+  // octo
+  ["nov"]
+  // novo
+], Ge = [
+  [],
+  ["decies"],
+  ["vicies", "vecies"],
+  ["tricies", "trecies"],
+  ["quadragies"],
+  ["quinquagies"],
+  ["sexagies"],
+  ["septuagies"],
+  ["octogies"],
+  ["nonagies"]
+], It = [
+  [],
+  ["semel"],
+  ["bis"],
+  ["ter"],
+  ["quater"],
+  ["quinquies"],
+  ["sexies"],
+  ["septies"],
+  ["octies"],
+  ["nonies", "novies"]
+], R = [
+  1e3,
+  "M",
+  900,
+  "CM",
+  500,
+  "D",
+  400,
+  "CD",
+  100,
+  "C",
+  90,
+  "XC",
+  50,
+  "L",
+  40,
+  "XL",
+  10,
+  "X",
+  9,
+  "IX",
+  5,
+  "V",
+  4,
+  "IV",
+  1,
+  "I"
+], de = [
+  "dix",
+  "onze",
+  "douze",
+  "treize",
+  "quatorze",
+  "quinze",
+  "seize",
+  "dix-sept",
+  "dix-huit",
+  "dix-neuf"
+], ht = [
+  "",
+  "dix",
+  "vingt",
+  "trente",
+  "quarante",
+  "cinquante",
+  "soixante",
+  "soixante-dix",
+  "quatre-vingt",
+  "quatre-vingt-dix"
+], ee = [
+  "",
+  "un",
+  "deux",
+  "trois",
+  "quatre",
+  "cinq",
+  "six",
+  "sept",
+  "huit",
+  "neuf"
+];
+function H(e) {
+  if (!(e < 0)) {
+    if (e === 0)
+      return "zéro";
+    if (e < 10)
+      return ee[e];
+    if (e < 20)
+      return de[e - 10];
+    if (e < 100) {
+      const t = Math.floor(e / 10), n = e % 10;
+      if (t === 7)
+        return `soixante-${de[n]}`;
+      if (t === 9)
+        return `quatre-vingt-${de[n]}`;
+      const a = ht[t];
+      return n === 0 ? a : n === 1 && t !== 8 ? `${a} et ${ee[n]}` : a + `-${ee[n]}`;
+    }
+    if (e < 1e3) {
+      const t = Math.floor(e / 100), n = e % 100;
+      let a = t === 1 ? "cent" : `${ee[t]} cents`;
+      return n === 0 ? a : (t > 1 && n > 0 && (a = a.slice(0, -1)), `${a} ${H(n)}`);
+    }
+    if (e < 1e6) {
+      const t = Math.floor(e / 1e3), n = e % 1e3, a = t === 1 ? "mille" : `${H(t)} mille`;
+      return n === 0 ? a : a + ` ${H(n)}`;
+    }
+    throw new Error("Number must be a less than one million.");
+  }
+}
+function* Wi(e) {
+  e === 1 && (yield "premier", yield "première", yield "unique", yield "Ier", yield "Ière", yield "1er", yield "1ère");
+  const t = H(e);
+  t !== void 0 && (yield t);
+  const n = Fe(e);
+  n !== void 0 && (yield n), yield e.toString();
+}
+function* Ji(e) {
+  if (!(e <= 0))
+    if (e < 10)
+      yield* It[e];
+    else if (e < 100) {
+      const t = Math.floor(e / 10), n = e % 10;
+      for (const a of Ge[t])
+        for (const o of mt[n])
+          yield `${o}${[2, 8, 9].includes(n) && a[0] !== "o" ? "o" : ""}${a}`;
+      if (t < 9 && [8, 9].includes(n)) {
+        const a = Ge[t + 1];
+        for (const o of a)
+          yield `${n === 8 ? "duo" : "un"}${o[0] === "o" ? "d" : "de"}${o}`;
+      }
+    } else
+      throw new Error("Number must be a less than 100.");
+}
+function* Yi(e) {
+  if (e === 1)
+    yield "premier", yield "première", yield "Ier", yield "Ière", yield "1er", yield "1ère";
+  else {
+    const t = Lt(e);
+    t !== void 0 && (yield t);
+    const n = Fe(e);
+    n !== void 0 && (yield `${n}e`, yield `${n}ème`), e > 0 && (yield `${e}e`, yield `${e}ème`), e === 2 && (yield "second", yield "seconde", yield "2nd", yield "2nde");
+  }
+}
+function ne(e) {
+  e = e.toUpperCase();
+  let t = 0, n = 0;
+  for (let a = 0; a < R.length; a += 2)
+    for (; e.substring(
+      t,
+      t + R[a + 1].length
+    ) === R[a + 1]; )
+      n += R[a], t += R[a + 1].length;
+  return n;
+}
+function Lt(e) {
+  if (e <= 0)
+    return;
+  if (e === 1)
+    return "premier";
+  const t = H(e);
+  if (t === void 0)
+    return;
+  const n = t.match(/(^| )([^ ]+)$/)[2];
+  return n === "un" ? t.slice(0, -2) + "unième" : n === "cinq" ? t.slice(0, -4) + "cinquième" : n === "neuf" ? t.slice(0, -3) + "euvième" : n.endsWith("e") ? t.slice(0, -1) + "ième" : t + "ième";
+}
+function Fe(e) {
+  if (e < 0)
+    return;
+  if (e === 0)
+    return "0I";
+  let t = "";
+  for (let n = 0; n < R.length; n += 2)
+    for (; e >= R[n]; )
+      t += R[n + 1], e -= R[n];
+  return t;
+}
+class Ct {
+  constructor(t, n = 0) {
+    this.input = t, this.offset = n;
+  }
+  currentArticle = void 0;
+  currentText = void 0;
+  length = 0;
+  usedInputs = void 0;
+  variables = {};
+  position() {
+    return {
+      start: this.offset,
+      stop: this.offset + this.length
+    };
+  }
+  remaining() {
+    return this.input.slice(this.offset);
+  }
+  text(t) {
+    return t === void 0 ? this.input.slice(this.offset, this.offset + this.length) : this.input.slice(t.start, t.stop);
+  }
+  textFromResults(t) {
+    return t === void 0 ? "" : Ue(t);
+  }
+}
+const r = (...e) => (t) => {
+  for (const n of e) {
+    const a = (Array.isArray(n) ? l(n, { exportVariables: !0 }) : n)(t);
+    if (a !== void 0)
+      return a;
+  }
+}, l = (e, {
+  exportVariables: t,
+  value: n
+} = {}) => (a) => {
+  const o = a.offset, s = a.variables;
+  a.variables = { ...s };
+  const u = [], f = [];
+  for (const c of e) {
+    const g = (Array.isArray(c) ? l(c, { exportVariables: t }) : c)(a);
+    if (g === void 0) {
+      a.length = 0, a.offset = o, a.usedInputs = void 0, a.variables = s;
+      return;
+    }
+    a.usedInputs !== void 0 && u.push(a.usedInputs), f.push(g);
+  }
+  a.length = a.offset - o, a.offset -= a.length, a.usedInputs = u.length === 0 ? void 0 : u;
+  let d;
+  if (n === void 0)
+    d = f;
+  else if (typeof n == "function") {
+    const c = n(f, a);
+    if (c === void 0) {
+      a.length = 0, a.offset = o, a.usedInputs = void 0, a.variables = s;
+      return;
+    }
+    d = c;
+  } else
+    d = n;
+  return a.offset += a.length, a.length = 0, t || (a.variables = s), d;
+}, O = (e, { value: t }) => (n) => {
+  const a = n.offset, o = n.variables;
+  n.variables = { ...o };
+  const s = (Array.isArray(e) ? l(e, { exportVariables: !0 }) : e)(n);
+  if (s !== void 0) {
+    if (n.length = n.offset - a, n.offset -= n.length, typeof t == "function") {
+      const u = t(s, n);
+      if (u === void 0) {
+        n.length = 0, n.offset = a, n.usedInputs = void 0, n.variables = o;
+        return;
+      }
+      return n.offset += n.length, n.length = 0, u;
+    }
+    return n.offset += n.length, n.length = 0, t;
+  }
+}, p = (e, {
+  default: t,
+  value: n
+}) => (a) => {
+  let o = (Array.isArray(e) ? l(e, { exportVariables: !0 }) : e)(a);
+  if (o === void 0)
+    o = typeof t == "function" ? t(a) : t;
+  else if (n !== void 0)
+    if (typeof n == "function") {
+      const s = n(o, a);
+      if (s === void 0) {
+        a.length = 0, a.usedInputs = void 0;
+        return;
+      }
+      o = s;
+    } else
+      o = n;
+  return o;
+}, Zi = (e, t) => (Array.isArray(t) ? l(t) : t)(new Ct(e)), i = (e, {
+  flags: t,
+  value: n
+} = {}) => (a) => {
+  const o = new RegExp(e, "gy" + (t ?? ""));
+  o.lastIndex = a.offset;
+  const s = o.exec(a.input);
+  if (s === null)
+    return;
+  a.length = s[0].length, a.usedInputs = s[0];
+  let u;
+  if (n === void 0)
+    u = s[0];
+  else if (typeof n == "function") {
+    const f = n(s, a);
+    if (f === void 0) {
+      a.length = 0, a.usedInputs = void 0;
+      return;
+    }
+    u = f;
+  } else
+    u = n;
+  return a.offset += a.length, a.length = 0, u;
+}, G = (e, {
+  max: t,
+  min: n,
+  separator: a,
+  value: o
+} = {}) => (s) => {
+  const u = s.offset, f = s.variables;
+  s.variables = { ...f };
+  const d = [], c = [];
+  let g = 0;
+  for (; t === void 0 || g < t; g++) {
+    const E = (g === 0 || a === void 0 ? Array.isArray(e) ? l(e) : e : l([a, e]))(s);
+    if (E === void 0)
+      break;
+    s.usedInputs !== void 0 && d.push(s.usedInputs), c.push(E);
+  }
+  if (n !== void 0 && g < n) {
+    s.length = 0, s.offset = u, s.usedInputs = void 0, s.variables = f;
+    return;
+  }
+  s.length = s.offset - u, s.offset -= s.length, s.usedInputs = d.length === 0 ? void 0 : d;
+  let m;
+  if (o === void 0)
+    m = c;
+  else if (typeof o == "function") {
+    const E = o(c, s);
+    if (E === void 0) {
+      s.length = 0, s.offset = u, s.usedInputs = void 0, s.variables = f;
+      return;
+    }
+    m = E;
+  } else
+    m = o;
+  return s.offset += s.length, s.length = 0, m;
+}, Ue = (e) => e.filter((t) => t !== null).map((t) => typeof t == "string" ? t : Ue(t)).join(""), b = (e, t, { value: n } = {}) => (a) => {
+  const o = a.offset, s = a.variables;
+  a.variables = { ...s };
+  const u = (Array.isArray(t) ? l(t, { exportVariables: !0 }) : t)(a);
+  if (u === void 0) {
+    delete a.variables[e];
+    return;
+  }
+  if (n === void 0)
+    return a.variables[e] = u, u;
+  if (a.length = a.offset - o, a.offset -= a.length, typeof n == "function") {
+    const f = n(u, a);
+    if (f === void 0) {
+      a.length = 0, a.offset = o, a.usedInputs = void 0, a.variables = s, delete a.variables[e];
+      return;
+    }
+    return a.offset += a.length, a.length = 0, a.variables[e] = f, f;
+  }
+  return a.offset += a.length, a.length = 0, a.variables[e] = n, n;
+}, ye = (e, {
+  value: t
+} = {}) => (n) => {
+  let a = e, o = n.offset;
+  const s = /([\-\/\d\p{Alphabetic}'°]+)($|[^\-\/\d\p{Alphabetic}°]+)/gvy;
+  s.lastIndex = n.offset;
+  const u = [];
+  let f;
+  for (; ; ) {
+    const g = s.exec(n.input);
+    if (g === null)
+      break;
+    let m = g[1];
+    if (m = /^[IVX]+$/g.test(m) ? ne(m).toString() : m.toLowerCase().replace(/^no$/, "n°"), m === "constitution" && g[1][0] !== "C")
+      break;
+    const E = a[m];
+    if (E === void 0)
+      break;
+    f = g[2], a = E, o = s.lastIndex, u.push(g[0]);
+  }
+  if (a.cid === void 0) {
+    n.length = 0, n.usedInputs = void 0;
+    return;
+  }
+  f && (o -= f.length, u[u.length - 1] = u[u.length - 1].slice(0, -f.length)), n.length = o - n.offset, n.usedInputs = u.length === 0 ? void 0 : u;
+  const d = { cid: a.cid };
+  let c;
+  if (t === void 0)
+    c = d;
+  else if (typeof t == "function") {
+    const g = t(d, n);
+    if (g === void 0) {
+      n.length = 0, n.usedInputs = void 0;
+      return;
+    }
+    c = g;
+  } else
+    c = t;
+  return n.offset = o, n.length = 0, c;
+};
+i(" ?' ?", { value: "'" });
+const T = i(" "), pe = i(" ?", { value: "" }), Ot = i("[a-z]"), Xt = i(String.raw`(?=$|\P{Alphabetic})`, {
+  flags: "iv"
+}), Be = i("n ?[°o] ?", { flags: "i", value: "n° " }), xe = i("-"), Gt = i(", ?", { value: ", " }), S = i("(, ?| )", { value: ", " }), yt = i(String.raw`^« ?([^»\n]+)`, {
+  flags: "dm",
+  value: (e) => {
+    let t = e.indices[1][1];
+    return e[1].endsWith(" ") && t--, {
+      position: {
+        start: e.indices[1][0],
+        stop: t
+      }
+    };
+  }
+}), xt = i(String.raw`« ?(.*?) ?»`, {
+  flags: "d",
+  value: (e, t) => ({
+    content: [
+      {
+        position: {
+          start: e.indices[1][0],
+          stop: e.indices[1][1]
+        }
+      }
+    ],
+    position: t.position(),
+    type: "citation"
+  })
+}), F = r(
+  l(
+    [
+      G(yt, {
+        separator: i(String.raw`»?\n`),
+        // Remove separators from results.
+        value: (e) => e.map(
+          (t, n) => n === 0 ? t : t[1]
+        )
+      }),
+      i("»")
+    ],
+    {
+      value: (e, t) => ({
+        content: e[0],
+        position: t.position(),
+        type: "citation"
+      })
+    }
+  ),
+  l([pe, xt], { value: (e) => e[1] })
+), je = r(
+  l(
+    [
+      S,
+      i("(après|avant) (le mot|les mots) :", { flags: "i" }),
+      F,
+      S,
+      r(
+        i("(il )?est (ajouté|inséré)e?", { flags: "i" }),
+        i("sont (ajouté|inséré)e?s", { flags: "i" })
+      )
+    ],
+    { value: { action: "CREATION", actionInContent: !0 } }
+  ),
+  l(
+    [
+      S,
+      r(
+        l([
+          p(
+            l([
+              i("(après|avant) la référence :", { flags: "i" }),
+              F,
+              S
+            ]),
+            { default: [] }
+          ),
+          r(
+            i("(il )?est (ajouté|inséré)e?", { flags: "i" }),
+            i("sont (ajouté|inséré)e?s", { flags: "i" })
+          )
+        ]),
+        i("est complétée?", { flags: "i" }),
+        i("sont complétée?s", { flags: "i" })
+      )
+    ],
+    { value: { action: "CREATION" } }
+  ),
+  l(
+    [
+      S,
+      r(
+        i("est ainsi rédigée?", { flags: "i" }),
+        i("est rédigée? (ainsi qu'il|comme) suit", { flags: "i" }),
+        i("sont ainsi rédigée?s", { flags: "i" }),
+        i("sont rédigée?s (ainsi qu'il|comme) suit", { flags: "i" })
+      )
+    ],
+    { value: { action: "CREATION_OU_MODIFICATION" } }
+  ),
+  l(
+    [
+      S,
+      r(
+        i("est ainsi (modifié|rétabli)e?", { flags: "i" }),
+        i("est (modifié|rétabli)e? (ainsi qu'il|comme) suit", {
+          flags: "i"
+        }),
+        i("est remplacée?", { flags: "i" }),
+        i("sont ainsi (modifié|rétabli)e?s", { flags: "i" }),
+        i("sont (modifié|rétabli)e?s (ainsi qu'il|comme) suit", {
+          flags: "i"
+        }),
+        i("sont remplacée?s", { flags: "i" })
+      )
+    ],
+    { value: { action: "MODIFICATION" } }
+  ),
+  l(
+    [
+      S,
+      r(
+        l([
+          r(
+            i("l'année", { flags: "i" }),
+            i("la (date|mention|référence)", { flags: "i" }),
+            i("le (montant|mot|taux)", { flags: "i" }),
+            i("le tableau intitulé", { flags: "i" }),
+            i("les mots", { flags: "i" })
+          ),
+          i(" ?:"),
+          F,
+          T,
+          r(
+            i("est ainsi modifiée?", { flags: "i" }),
+            i("est remplacée?", { flags: "i" }),
+            i("sont remplacée?s", { flags: "i" })
+          )
+        ]),
+        l([
+          i("les nombres", { flags: "i" }),
+          i(" ?:"),
+          G(F, {
+            min: 1,
+            separator: i("(,| et)", { flags: "i" })
+          }),
+          T,
+          i("sont respectivement remplacés", { flags: "i" })
+        ])
+      )
+    ],
+    { value: { action: "MODIFICATION", actionInContent: !0 } }
+  ),
+  l(
+    [
+      S,
+      r(
+        i("est supprimée la (mention|référence)", { flags: "i" }),
+        l([
+          i("la (mention|référence)", { flags: "i" }),
+          i(" ?:"),
+          F,
+          T,
+          i("est supprimée", { flags: "i" })
+        ]),
+        l([
+          i("les mots", { flags: "i" }),
+          i(" ?:"),
+          F,
+          T,
+          i("sont supprimés", { flags: "i" })
+        ]),
+        l([
+          i("les références", { flags: "i" }),
+          i(" ?:"),
+          F,
+          T,
+          i("sont supprimées", { flags: "i" })
+        ])
+      )
+    ],
+    { value: { action: "SUPPRESSION", actionInContent: !0 } }
+  ),
+  l([S, i("est (abrogé|supprimé)e?", { flags: "i" })], {
+    value: { action: "SUPPRESSION" }
+  })
+);
+function ae(e, t) {
+  throw `Unexpected type ${e}: ${t}`;
+}
+const Qi = [
+  ",",
+  "à",
+  "et",
+  "ou",
+  "sauf"
+], bt = [
+  "DIRECTIVE_EURO",
+  "REGLEMENTEUROPEEN"
+], St = [
+  "ARRETE",
+  "CIRCULAIRE",
+  "CODE",
+  "CONSTITUTION",
+  "DECRET",
+  "DECRET_LOI",
+  "LOI",
+  "LOI_CONSTIT",
+  "LOI_ORGANIQUE",
+  "ORDONNANCE"
+], Dt = ["CONVENTION"], At = [
+  "partie",
+  "livre",
+  "titre",
+  "sous-titre",
+  "chapitre",
+  "section",
+  "sous-section",
+  "paragraphe",
+  "sous-paragraphe",
+  "sous-sous-paragraphe"
+], Ki = [
+  ...bt,
+  ...St,
+  ...Dt
+], Nt = ["item", "alinéa", "phrase"], en = [
+  "après",
+  "avant",
+  "dessous",
+  "dessus"
+];
+function Rt(e) {
+  switch (e.type) {
+    case "alinéa":
+    case "article":
+    case "chapitre":
+    case "incomplete-header":
+    case "livre":
+    case "paragraphe":
+    case "item":
+    case "partie":
+    case "phrase":
+    case "section":
+    case "sous-paragraphe":
+    case "sous-section":
+    case "sous-sous-paragraphe":
+    case "sous-titre":
+    case "texte":
+    case "titre":
+      return !0;
+    case "bounded-interval":
+    case "counted-interval":
+    case "enumeration":
+    case "exclusion":
+    case "parent-enfant":
+    case "reference_et_action":
+      return !1;
+    default:
+      ae("isTextAstAtomicReference", e);
+  }
+}
+function tn(e) {
+  return At.includes(e.type);
+}
+function nn(e) {
+  return Nt.includes(e.type);
+}
+const be = {
+  ",": 1,
+  à: 3,
+  et: 1,
+  ou: 1,
+  sauf: 2
+}, D = (e, t) => {
+  if (!Rt(e) && e.type !== "parent-enfant")
+    switch (e.type) {
+      case "bounded-interval":
+        return {
+          ...e,
+          first: D(e.first, t),
+          last: D(e.last, t)
+          // Don't update position,
+        };
+      case "counted-interval":
+        return {
+          ...e,
+          first: D(e.first, t)
+          // Don't update position,
+        };
+      case "enumeration":
+        return {
+          ...e,
+          left: D(e.left, t),
+          right: D(e.right, t)
+          // Don't update position,
+        };
+      case "exclusion":
+        return {
+          ...e,
+          left: D(e.left, t)
+          // Don't add child to right, because it is excluded.
+          // Don't update position,
+        };
+      case "reference_et_action":
+        return {
+          ...e,
+          reference: D(e.reference, t)
+          // Don't update position,
+        };
+      default:
+        ae("Neither AtomicReference nor ParentChild", e);
     }
-    return { input: t, output: e, title: u, transformations: s };
+  if (e.type === "parent-enfant") {
+    if (e.parent.type === "texte")
+      for (const n of y(t))
+        n.type === "article" && delete n.implicitText;
+    return {
+      ...e,
+      child: D(e.child, t),
+      position: {
+        start: t.position.start,
+        stop: e.position.stop
+      }
+    };
+  }
+  if (e.type === "texte")
+    for (const n of y(t))
+      n.type === "article" && delete n.implicitText;
+  return {
+    child: t,
+    parent: e,
+    position: {
+      start: t.position.start,
+      stop: e.position.stop
+    },
+    type: "parent-enfant"
   };
+}, $ = (e, t, n) => {
+  for (; t.length > 0; )
+    e = ke(
+      e,
+      t,
+      n,
+      0
+    );
+  return {
+    ...e,
+    position: n
+  };
+}, ke = (e, t, n, a) => {
+  if (t.length > a) {
+    const [o, s] = t[a], u = be[o], f = t[a + 1]?.[0], d = f === void 0 ? 0 : be[f];
+    if (u < d)
+      t[a][1] = ke(
+        s,
+        t,
+        {
+          start: s.position.start,
+          stop: n.stop
+        },
+        a + 1
+      );
+    else {
+      if (o === "sauf") {
+        let c;
+        for (let g = e; g.type === "enumeration"; g = g.right)
+          c = g;
+        c === void 0 ? e = {
+          left: e,
+          position: {
+            start: e.position.start,
+            stop: s.position.stop
+          },
+          right: s,
+          type: "exclusion"
+        } : c.right = {
+          left: c.right,
+          position: {
+            start: c.right.position.start,
+            stop: s.position.stop
+          },
+          right: s,
+          type: "exclusion"
+        };
+      } else if (e.type !== "texte" && s.type === "parent-enfant" && s.parent.type === "texte") {
+        for (const c of y(e))
+          c.type === "article" && delete c.implicitText;
+        e = {
+          ...s,
+          child: o === "à" ? {
+            first: e,
+            last: s.child,
+            position: {
+              start: e.position.start,
+              stop: s.child.position.stop
+            },
+            type: "bounded-interval"
+          } : {
+            coordinator: o,
+            left: e,
+            right: s.child,
+            position: {
+              start: e.position.start,
+              stop: s.child.position.stop
+            },
+            type: "enumeration"
+          },
+          position: {
+            start: e.position.start,
+            stop: s.position.stop
+          }
+        };
+      } else if (e.type === "parent-enfant" && e.parent.type === "texte" && s.type !== "texte") {
+        for (const c of y(s))
+          c.type === "article" && delete c.implicitText;
+        e = {
+          ...e,
+          child: o === "à" ? {
+            first: e.child,
+            last: s,
+            position: {
+              start: e.child.position.start,
+              stop: s.position.stop
+            },
+            type: "bounded-interval"
+          } : {
+            coordinator: o,
+            left: e.child,
+            right: s,
+            position: {
+              start: e.child.position.start,
+              stop: s.position.stop
+            },
+            type: "enumeration"
+          },
+          position: {
+            start: e.position.start,
+            stop: s.position.stop
+          }
+        };
+      } else
+        e = o === "à" ? {
+          first: e,
+          last: s,
+          position: {
+            start: e.position.start,
+            stop: s.position.stop
+          },
+          type: "bounded-interval"
+        } : {
+          coordinator: o,
+          left: e,
+          position: {
+            start: e.position.start,
+            stop: s.position.stop
+          },
+          right: s,
+          type: "enumeration"
+        };
+      t.splice(a, 1);
+    }
+  }
+  return e;
+}, se = (e, t, n) => {
+  for (const a of t) {
+    if (a.type === "texte")
+      for (const o of y(e))
+        o.type === "article" && delete o.implicitText;
+    e = {
+      child: e,
+      parent: a,
+      position: {
+        start: e.position.start,
+        stop: a.position.stop
+      },
+      type: "parent-enfant"
+    };
+  }
+  return e.position = n, e;
+};
+function* C(e) {
+  switch (e.type) {
+    case "bounded-interval": {
+      yield* C(e.first), yield* C(e.last);
+      break;
+    }
+    case "counted-interval": {
+      yield* C(e.first);
+      break;
+    }
+    case "enumeration":
+    case "exclusion": {
+      yield* C(e.left), yield* C(e.right);
+      break;
+    }
+    case "parent-enfant": {
+      yield e.parent;
+      break;
+    }
+    case "reference_et_action": {
+      yield* C(e.reference);
+      break;
+    }
+    default:
+      yield e;
+  }
 }
-function* $(u) {
-  if (u.transformations === void 0)
-    yield u;
+function* B(e) {
+  switch (e.type) {
+    case "bounded-interval": {
+      yield* B(e.first), yield* B(e.last);
+      break;
+    }
+    case "counted-interval": {
+      yield* B(e.first);
+      break;
+    }
+    case "enumeration":
+    case "exclusion": {
+      yield* B(e.left), yield* B(e.right);
+      break;
+    }
+    case "reference_et_action": {
+      yield* B(e.reference);
+      break;
+    }
+    default:
+      yield e;
+  }
+}
+function* y(e) {
+  switch (e.type) {
+    case "bounded-interval": {
+      yield* y(e.first), yield* y(e.last);
+      break;
+    }
+    case "counted-interval": {
+      yield* y(e.first);
+      break;
+    }
+    case "enumeration":
+    case "exclusion": {
+      yield* y(e.left), yield* y(e.right);
+      break;
+    }
+    case "parent-enfant": {
+      yield* y(e.parent), yield* y(e.child);
+      break;
+    }
+    case "reference_et_action": {
+      yield* y(e.reference);
+      break;
+    }
+    default:
+      yield e;
+  }
+}
+function* w(e) {
+  switch (yield e, e.type) {
+    case "bounded-interval": {
+      yield* w(e.first), yield* w(e.last);
+      break;
+    }
+    case "counted-interval": {
+      yield* w(e.first);
+      break;
+    }
+    case "enumeration":
+    case "exclusion": {
+      yield* w(e.left), yield* w(e.right);
+      break;
+    }
+    case "parent-enfant": {
+      yield* w(e.parent), yield* w(e.child);
+      break;
+    }
+    case "reference_et_action": {
+      yield* w(e.reference);
+      break;
+    }
+  }
+}
+const oe = i("(èm)?e"), Pt = r(
+  i("1er", {
+    value: (e, t) => ({
+      position: t.position(),
+      text: t.text(),
+      value: 1
+    })
+  }),
+  i("unique", {
+    value: (e, t) => ({
+      position: t.position(),
+      text: t.text(),
+      value: 1
+    })
+  }),
+  l([i(String.raw`\d+`), p(oe, { default: "" })], {
+    value: (e, t) => ({
+      position: t.position(),
+      text: t.text(),
+      value: parseInt(e[0])
+    })
+  })
+), fe = i(String.raw`\d+`, {
+  value: (e) => parseInt(e[0])
+}), qt = r(
+  i("1er", { value: 1 }),
+  l([i(String.raw`\d+`), oe], {
+    value: (e) => parseInt(e[0])
+  })
+), wt = i(String.raw`[IVXLCDM]+`, {
+  value: (e) => ne(e[0])
+}), an = r(
+  i("Ier", { value: 1 }),
+  l([i(String.raw`[IVXLCDM]+`), oe], {
+    value: (e) => ne(e[0])
+  })
+), $t = r(
+  i("0I", {
+    value: (e, t) => ({
+      position: t.position(),
+      text: t.text(),
+      value: 0
+    })
+  }),
+  i("Ier", {
+    value: (e, t) => ({
+      position: t.position(),
+      text: t.text(),
+      value: 1
+    })
+  }),
+  l([i(String.raw`[IVXLCDM]+`), p(oe, { default: "" })], {
+    value: (e, t) => ({
+      position: t.position(),
+      text: t.text(),
+      value: ne(e[0])
+    })
+  })
+), Mt = r(
+  i("dix", { flags: "i", value: 10 }),
+  i("onze?", { flags: "i", value: 11 }),
+  i("douze?", { flags: "i", value: 12 }),
+  i("treize?", { flags: "i", value: 13 }),
+  i("quatorze?", { flags: "i", value: 14 }),
+  i("quinze?", { flags: "i", value: 15 }),
+  i("seize?", { flags: "i", value: 16 })
+), _t = r(
+  i("vingt", { flags: "i", value: 20 }),
+  i("trente?", { flags: "i", value: 30 }),
+  i("quarante?", { flags: "i", value: 40 }),
+  i("cinquante?", { flags: "i", value: 50 }),
+  i("soixante?", { flags: "i", value: 60 }),
+  i("septante?", { flags: "i", value: 70 }),
+  i("quatre-vingt", { flags: "i", value: 80 }),
+  i("huitante?", { flags: "i", value: 80 }),
+  i("octante?", { flags: "i", value: 80 }),
+  i("nonante?", { flags: "i", value: 90 })
+), Se = r(
+  i("une?", { flags: "i", value: 1 }),
+  i("deux", { flags: "i", value: 2 }),
+  i("trois", { flags: "i", value: 3 }),
+  i("quatre?", { flags: "i", value: 4 }),
+  i("cinqu?", { flags: "i", value: 5 }),
+  i("six", { flags: "i", value: 6 }),
+  i("sept", { flags: "i", value: 7 }),
+  i("huit", { flags: "i", value: 8 }),
+  i("neu[fv]", { flags: "i", value: 9 })
+), ze = l(
+  [
+    b(
+      "centaines",
+      p(
+        [
+          b(
+            "centaine",
+            p([Se, xe], {
+              default: 0,
+              value: (e) => e[0]
+            })
+          ),
+          i("cent-", { flags: "i", value: 1 })
+        ],
+        {
+          default: 0,
+          value: (e, { variables: t }) => 100 * t.centaine
+        }
+      )
+    ),
+    b(
+      "dizaines",
+      p(_t, { default: 0 })
+    ),
+    p(i("-(et-)?", { flags: "i" }), { default: "" }),
+    b("dix", p(Mt, { default: 0 })),
+    p(xe, { default: "" }),
+    b("unite", p(Se, { default: 0 }))
+  ],
+  {
+    value: (e, { variables: t }) => t.centaines + t.dizaines + t.dix + t.unite
+  }
+), He = r(
+  i("premi(er|ère)", { flags: "i", value: 1 }),
+  i("seconde?", { flags: "i", value: 2 }),
+  l([ze, i("ième", { flags: "i" })], {
+    value: (e) => e[0]
+  })
+), Ft = r(
+  qt,
+  He
+), le = O(
+  r(
+    // Mustt be first:
+    i("quinquagies", { flags: "i", value: 50 }),
+    i("sexagies", { flags: "i", value: 60 }),
+    i("septuagies", { flags: "i", value: 70 }),
+    i("octogies", { flags: "i", value: 80 }),
+    l(
+      [
+        b(
+          "unites",
+          p(
+            r(
+              i("unde?", { flags: "i", value: -1 }),
+              i("duode?", { flags: "i", value: -2 }),
+              i("un", { flags: "i", value: 1 }),
+              i("duo", { flags: "i", value: 2 }),
+              i("ter", { flags: "i", value: 3 }),
+              i("quater", { flags: "i", value: 4 }),
+              i("quin", { flags: "i", value: 5 }),
+              i("sept", { flags: "i", value: 7 }),
+              i("sex?", { flags: "i", value: 6 }),
+              i("octo", { flags: "i", value: 8 }),
+              i("novo", { flags: "i", value: 9 })
+            ),
+            { default: 0 }
+          )
+        ),
+        b(
+          "dizaines",
+          r(
+            i("decies", { flags: "i", value: 10 }),
+            i("v[ei]cies", { flags: "i", value: 20 }),
+            i("tr[ei]cies", { flags: "i", value: 30 }),
+            i("quadragies", { flags: "i", value: 40 }),
+            i("quinquagies", { flags: "i", value: 50 }),
+            i("sexagies", { flags: "i", value: 60 }),
+            i("septuagies", { flags: "i", value: 70 }),
+            i("o?ctogies", { flags: "i", value: 80 }),
+            i("nonagies", { flags: "i", value: 90 })
+          )
+        )
+      ],
+      {
+        value: (e, { variables: t }) => t.dizaines + t.unites
+      }
+    ),
+    // Must be last:
+    i("semel", { flags: "i", value: 1 }),
+    i("bis", { flags: "i", value: 2 }),
+    i("ter", { flags: "i", value: 3 }),
+    i("quater", { flags: "i", value: 4 }),
+    i("quinquies", { flags: "i", value: 5 }),
+    i("sexies", { flags: "i", value: 6 }),
+    i("septies", { flags: "i", value: 7 }),
+    i("octies", { flags: "i", value: 8 }),
+    i("no[nv]ies", { flags: "i", value: 9 }),
+    i("undecies", { flags: "i", value: 11 }),
+    i("duodecies", { flags: "i", value: 12 })
+  ),
+  {
+    value: (e, t) => ({
+      position: t.position(),
+      text: t.text().toLowerCase(),
+      value: e
+    })
+  }
+), Ve = i("(aux|des|les)( |(?=dite?s ))", {
+  flags: "i"
+}), We = r(
+  i("(au|du|le)( |(?=dit ))", { flags: "i" }),
+  i("([àa] )?la( |(?=dite ))", { flags: "i" }),
+  i("([àa] )?l'", { flags: "i" })
+), Je = l(
+  [
+    r(
+      i(" de (?=ce(tte)?s )", { flags: "i" }),
+      i(" des( |(?=dite?s ))", { flags: "i" })
+    )
+  ],
+  { value: "des" }
+), re = O(
+  r(
+    i(" de (?=ce(tte|t)? )", { flags: "i" }),
+    i(" de l'", { flags: "i" }),
+    i(" de la( |(?=dite ))", { flags: "i" }),
+    i(" du( |(?=dit ))", { flags: "i" })
+  ),
+  { value: "de" }
+), me = i("dite?s ", { flags: "i", value: !0 }), ue = i("dite? ", { flags: "i", value: !0 }), W = r(
+  i("derni(er|ère)s", {
+    flags: "i",
+    value: (e, t) => ({
+      index: -1,
+      num: t.text()
+    })
+  }),
+  i("mêmes", {
+    flags: "i",
+    value: { relative: 0 }
+  }),
+  i("premi(er|ère)s", {
+    flags: "i",
+    value: (e, t) => ({
+      index: 1,
+      num: t.text()
+    })
+  }),
+  i("présente?s", {
+    flags: "i",
+    value: { relative: 0 }
+  }),
+  i("suivante?s", {
+    flags: "i",
+    value: { relative: "+∞" }
+  })
+), J = r(
+  i("antépénultième", {
+    flags: "i",
+    value: (e, t) => ({
+      index: -3,
+      num: t.text()
+    })
+  }),
+  i("avant-derni(er|ère)", {
+    flags: "i",
+    value: (e, t) => ({
+      index: -2,
+      num: t.text()
+    })
+  }),
+  i("derni(er|ère)", {
+    flags: "i",
+    value: (e, t) => ({
+      index: -1,
+      num: t.text()
+    })
+  }),
+  i("même", {
+    flags: "i",
+    value: { relative: 0 }
+  }),
+  i("pénultième", {
+    flags: "i",
+    value: (e, t) => ({
+      index: -2,
+      num: t.text()
+    })
+  }),
+  i("précédente?", {
+    flags: "i",
+    value: { relative: -1 }
+  }),
+  i("premi(er|ère)", {
+    flags: "i",
+    value: (e, t) => ({
+      index: 1,
+      num: t.text()
+    })
+  }),
+  i("présente?", {
+    flags: "i",
+    value: { relative: 0 }
+  }),
+  i("suivante?", {
+    flags: "i",
+    value: { relative: 1 }
+  })
+), Ie = i("ci ?- ?(après|avant|dessous|dessus)", {
+  flags: "i",
+  value: (e) => `ci-${e[1]}`
+}), ge = l([T, Ie], {
+  value: (e) => e[1]
+}), De = i(" précitée?", {
+  flags: "i"
+}), Ye = r(
+  Ie,
+  W
+), he = l(
+  [
+    p(
+      i("ces ", {
+        flags: "i"
+      }),
+      { default: "" }
+    ),
+    W
+  ],
+  { value: (e) => e[1] }
+), Ut = r(
+  Ie,
+  J
+), Le = l(
+  [
+    p(
+      i("ce(tte|t)? ", {
+        flags: "i"
+      }),
+      { default: "" }
+    ),
+    J
+  ],
+  { value: (e) => e[1] }
+), M = r(
+  l(
+    [
+      T,
+      b(
+        "etOu",
+        r(
+          i("et", { flags: "i" }),
+          i("ou", { flags: "i" })
+        )
+      ),
+      T
+    ],
+    { value: (e, { variables: t }) => t.etOu }
+  ),
+  l(
+    [
+      Gt,
+      p(
+        [
+          b(
+            "etOu",
+            r(
+              i("et", { flags: "i" }),
+              i("ou", { flags: "i" })
+            )
+          ),
+          T
+        ],
+        { default: "" }
+      )
+    ],
+    { value: (e, { variables: t }) => t.etOu ?? "," }
+  )
+), Bt = l(
+  [S, i("à l'exception ", { flags: "i" })],
+  { value: "sauf" }
+), Y = i(" à ", { flags: "i", value: "à" }), Ze = r(
+  i("alinéa", { flags: "i", value: "alinéa" }),
+  i("phrase", { flags: "i", value: "phrase" })
+), jt = l(
+  [Ze, i("s", { flags: "i" })],
+  { value: (e) => e[0] }
+), kt = l(
+  [
+    r(
+      O(wt, {
+        value: (e, t) => ({
+          position: t.position(),
+          text: t.text(),
+          value: e
+        })
+      }),
+      O(Ot, {
+        value: (e, t) => ({
+          position: t.position(),
+          text: e,
+          value: e.charCodeAt(0) - 97 + 1
+        })
+      }),
+      l([fe, i("[°o]?", { flags: "i" })], {
+        value: (e, t) => ({
+          position: t.position(),
+          text: t.text(),
+          value: e[0]
+        })
+      })
+    ),
+    p([T, le], { default: null }),
+    Xt
+  ],
+  {
+    value: (e, t) => {
+      const n = e[0], a = e[1]?.[1];
+      return {
+        index: n.value + (a === void 0 ? 0 : a.value / 1e3),
+        num: `${n.text}${a === void 0 ? "" : ` ${a.text}`}`,
+        position: t.position(),
+        type: "item"
+      };
+    }
+  }
+), Qe = l(
+  [
+    r(
+      O(He, {
+        value: (e) => ({ index: e })
+      }),
+      O(J, {
+        value: (e) => e
+      })
+    ),
+    T,
+    Ze
+  ],
+  {
+    value: (e, t) => ({
+      ...e[0],
+      position: t.position(),
+      type: e[2]
+    })
+  }
+), te = r(Qe, kt), j = l(
+  [
+    ze,
+    T,
+    O(W, {
+      value: (e) => e
+    }),
+    T,
+    jt
+  ],
+  {
+    value: (e, t) => ({
+      count: e[0],
+      first: {
+        ...e[2],
+        type: e[4]
+      },
+      position: t.position(),
+      type: "counted-interval"
+    })
+  }
+), zt = l(
+  [
+    j,
+    G([
+      r(M, Y),
+      r(Qe, j)
+    ])
+  ],
+  {
+    value: (e, t) => $(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), Ce = l(
+  [
+    r(te, j),
+    G([
+      r(M, Y),
+      r(te, j)
+    ])
+  ],
+  {
+    value: (e, t) => $(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), Ht = l(
+  [
+    r(te, j),
+    G(
+      [
+        r(M, Y),
+        r(te, j)
+      ],
+      { min: 1 }
+    )
+  ],
+  {
+    value: (e, t) => $(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), Ke = r(
+  zt,
+  Ht
+), et = l(
+  [
+    T,
+    i(String.raw`\(`),
+    pe,
+    Ce,
+    pe,
+    i(String.raw`\)`)
+  ],
+  { value: (e) => e[3] }
+), tt = r(
+  l([re, Ce], { value: (e) => e[1] }),
+  l([Je, Ke], { value: (e) => e[1] }),
+  et
+), it = l(
+  [
+    p(ue, { default: null }),
+    Ce,
+    G(tt)
+  ],
+  {
+    value: (e, t) => se(
+      e[1],
+      e[2],
+      t.position()
+    )
+  }
+), nt = l(
+  [
+    p(me, { default: null }),
+    p(
+      l([he, T], {
+        value: (e) => e[0]
+      }),
+      { default: null }
+    ),
+    Ke,
+    G(tt)
+  ],
+  {
+    value: (e, t) => se(
+      e[2],
+      e[3],
+      t.position()
+    )
+  }
+), at = l([We, it], {
+  value: (e, t) => ({
+    ...e[1],
+    position: t.position()
+  })
+}), st = l([Ve, nt], {
+  value: (e, t) => ({
+    ...e[1],
+    position: t.position()
+  })
+}), Vt = l(
+  [
+    nt,
+    G([M, r(st, at)])
+  ],
+  {
+    value: (e, t) => $(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), Wt = l(
+  [
+    it,
+    G([M, r(st, at)])
+  ],
+  {
+    value: (e, t) => $(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), ot = r(
+  i("annexe", { flags: "i", value: "annexe" }),
+  i("exécution", { flags: "i", value: "exécution" }),
+  i("liminaire", { flags: "i", value: "liminaire" }),
+  i("préambule", { flags: "i", value: "préambule" }),
+  i("préliminaire", { flags: "i", value: "préliminaire" }),
+  i("unique", { flags: "i", value: "unique" })
+), lt = l(
+  [
+    i(String.raw`\*?\*?`),
+    p(
+      [
+        r(
+          [i(String.raw`L\.?O`, { value: "LO" }), i(String.raw`\*?`)],
+          i(String.raw`([ARDL]|LO)\*?`)
+        ),
+        i(String.raw`\*?\*?`),
+        i(String.raw`\.?\ ?`, { value: "" })
+      ],
+      { default: "" }
+    )
+  ],
+  { value: (e, t) => t.textFromResults(e) }
+), Jt = r(
+  l(
+    [
+      lt,
+      i(String.raw`\d+`),
+      p(i("(ème|e?r?)", { value: "" }), { default: "" }),
+      G([
+        r(i(" ?- ?"), i(String.raw` ?\.`), T),
+        r(
+          [
+            i(String.raw`[\dA-Z]+`),
+            p(i("(ème|e?r?)", { value: "" }), { default: "" })
+          ],
+          O(le, {
+            value: (e) => e.text
+          })
+        )
+      ])
+    ],
+    { value: (e, t) => t.textFromResults(e) }
+  ),
+  ot
+), Yt = r(
+  l(
+    [
+      lt,
+      i(String.raw`\d+`),
+      p(i("(ème|e?r?)", { value: "" }), { default: "" }),
+      G([
+        r(i("-"), i(String.raw` ?\.`), T),
+        r(
+          [
+            i(String.raw`[\dA-Z]+`),
+            p(i("(ème|e?r?)", { value: "" }), { default: "" })
+          ],
+          O(le, {
+            value: (e) => e.text
+          })
+        )
+      ])
+    ],
+    { value: (e, t) => t.textFromResults(e) }
+  ),
+  ot
+), sn = l(
+  [
+    l(
+      [i(String.raw`^art\. `, { flags: "im" }), Yt],
+      {
+        value: (e, t) => ({
+          definition: !0,
+          num: e[1],
+          position: t.position(),
+          type: "article"
+        })
+      }
+    ),
+    i(String.raw`\.? ?- ?`)
+  ],
+  {
+    value: (e) => e[0]
+  }
+), ie = r(
+  l(
+    [
+      l([Jt, p(ge, { default: null })], {
+        value: (e, t) => ({
+          ...e[1] ? { localizationAdverb: e[1] } : {},
+          num: e[0],
+          position: t.position(),
+          type: "article"
+        })
+      }),
+      p(et, { default: null })
+    ],
+    {
+      value: (e, t) => {
+        const n = e[0], a = e[1];
+        return a === null ? n : {
+          child: a,
+          parent: n,
+          position: t.position(),
+          type: "parent-enfant"
+        };
+      }
+    }
+  ),
+  O(J, {
+    value: (e, t) => ({
+      ...e,
+      position: t.position(),
+      type: "article"
+    })
+  })
+), Zt = O(W, {
+  value: (e, t) => ({
+    ...e,
+    position: t.position(),
+    type: "article"
+  })
+}), Qt = l(
+  [
+    ie,
+    G(
+      [
+        r(M, Y),
+        r(Zt, ie)
+      ],
+      { min: 1 }
+    )
+  ],
+  {
+    value: (e, t) => $(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), Ae = r(
+  Qt,
+  O(Ye, {
+    value: (e, t) => ({
+      ...e,
+      position: t.position(),
+      type: "article"
+    })
+  })
+), Kt = r(
+  l(
+    [
+      he,
+      T,
+      i("articles", { flags: "i" }),
+      p([T, Ae], { default: [] })
+    ],
+    {
+      value: (e, t) => {
+        const n = e[3][1] ?? {
+          position: t.position(),
+          type: "article"
+        };
+        for (const a of C(n))
+          a.type === "incomplete-header" && (a.type = "article"), a.index === void 0 && a.relative === void 0 && Object.assign(a, e[0]);
+        return { ...n, position: t.position() };
+      }
+    }
+  ),
+  l([i("articles", { flags: "i" }), T, Ae], {
+    value: (e, t) => ({
+      ...e[2],
+      position: t.position()
+    })
+  })
+), ei = l(
+  [p(me, { default: !1 }), Kt],
+  {
+    value: (e, t) => {
+      const n = e[1];
+      if (e[0])
+        for (const a of C(
+          n
+        ))
+          a.ofTheSaid = !0;
+      if (t.currentText !== void 0)
+        for (const a of C(
+          n
+        ))
+          a.implicitText === void 0 && (a.implicitText = t.currentText);
+      return delete t.currentArticle, {
+        ...n,
+        position: t.position()
+      };
+    }
+  }
+), ti = r(
+  l(
+    [
+      Le,
+      T,
+      i("article", { flags: "i" }),
+      p([T, ie], { default: [] })
+    ],
+    {
+      value: (e, t) => {
+        const n = e[3][1] ?? {
+          position: t.position(),
+          type: "article"
+        };
+        for (const a of C(n))
+          a.type === "incomplete-header" && (a.type = "article"), a.index === void 0 && a.relative === void 0 && Object.assign(a, e[0]);
+        return { ...n, position: t.position() };
+      }
+    }
+  ),
+  l([i("article", { flags: "i" }), T, ie], {
+    value: (e, t) => ({
+      ...e[2],
+      position: t.position()
+    })
+  })
+), ii = l(
+  [p(ue, { default: null }), ti],
+  {
+    value: (e, t) => {
+      const n = e[1];
+      if (e[0])
+        for (const o of C(
+          n
+        ))
+          o.ofTheSaid = !0;
+      if (t.currentText !== void 0)
+        for (const o of C(
+          n
+        ))
+          o.implicitText === void 0 && (o.implicitText = t.currentText);
+      const a = {
+        ...n,
+        position: t.position()
+      };
+      return t.currentArticle = a.type === "parent-enfant" ? a.parent : a, a;
+    }
+  }
+), ni = i(String.raw`[12]\d{3}`), ai = r(
+  i("1er", { flags: "i", value: "01" }),
+  i(String.raw`([12]\d|3[01])`, { value: (e) => e[0] }),
+  i(String.raw`\d`, { value: (e) => "0" + e[0] })
+), si = r(
+  i("janvier", { flags: "i", value: "01" }),
+  i("février", { flags: "i", value: "02" }),
+  i("mars", { flags: "i", value: "03" }),
+  i("avril", { flags: "i", value: "04" }),
+  i("mai", { flags: "i", value: "05" }),
+  i("juin", { flags: "i", value: "06" }),
+  i("juillet", { flags: "i", value: "07" }),
+  i("août", { flags: "i", value: "08" }),
+  i("septembre", { flags: "i", value: "09" }),
+  i("octobre", { flags: "i", value: "10" }),
+  i("novembre", { flags: "i", value: "11" }),
+  i("décembre", { flags: "i", value: "12" })
+), oi = l(
+  [
+    b("jour", ai),
+    T,
+    b("mois", si),
+    T,
+    b("annee", ni)
+  ],
+  {
+    value: (e, { variables: t }) => `${t.annee}-${t.mois}-${t.jour}`
+  }
+), Oe = l([i("du ", { flags: "i" }), oi], {
+  value: (e) => e[1]
+}), rt = l([T, Oe], {
+  value: (e) => e[1]
+}), V = r(
+  i("chapitre", { flags: "i", value: "chapitre" }),
+  i("livre(?! des procédures fiscales)", { flags: "i", value: "livre" }),
+  i("paragraphe", { flags: "i", value: "paragraphe" }),
+  i("partie", { flags: "i", value: "partie" }),
+  i("section", { flags: "i", value: "section" }),
+  i("sous-paragraphe", { flags: "i", value: "sous-paragraphe" }),
+  i("sous-section", { flags: "i", value: "sous-section" }),
+  i("sous-sous-paragraphe", { flags: "i", value: "sous-sous-paragraphe" }),
+  i("sous-titre", { flags: "i", value: "sous-titre" }),
+  i("titre", { flags: "i", value: "titre" })
+), Ne = l(
+  [V, i("s", { flags: "i" })],
+  { value: (e) => e[0] }
+), li = r(
+  i("arrêtés", { flags: "i" }),
+  i("législative", { flags: "i" }),
+  l(
+    [
+      i("réglementaire( ancienne)? ", { flags: "i" }),
+      p(
+        [
+          i(" [-:] ", { flags: "i" }),
+          r(i("arrêtés", { flags: "i" }), [
+            i("décrets", { flags: "i" }),
+            r(
+              i(" en Conseil d'[ÉE]tat", {
+                flags: "i",
+                value: " en Conseil d'État"
+              }),
+              i(" simples", { flags: "i" })
+            )
+          ])
+        ],
+        { default: "" }
+      )
+    ],
+    { value: (e, t) => t.textFromResults(e) }
+  )
+), ut = l(
+  [
+    r($t, Pt),
+    p([T, le], { default: null })
+  ],
+  {
+    value: (e) => {
+      const t = e[0], n = e[1]?.[1];
+      return {
+        index: t.value + (n === void 0 ? 0 : n.value / 1e3),
+        num: `${t.text}${n === void 0 ? "" : ` ${n.text}`}`
+      };
+    }
+  }
+), on = l(
+  [
+    i("^", { flags: "m" }),
+    V,
+    T,
+    ut,
+    i("$", { flags: "m" })
+  ],
+  {
+    value: (e, t) => ({
+      definition: !0,
+      ...e[3],
+      position: t.position(),
+      type: e[1]
+    })
+  }
+), Ee = r(
+  l([ut, p(ge, { default: "" })], {
+    value: (e, t) => ({
+      ...e[0],
+      ...e[1] ? { localizationAdverb: e[1] } : {},
+      position: t.position(),
+      type: "incomplete-header"
+    })
+  }),
+  l([li, p(ge, { default: "" })], {
+    value: (e, t) => ({
+      ...e[1] ? { localizationAdverb: e[1] } : {},
+      num: e[0],
+      position: t.position(),
+      type: "incomplete-header"
+    })
+  }),
+  O(J, {
+    value: (e, t) => ({
+      ...e,
+      position: t.position(),
+      type: "incomplete-header"
+    })
+  })
+), Re = r(
+  Ee,
+  O(Ut, {
+    value: (e, t) => ({
+      ...e,
+      position: t.position(),
+      type: "incomplete-header"
+    })
+  })
+), ri = r(
+  l(
+    [
+      Le,
+      T,
+      V,
+      p([T, Re], { default: [] })
+    ],
+    {
+      value: (e, t) => {
+        const n = e[3][1] ?? {
+          position: t.position(),
+          type: e[2]
+        };
+        for (const a of C(
+          n
+        ))
+          a.type = e[2], a.index === void 0 && a.relative === void 0 && Object.assign(a, e[0]);
+        return { ...n, position: t.position() };
+      }
+    }
+  ),
+  l([Ft, T, V], {
+    value: (e, t) => ({
+      index: e[0],
+      position: t.position(),
+      type: e[2]
+    })
+  }),
+  l([V, T, Re], {
+    value: (e, t) => {
+      const n = e[2];
+      for (const a of C(
+        n
+      ))
+        a.type = e[0];
+      return {
+        ...n,
+        position: t.position()
+      };
+    }
+  })
+), ui = l(
+  [p(ue, { default: !1 }), ri],
+  {
+    value: (e, t) => {
+      const n = e[1];
+      if (e[0])
+        for (const a of C(
+          n
+        ))
+          a.ofTheSaid = !0;
+      return {
+        ...n,
+        position: t.position()
+      };
+    }
+  }
+), di = l(
+  [
+    Ee,
+    G([
+      r(M, Y),
+      r(
+        l([W], {
+          value: (e, t) => ({
+            ...e[0],
+            position: t.position(),
+            type: "incomplete-header"
+          })
+        }),
+        Ee
+      )
+    ])
+  ],
+  {
+    value: (e, t) => $(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), Pe = r(
+  di,
+  O(Ye, {
+    value: (e, t) => ({
+      ...e,
+      position: t.position(),
+      type: "incomplete-header"
+    })
+  })
+), ci = r(
+  l(
+    [
+      he,
+      T,
+      Ne,
+      p([T, Pe], { default: [] })
+    ],
+    {
+      value: (e, t) => {
+        const n = e[3][1] ?? {
+          position: t.position(),
+          type: e[2]
+        };
+        for (const a of C(
+          n
+        ))
+          a.type = e[2], a.index === void 0 && a.relative === void 0 && Object.assign(a, e[0]);
+        return { ...n, position: t.position() };
+      }
+    }
+  ),
+  l([Ne, T, Pe], {
+    value: (e, t) => {
+      const n = e[2];
+      for (const a of C(
+        n
+      ))
+        a.type = e[0];
+      return {
+        ...n,
+        position: t.position()
+      };
+    }
+  })
+), pi = l(
+  [p(me, { default: !1 }), ci],
+  {
+    value: (e, t) => {
+      const n = e[1];
+      if (e[0])
+        for (const a of C(
+          n
+        ))
+          a.ofTheSaid = !0;
+      return {
+        ...n,
+        position: t.position()
+      };
+    }
+  }
+), fi = { LEGITEXT000006069574: { nature: "CODE", title: "Code général des impôts, annexe III" }, LEGITEXT000006072026: { nature: "CODE", title: "Code monétaire et financier" }, LEGITEXT000006074069: { nature: "CODE", title: "Code de l'action sociale et des familles" }, LEGITEXT000006071646: { nature: "CODE", title: "Code du blé" }, LEGITEXT000005634379: { nature: "CODE", title: "Code de commerce" }, LEGITEXT000006074234: { nature: "CODE", title: "Code de l'aviation civile" }, LEGITEXT000006072360: { nature: "CODE", title: "Code de déontologie vétérinaire" }, LEGITEXT000006072665: { nature: "CODE", title: "Code de la santé publique" }, LEGITEXT000006074237: { nature: "CODE", title: "Code du domaine public fluvial et de la navigation intérieure" }, LEGITEXT000006069565: { nature: "CODE", title: "Code de la consommation" }, LEGITEXT000025244092: { nature: "CODE", title: "Code forestier (nouveau)" }, LEGITEXT000006074068: { nature: "CODE", title: "Code des pensions militaires d'invalidité et des victimes de guerre" }, LEGITEXT000006069472: { nature: "CODE", title: "Code de la consommation des boissons et des mesures contre l'alcoolisme applicable dans la collectivité territoriale de Mayotte" }, LEGITEXT000006069583: { nature: "CODE", title: "Livre des procédures fiscales" }, LEGITEXT000006070208: { nature: "CODE", title: "Code du domaine de l'Etat" }, LEGITEXT000023086525: { nature: "CODE", title: "Code des transports" }, LEGITEXT000006070239: { nature: "CODE", title: "Code électoral" }, LEGITEXT000006071367: { nature: "CODE", title: "Code rural et de la pêche maritime" }, LEGITEXT000006070721: { nature: "CODE", title: "Code civil" }, LEGITEXT000037701019: { nature: "CODE", title: "Code de la commande publique" }, LEGITEXT000006070302: { nature: "CODE", title: "Code des pensions civiles et militaires de retraite" }, LEGITEXT000006069441: { nature: "CODE", title: "Code de commerce (ancien)" }, LEGITEXT000006074510: { nature: "CODE", title: "Code de déontologie des professionnels de l'expertise comptable" }, LEGITEXT000006070933: { nature: "CODE", title: "Code de justice administrative" }, LEGITEXT000006073422: { nature: "CODE", title: "Code des caisses d'épargne" }, LEGITEXT000006071154: { nature: "CODE", title: "Code de procédure pénale" }, LEGITEXT000006075115: { nature: "CODE", title: "Code des débits de boissons et des mesures contre l'alcoolisme" }, LEGITEXT000006069564: { nature: "CODE", title: "Code des marchés publics (édition 2001)" }, LEGITEXT000006070162: { nature: "CODE", title: "Code des communes" }, LEGITEXT000006071007: { nature: "CODE", title: "Code de la légion d'honneur et de la médaille militaire" }, LEGITEXT000006070666: { nature: "CODE", title: "Code des instruments monétaires et des médailles" }, LEGITEXT000006070716: { nature: "CODE", title: "Code de procédure civile" }, LEGITEXT000025024948: { nature: "CODE", title: "Code des procédures civiles d'exécution" }, LEGITEXT000044416551: { nature: "CODE", title: "Code général de la fonction publique" }, LEGITEXT000006069568: { nature: "CODE", title: "Code général des impôts, annexe I" }, LEGITEXT000006071103: { nature: "CODE", title: "Code de déontologie de la profession de commissaire aux comptes" }, LEGITEXT000006070633: { nature: "CODE", title: "Code général des collectivités territoriales" }, LEGITEXT000006071071: { nature: "CODE", title: "Code de déontologie de la police nationale" }, LEGITEXT000006071344: { nature: "CODE", title: "Code des tribunaux administratifs et des cours administratives d'appel" }, LEGITEXT000006074096: { nature: "CODE", title: "Code de la construction et de l'habitation" }, LEGITEXT000044595989: { nature: "CODE", title: "Code des impositions sur les biens et services" }, LEGITEXT000006074236: { nature: "CODE", title: "Code du patrimoine" }, LEGITEXT000006070249: { nature: "CODE", title: "Code des juridictions financières" }, LEGITEXT000006069562: { nature: "CODE", title: "Code des marchés publics (édition 1964)" }, LEGITEXT000006071657: { nature: "CODE", title: "Code du vin" }, LEGITEXT000006069569: { nature: "CODE", title: "Code général des impôts, annexe II" }, LEGITEXT000006070882: { nature: "CODE", title: "Code de l'industrie cinématographique" }, LEGITEXT000006072635: { nature: "CODE", title: "Code de déontologie des sages-femmes" }, LEGITEXT000006071335: { nature: "CODE", title: "Code du service national" }, LEGITEXT000006070159: { nature: "CODE", title: "Code de déontologie des agents de police municipale" }, LEGITEXT000006070719: { nature: "CODE", title: "Code pénal" }, LEGITEXT000006074232: { nature: "CODE", title: "Code de déontologie des architectes" }, LEGITEXT000025503132: { nature: "CODE", title: "Code de la sécurité intérieure" }, LEGITEXT000006072052: { nature: "CODE", title: "Code du travail applicable à Mayotte" }, LEGITEXT000023983208: { nature: "CODE", title: "Code de l'énergie" }, LEGITEXT000006074947: { nature: "CODE", title: "Code de la route (ancien)" }, LEGITEXT000006071785: { nature: "CODE", title: "Code minier" }, LEGITEXT000006074066: { nature: "CODE", title: "Code des pensions de retraite des marins français du commerce, de pêche ou de plaisance" }, LEGITEXT000006072050: { nature: "CODE", title: "Code du travail" }, LEGITEXT000006074235: { nature: "CODE", title: "Code du domaine de l'Etat et des collectivités publiques applicable à la collectivité territoriale de Mayotte" }, LEGITEXT000006070158: { nature: "CODE", title: "Code de l'entrée et du séjour des étrangers et du droit d'asile" }, LEGITEXT000006074228: { nature: "CODE", title: "Code de la route" }, LEGITEXT000031366350: { nature: "CODE", title: "Code des relations entre le public et l'administration" }, LEGITEXT000006073984: { nature: "CODE", title: "Code des assurances" }, LEGITEXT000006070299: { nature: "CODE", title: "Code général de la propriété des personnes publiques" }, LEGITEXT000006071645: { nature: "CODE", title: "Code des douanes de Mayotte" }, LEGITEXT000006070300: { nature: "CODE", title: "Code des communes de la Nouvelle-Calédonie" }, LEGITEXT000006071164: { nature: "CODE", title: "Code de l'organisation judiciaire" }, LEGITEXT000006071014: { nature: "CODE", title: "Code de l'enseignement technique" }, LEGITEXT000006071360: { nature: "CODE", title: "Code de justice militaire (nouveau)" }, LEGITEXT000006073189: { nature: "CODE", title: "Code de la sécurité sociale" }, LEGITEXT000006074075: { nature: "CODE", title: "Code de l'urbanisme" }, LEGITEXT000006074224: { nature: "CODE", title: "Code de l'expropriation pour cause d'utilité publique" }, LEGITEXT000006072051: { nature: "CODE", title: "Code du travail maritime" }, LEGITEXT000006070987: { nature: "CODE", title: "Code des postes et des communications électroniques" }, LEGITEXT000005627819: { nature: "CODE", title: "Code des marchés publics (édition 2006)" }, LEGITEXT000006071318: { nature: "CODE", title: "Code du sport" }, LEGITEXT000006074220: { nature: "CODE", title: "Code de l'environnement" }, LEGITEXT000006075116: { nature: "CODE", title: "Code de l'artisanat" }, LEGITEXT000020908868: { nature: "CODE", title: "Code du cinéma et de l'image animée" }, LEGITEXT000006070884: { nature: "CODE", title: "Code de justice militaire" }, LEGITEXT000006070667: { nature: "CODE", title: "Code de la voirie routière" }, LEGITEXT000006071307: { nature: "CODE", title: "Code de la défense" }, LEGITEXT000006072637: { nature: "CODE", title: "Code de la famille et de l'aide sociale" }, LEGITEXT000006074233: { nature: "CODE", title: "Code des ports maritimes" }, LEGITEXT000006074067: { nature: "CODE", title: "Code de la mutualité" }, LEGITEXT000006074073: { nature: "CODE", title: "Code du tourisme" }, LEGITEXT000006072636: { nature: "CODE", title: "Code de déontologie des chirurgiens-dentistes" }, LEGITEXT000023501962: { nature: "CODE", title: "Code minier (nouveau)" }, LEGITEXT000006071188: { nature: "CODE", title: "Code disciplinaire et pénal de la marine marchande" }, LEGITEXT000006071191: { nature: "CODE", title: "Code de l'éducation" }, LEGITEXT000006071570: { nature: "CODE", title: "Code des douanes" }, LEGITEXT000006071366: { nature: "CODE", title: "Code rural (ancien)" }, LEGITEXT000045476241: { nature: "CODE", title: "Code pénitentiaire" }, LEGITEXT000006071189: { nature: "CODE", title: "Code de la nationalité française" }, LEGITEXT000006071737: { nature: "CODE", title: "Code de l'Office national interprofessionnel du blé" }, LEGITEXT000006072634: { nature: "CODE", title: "Code de déontologie médicale" }, LEGITEXT000006069414: { nature: "CODE", title: "Code de la propriété intellectuelle" }, LEGITEXT000006069576: { nature: "CODE", title: "Code général des impôts, annexe IV" }, LEGITEXT000006069577: { nature: "CODE", title: "Code général des impôts" }, LEGITEXT000006071190: { nature: "CODE", title: "Code de la recherche" }, LEGITEXT000039086952: { nature: "CODE", title: "Code de la justice pénale des mineurs" }, LEGITEXT000006071029: { nature: "CODE", title: "Code pénal (ancien)" }, LEGITEXT000006072666: { nature: "CODE", title: "Code des marchés publics (édition 2004)" }, LEGITEXT000006070680: { nature: "CODE", title: "Code de procédure civile" }, LEGITEXT000006072664: { nature: "CODE", title: "Code de déontologie des médecins" }, LEGITEXT000006071556: { nature: "CODE", title: "Code forestier de Mayotte" }, LEGITEXT000006071514: { nature: "CODE", title: "Code forestier" }, JORFTEXT000000571356: { nature: "CONSTITUTION", title: "Constitution du 4 octobre 1958" }, JORFTEXT000000868390: { nature: "CONSTITUTION", title: "Constitution du 27 octobre 1946" }, LEGITEXT000006071195: { nature: "CONSTITUTION", title: "Constitution du 4 novembre 1848" } }, gi = { code: { général: { des: { impôts: { annexe: { 1: { cid: "LEGITEXT000006069568" }, 2: { cid: "LEGITEXT000006069569" }, 3: { cid: "LEGITEXT000006069574" }, 4: { cid: "LEGITEXT000006069576" } }, cid: "LEGITEXT000006069577" }, collectivités: { territoriales: { cid: "LEGITEXT000006070633" } } }, de: { la: { fonction: { publique: { cid: "LEGITEXT000044416551" } }, propriété: { des: { personnes: { publiques: { cid: "LEGITEXT000006070299" } } } } } } }, monétaire: { et: { financier: { cid: "LEGITEXT000006072026" } } }, de: { "l'action": { sociale: { et: { des: { familles: { cid: "LEGITEXT000006074069" } } } } }, commerce: { cid: "LEGITEXT000005634379", ancien: { cid: "LEGITEXT000006069441" } }, "l'aviation": { civile: { cid: "LEGITEXT000006074234" } }, déontologie: { vétérinaire: { cid: "LEGITEXT000006072360" }, des: { professionnels: { de: { "l'expertise": { comptable: { cid: "LEGITEXT000006074510" } } } }, "sages-femmes": { cid: "LEGITEXT000006072635" }, agents: { de: { police: { municipale: { cid: "LEGITEXT000006070159" } } } }, architectes: { cid: "LEGITEXT000006074232" }, "chirurgiens-dentistes": { cid: "LEGITEXT000006072636" }, médecins: { cid: "LEGITEXT000006072664" } }, de: { la: { profession: { de: { commissaire: { aux: { comptes: { cid: "LEGITEXT000006071103" } } } } }, police: { nationale: { cid: "LEGITEXT000006071071" } } } }, médicale: { cid: "LEGITEXT000006072634" } }, la: { santé: { publique: { cid: "LEGITEXT000006072665" } }, consommation: { cid: "LEGITEXT000006069565", des: { boissons: { et: { des: { mesures: { contre: { "l'alcoolisme": { applicable: { dans: { la: { collectivité: { territoriale: { de: { mayotte: { cid: "LEGITEXT000006069472" } } } } } } } } } } } } } } }, commande: { publique: { cid: "LEGITEXT000037701019" } }, légion: { "d'honneur": { de: { la: { médaille: { militaire: { et: { de: { "l'ordre": { national: { du: { mérite: { cid: "LEGITEXT000006071007" } } } } } } } } } }, et: { de: { la: { médaille: { militaire: { cid: "LEGITEXT000006071007" } } } } } } }, construction: { et: { de: { "l'habitation": { cid: "LEGITEXT000006074096" } } } }, sécurité: { intérieure: { cid: "LEGITEXT000025503132" }, sociale: { cid: "LEGITEXT000006073189" } }, route: { ancien: { cid: "LEGITEXT000006074947" }, cid: "LEGITEXT000006074228" }, voirie: { routière: { cid: "LEGITEXT000006070667" } }, défense: { cid: "LEGITEXT000006071307" }, famille: { et: { de: { "l'aide": { sociale: { cid: "LEGITEXT000006072637" } } } } }, mutualité: { cid: "LEGITEXT000006074067" }, nationalité: { française: { cid: "LEGITEXT000006071189" } }, propriété: { intellectuelle: { cid: "LEGITEXT000006069414" } }, recherche: { cid: "LEGITEXT000006071190" }, justice: { pénale: { des: { mineurs: { cid: "LEGITEXT000039086952" } } } } }, justice: { administrative: { cid: "LEGITEXT000006070933" }, militaire: { nouveau: { cid: "LEGITEXT000006071360" }, cid: "LEGITEXT000006070884" } }, procédure: { pénale: { cid: "LEGITEXT000006071154" }, civile: { cid: ["LEGITEXT000006070716", "LEGITEXT000006070680"] } }, "l'industrie": { cinématographique: { cid: "LEGITEXT000006070882" } }, "l'énergie": { cid: "LEGITEXT000023983208" }, "l'entrée": { et: { du: { séjour: { des: { étrangers: { et: { du: { droit: { "d'asile": { cid: "LEGITEXT000006070158" } } } } } } } } } }, "l'organisation": { judiciaire: { cid: "LEGITEXT000006071164" } }, "l'enseignement": { technique: { cid: "LEGITEXT000006071014" } }, "l'urbanisme": { cid: "LEGITEXT000006074075" }, "l'expropriation": { pour: { cause: { "d'utilité": { publique: { cid: "LEGITEXT000006074224" } } } } }, "l'environnement": { cid: "LEGITEXT000006074220" }, "l'artisanat": { cid: "LEGITEXT000006075116" }, "l'éducation": { cid: "LEGITEXT000006071191" }, "l'office": { national: { interprofessionnel: { du: { blé: { cid: "LEGITEXT000006071737" } } } } } }, du: { blé: { cid: "LEGITEXT000006071646" }, domaine: { public: { fluvial: { et: { de: { la: { navigation: { intérieure: { cid: "LEGITEXT000006074237" } } } } } } }, de: { "l'etat": { cid: "LEGITEXT000006070208", et: { des: { collectivités: { publiques: { applicable: { à: { la: { collectivité: { territoriale: { de: { mayotte: { cid: "LEGITEXT000006074235" } } } } } } } } } } } } } }, patrimoine: { cid: "LEGITEXT000006074236" }, vin: { cid: "LEGITEXT000006071657" }, service: { national: { cid: "LEGITEXT000006071335" } }, travail: { applicable: { à: { mayotte: { cid: "LEGITEXT000006072052" } } }, cid: "LEGITEXT000006072050", maritime: { cid: "LEGITEXT000006072051" } }, sport: { cid: "LEGITEXT000006071318" }, cinéma: { et: { de: { "l'image": { animée: { cid: "LEGITEXT000020908868" } } } } }, tourisme: { cid: "LEGITEXT000006074073" } }, forestier: { nouveau: { cid: "LEGITEXT000025244092" }, de: { mayotte: { cid: "LEGITEXT000006071556" } }, cid: "LEGITEXT000006071514" }, des: { pensions: { militaires: { "d'invalidité": { et: { des: { victimes: { de: { la: { guerre: { cid: "LEGITEXT000006074068" } }, guerre: { cid: "LEGITEXT000006074068" } } } } } } }, civiles: { et: { militaires: { de: { retraite: { cid: "LEGITEXT000006070302" } } } } }, de: { retraite: { des: { marins: { français: { du: { commerce: { de: { pêche: { ou: { de: { plaisance: { cid: "LEGITEXT000006074066" } } } } } } } } } } } } }, transports: { cid: "LEGITEXT000023086525" }, caisses: { "d'épargne": { cid: "LEGITEXT000006073422" } }, débits: { de: { boissons: { et: { des: { mesures: { contre: { "l'alcoolisme": { cid: "LEGITEXT000006075115" } } } } } } } }, marchés: { publics: { édition: { 1964: { cid: "LEGITEXT000006069562" }, 2001: { cid: "LEGITEXT000006069564" }, 2004: { cid: "LEGITEXT000006072666" }, 2006: { cid: "LEGITEXT000005627819" } } } }, communes: { cid: "LEGITEXT000006070162", de: { la: { "nouvelle-calédonie": { cid: "LEGITEXT000006070300" } } } }, instruments: { monétaires: { et: { des: { médailles: { cid: "LEGITEXT000006070666" } } } } }, procédures: { civiles: { "d'exécution": { cid: "LEGITEXT000025024948" } } }, tribunaux: { administratifs: { et: { des: { cours: { administratives: { "d'appel": { cid: "LEGITEXT000006071344" } } } } } } }, impositions: { sur: { les: { biens: { et: { services: { cid: "LEGITEXT000044595989" } } } } } }, juridictions: { financières: { cid: "LEGITEXT000006070249" } }, relations: { entre: { le: { public: { et: { "l'administration": { cid: "LEGITEXT000031366350" } } } } } }, assurances: { cid: "LEGITEXT000006073984" }, douanes: { de: { mayotte: { cid: "LEGITEXT000006071645" } }, cid: "LEGITEXT000006071570" }, postes: { et: { des: { communications: { électroniques: { cid: "LEGITEXT000006070987" } } } } }, ports: { maritimes: { cid: "LEGITEXT000006074233" } } }, électoral: { cid: "LEGITEXT000006070239" }, rural: { nouveau: { cid: "LEGITEXT000006071367" }, et: { de: { la: { pêche: { maritime: { cid: "LEGITEXT000006071367" } } } } }, ancien: { cid: "LEGITEXT000006071366" } }, civil: { cid: "LEGITEXT000006070721" }, pénal: { cid: "LEGITEXT000006070719", ancien: { cid: "LEGITEXT000006071029" } }, minier: { cid: "LEGITEXT000006071785", nouveau: { cid: "LEGITEXT000023501962" } }, disciplinaire: { et: { pénal: { de: { la: { marine: { marchande: { cid: "LEGITEXT000006071188" } } } } } } }, pénitentiaire: { cid: "LEGITEXT000045476241" } }, livre: { des: { procédures: { fiscales: { cid: "LEGITEXT000006069583" } } } }, constitution: { cid: "JORFTEXT000000571356" } }, Ei = {}, Ti = { CONSTITUTION: { "1958-10-04": ["JORFTEXT000000571356"], "1946-10-27": ["JORFTEXT000000868390"], "1848-11-04": ["LEGITEXT000006071195"] } }, vi = {}, Z = {
+  textInfosByCid: fi,
+  textCidByOtherTitleWordsTree: gi,
+  textCidByStandardTitleWordsTree: Ei,
+  textsCidsByNatureAndDate: Ti,
+  textsCidsByNatureAndNum: vi
+}, ce = Z.textInfosByCid ?? {}, mi = Z.textCidByOtherTitleWordsTree ?? {}, Ii = Z.textCidByStandardTitleWordsTree ?? {}, hi = Z.textsCidsByNatureAndDate ?? {}, Li = Z.textsCidsByNatureAndNum ?? {}, dt = O(
+  r(
+    i("arrêté", { flags: "i", value: "ARRETE" }),
+    i("circulaire", { flags: "i", value: "CIRCULAIRE" }),
+    // JORFTEXT000000702211 Code professionnel local du 26 juillet 1900 pour l'Alsace et la Moselle
+    i("code professionnel local", { flags: "i", value: "LOI" }),
+    i("code", { flags: "i", value: "CODE" }),
+    i("Constitution", { value: "CONSTITUTION" }),
+    i("décret-loi", { flags: "i", value: "DECRET_LOI" }),
+    i("décret", { flags: "i", value: "DECRET" }),
+    i("loi constitutionnelle", {
+      flags: "i",
+      value: "LOI_CONSTIT"
+    }),
+    i("loi d'orientation quinquennale", { flags: "i", value: "LOI" }),
+    i("loi d'orientation", { flags: "i", value: "LOI" }),
+    i("loi de programme", { flags: "i", value: "LOI" }),
+    i("loi locale", { flags: "i", value: "LOI" }),
+    i("loi organique", { flags: "i", value: "LOI_ORGANIQUE" }),
+    i("loi quinquennale", { flags: "i", value: "LOI" }),
+    i("loi", { flags: "i", value: "LOI" }),
+    i("ordonnance (du Roi|locale|ministérielle|royale)", {
+      flags: "i",
+      value: "ORDONNANCE"
+    }),
+    i("ordonnance", { flags: "i", value: "ORDONNANCE" })
+  ),
+  {
+    value: (e) => ({
+      nature: e,
+      type: "texte"
+    })
+  }
+), Ci = l(
+  [Be, i(String.raw`\d+(-\d+)?`)],
+  {
+    value: (e) => e[1]
+  }
+), qe = r(
+  l([Ci, p(rt, { default: "" })], {
+    value: (e) => e[1] ? { date: e[1], num: e[0] } : { num: e[0] }
+  }),
+  O(Oe, {
+    value: (e) => ({ date: e })
+  })
+);
+i(
+  "décision( du Conseil constitutionnel)? (?<numero>[-/0-9A-Z]+ (QPC|DC|AN|D|ELEC|FNR|I|LOM|LP|L|ORGA|PDR|REF|SEN|AUTR|AR16))",
+  {
+    flags: "i",
+    value: (e, t) => ({
+      num: e.groups.numero,
+      position: t.position(),
+      type: "décision du Conseil constitutionnel"
+    })
+  }
+);
+const Oi = p(
+  r(
+    i(" de la République française", { flags: "i" }),
+    i(" du pays", { flags: "i" })
+  ),
+  { default: null }
+), we = r(
+  l(
+    [
+      dt,
+      Oi,
+      p([T, qe], {
+        default: null,
+        value: (e) => e[1]
+      }),
+      p(
+        [
+          T,
+          ye(Ii)
+        ],
+        {
+          default: null,
+          value: (e) => e[1]
+        }
+      ),
+      p(
+        [
+          i(String.raw` ?\( ?`),
+          qe,
+          i(String.raw` ?\)`)
+        ],
+        {
+          default: null,
+          value: (e) => e[1]
+        }
+      ),
+      p(De, { default: "" })
+    ],
+    {
+      value: (e) => {
+        const { nature: t, type: n } = e[0], { date: a, num: o } = e[2] ?? e[4] ?? {}, { cid: s } = e[3] ?? {};
+        if (s === void 0 && a === void 0 && o === void 0)
+          return;
+        let u = /* @__PURE__ */ new Set();
+        if (a !== void 0) {
+          const c = hi[t]?.[a];
+          c !== void 0 && (u = u.size === 0 ? new Set(c) : u.intersection(new Set(c)));
+        }
+        if (o !== void 0) {
+          const c = Li[t]?.[o];
+          c !== void 0 && (u = u.size === 0 ? new Set(c) : u.intersection(new Set(c)));
+        }
+        if (s !== void 0) {
+          const c = Array.isArray(s) ? s : [s];
+          u = u.size === 0 ? new Set(c) : u.intersection(
+            new Set(
+              c.filter((g) => ce[g].nature === t)
+            )
+          );
+        }
+        const f = u.size === 1 ? u.values().next().value : void 0, d = f === void 0 ? void 0 : ce[f];
+        return Object.fromEntries(
+          Object.entries({
+            cid: f,
+            date: a,
+            nature: t ?? d?.nature,
+            num: o,
+            title: d?.title,
+            type: n
+          }).filter(([, c]) => c !== void 0)
+        );
+      }
+    }
+  ),
+  l(
+    [
+      ye(mi),
+      p(De, { default: "" })
+    ],
+    {
+      value: (e) => {
+        const { cid: t } = e[0], n = typeof t == "string" ? ce[t] : void 0;
+        return Object.fromEntries(
+          Object.entries({
+            cid: t,
+            ...n ?? {},
+            type: "texte"
+          }).filter(([, a]) => a !== void 0)
+        );
+      }
+    }
+  )
+), Xi = l(
+  [
+    fe,
+    i("/"),
+    fe,
+    p(i(" ?/ ?(CEE?)", { value: (e) => e[1] }), {
+      default: ""
+    })
+  ],
+  {
+    value: (e) => `${e[0]}/${e[2]}${e[3] ? `/${e[3]}` : ""}`
+  }
+), Gi = l(
+  [p(Be, { default: "" }), Xi],
+  { value: (e) => e[1] }
+), yi = r(
+  l([Gi, p(rt, { default: "" })], {
+    value: (e) => e[1] ? { date: e[1], num: e[0] } : { num: e[0] }
+  }),
+  O(Oe, {
+    value: (e) => ({ date: e })
+  })
+), ct = l(
+  [
+    r(
+      i("directive", { flags: "i", value: "DIRECTIVE_EURO" }),
+      i("règlement", { flags: "i", value: "REGLEMENTEUROPEEN" })
+    ),
+    p(i(String.raw` \(UE\)`, { flags: "i" }), { default: "" })
+  ],
+  {
+    value: (e) => ({
+      nature: e[0],
+      legislation: "UE",
+      type: "texte"
+    })
+  }
+), $e = l(
+  [ct, T, yi],
+  {
+    value: (e) => ({
+      ...e[2],
+      ...e[0]
+    })
+  }
+), Me = i("convention", {
+  flags: "i",
+  value: {
+    nature: "CONVENTION",
+    legislation: "international",
+    type: "texte"
+  }
+}), xi = l(
+  [
+    p(ue, { default: !1 }),
+    r(
+      l(
+        [
+          Le,
+          T,
+          r(
+            we,
+            $e,
+            Me,
+            dt,
+            ct
+          )
+        ],
+        {
+          value: (e) => ({
+            ...e[2],
+            ...e[0] === void 0 ? {} : e[0]
+          })
+        }
+      ),
+      we,
+      $e,
+      Me
+    )
+  ],
+  {
+    value: (e, t) => {
+      const n = {
+        ...e[1],
+        ...e[0] ? { ofTheSaid: !0 } : {},
+        position: t.position()
+      };
+      return t.currentText = n, n;
+    }
+  }
+), bi = r(ei, pi), Te = r(ii, ui, xi), pt = l(
+  [
+    bi,
+    G(
+      l([re, Te], {
+        value: (e) => e[1]
+      })
+    )
+  ],
+  {
+    value: (e, t) => se(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), ft = l(
+  [
+    Te,
+    G(
+      l([re, Te], {
+        value: (e) => e[1]
+      })
+    )
+  ],
+  {
+    value: (e, t) => se(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), Si = l(
+  [Je, pt],
+  { value: (e) => e[1] }
+), Di = l(
+  [re, ft],
+  { value: (e) => e[1] }
+), gt = r(
+  Di,
+  Si
+), Ai = r(
+  l(
+    [Vt, p(gt, { default: null })],
+    {
+      value: (e) => {
+        const t = e[0], n = e[1];
+        return n === null ? t : D(n, t);
+      }
+    }
+  ),
+  pt
+), Ni = r(
+  l(
+    [Wt, p(gt, { default: null })],
+    {
+      value: (e) => {
+        const t = e[0], n = e[1];
+        return n === null ? t : D(n, t);
+      }
+    }
+  ),
+  ft
+), Ri = l(
+  [
+    l(
+      [
+        Ve,
+        Ai,
+        p(
+          [
+            p(i(" modifiée?s", { flags: "i" }), { default: "" }),
+            i(" susvisée?s", { flags: "i" })
+          ],
+          { default: "" }
+        )
+        // optional(regExp(String.raw` \([^)]+\)`, {flags: "i"}), { default: "" }),
+      ],
+      {
+        value: (e, t) => ({
+          ...e[1],
+          position: t.position()
+        })
+      }
+    ),
+    p(je, { default: null })
+  ],
+  {
+    value: (e, t) => e[1] === null ? e[0] : {
+      action: e[1],
+      position: t.position(),
+      reference: e[0],
+      type: "reference_et_action"
+    }
+  }
+), Pi = l(
+  [
+    l(
+      [
+        We,
+        Ni,
+        p(
+          [
+            p(i(" modifiée?", { flags: "i" }), { default: "" }),
+            i(" susvisée?", { flags: "i" })
+          ],
+          { default: "" }
+        ),
+        // optional(regExp(String.raw` \([^)]+\)`, { flags: "i" }), {
+        //   default: "",
+        // }),
+        p(i(String.raw`, ?qui devient [^,]+ ","`, { flags: "i" }), {
+          default: ""
+        })
+      ],
+      {
+        value: (e, t) => ({
+          ...e[1],
+          position: t.position()
+        })
+      }
+    ),
+    p(je, { default: null })
+  ],
+  {
+    value: (e, t) => e[1] === null ? e[0] : {
+      action: e[1],
+      position: t.position(),
+      reference: e[0],
+      type: "reference_et_action"
+    }
+  }
+), _e = r(
+  Pi,
+  Ri
+), ln = l(
+  [
+    _e,
+    G([
+      r(Bt, M),
+      _e
+    ])
+  ],
+  {
+    value: (e, t) => $(
+      e[0],
+      e[1],
+      t.position()
+    )
+  }
+), ve = /^<\/?(!DOCTYPE|\?XML|[A-Z][A-Z0-9]*)/i;
+function qi(e, t) {
+  return (n) => {
+    const a = [];
+    let o = n;
+    for (const s of t) {
+      const u = s(o);
+      (u.transformations !== void 0 || u.sourceMap.length !== 0) && (a.push(u), o = u.output);
+    }
+    return { input: n, output: o, title: e, transformations: a };
+  };
+}
+function* Xe(e) {
+  if (e.transformations === void 0)
+    yield e;
   else
-    for (const n of u.transformations)
-      yield* $(n);
+    for (const t of e.transformations)
+      yield* Xe(t);
 }
-function* U(u) {
-  const n = [
-    ...$(u)
+function* wi(e) {
+  const t = [
+    ...Xe(e)
   ].reverse();
-  let t = {
+  let n = {
     position: { start: 0, stop: 0 }
   };
-  const s = n.map(
-    (i) => {
-      const r = y(
-        i
+  const a = t.map(
+    (s) => {
+      const u = $i(
+        s
       );
-      return r.next(t), r;
+      return u.next(n), u;
     }
   );
-  let e = yield t;
-  for (; e !== void 0; ) {
-    t = {
-      position: e
+  let o = yield n;
+  for (; o !== void 0; ) {
+    n = {
+      position: o
     };
-    for (const i of s) {
-      const r = i.next(t);
-      if (r.done)
+    for (const s of a) {
+      const u = s.next(n);
+      if (u.done)
         return;
-      t = r.value;
+      n = u.value;
     }
-    e = yield t;
+    o = yield n;
   }
-  for (const i of s)
-    i.next(void 0);
+  for (const s of a)
+    s.next(void 0);
 }
-function* y(u) {
-  let n, t = "looking_for_start_segment", s = yield {
+function* $i(e) {
+  let t, n = "looking_for_start_segment", a = yield {
     position: { start: 0, stop: 0 }
   };
-  const e = [
+  const o = [
     { inputIndex: 0, inputLength: 0, outputIndex: 0, outputLength: 0 },
-    ...u.sourceMap,
+    ...e.sourceMap,
     {
       inputIndex: Number.MAX_SAFE_INTEGER,
       inputLength: 0,
@@ -65,35 +2553,35 @@ function* y(u) {
       outputLength: 0
     }
   ];
-  for (const [i, r] of e.entries())
-    for (let c = !1; !c; ) {
-      if (s === void 0)
+  for (const [s, u] of o.entries())
+    for (let f = !1; !f; ) {
+      if (a === void 0)
         return;
-      let { position: o } = s, p, l, d, g;
-      switch (t) {
+      let { position: d } = a, c, g, m, E;
+      switch (n) {
         case "looking_for_start_segment": {
-          const x = e[i + 1];
-          x !== void 0 && x.outputIndex + x.outputLength <= o.start ? c = !0 : (n = i, t = "looking_for_stop_segment");
+          const X = o[s + 1];
+          X !== void 0 && X.outputIndex + X.outputLength <= d.start ? f = !0 : (t = s, n = "looking_for_stop_segment");
           break;
         }
         case "looking_for_stop_segment": {
-          if (r.outputIndex < o.stop)
-            c = !0;
+          if (u.outputIndex < d.stop)
+            f = !0;
           else {
-            const x = e[n], T = i, f = r;
-            let m = o.start < x.outputIndex + x.outputLength ? n : n + 1, a = o.stop > f.outputIndex ? T : T - 1;
-            for (let M = !0; M; ) {
-              M = !1, p = void 0, l = void 0, d = void 0, g = void 0;
-              for (let P = m; P <= a; P++) {
-                const E = e[P].matchingSegmentIndex;
-                if (E !== void 0) {
-                  if (E + 1 < m) {
-                    let R = !1;
-                    const L = e[E + 1];
-                    if (L.openingTag !== void 0 && L.outputIndex + L.outputLength < o.start) {
-                      const A = L.openingTag.match(N);
-                      if (A !== null) {
-                        const v = A[1], O = v.toUpperCase();
+            const X = o[t], P = s, I = u;
+            let h = d.start < X.outputIndex + X.outputLength ? t : t + 1, v = d.stop > I.outputIndex ? P : P - 1;
+            for (let U = !0; U; ) {
+              U = !1, c = void 0, g = void 0, m = void 0, E = void 0;
+              for (let Q = h; Q <= v; Q++) {
+                const _ = o[Q].matchingSegmentIndex;
+                if (_ !== void 0) {
+                  if (_ + 1 < h) {
+                    let k = !1;
+                    const N = o[_ + 1];
+                    if (N.openingTag !== void 0 && N.outputIndex + N.outputLength < d.start) {
+                      const z = N.openingTag.match(ve);
+                      if (z !== null) {
+                        const q = z[1], K = q.toUpperCase();
                         [
                           "B",
                           "EM",
@@ -102,24 +2590,24 @@ function* y(u) {
                           "STRONG",
                           "SUB",
                           "SUP"
-                        ].includes(O) && (d = `${d ?? ""}</${v}>`, p = `${L.openingTag}${p ?? ""}`, R = !0);
+                        ].includes(K) && (m = `${m ?? ""}</${q}>`, c = `${N.openingTag}${c ?? ""}`, k = !0);
                       }
                     }
-                    if (!R) {
-                      p = void 0, d = void 0, m = E + 1, o = {
-                        start: e[m].outputIndex,
-                        stop: o.stop
-                      }, M = !0;
+                    if (!k) {
+                      c = void 0, m = void 0, h = _ + 1, d = {
+                        start: o[h].outputIndex,
+                        stop: d.stop
+                      }, U = !0;
                       break;
                     }
                   }
-                  if (E + 1 > a) {
-                    let R = !1;
-                    const L = e[P], A = e[E + 1];
-                    if (L.openingTag !== void 0 && o.stop < A.outputIndex) {
-                      const v = L.openingTag.match(N);
-                      if (v !== null) {
-                        const O = v[1], F = O.toUpperCase();
+                  if (_ + 1 > v) {
+                    let k = !1;
+                    const N = o[Q], z = o[_ + 1];
+                    if (N.openingTag !== void 0 && d.stop < z.outputIndex) {
+                      const q = N.openingTag.match(ve);
+                      if (q !== null) {
+                        const K = q[1], Tt = K.toUpperCase();
                         [
                           "B",
                           "EM",
@@ -128,72 +2616,72 @@ function* y(u) {
                           "STRONG",
                           "SUB",
                           "SUP"
-                        ].includes(F) && (l = `${l ?? ""}</${O}>`, g = `${L.openingTag}${g ?? ""}`, R = !0);
+                        ].includes(Tt) && (g = `${g ?? ""}</${K}>`, E = `${N.openingTag}${E ?? ""}`, k = !0);
                       }
                     }
-                    if (!R) {
-                      l = void 0, g = void 0, a = E + 1;
-                      const v = e[a];
-                      o = {
-                        start: o.start,
-                        stop: v.outputIndex + v.outputLength
-                      }, M = !0;
+                    if (!k) {
+                      g = void 0, E = void 0, v = _ + 1;
+                      const q = o[v];
+                      d = {
+                        start: d.start,
+                        stop: q.outputIndex + q.outputLength
+                      }, U = !0;
                       break;
                     }
                   }
                 }
               }
             }
-            const h = e[m - 1], S = h.inputIndex + h.inputLength + o.start - (h.outputIndex + h.outputLength), I = e[a], C = I.inputIndex + I.inputLength + o.stop - (I.outputIndex + I.outputLength);
-            s = yield Object.fromEntries(
+            const L = o[h - 1], A = L.inputIndex + L.inputLength + d.start - (L.outputIndex + L.outputLength), x = o[v], Et = x.inputIndex + x.inputLength + d.stop - (x.outputIndex + x.outputLength);
+            a = yield Object.fromEntries(
               Object.entries({
-                innerPrefix: `${p ?? ""}${s.innerPrefix ?? ""}` || void 0,
-                innerSuffix: `${s.innerSuffix ?? ""}${l ?? ""}` || void 0,
-                outerPrefix: `${s.outerPrefix ?? ""}${d ?? ""}` || void 0,
-                outerSuffix: `${g ?? ""}${s.outerSuffix ?? ""}` || void 0,
+                innerPrefix: `${c ?? ""}${a.innerPrefix ?? ""}` || void 0,
+                innerSuffix: `${a.innerSuffix ?? ""}${g ?? ""}` || void 0,
+                outerPrefix: `${a.outerPrefix ?? ""}${m ?? ""}` || void 0,
+                outerSuffix: `${E ?? ""}${a.outerSuffix ?? ""}` || void 0,
                 position: {
-                  start: S,
-                  stop: C
+                  start: A,
+                  stop: Et
                 }
-              }).filter(([, M]) => M !== void 0)
-            ), t = "looking_for_start_segment";
+              }).filter(([, U]) => U !== void 0)
+            ), n = "looking_for_start_segment";
           }
           break;
         }
         default:
-          _(
+          ae(
             "iterOriginalMergedPositionsFromTransformedUsingTransformationLeaf.state",
-            t
+            n
           );
       }
     }
 }
-function q(u, n) {
-  const t = U(u);
-  return t.next({ start: 0, stop: 0 }), n.map((s) => {
-    const e = t.next(s);
-    if (e.done)
+function rn(e, t) {
+  const n = wi(e);
+  return n.next({ start: 0, stop: 0 }), t.map((a) => {
+    const o = n.next(a);
+    if (o.done)
       throw new Error(
-        `Reverse transformation of position failed: ${s}`
+        `Reverse transformation of position failed: ${a}`
       );
-    return e.value;
+    return o.value;
   });
 }
-function W(u, n) {
-  for (const { sourceMap: t } of [
-    ...$(u)
+function un(e, t) {
+  for (const { sourceMap: n } of [
+    ...Xe(e)
   ].reverse())
-    n = b(
-      t,
-      n
+    t = Mi(
+      n,
+      t
     );
-  return n;
+  return t;
 }
-function b(u, n) {
-  const t = [];
-  u = [
+function Mi(e, t) {
+  const n = [];
+  e = [
     { inputIndex: 0, inputLength: 0, outputIndex: 0, outputLength: 0 },
-    ...u,
+    ...e,
     {
       inputIndex: Number.MAX_SAFE_INTEGER,
       inputLength: 0,
@@ -201,57 +2689,57 @@ function b(u, n) {
       outputLength: 0
     }
   ];
-  let s = 0, e = u[s];
-  for (const i of n) {
-    let { start: r } = i;
-    const { stop: c } = i;
-    t: for (let o = !1; !o; ) {
-      for (; e.outputIndex + e.outputLength <= r; s++, e = u[s]) ;
-      let p = s;
-      const l = u[p - 1];
-      let d = l.inputIndex + l.inputLength + r - (l.outputIndex + l.outputLength), g;
-      for (g = p - 1; u[g + 1].outputIndex < c; g++) ;
-      const x = u[g];
-      let T = x.inputIndex + x.inputLength + c - (x.outputIndex + x.outputLength);
-      for (let f = p; f <= g; f++) {
-        const m = u[f], a = m.matchingSegmentIndex;
-        if (a !== void 0) {
-          if (a + 1 < p) {
-            const h = u[a + 1];
-            if (h.outputIndex < r) {
-              m.inputIndex > d && t.push({
-                start: d,
-                stop: m.inputIndex
-              }), r = m.outputIndex + m.outputLength;
-              for (let S = f, I = m; I.outputIndex + I.outputLength === r; S++, I = u[S])
-                s = S;
-              continue t;
+  let a = 0, o = e[a];
+  for (const s of t) {
+    let { start: u } = s;
+    const { stop: f } = s;
+    e: for (let d = !1; !d; ) {
+      for (; o.outputIndex + o.outputLength <= u; a++, o = e[a]) ;
+      let c = a;
+      const g = e[c - 1];
+      let m = g.inputIndex + g.inputLength + u - (g.outputIndex + g.outputLength), E;
+      for (E = c - 1; e[E + 1].outputIndex < f; E++) ;
+      const X = e[E];
+      let P = X.inputIndex + X.inputLength + f - (X.outputIndex + X.outputLength);
+      for (let I = c; I <= E; I++) {
+        const h = e[I], v = h.matchingSegmentIndex;
+        if (v !== void 0) {
+          if (v + 1 < c) {
+            const L = e[v + 1];
+            if (L.outputIndex < u) {
+              h.inputIndex > m && n.push({
+                start: m,
+                stop: h.inputIndex
+              }), u = h.outputIndex + h.outputLength;
+              for (let A = I, x = h; x.outputIndex + x.outputLength === u; A++, x = e[A])
+                a = A;
+              continue e;
             }
-            p = a + 1, d = h.inputIndex;
-          } else if (a + 1 > g) {
-            const h = u[a + 1];
-            if (h.outputIndex + h.outputLength > c) {
-              m.inputIndex > d && t.push({
-                start: d,
-                stop: m.inputIndex
-              }), r = m.outputIndex + m.outputLength;
-              for (let S = f, I = m; I.outputIndex + I.outputLength === r; S++, I = u[S])
-                s = S;
-              continue t;
+            c = v + 1, m = L.inputIndex;
+          } else if (v + 1 > E) {
+            const L = e[v + 1];
+            if (L.outputIndex + L.outputLength > f) {
+              h.inputIndex > m && n.push({
+                start: m,
+                stop: h.inputIndex
+              }), u = h.outputIndex + h.outputLength;
+              for (let A = I, x = h; x.outputIndex + x.outputLength === u; A++, x = e[A])
+                a = A;
+              continue e;
             }
-            g = a + 1, T = h.inputIndex + h.inputLength;
+            E = v + 1, P = L.inputIndex + L.inputLength;
           }
         }
       }
-      t.push({
-        start: d,
-        stop: T
-      }), o = !0;
+      n.push({
+        start: m,
+        stop: P
+      }), d = !0;
     }
   }
-  return t;
+  return n;
 }
-const B = {
+const _i = {
   amp: "&",
   apos: "'",
   asymp: "≈",
@@ -269,38 +2757,38 @@ const B = {
   reg: "®",
   trade: "™"
 };
-function k({
-  removeAWithHref: u
+function Fi({
+  removeAWithHref: e
 } = {}) {
-  return (n) => {
-    let t = 0, s = 0, e = [], i = [];
-    const r = [], c = "Conversion des éléments HTML en texte";
-    for (; t < n.length; ) {
-      const o = n.indexOf("<", t);
-      if (o === -1)
-        return e.push(n.slice(t).replace(/[\n\r]/g, " ")), {
-          input: n,
-          output: e.join(""),
-          sourceMap: i,
-          title: c
+  return (t) => {
+    let n = 0, a = 0, o = [], s = [];
+    const u = [], f = "Conversion des éléments HTML en texte";
+    for (; n < t.length; ) {
+      const d = t.indexOf("<", n);
+      if (d === -1)
+        return o.push(t.slice(n).replace(/[\n\r]/g, " ")), {
+          input: t,
+          output: o.join(""),
+          sourceMap: s,
+          title: f
         };
-      const p = n.indexOf(">", o);
-      if (p === -1)
-        return e.push(n.slice(t).replace(/[\n\r]/g, " ")), {
-          input: n,
-          output: e.join(""),
-          sourceMap: i,
-          title: c
+      const c = t.indexOf(">", d);
+      if (c === -1)
+        return o.push(t.slice(n).replace(/[\n\r]/g, " ")), {
+          input: t,
+          output: o.join(""),
+          sourceMap: s,
+          title: f
         };
-      const l = n.slice(o, p + 1), d = l.startsWith("</"), g = l.length, x = l.match(N);
-      if (x === null) {
-        e.push(
-          n.slice(t, p + 1).replace(/[\n\r]/g, " ")
-        ), t = p + 1;
+      const g = t.slice(d, c + 1), m = g.startsWith("</"), E = g.length, X = g.match(ve);
+      if (X === null) {
+        o.push(
+          t.slice(n, c + 1).replace(/[\n\r]/g, " ")
+        ), n = c + 1;
         continue;
       }
-      const f = x[1].toUpperCase();
-      if (l.endsWith("/>") || [
+      const I = X[1].toUpperCase();
+      if (g.endsWith("/>") || [
         "!DOCTYPE",
         "?XML",
         "AREA",
@@ -317,100 +2805,100 @@ function k({
         "SOURCE",
         "TRACK",
         "WBR"
-      ].includes(f))
-        if (d)
-          o > t && e.push(
-            n.slice(t, o).replace(/[\n\r]/g, " ")
-          ), i.push({
-            inputIndex: o,
-            inputLength: g,
-            outputIndex: o + s,
+      ].includes(I))
+        if (m)
+          d > n && o.push(
+            t.slice(n, d).replace(/[\n\r]/g, " ")
+          ), s.push({
+            inputIndex: d,
+            inputLength: E,
+            outputIndex: d + a,
             outputLength: 0
-          }), s -= g;
-        else if (["BR", "HR"].includes(f)) {
-          o > t && e.push(
-            n.slice(t, o).replace(/[\n\r]/g, " ")
+          }), a -= E;
+        else if (["BR", "HR"].includes(I)) {
+          d > n && o.push(
+            t.slice(n, d).replace(/[\n\r]/g, " ")
           );
-          const a = p + 1 - o;
-          e.push(`
-`), i.push({
-            inputIndex: o,
-            inputLength: a,
-            openingTag: l,
-            outputIndex: o + s,
+          const v = c + 1 - d;
+          o.push(`
+`), s.push({
+            inputIndex: d,
+            inputLength: v,
+            openingTag: g,
+            outputIndex: d + a,
             outputLength: 1
-          }), s += 1 - a;
-        } else ["!DOCTYPE", "?XML", "COL", "IMG", "INPUT"].includes(f) ? (o > t && e.push(
-          n.slice(t, o).replace(/[\n\r]/g, " ")
-        ), i.push({
-          inputIndex: o,
-          inputLength: g,
-          openingTag: l,
-          outputIndex: o + s,
+          }), a += 1 - v;
+        } else ["!DOCTYPE", "?XML", "COL", "IMG", "INPUT"].includes(I) ? (d > n && o.push(
+          t.slice(n, d).replace(/[\n\r]/g, " ")
+        ), s.push({
+          inputIndex: d,
+          inputLength: E,
+          openingTag: g,
+          outputIndex: d + a,
           outputLength: 0
-        }), s -= g) : e.push(
-          n.slice(t, p + 1).replace(/[\n\r]/g, " ")
+        }), a -= E) : o.push(
+          t.slice(n, c + 1).replace(/[\n\r]/g, " ")
         );
-      else if (d) {
-        const a = r.at(-1);
-        if (f === a?.name)
-          switch (r.pop(), a.action) {
+      else if (m) {
+        const v = u.at(-1);
+        if (I === v?.name)
+          switch (u.pop(), v.action) {
             case void 0: {
-              e.push(
-                n.slice(t, p + 1).replace(/[\n\r]/g, " ")
+              o.push(
+                t.slice(n, c + 1).replace(/[\n\r]/g, " ")
               );
               break;
             }
             case "ignore": {
-              e = a.outputFragments, s = a.outputOffset, i = a.sourceMap;
-              const h = p + 1 - a.inputIndex;
-              i.push({
-                inputIndex: a.inputIndex,
-                inputLength: h,
-                outputIndex: a.inputIndex + s,
+              o = v.outputFragments, a = v.outputOffset, s = v.sourceMap;
+              const L = c + 1 - v.inputIndex;
+              s.push({
+                inputIndex: v.inputIndex,
+                inputLength: L,
+                outputIndex: v.inputIndex + a,
                 outputLength: 0
-              }), s = s - h;
+              }), a = a - L;
               break;
             }
             case "keep_content": {
-              e.push(
-                n.slice(t, o).replace(/[\n\r]/g, " ")
-              ), a.closingTagReplacement.length !== 0 && e.push(a.closingTagReplacement);
-              const h = p + 1 - o;
-              i[a.openingSegmentIndex].matchingSegmentIndex = i.length, i.push({
-                inputIndex: o,
-                inputLength: h,
-                matchingSegmentIndex: a.openingSegmentIndex,
-                outputIndex: o + s,
-                outputLength: a.closingTagReplacement.length
-              }), s += a.closingTagReplacement.length - h;
+              o.push(
+                t.slice(n, d).replace(/[\n\r]/g, " ")
+              ), v.closingTagReplacement.length !== 0 && o.push(v.closingTagReplacement);
+              const L = c + 1 - d;
+              s[v.openingSegmentIndex].matchingSegmentIndex = s.length, s.push({
+                inputIndex: d,
+                inputLength: L,
+                matchingSegmentIndex: v.openingSegmentIndex,
+                outputIndex: d + a,
+                outputLength: v.closingTagReplacement.length
+              }), a += v.closingTagReplacement.length - L;
               break;
             }
             default:
-              _("TagInfos.action", a);
+              ae("TagInfos.action", v);
           }
         else
-          o > t && e.push(
-            n.slice(t, o).replace(/[\n\r]/g, " ")
-          ), i.push({
-            inputIndex: o,
-            inputLength: g,
-            outputIndex: o + s,
+          d > n && o.push(
+            t.slice(n, d).replace(/[\n\r]/g, " ")
+          ), s.push({
+            inputIndex: d,
+            inputLength: E,
+            outputIndex: d + a,
             outputLength: 0
-          }), s -= g;
-      } else if (["COLGROUP", "HEAD", "SCRIPT", "STYLE"].includes(f) || u && f === "A" && / href=/i.test(l))
-        o > t && e.push(
-          n.slice(t, o).replace(/[\n\r]/g, " ")
-        ), r.push({
+          }), a -= E;
+      } else if (["COLGROUP", "HEAD", "SCRIPT", "STYLE"].includes(I) || e && I === "A" && / href=/i.test(g))
+        d > n && o.push(
+          t.slice(n, d).replace(/[\n\r]/g, " ")
+        ), u.push({
           action: "ignore",
-          inputIndex: o,
-          name: f,
+          inputIndex: d,
+          name: I,
           // Backup outputFragments, outputOffset & sourceMap, because
           // every changes made inside ignored element will be ignored.
-          outputFragments: e,
-          outputOffset: s,
-          sourceMap: i
-        }), e = [], i = [];
+          outputFragments: o,
+          outputOffset: a,
+          sourceMap: s
+        }), o = [], s = [];
       else if ([
         "A",
         // When removeAWithHref is false or no href
@@ -430,22 +2918,22 @@ function k({
         "THEAD",
         "TR",
         "UL"
-      ].includes(f)) {
-        o > t && e.push(
-          n.slice(t, o).replace(/[\n\r]/g, " ")
+      ].includes(I)) {
+        d > n && o.push(
+          t.slice(n, d).replace(/[\n\r]/g, " ")
         );
-        const a = i.length;
-        i.push({
-          inputIndex: o,
-          inputLength: g,
-          openingTag: l,
-          outputIndex: o + s,
+        const v = s.length;
+        s.push({
+          inputIndex: d,
+          inputLength: E,
+          openingTag: g,
+          outputIndex: d + a,
           outputLength: 0
-        }), s -= g, r.push({
+        }), a -= E, u.push({
           action: "keep_content",
           closingTagReplacement: "",
-          name: f,
-          openingSegmentIndex: a
+          name: I,
+          openingSegmentIndex: v
         });
       } else if ([
         "CAPTION",
@@ -463,115 +2951,115 @@ function k({
         "P",
         "TD",
         "TH"
-      ].includes(f)) {
-        o > t && e.push(
-          n.slice(t, o).replace(/[\n\r]/g, " ")
-        ), e.push(`
+      ].includes(I)) {
+        d > n && o.push(
+          t.slice(n, d).replace(/[\n\r]/g, " ")
+        ), o.push(`
 `);
-        const a = i.length;
-        i.push({
-          inputIndex: o,
-          inputLength: g,
-          openingTag: l,
-          outputIndex: o + s,
+        const v = s.length;
+        s.push({
+          inputIndex: d,
+          inputLength: E,
+          openingTag: g,
+          outputIndex: d + a,
           outputLength: 1
-        }), s += 1 - g, r.push({
+        }), a += 1 - E, u.push({
           action: "keep_content",
           closingTagReplacement: `
 `,
-          name: f,
-          openingSegmentIndex: a
+          name: I,
+          openingSegmentIndex: v
         });
       } else
-        e.push(
-          n.slice(t, p + 1).replace(/[\n\r]/g, " ")
-        ), r.push({
-          name: f
+        o.push(
+          t.slice(n, c + 1).replace(/[\n\r]/g, " ")
+        ), u.push({
+          name: I
         });
-      t = p + 1;
+      n = c + 1;
     }
     return {
-      input: n,
-      output: e.join(""),
-      sourceMap: i,
-      title: c
+      input: t,
+      output: o.join(""),
+      sourceMap: s,
+      title: f
     };
   };
 }
-function D(u) {
-  let n = 0;
-  const t = [], s = u.replace(
+function Ui(e) {
+  let t = 0;
+  const n = [], a = e.replace(
     /&(amp|apos|asymp|copy|deg|euro|gt|lt|mdash|nbsp|ndash|ne|pound|quot|reg|trade);/gi,
-    (e, i, r) => {
-      const c = B[i.toLowerCase()];
-      return t.push({
-        inputIndex: r,
-        inputLength: e.length,
-        outputIndex: r + n,
-        outputLength: c.length
-      }), n += c.length - e.length, c;
+    (o, s, u) => {
+      const f = _i[s.toLowerCase()];
+      return n.push({
+        inputIndex: u,
+        inputLength: o.length,
+        outputIndex: u + t,
+        outputLength: f.length
+      }), t += f.length - o.length, f;
     }
   );
   return {
-    input: u,
-    output: s,
-    sourceMap: t,
+    input: e,
+    output: a,
+    sourceMap: n,
     title: "Décodage des entités HTML nommées"
   };
 }
-function G(u) {
-  let n = 0;
-  const t = [], s = u.replace(
+function Bi(e) {
+  let t = 0;
+  const n = [], a = e.replace(
     /&#(?:(\d+)|x([0-9A-F]+));/gi,
-    (e, i, r, c) => {
-      const o = parseInt(
-        i ?? r,
-        i === void 0 ? 16 : 10
-      ), p = String.fromCharCode(o);
-      return t.push({
-        inputIndex: c,
-        inputLength: e.length,
-        outputIndex: c + n,
-        outputLength: p.length
-      }), n += p.length - e.length, p;
+    (o, s, u, f) => {
+      const d = parseInt(
+        s ?? u,
+        s === void 0 ? 16 : 10
+      ), c = String.fromCharCode(d);
+      return n.push({
+        inputIndex: f,
+        inputLength: o.length,
+        outputIndex: f + t,
+        outputLength: c.length
+      }), t += c.length - o.length, c;
     }
   );
   return {
-    input: u,
-    output: s,
-    sourceMap: t,
+    input: e,
+    output: a,
+    sourceMap: n,
     title: "Décodage des entités HTML numériques"
   };
 }
-function w(u, n) {
-  return (t) => {
-    const s = [], e = t.replaceAll(u, (r, ...c) => {
-      const o = c.at(-2);
-      let p = n;
-      for (const [l, d] of c.slice(0, -2).entries())
-        p = p.replaceAll(`$${l + 1}`, d);
-      return s.push({
-        inputIndex: o,
-        inputLength: r.length,
+function ji(e, t) {
+  return (n) => {
+    const a = [], o = n.replaceAll(e, (u, ...f) => {
+      const d = f.at(-2);
+      let c = t;
+      for (const [g, m] of f.slice(0, -2).entries())
+        c = c.replaceAll(`$${g + 1}`, m);
+      return a.push({
+        inputIndex: d,
+        inputLength: u.length,
         // Note: `outputIndex` is added below.
-        outputLength: p.length
-      }), p;
+        outputLength: c.length
+      }), c;
     });
-    let i = 0;
-    for (const r of s)
-      r.outputIndex = r.inputIndex + i, i += r.outputLength - r.inputLength;
+    let s = 0;
+    for (const u of a)
+      u.outputIndex = u.inputIndex + s, s += u.outputLength - u.inputLength;
     return {
-      input: t,
-      output: e,
-      sourceMap: s,
-      title: `Remplacement de ${u} par ${JSON.stringify(n)}`
+      input: n,
+      output: o,
+      sourceMap: a,
+      title: `Remplacement de ${e} par ${JSON.stringify(t)}`
     };
   };
 }
-function X(u) {
-  const n = [];
-  let t = u;
-  for (const [s, e] of [
+function ki(e) {
+  const t = [];
+  let n = e;
+  for (const [a, o] of [
     // Note: The most englobing patterns must be first.
     // Remove HTML comment.
     [/<!--.*?-->/gs, ""],
@@ -581,6 +3069,9 @@ function X(u) {
     [/<style.*?>.*?<\/style>/gis, ""],
     // Ensure that there is always a space after "n°".
     [/(\sn°)([^\s])/gi, "$1 $2"],
+    // \u200E: left-to-right mark
+    // \u200E: right-to-left mark
+    [/[\u200E\u200F]/g, ""],
     // Remove Sénat "pastillage":
     // - \uF04B-\uF054 are circled numbers 0-9.
     // - \uF031-\uF039 are left-half circled numbers 1-9.
@@ -588,32 +3079,32 @@ function X(u) {
     // - \uF061-\uF06A are right-half circled numbers 0-9.
     [/[\uF031-\uF039\uF041-\uF054\uF061-\uF06A]/g, ""]
   ]) {
-    const i = w(s, e)(t);
-    i.sourceMap.length !== 0 && (n.push(i), t = i.output);
+    const s = ji(a, o)(n);
+    s.sourceMap.length !== 0 && (t.push(s), n = s.output);
   }
   return {
-    input: u,
-    output: t,
+    input: e,
+    output: n,
     title: "Suppression des commentaires, scripts et styles HTML et nettoyage d'expressions",
-    transformations: n
+    transformations: t
   };
 }
-function K({
-  removeAWithHref: u
+function dn({
+  removeAWithHref: e
 } = {}) {
-  return (n) => H("Simplification du HTML", [
-    D,
-    G,
-    X,
-    j,
-    k({ removeAWithHref: u }),
-    Y
-  ])(n);
+  return (t) => qi("Simplification du HTML", [
+    Ui,
+    Bi,
+    ki,
+    Hi,
+    Fi({ removeAWithHref: e }),
+    zi
+  ])(t);
 }
-function Y(u) {
-  const n = [];
-  let t = u;
-  for (const [s, e, i] of [
+function zi(e) {
+  const t = [];
+  let n = e;
+  for (const [a, o, s] of [
     ["Remplacement des espaces multiples par une espace unique", /  +/g, " "],
     ["Suppression d'une espace en début de ligne", /^ /gm, ""],
     ["Suppression d'une espace en fin de ligne", / $/gm, ""],
@@ -626,41 +3117,41 @@ function Y(u) {
     ["Suppression d'un saut de ligne en début de texte", /^\n/g, ""],
     ["Suppression d'un saut de ligne en fin de texte", /\n$/g, ""]
   ]) {
-    let r = 0;
-    const c = [], o = t.replaceAll(e, (p, ...l) => {
-      const d = l.at(-2);
-      let g = i;
-      for (const [x, T] of l.slice(0, -2).entries())
-        g = g.replaceAll(`$${x + 1}`, T);
-      return c.push({
-        inputIndex: d,
-        inputLength: p.length,
-        outputIndex: d + r,
-        outputLength: g.length
-      }), r += g.length - p.length, g;
+    let u = 0;
+    const f = [], d = n.replaceAll(o, (c, ...g) => {
+      const m = g.at(-2);
+      let E = s;
+      for (const [X, P] of g.slice(0, -2).entries())
+        E = E.replaceAll(`$${X + 1}`, P);
+      return f.push({
+        inputIndex: m,
+        inputLength: c.length,
+        outputIndex: m + u,
+        outputLength: E.length
+      }), u += E.length - c.length, E;
     });
-    c.length !== 0 && (n.push({
-      input: t,
-      output: o,
-      sourceMap: c,
-      title: s
-    }), t = o);
+    f.length !== 0 && (t.push({
+      input: n,
+      output: d,
+      sourceMap: f,
+      title: a
+    }), n = d);
   }
   return {
-    input: u,
-    output: t,
+    input: e,
+    output: n,
     title: "Simplification du texte",
-    transformations: n
+    transformations: t
   };
 }
-function j(u) {
-  const n = [];
-  let t = u;
-  for (const [e, i] of [
+function Hi(e) {
+  const t = [];
+  let n = e;
+  for (const [o, s] of [
     // Replace U+00A0 (no-break space) and tab with a normal space.
     [/[ \t]/g, " "],
-    // Replace three non-ASCII dashes (U+2010, U+2011 et U+2013) with a minus sign.
-    [/[‐‑–]/g, "-"],
+    // Replace three non-ASCII dashes (U+2010, U+2011, U+2013 et U+00B7) with a minus sign.
+    [/[‐‑–·]/g, "-"],
     // Replace non-ASCII apostrophe.
     [/’/g, "'"],
     // Replace İ (I with a point) with normal I.
@@ -669,39 +3160,146 @@ function j(u) {
     // But Légifrance uses a classic I…
     ["İ", "I"]
   ])
-    t = t.replaceAll(e, (r, ...c) => {
-      const o = c.at(-2), p = {
-        inputIndex: o,
+    n = n.replaceAll(o, (u, ...f) => {
+      const d = f.at(-2), c = {
+        inputIndex: d,
         inputLength: 1,
-        outputIndex: o,
+        outputIndex: d,
         // Note: `outputIndex` is added below.
         outputLength: 1
-      }, l = n.findIndex(
-        (d) => d.inputIndex > o
+      }, g = t.findIndex(
+        (m) => m.inputIndex > d
       );
-      return l === -1 ? n.push(p) : n.splice(l, 0, p), i;
+      return g === -1 ? t.push(c) : t.splice(g, 0, c), s;
     });
-  let s = 0;
-  for (const e of n)
-    e.outputIndex = e.inputIndex + s, s += e.outputLength - e.inputLength;
+  let a = 0;
+  for (const o of t)
+    o.outputIndex = o.inputIndex + a, a += o.outputLength - o.inputLength;
   return {
-    input: u,
-    output: t,
-    sourceMap: n,
+    input: e,
+    output: n,
+    sourceMap: t,
     title: "Simplification des caractères unicodes"
   };
 }
+function cn(e, t = !1) {
+  if (e === void 0)
+    return;
+  const n = t ? /[&"<]/g : /[&<]/g;
+  n.lastIndex = 0;
+  let a = "", o = 0;
+  for (; n.test(e); ) {
+    const s = n.lastIndex - 1, u = e[s];
+    a += e.substring(o, s) + (u === "&" ? "&amp;" : u === '"' ? "&quot;" : "&lt;"), o = s + 1;
+  }
+  return a + e.substring(o);
+}
 export {
-  H as chainTransformers,
-  k as convertHtmlElementsToText,
-  D as decodeNamedHtmlEntities,
-  G as decodeNumericHtmlEntities,
-  U as iterOriginalMergedPositionsFromTransformed,
-  q as originalMergedPositionsFromTransformed,
-  W as originalSplitPositionsFromTransformed,
-  w as replacePattern,
-  X as replacePatterns,
-  K as simplifyHtml,
-  Y as simplifyText,
-  j as simplifyUnicodeCharacters
+  Ct as TextParserContext,
+  je as action,
+  D as addChildLeftToLastChild,
+  qt as adjectifNumeralOrdinalCourt,
+  le as adverbeMultiplicatifLatin,
+  Ie as adverbeRelatif,
+  r as alternatives,
+  ii as article,
+  ei as articles,
+  at as auPortion,
+  st as auxPortions,
+  l as chain,
+  qi as chainTransformers,
+  F as citation,
+  yt as citationLigne,
+  xt as citationSimple,
+  Qi as compoundReferencesSeparators,
+  O as convert,
+  Fi as convertHtmlElementsToText,
+  $ as createEnumerationOrBoundedInterval,
+  se as createParentChildTreeFromReferences,
+  oi as date,
+  Ui as decodeNamedHtmlEntities,
+  Bi as decodeNumericHtmlEntities,
+  sn as definitionArticle,
+  on as definitionDivision,
+  ie as designationArticle,
+  Ee as designationDivision,
+  me as ditPluriel,
+  ue as ditSingulier,
+  ui as division,
+  At as divisionTypes,
+  pi as divisions,
+  Oe as duDate,
+  cn as escapeHtml,
+  T as espace,
+  ge as espaceAdverbeRelatif,
+  bt as europeanLawNatures,
+  Vi as formatLongDate,
+  St as frenchLawNatures,
+  yi as identificationTexteEuropeen,
+  Dt as internationalLawNatures,
+  Ve as introPluriel,
+  We as introSingulier,
+  Rt as isTextAstAtomicReference,
+  tn as isTextAstDivision,
+  nn as isTextAstPortion,
+  C as iterAtomicFirstParentReferences,
+  B as iterAtomicOrParentChildReferences,
+  y as iterAtomicReferences,
+  Wi as iterCardinalNumeralFormsFromNumber,
+  w as iterIncludedReferences,
+  Ji as iterLatinMultiplicativeAdverbsFromNumber,
+  Yi as iterOrdinalNumeralFormsFromNumber,
+  wi as iterOriginalMergedPositionsFromTransformed,
+  Ki as lawNatures,
+  Ot as lettreAsciiMinuscule,
+  Je as liaisonPluriel,
+  re as liaisonSingulier,
+  Qt as listeArticles,
+  en as localizationAdverbs,
+  V as natureDivisionSingulier,
+  dt as natureTexteFrancais,
+  Jt as nomArticle,
+  ot as nomSpecialArticle,
+  Pt as nombreAsTextAstNumber,
+  fe as nombreCardinal,
+  wt as nombreRomainCardinal,
+  an as nombreRomainOrdinal,
+  $t as nombreRomainOu0iAsTextAstNumber,
+  Xt as nonLettre,
+  ne as numberFromRomanNumeral,
+  Be as numero,
+  ut as numeroDivision,
+  qe as numeroEtOuDateTexteFrancais,
+  kt as numeroPortion,
+  Gi as numeroTexteEuropeen,
+  Ci as numeroTexteFrancais,
+  p as optional,
+  Oi as optionalEspaceDuTerritoire,
+  Lt as ordinalNumeralFromNumber,
+  rn as originalMergedPositionsFromTransformed,
+  un as originalSplitPositionsFromTransformed,
+  Zi as parseText,
+  Nt as portionTypes,
+  nt as portions,
+  ln as reference,
+  i as regExp,
+  he as relatifPlurielPrepose,
+  Le as relatifSingulierPrepose,
+  G as repeat,
+  ji as replacePattern,
+  ki as replacePatterns,
+  Fe as romanNumeralFromNumber,
+  dn as simplifyHtml,
+  zi as simplifyText,
+  Hi as simplifyUnicodeCharacters,
+  xi as texte,
+  $e as texteEuropeen,
+  we as texteFrancais,
+  Me as texteInternational,
+  Qe as unePortion,
+  ft as uniteBasePreciseeSingulier,
+  Te as uniteBaseSingulier,
+  b as variable,
+  S as virguleOuEspace,
+  ye as wordsTree
 };