@scalar/api-reference 1.28.20 → 1.28.22

package/dist/helpers/parse.js

@@ -1,68 +1,63 @@
-import { redirectToProxy as A, shouldIgnoreEntity as u } from "@scalar/oas-utils/helpers";
-import { load as M, dereference as R } from "@scalar/openapi-parser";
-import { fetchUrls as q } from "@scalar/openapi-parser/plugins/fetch-urls";
+import { redirectToProxy as R, shouldIgnoreEntity as u } from "@scalar/oas-utils/helpers";
+import { load as M, dereference as q } from "@scalar/openapi-parser";
+import { fetchUrls as D } from "@scalar/openapi-parser/plugins/fetch-urls";
 import { createEmptySpecification as O } from "./createEmptySpecification.js";
-import { normalizeRequestMethod as $ } from "../legacy/helpers/normalizeRequestMethod.js";
-import { validRequestMethods as D } from "../legacy/fixtures/httpRequestMethods.js";
+import { normalizeRequestMethod as j } from "../legacy/helpers/normalizeRequestMethod.js";
+import { validRequestMethods as C } from "../legacy/fixtures/httpRequestMethods.js";
 const G = (m, {
-  proxyUrl: e,
-  source: h
-} = {}) => new Promise(async (l, g) => {
-  var y;
+  proxyUrl: e
+} = {}) => new Promise(async (n, b) => {
+  var h;
   try {
     if (!m)
-      return l(x(O()));
-    const s = performance.now(), { filesystem: c } = await M(m, {
-      source: h,
+      return n(I(O()));
+    const f = performance.now(), { filesystem: s } = await M(m, {
       plugins: [
-        q({
-          fetch: async (a) => {
-            const n = await fetch(e ? A(e, a) : a);
-            return n.ok ? console.info(`fetch($ref): ${a} (${Math.round((await n.clone().text()).length / 1024)} kB)`) : console.error(`fetch($ref): ${a} (${n.status} ${n.statusText})`), n;
-          }
+        D({
+          fetch: (o) => fetch(e ? R(e, o) : o)
         })
       ]
-    }), { schema: o, errors: t } = await R(c), r = performance.now();
-    return console.info(`dereference: ${Math.round(r - s)} ms`), t != null && t.length && console.warn(
+    }), { schema: a, errors: r } = await q(s), t = performance.now();
+    return console.log(`dereference: ${Math.round(t - f)} ms`), r != null && r.length && console.warn(
       `Please open an issue on https://github.com/scalar/scalar
 `,
       `Scalar OpenAPI Parser Warning:
 `,
-      t
-    ), o === void 0 ? (g(((y = t == null ? void 0 : t[0]) == null ? void 0 : y.message) ?? "Failed to parse the OpenAPI file."), l(x(O()))) : l(x(o));
-  } catch (s) {
-    console.error("[@scalar/api-reference]", "Failed to parse the OpenAPI document. It might be invalid?"), console.error(s), g(s);
+      r
+    ), a === void 0 ? (b(((h = r == null ? void 0 : r[0]) == null ? void 0 : h.message) ?? "Failed to parse the OpenAPI file."), n(I(O()))) : n(I(a));
+  } catch (f) {
+    console.error("[@scalar/api-reference]", "Failed to parse the OpenAPI document. It might be invalid?"), console.error(f), b(f);
   }
-  return l(x(O()));
-}), x = (m) => {
-  var g, y;
+  return n(I(O()));
+}), I = (m) => {
+  var h, f;
   let e = {};
   m && typeof m == "object" ? e = structuredClone(m) : e = O(), e.tags || (e.tags = []), e.paths || (e.paths = {}), e.components || (e.components = {}), e.webhooks || (e.webhooks = {}), e.servers || (e.servers = []), e.security || (e.security = []), e.externalDocs || (e.externalDocs = {});
-  const h = {};
+  const n = {};
   return Object.keys(e.webhooks ?? {}).forEach((s) => {
-    var c;
-    Object.keys(((c = e.webhooks) == null ? void 0 : c[s]) ?? {}).forEach((o) => {
-      var r, a, n, w;
-      const t = (r = e.webhooks) == null ? void 0 : r[s][o];
+    var a;
+    Object.keys(((a = e.webhooks) == null ? void 0 : a[s]) ?? {}).forEach((r) => {
+      var o, l, g, y;
+      const t = (o = e.webhooks) == null ? void 0 : o[s][r];
       if (!(!t || u(t))) {
         if (Array.isArray(t.tags)) {
-          const i = (a = t.tags) == null ? void 0 : a.map(
-            (f) => {
-              var I;
-              return (I = e.tags) == null ? void 0 : I.find((p) => p.name === f);
+          const i = (l = t.tags) == null ? void 0 : l.map(
+            (c) => {
+              var w;
+              return (w = e.tags) == null ? void 0 : w.find((p) => p.name === c);
             }
           );
-          if (t.tags = i == null ? void 0 : i.filter((f) => !u(f)), i != null && i.some((f) => u(f)))
+          if (t.tags = i == null ? void 0 : i.filter((c) => !u(c)), i != null && i.some((c) => u(c)))
             return;
         }
-        h[s] === void 0 && (h[s] = {}), h[s][o] = {
+        n[s] === void 0 && (n[s] = {}), n[s][r] = {
           // Transformed data
-          httpVerb: $(o),
+          httpVerb: j(r),
           path: s,
           operationId: (t == null ? void 0 : t.operationId) || s,
           name: (t == null ? void 0 : t.summary) || s || "",
           description: (t == null ? void 0 : t.description) || "",
-          pathParameters: (w = (n = e.paths) == null ? void 0 : n[s]) == null ? void 0 : w.parameters,
+          pathParameters: (y = (g = e.paths) == null ? void 0 : g[s]) == null ? void 0 : y.parameters,
           // Original webhook
           information: {
             ...t
@@ -70,19 +65,19 @@ const G = (m, {
         };
       }
     });
-  }), Object.keys(((g = e.components) == null ? void 0 : g.schemas) ?? {}).forEach((s) => {
-    var c, o, t, r;
-    u((o = (c = e.components) == null ? void 0 : c.schemas) == null ? void 0 : o[s]) && ((r = (t = e.components) == null ? void 0 : t.schemas) == null || delete r[s]);
+  }), Object.keys(((h = e.components) == null ? void 0 : h.schemas) ?? {}).forEach((s) => {
+    var a, r, t, o;
+    u((r = (a = e.components) == null ? void 0 : a.schemas) == null ? void 0 : r[s]) && ((o = (t = e.components) == null ? void 0 : t.schemas) == null || delete o[s]);
   }), Object.keys(e.paths).forEach((s) => {
     Object.keys(e.paths[s]).filter(
-      (o) => D.includes(o.toUpperCase())
-    ).forEach((o) => {
-      var a, n, w, i, f, I;
-      const t = e.paths[s][o];
+      (r) => C.includes(r.toUpperCase())
+    ).forEach((r) => {
+      var l, g, y, i, c, w;
+      const t = e.paths[s][r];
       if (t === void 0 || u(t))
         return;
-      const r = {
-        httpVerb: $(o),
+      const o = {
+        httpVerb: j(r),
         path: s,
         operationId: t.operationId || s,
         name: t.summary || s || "",
@@ -90,33 +85,33 @@ const G = (m, {
         information: {
           ...t
         },
-        pathParameters: (n = (a = e.paths) == null ? void 0 : a[s]) == null ? void 0 : n.parameters
+        pathParameters: (g = (l = e.paths) == null ? void 0 : l[s]) == null ? void 0 : g.parameters
       };
       if (!t.tags || t.tags.length === 0) {
-        (w = e.tags) != null && w.find((d) => d.name === "default") || (i = e.tags) == null || i.push({
+        (y = e.tags) != null && y.find((d) => d.name === "default") || (i = e.tags) == null || i.push({
           name: "default",
           description: "",
           operations: []
         });
-        const p = (f = e.tags) == null ? void 0 : f.findIndex(
+        const p = (c = e.tags) == null ? void 0 : c.findIndex(
           (d) => d.name === "default"
         );
-        p >= 0 && ((I = e.tags[p]) == null || I.operations.push(r));
+        p >= 0 && ((w = e.tags[p]) == null || w.operations.push(o));
       } else
         t.tags.forEach((p) => {
-          var k, E, P;
-          const d = (k = e.tags) == null ? void 0 : k.findIndex((j) => j.name === p);
-          d === -1 && ((E = e.tags) == null || E.push({
+          var E, P, k;
+          const d = (E = e.tags) == null ? void 0 : E.findIndex((A) => A.name === p);
+          d === -1 && ((P = e.tags) == null || P.push({
             name: p,
             description: ""
           }));
-          const b = d !== -1 ? d : e.tags.length - 1;
-          typeof ((P = e.tags[b]) == null ? void 0 : P.operations) > "u" && (e.tags[b].operations = []), e.tags[b].operations.push(r);
+          const x = d !== -1 ? d : e.tags.length - 1;
+          typeof ((k = e.tags[x]) == null ? void 0 : k.operations) > "u" && (e.tags[x].operations = []), e.tags[x].operations.push(o);
         });
     });
-  }), e.tags = (y = e.tags) == null ? void 0 : y.filter((s) => !u(s)), {
+  }), e.tags = (f = e.tags) == null ? void 0 : f.filter((s) => !u(s)), {
     ...e,
-    webhooks: h
+    webhooks: n
   };
 };
 export {

package/dist/hooks/useMultipleDocuments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMultipleDocuments.d.ts","sourceRoot":"","sources":["../../src/hooks/useMultipleDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,iBAAiB,EAEvB,MAAM,6BAA6B,CAAA;AAGpC,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,KAAK,CAAA;AAKpD,KAAK,yBAAyB,GAAG;IAC/B;;;OAGG;IACH,aAAa,EAAE,GAAG,CAAC,4BAA4B,GAAG,SAAS,CAAC,CAAA;IAC5D,2FAA2F;IAC3F,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,GAAG,QAAQ,CAAA;AAIZ;;GAEG;AACH,eAAO,MAAM,uBAAuB,kBACnB,4BAA4B,GAAG,SAAS,KACtD,iBAAiB,EA6BnB,CAAA;AA0CD,eAAO,MAAM,oBAAoB,8EAM9B,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;0CA8H2zoB,GAAI;oBAAuF,GAAG;;;;yBAAiH,CAAC;;;;;;;;;;;;;yCAAymB,GAAI;2CAA6E,GAAI;6BAAgE,GAAG;qBAAwE,GAAG;uCAAyF,GAAI;2CAA6F,GAAI;;;;;gBAA0K,CAAC;WAA4B,GAAI;;gBAAyF,CAAC;WAA4B,GAAI;;gBAAuF,CAAC;WAA4B,GAAI;;;;uBAAkJ,CAAC;mBAAqC,CAAC;WAA4B,GAAI;;;kBAAmH,CAAC;WAA4B,GAAI;qCAAyE,GAAI;;2DAAgK,GAAI;4EAAgH,GAAI;;;uDA/K7otB,GAAG;;;;;;;;;mDAAH,GAAG;;;;;;;;CA8KrD,CAAA"}
+{"version":3,"file":"useMultipleDocuments.d.ts","sourceRoot":"","sources":["../../src/hooks/useMultipleDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,iBAAiB,EAEvB,MAAM,6BAA6B,CAAA;AAGpC,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,KAAK,CAAA;AAKpD,KAAK,yBAAyB,GAAG;IAC/B;;;OAGG;IACH,aAAa,EAAE,GAAG,CAAC,4BAA4B,GAAG,SAAS,CAAC,CAAA;IAC5D,2FAA2F;IAC3F,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,GAAG,QAAQ,CAAA;AAIZ;;GAEG;AACH,eAAO,MAAM,uBAAuB,kBACnB,4BAA4B,GAAG,SAAS,KACtD,iBAAiB,EA6BnB,CAAA;AA0CD,eAAO,MAAM,oBAAoB,8EAM9B,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;0CAmIgooB,GAAI;oBAAuF,GAAG;;;;yBAAiH,CAAC;;;;;;;;;;;;;yCAAymB,GAAI;2CAA6E,GAAI;6BAAgE,GAAG;qBAAwE,GAAG;uCAAyF,GAAI;2CAA6F,GAAI;;;;;gBAA0K,CAAC;WAA4B,GAAI;;gBAAyF,CAAC;WAA4B,GAAI;;gBAAuF,CAAC;WAA4B,GAAI;;;;uBAAkJ,CAAC;mBAAqC,CAAC;WAA4B,GAAI;;;kBAAmH,CAAC;WAA4B,GAAI;qCAAyE,GAAI;;2DAAgK,GAAI;4EAAgH,GAAI;;;uDApLl9sB,GAAG;;;;;;;;;mDAAH,GAAG;;;;;;;;CAmLrD,CAAA"}

package/dist/hooks/useMultipleDocuments.js

@@ -1,45 +1,45 @@
-import { isDefined as h } from "@scalar/oas-utils/helpers";
+import { isDefined as S } from "@scalar/oas-utils/helpers";
 import { isConfigurationWithSources as y } from "@scalar/types/api-reference";
-import S from "github-slugger";
-import { computed as v, ref as A, watch as b } from "vue";
-const w = "api", g = new S(), C = (t) => t ? (Array.isArray(t) ? t : [t]).flatMap((u) => {
+import R from "github-slugger";
+import { computed as g, ref as b, watch as A } from "vue";
+const w = "api", h = new R(), C = (t) => t ? (Array.isArray(t) ? t : [t]).flatMap((u) => {
   if (y(u)) {
-    const { sources: a, ...r } = u;
-    return (a == null ? void 0 : a.map((m) => ({ ...r, ...m }))) ?? [];
+    const { sources: s, ...r } = u;
+    return (s == null ? void 0 : s.map((m) => ({ ...r, ...m }))) ?? [];
   }
   return [u];
-}).map((u, a) => u && I(u, a)).filter(h) : [], I = (t, s = 0) => {
+}).map((u, s) => u && I(u, s)).filter(S) : [], I = (t, a = 0) => {
   const e = {
     ...t,
     // @ts-expect-error this is before parsing so we transform the old style
     ...t.spec ?? {}
   };
   if (!(!(e != null && e.url) && !(e != null && e.content)))
-    return g.reset(), e.title ? {
+    return h.reset(), e.title ? {
       ...e,
-      slug: e.slug || g.slug(e.title),
+      slug: e.slug || h.slug(e.title),
       title: e.title
     } : e.slug ? {
       ...e,
       title: e.slug
     } : {
       ...e,
-      slug: `api-${s + 1}`,
-      title: `API #${s + 1}`
+      slug: `api-${a + 1}`,
+      title: `API #${a + 1}`
     };
-}, P = ({
+}, T = ({
   configuration: t,
-  initialIndex: s,
+  initialIndex: a,
   isIntersectionEnabled: e,
   hash: u,
-  hashPrefix: a
+  hashPrefix: s
 }) => {
-  const r = v(() => C(t.value)), f = A((() => {
+  const r = g(() => C(t.value)), f = b((() => {
     if (typeof window > "u")
-      return typeof s == "number" ? s : 0;
+      return typeof a == "number" ? a : 0;
     const n = new URL(window.location.href).searchParams.get(w);
     if (n) {
-      const o = r.value.findIndex((d) => d.slug === n);
+      const o = r.value.findIndex((p) => p.slug === n);
       if (o !== -1)
         return o;
       const i = Number.parseInt(n, 10);
@@ -47,8 +47,8 @@ const w = "api", g = new S(), C = (t) => t ? (Array.isArray(t) ? t : [t]).flatMa
         return i;
     }
     const l = r.value.findIndex((o) => "default" in o && o.default === !0);
-    return l !== -1 ? l : typeof s == "number" ? s : 0;
-  })()), p = v(() => {
+    return l !== -1 ? l : typeof a == "number" ? a : 0;
+  })()), c = g(() => {
     var n, l;
     return t.value && y(t.value) ? {
       ...t.value,
@@ -59,26 +59,28 @@ const w = "api", g = new S(), C = (t) => t ? (Array.isArray(t) ? t : [t]).flatMa
       ...r.value[f.value]
     };
   });
-  return b(
+  return A(
     f,
-    (c) => {
-      var i, d;
+    (d) => {
+      var i, p, v;
       if (typeof window > "u" || r.value.length === 1)
         return;
-      const n = new URL(window.location.href), l = r.value[c], o = (l == null ? void 0 : l.slug) ?? c.toString();
-      n.searchParams.set(w, o), n.hash = "", window.history.replaceState({}, "", n.toString()), u.value = "", a.value = "", e.value = !1, typeof window < "u" && window.scrollTo({ top: 0, behavior: "instant" }), (d = (i = p.value).onDocumentSelect) == null || d.call(i);
+      const n = new URL(window.location.href), l = r.value[d];
+      c.value.pathRouting && (n.pathname = ((i = c.value.pathRouting) == null ? void 0 : i.basePath) ?? "");
+      const o = (l == null ? void 0 : l.slug) ?? d.toString();
+      n.searchParams.set(w, o), n.hash = "", window.history.replaceState({}, "", n.toString()), u.value = "", s.value = "", e.value = !1, typeof window < "u" && window.scrollTo({ top: 0, behavior: "instant" }), (v = (p = c.value).onDocumentSelect) == null || v.call(p);
     },
     { flush: "sync" }
   ), {
-    selectedConfiguration: p,
+    selectedConfiguration: c,
     availableDocuments: r,
     selectedDocumentIndex: f,
     isIntersectionEnabled: e,
     hash: u,
-    hashPrefix: a
+    hashPrefix: s
   };
 };
 export {
   C as normalizeConfigurations,
-  P as useMultipleDocuments
+  T as useMultipleDocuments
 };

package/dist/hooks/useReactiveSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useReactiveSpec.d.ts","sourceRoot":"","sources":["../../src/hooks/useReactiveSpec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,KAAK,CAAA;AAgDhE;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAC9B,UAAU,EACV,QAAQ,GACT,EAAE;IACD,UAAU,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAAA;IAChD,QAAQ,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDA"}
+{"version":3,"file":"useReactiveSpec.d.ts","sourceRoot":"","sources":["../../src/hooks/useReactiveSpec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,KAAK,CAAA;AAgDhE;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAC9B,UAAU,EACV,QAAQ,GACT,EAAE;IACD,UAAU,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAAA;IAChD,QAAQ,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwDA"}

package/dist/hooks/useReactiveSpec.js

@@ -1,15 +1,15 @@
 import { fetchDocument as l, prettyPrintJson as d } from "@scalar/oas-utils/helpers";
-import { ref as f, watch as p, toValue as u } from "vue";
+import { ref as s, watch as u, toValue as f } from "vue";
 import { parse as h } from "../helpers/parse.js";
 import { createEmptySpecification as m } from "../helpers/createEmptySpecification.js";
-const v = async ({ url: r, content: e }, n) => {
-  if (r) {
+const v = async ({ url: a, content: e }, r) => {
+  if (a) {
     const i = performance.now();
     try {
-      const c = await l(r, n), o = performance.now();
-      return console.log(`fetch: ${Math.round(o - i)} ms (${r})`), console.log("size:", Math.round(c.length / 1024), "kB"), c;
-    } catch (c) {
-      console.error("Failed to fetch OpenAPI document from URL:", c);
+      const n = await l(a, r), o = performance.now();
+      return console.log(`fetch: ${Math.round(o - i)} ms (${a})`), console.log("size:", Math.round(n.length / 1024), "kB"), n;
+    } catch (n) {
+      console.error("Failed to fetch OpenAPI document from URL:", n);
     }
   }
   const t = typeof e == "function" ? e() : e;
@@ -18,44 +18,42 @@ const v = async ({ url: r, content: e }, n) => {
   if (typeof t == "object")
     return d(t);
 };
-function E({
-  specConfig: r,
+function C({
+  specConfig: a,
   proxyUrl: e
 }) {
-  const n = f(""), t = f(m()), i = f(null);
-  function c(o) {
-    var s;
+  const r = s(""), t = s(m()), i = s(null);
+  function n(o) {
     if (!o) {
       t.value = m();
       return;
     }
     h(o, {
-      proxyUrl: e ? u(e) : void 0,
-      source: (s = u(r)) == null ? void 0 : s.url
-    }).then((a) => {
-      i.value = null, t.value = a;
-    }).catch((a) => {
-      i.value = a.toString();
+      proxyUrl: e ? f(e) : void 0
+    }).then((c) => {
+      i.value = null, t.value = c;
+    }).catch((c) => {
+      i.value = c.toString();
     });
   }
-  return p(
-    () => u(r),
+  return u(
+    () => f(a),
     async (o) => {
-      var s;
+      var c;
       if (o) {
-        const a = (s = await v(o, u(e))) == null ? void 0 : s.trim();
-        typeof a == "string" && (n.value = a);
+        const p = (c = await v(o, f(e))) == null ? void 0 : c.trim();
+        typeof p == "string" && (r.value = p);
       }
     },
     { immediate: !0, deep: !0 }
-  ), p(n, () => {
-    c(n.value);
+  ), u(r, () => {
+    n(r.value);
   }), {
-    rawSpec: n,
+    rawSpec: r,
     parsedSpec: t,
     specErrors: i
   };
 }
 export {
-  E as useReactiveSpec
+  C as useReactiveSpec
 };