@bravostudioai/react 0.1.1 → 0.1.2

package/dist/codegen/parser.js

@@ -0,0 +1,720 @@
+function C(c) {
+  const f = c.replace(/[^a-zA-Z0-9\s]/g, "").trim();
+  return f ? f.split(/\s+/).map((n, p) => {
+    if (!n) return "";
+    const t = n === n.toUpperCase() && n.length > 1 ? n.toLowerCase() : n, m = t.charAt(0), a = t.slice(1);
+    return p === 0 ? m.toLowerCase() + a : m.toUpperCase() + a;
+  }).join("").replace(/^[0-9]/, "_$&") : "item";
+}
+function U(c, f) {
+  const n = C(c);
+  if (f.length === 0)
+    return n;
+  const p = f.filter((a) => a && a.trim()).reverse();
+  return p.length === 0 ? n : p.map(
+    (a) => C(a)
+  ).map((a) => a.charAt(0).toUpperCase() + a.slice(1)).join("") + n;
+}
+function L(c, f) {
+  if (f.length === 0)
+    return [];
+  let n = 0;
+  const p = Math.min(
+    c.length,
+    ...f.map((m) => m.length)
+  );
+  for (let m = 0; m < p; m++) {
+    const a = c[m];
+    if (f.every((y) => y[m] === a))
+      n++;
+    else
+      break;
+  }
+  const t = c.slice(n);
+  for (let m = 1; m <= t.length; m++) {
+    const a = t.slice(0, m);
+    if (f.every((y) => {
+      if (y.length < n + m)
+        return !0;
+      const r = y.slice(
+        n,
+        n + m
+      );
+      return !Q(a, r);
+    }))
+      return a;
+  }
+  return t;
+}
+function Q(c, f) {
+  return c.length !== f.length ? !1 : c.every((n, p) => n === f[p]);
+}
+function B(c, f) {
+  return c === "component:image" || c === "component:text" || c?.startsWith("component:input-") ? "string" : "any";
+}
+function K(c) {
+  return c === "component:image" ? "imageUrl" : c === "component:text" ? "text" : "value";
+}
+function O(c) {
+  const f = [];
+  function n(t, m = []) {
+    if (!(!t || typeof t != "object")) {
+      if (t.type === "container:slider") {
+        const a = {
+          id: t.id,
+          name: t.name || "Slider",
+          arrayContainer: null
+        };
+        let e = null;
+        const y = (r) => {
+          if (!e && !(!r || typeof r != "object")) {
+            if (Array.isArray(r.tags) && (r.tags.includes("encore:data:array") || r.tags.includes("bravo:data:array"))) {
+              e = r;
+              return;
+            }
+            r.body && Array.isArray(r.body) && r.body.forEach(y), r.containers && Array.isArray(r.containers) && r.containers.forEach(y), r.components && Array.isArray(r.components) && r.components.forEach(y);
+          }
+        };
+        if (t.containers && Array.isArray(t.containers) && t.containers.forEach(y), !e && t.components && Array.isArray(t.components) && t.components.forEach(y), e) {
+          const r = e;
+          let h = [];
+          const o = [], u = (s, l = []) => {
+            if (!s || typeof s != "object") return;
+            if (s.type === "component:image" && o.push(s), Array.isArray(s.tags) && (s.tags.includes("encore:data") || s.tags.includes("bravo:data"))) {
+              const P = C(s.name || "item"), v = B(s.type, s.name);
+              h.push({
+                id: s.id,
+                name: s.name || "Unnamed",
+                type: s.type,
+                tags: s.tags || [],
+                propName: P,
+                // Will be qualified later if needed
+                propType: v,
+                // Store parent path for later qualification
+                _parentPath: [...l]
+              });
+            }
+            const g = [...l];
+            if (s.name && (s.type?.startsWith("container:") || s.type?.startsWith("component:"))) {
+              const P = s.name.trim(), v = /^frame\s*\d*$/i.test(P) || P.toUpperCase() === "FRAME";
+              P && !v && g.push(s.name);
+            }
+            s.body && Array.isArray(s.body) && s.body.forEach(
+              (P) => u(P, g)
+            ), s.containers && Array.isArray(s.containers) && s.containers.forEach(
+              (P) => u(P, g)
+            ), s.components && Array.isArray(s.components) && s.components.forEach(
+              (P) => u(P, g)
+            );
+          };
+          if (r.components && Array.isArray(r.components) && r.components.forEach(
+            (s) => u(s, [])
+          ), !h.some(
+            (s) => s.type === "component:image"
+          ) && o.length > 0) {
+            const s = o[0], g = (s.name || "image").toLowerCase().includes("image") ? "imageUrl" : C(s.name || "image");
+            h.push({
+              id: s.id,
+              name: s.name || "Image",
+              type: s.type,
+              tags: s.tags || [],
+              propName: g,
+              // Will be qualified later if needed
+              propType: "string",
+              // imageUrl is always string
+              _parentPath: []
+            });
+          }
+          const A = /* @__PURE__ */ new Map();
+          if (h.forEach((s) => {
+            const l = s, g = s.propName;
+            A.has(g) || A.set(g, []), A.get(g).push(l);
+          }), A.forEach((s, l) => {
+            if (s.length === 1)
+              return;
+            s.forEach((b) => {
+              const _ = s.filter((E) => E.id !== b.id).map((E) => E._parentPath || []), N = L(
+                b._parentPath || [],
+                _
+              );
+              b.propName = U(
+                b.name || "item",
+                N
+              );
+            });
+            let g = !0, P = 0;
+            const v = 10;
+            for (; g && P < v; ) {
+              P++;
+              const b = /* @__PURE__ */ new Map();
+              s.forEach((_) => {
+                b.has(_.propName) || b.set(_.propName, []), b.get(_.propName).push(_);
+              }), g = !1, b.forEach((_, N) => {
+                _.length > 1 && (g = !0, _.forEach((E) => {
+                  const x = E._parentPath || [], W = _.filter((M) => M.id !== E.id).map((M) => M._parentPath || []);
+                  let S = 0;
+                  const I = Math.min(
+                    x.length,
+                    ...W.map((M) => M.length)
+                  );
+                  for (let M = 0; M < I; M++) {
+                    const w = x[M];
+                    if (W.every((z) => z[M] === w))
+                      S++;
+                    else
+                      break;
+                  }
+                  const q = x.slice(S);
+                  let k = !1;
+                  for (let M = 1; M <= q.length; M++) {
+                    const w = q.slice(
+                      0,
+                      M
+                    ), j = U(
+                      E.name || "item",
+                      w
+                    );
+                    if (h.every((F) => {
+                      if (F.id === E.id) return !0;
+                      if (_.some(($) => $.id === F.id)) {
+                        const $ = F._parentPath || [], R = Math.min(
+                          S,
+                          $.length
+                        ), T = $.slice(
+                          R
+                        ).slice(0, M), Z = U(
+                          F.name || "item",
+                          T
+                        );
+                        return j !== Z;
+                      }
+                      return j !== F.propName;
+                    })) {
+                      E.propName = j, k = !0;
+                      break;
+                    }
+                  }
+                  k || (E.propName = U(
+                    E.name || "item",
+                    q.length > 0 ? q : []
+                  ));
+                }));
+              });
+            }
+            const d = /* @__PURE__ */ new Map();
+            s.forEach((b) => {
+              d.has(b.propName) || d.set(b.propName, []), d.get(b.propName).push(b);
+            }), d.forEach(
+              (b, _) => {
+                if (b.length > 1 && b.every((E) => {
+                  const x = E._parentPath || [];
+                  return b.every((W) => {
+                    if (W.id === E.id) return !0;
+                    const S = W._parentPath || [];
+                    return Q(x, S);
+                  });
+                })) {
+                  let E = 0;
+                  b.forEach((x) => {
+                    E > 0 && (x.propName = `${_}${E + 1}`), E++;
+                  });
+                }
+              }
+            ), s.forEach((b) => {
+              delete b._parentPath;
+            });
+          }), o.length > 0) {
+            const l = (o[0].name || "").toLowerCase();
+            h = h.filter((g) => {
+              if (g.type === "component:image") return !0;
+              if (g.type === "component:color") {
+                const P = (g.name || "").toLowerCase();
+                if (l.includes(P) || P.includes("image"))
+                  return !1;
+              }
+              return !0;
+            });
+          }
+          a.arrayContainer = {
+            id: r.id,
+            name: r.name || "Item",
+            propName: C(r.name || "items"),
+            components: h
+          };
+        }
+        f.push(a);
+      }
+      t.body && Array.isArray(t.body) && t.body.forEach((a) => n(a, [...m, "body"])), t.containers && Array.isArray(t.containers) && t.containers.forEach(
+        (a) => n(a, [...m, "containers"])
+      ), t.components && Array.isArray(t.components) && t.components.forEach(
+        (a) => n(a, [...m, "components"])
+      );
+    }
+  }
+  const p = c.data?.body || c.body || c.data?.body || [];
+  return Array.isArray(p) && p.length > 0 && p.forEach((t) => n(t)), f;
+}
+function V(c) {
+  const f = [], n = /* @__PURE__ */ new Set();
+  function p(e) {
+    !e || typeof e != "object" || (e.type === "container:slider" && n.add(e.id), e.body && Array.isArray(e.body) && e.body.forEach(p), e.containers && Array.isArray(e.containers) && e.containers.forEach(p));
+  }
+  function t(e, y, r = []) {
+    if (!e || typeof e != "object" || y && n.has(y)) return;
+    if (Array.isArray(e.tags) && (e.tags.includes("encore:data") || e.tags.includes("bravo:data")) && (e.type === "component:text" || e.type === "component:image")) {
+      const u = C(e.name || "item"), i = B(e.type, e.name);
+      f.push({
+        id: e.id,
+        name: e.name || "Unnamed",
+        type: e.type,
+        tags: e.tags || [],
+        propName: u,
+        // Will be qualified later if needed
+        propType: i,
+        // Store parent path for later qualification
+        _parentPath: [...r]
+      });
+    }
+    const h = [...r];
+    if (e.name && (e.type?.startsWith("container:") || e.type?.startsWith("component:"))) {
+      const u = e.name.trim(), i = /^frame\s*\d*$/i.test(u) || u.toUpperCase() === "FRAME";
+      u && !i && h.push(e.name);
+    }
+    const o = e.id;
+    e.body && Array.isArray(e.body) && e.body.forEach(
+      (u) => t(u, o, h)
+    ), e.containers && Array.isArray(e.containers) && e.containers.forEach(
+      (u) => t(u, o, h)
+    ), e.components && Array.isArray(e.components) && e.components.forEach(
+      (u) => t(u, o, h)
+    );
+  }
+  const m = c.data?.body || c.body || c.data?.body || [];
+  Array.isArray(m) && m.length > 0 && (m.forEach(p), m.forEach((e) => t(e)));
+  const a = /* @__PURE__ */ new Map();
+  return f.forEach((e) => {
+    const y = e, r = e.propName;
+    a.has(r) || a.set(r, []), a.get(r).push(y);
+  }), a.forEach((e, y) => {
+    if (e.length === 1)
+      return;
+    e.forEach((i) => {
+      const A = e.filter((l) => l.id !== i.id).map((l) => l._parentPath || []), s = L(
+        i._parentPath || [],
+        A
+      );
+      i.propName = U(
+        i.name || "item",
+        s
+      );
+    });
+    let r = !0, h = 0;
+    const o = 10;
+    for (; r && h < o; ) {
+      h++;
+      const i = /* @__PURE__ */ new Map();
+      e.forEach((A) => {
+        i.has(A.propName) || i.set(A.propName, []), i.get(A.propName).push(A);
+      }), r = !1, i.forEach((A, s) => {
+        A.length > 1 && (r = !0, A.forEach((l) => {
+          const g = l._parentPath || [], P = A.filter((N) => N.id !== l.id).map((N) => N._parentPath || []);
+          let v = 0;
+          const d = Math.min(
+            g.length,
+            ...P.map((N) => N.length)
+          );
+          for (let N = 0; N < d; N++) {
+            const E = g[N];
+            if (P.every((W) => W[N] === E))
+              v++;
+            else
+              break;
+          }
+          const b = g.slice(v);
+          let _ = !1;
+          for (let N = 1; N <= b.length; N++) {
+            const E = b.slice(0, N), x = U(
+              l.name || "item",
+              E
+            );
+            if (f.every((S) => {
+              if (S.id === l.id) return !0;
+              if (A.some((I) => I.id === S.id)) {
+                const I = S._parentPath || [], q = Math.min(
+                  v,
+                  I.length
+                ), M = I.slice(
+                  q
+                ).slice(
+                  0,
+                  N
+                ), w = U(
+                  S.name || "item",
+                  M
+                );
+                return x !== w;
+              }
+              return x !== S.propName;
+            })) {
+              l.propName = x, _ = !0;
+              break;
+            }
+          }
+          _ || (l.propName = U(
+            l.name || "item",
+            g
+          ));
+        }));
+      });
+    }
+    const u = /* @__PURE__ */ new Map();
+    e.forEach((i) => {
+      u.has(i.propName) || u.set(i.propName, []), u.get(i.propName).push(i);
+    }), u.forEach((i, A) => {
+      if (i.length > 1 && i.every((l) => {
+        const g = l._parentPath || [];
+        return i.every((P) => {
+          if (P.id === l.id) return !0;
+          const v = P._parentPath || [];
+          return Q(g, v);
+        });
+      })) {
+        let l = 0;
+        i.forEach((g) => {
+          l > 0 && (g.propName = `${A}${l + 1}`), l++;
+        });
+      }
+    }), e.forEach((i) => {
+      delete i._parentPath;
+    });
+  }), f;
+}
+function X(c) {
+  const f = /* @__PURE__ */ new Map();
+  function n(t) {
+    if (!(!t || typeof t != "object")) {
+      if (t.type === "component:input-stateful-set" && Array.isArray(t.tags)) {
+        const m = t.tags.find(
+          (a) => a.startsWith("input-group:")
+        );
+        if (m) {
+          const a = m.split(":");
+          if (a.length >= 3) {
+            const e = a[1], y = a[2];
+            f.has(y) || f.set(y, {
+              groupName: y,
+              groupType: e,
+              elements: []
+            }), f.get(y).elements.push({
+              id: t.id,
+              name: t.name || "Unnamed"
+            });
+          }
+        }
+      }
+      t.body && Array.isArray(t.body) && t.body.forEach(n), t.containers && Array.isArray(t.containers) && t.containers.forEach(n), t.components && Array.isArray(t.components) && t.components.forEach(n);
+    }
+  }
+  const p = c.data?.body || c.body || c.data?.body || [];
+  return Array.isArray(p) && p.length > 0 && p.forEach((t) => n(t)), Array.from(f.values());
+}
+function Y(c) {
+  const f = [];
+  function n(t, m) {
+    if (!t || typeof t != "object") return;
+    const a = t.type?.startsWith("container:") || t.type === "container:default", e = t.name?.toLowerCase().includes("form") || Array.isArray(t.tags) && t.tags.includes("form");
+    let y = !1, r;
+    function h(o) {
+      if (!(!o || typeof o != "object")) {
+        if (Array.isArray(o.tags) && (o.tags.includes("action:submit") || o.tags.includes("submit"))) {
+          y = !0, r = o.id;
+          return;
+        }
+        if (o.actions?.tap?.action === "submit") {
+          y = !0, r = o.id;
+          return;
+        }
+        o.components && Array.isArray(o.components) && o.components.forEach(h), o.body && Array.isArray(o.body) && o.body.forEach(h);
+      }
+    }
+    if (a && (e || m === void 0) && h(t), a && (y || e)) {
+      const o = [], u = (i, A = []) => {
+        if (!i || typeof i != "object") return;
+        if (i.type?.startsWith("component:input-") || i.type === "component:input-text" || i.type === "component:input-image" || i.type === "component:input-email" || i.type === "component:input-password" || i.type === "component:input-select") {
+          const l = C(i.name || "Unnamed input");
+          o.push({
+            id: i.id,
+            name: i.name || "Unnamed input",
+            type: i.type,
+            propName: l,
+            // Will be qualified later if needed
+            _parentPath: [...A]
+            // Store parent path for qualification
+          });
+        }
+        const s = [...A];
+        if (i.name && (i.type?.startsWith("container:") || i.type?.startsWith("component:"))) {
+          const l = i.name.trim(), g = /^frame\s*\d*$/i.test(l) || l.toUpperCase() === "FRAME";
+          l && !g && s.push(i.name);
+        }
+        i.components && Array.isArray(i.components) && i.components.forEach(
+          (l) => u(l, s)
+        ), i.body && Array.isArray(i.body) && i.body.forEach((l) => u(l, s));
+      };
+      u(t, []), o.length > 0 && f.push({
+        formId: t.id,
+        formName: t.name || "Form",
+        submitButtonId: r,
+        inputs: o
+      });
+    }
+    t.body && Array.isArray(t.body) && t.body.forEach(
+      (o) => n(o, a ? t : m)
+    ), t.containers && Array.isArray(t.containers) && t.containers.forEach(
+      (o) => n(o, a ? t : m)
+    ), t.components && Array.isArray(t.components) && t.components.forEach(
+      (o) => n(o, a ? t : m)
+    );
+  }
+  const p = c.data?.body || c.body || c.data?.body || [];
+  return Array.isArray(p) && p.length > 0 && p.forEach((t) => n(t)), f;
+}
+function D(c, f) {
+  const n = [], p = /* @__PURE__ */ new Set();
+  f.forEach((a) => {
+    a.inputs.forEach((e) => {
+      p.add(e.id);
+    });
+  });
+  function t(a, e = []) {
+    if (!a || typeof a != "object") return;
+    if (a.type === "component:input-select" && !p.has(a.id)) {
+      const r = C(a.name || "selectInput");
+      n.push({
+        id: a.id,
+        name: a.name || "Select Input",
+        propName: r,
+        _parentPath: [...e]
+      });
+    }
+    const y = [...e];
+    if (a.name && (a.type?.startsWith("container:") || a.type?.startsWith("component:"))) {
+      const r = a.name.trim(), h = /^frame\s*\d*$/i.test(r) || r.toUpperCase() === "FRAME";
+      r && !h && y.push(a.name);
+    }
+    a.body && Array.isArray(a.body) && a.body.forEach((r) => t(r, y)), a.containers && Array.isArray(a.containers) && a.containers.forEach(
+      (r) => t(r, y)
+    ), a.components && Array.isArray(a.components) && a.components.forEach(
+      (r) => t(r, y)
+    );
+  }
+  const m = c.data?.body || c.body || c.data?.body || [];
+  return Array.isArray(m) && m.length > 0 && m.forEach((a) => t(a)), G(n), n;
+}
+function G(c) {
+  const f = /* @__PURE__ */ new Map();
+  c.forEach((n) => {
+    const p = n, t = n.propName;
+    f.has(t) || f.set(t, []), f.get(t).push(p);
+  }), f.forEach((n, p) => {
+    if (n.length === 1) {
+      delete n[0]._parentPath;
+      return;
+    }
+    n.forEach((t) => {
+      const m = n.filter((e) => e.id !== t.id).map((e) => e._parentPath || []), a = L(
+        t._parentPath || [],
+        m
+      );
+      t.propName = U(
+        t.name || "input",
+        a
+      );
+    }), n.forEach((t) => {
+      delete t._parentPath;
+    });
+  });
+}
+function tt(c) {
+  const f = [];
+  function n(t, m = []) {
+    if (!t || typeof t != "object") return;
+    const a = Array.isArray(t.tags) && t.tags.some((r) => r.startsWith("action:")), e = t.actions && typeof t.actions == "object";
+    if (a || e) {
+      let r = "tap";
+      if (Array.isArray(t.tags)) {
+        const o = t.tags.find(
+          (u) => u.startsWith("action:")
+        );
+        o && (r = o.replace("action:", ""));
+      }
+      t.actions?.tap?.action && (r = t.actions.tap.action);
+      const h = C(t.name || "button");
+      f.push({
+        id: t.id,
+        name: t.name || "Button",
+        propName: h,
+        actionType: r,
+        _parentPath: [...m]
+      });
+    }
+    const y = [...m];
+    if (t.name && (t.type?.startsWith("container:") || t.type?.startsWith("component:"))) {
+      const r = t.name.trim(), h = /^frame\s*\d*$/i.test(r) || r.toUpperCase() === "FRAME";
+      r && !h && y.push(t.name);
+    }
+    t.body && Array.isArray(t.body) && t.body.forEach((r) => n(r, y)), t.containers && Array.isArray(t.containers) && t.containers.forEach(
+      (r) => n(r, y)
+    ), t.components && Array.isArray(t.components) && t.components.forEach(
+      (r) => n(r, y)
+    );
+  }
+  const p = c.data?.body || c.body || c.data?.body || [];
+  return Array.isArray(p) && p.length > 0 && p.forEach((t) => n(t)), H(f), f;
+}
+function H(c) {
+  const f = /* @__PURE__ */ new Map();
+  c.forEach((n) => {
+    const p = n, t = n.propName;
+    f.has(t) || f.set(t, []), f.get(t).push(p);
+  }), f.forEach((n, p) => {
+    if (n.length === 1) {
+      delete n[0]._parentPath;
+      return;
+    }
+    n.forEach((t) => {
+      const m = n.filter((e) => e.id !== t.id).map((e) => e._parentPath || []), a = L(
+        t._parentPath || [],
+        m
+      );
+      t.propName = U(
+        t.name || "button",
+        a
+      );
+    }), n.forEach((t) => {
+      delete t._parentPath;
+    });
+  });
+}
+function et(c) {
+  c.forEach((f) => {
+    const n = f.inputs, p = /* @__PURE__ */ new Map();
+    n.forEach((t) => {
+      const m = t, a = t.propName;
+      p.has(a) || p.set(a, []), p.get(a).push(m);
+    }), p.forEach((t, m) => {
+      if (t.length === 1) {
+        delete t[0]._parentPath;
+        return;
+      }
+      t.forEach((h) => {
+        const o = t.filter((i) => i.id !== h.id).map((i) => i._parentPath || []), u = L(
+          h._parentPath || [],
+          o
+        );
+        h.propName = U(
+          h.name || "input",
+          u
+        );
+      });
+      let a = !0, e = 0;
+      const y = 10;
+      for (; a && e < y; ) {
+        e++;
+        const h = /* @__PURE__ */ new Map();
+        t.forEach((o) => {
+          h.has(o.propName) || h.set(o.propName, []), h.get(o.propName).push(o);
+        }), a = !1, h.forEach((o, u) => {
+          o.length > 1 && (a = !0, o.forEach((i) => {
+            const A = i._parentPath || [], s = o.filter((d) => d.id !== i.id).map((d) => d._parentPath || []);
+            let l = 0;
+            const g = Math.min(
+              A.length,
+              ...s.map((d) => d.length)
+            );
+            for (let d = 0; d < g; d++) {
+              const b = A[d];
+              if (s.every((N) => N[d] === b))
+                l++;
+              else
+                break;
+            }
+            const P = A.slice(l);
+            let v = !1;
+            for (let d = 1; d <= P.length; d++) {
+              const b = P.slice(
+                0,
+                d
+              ), _ = U(
+                i.name || "input",
+                b
+              );
+              if (n.every((E) => {
+                if (E.id === i.id) return !0;
+                if (o.some((x) => x.id === E.id)) {
+                  const x = E._parentPath || [], W = Math.min(
+                    l,
+                    x.length
+                  ), I = x.slice(
+                    W
+                  ).slice(
+                    0,
+                    d
+                  ), q = U(
+                    E.name || "input",
+                    I
+                  );
+                  return _ !== q;
+                }
+                return _ !== E.propName;
+              })) {
+                i.propName = _, v = !0;
+                break;
+              }
+            }
+            v || (i.propName = U(
+              i.name || "input",
+              P.length > 0 ? P : []
+            ));
+          }));
+        });
+      }
+      const r = /* @__PURE__ */ new Map();
+      t.forEach((h) => {
+        r.has(h.propName) || r.set(h.propName, []), r.get(h.propName).push(h);
+      }), r.forEach((h, o) => {
+        if (h.length > 1 && h.every((i) => {
+          const A = i._parentPath || [];
+          return h.every((s) => {
+            if (s.id === i.id) return !0;
+            const l = s._parentPath || [];
+            return Q(A, l);
+          });
+        })) {
+          let i = 0;
+          h.forEach((A) => {
+            i > 0 && (A.propName = `${o}${i + 1}`), i++;
+          });
+        }
+      }), t.forEach((h) => {
+        delete h._parentPath;
+      });
+    });
+  });
+}
+export {
+  Q as arraysEqual,
+  tt as findActionButtons,
+  Y as findForms,
+  X as findInputGroups,
+  L as findMinimalDistinguishingPath,
+  O as findSlidersAndDataBindings,
+  V as findStandaloneComponents,
+  D as findStandaloneSelectInputs,
+  U as generateQualifiedPropName,
+  K as getComponentPropName,
+  B as getComponentPropType,
+  et as qualifyFormInputs,
+  C as sanitizePropName
+};
+//# sourceMappingURL=parser.js.map