@blukavantui/community 0.0.0-stage → 1.0.1

package/src/runtime/quote-card.d.ts

@@ -0,0 +1 @@
+export function installQuoteCard(): any;

package/src/runtime/quote-card.js

@@ -0,0 +1,153 @@
+// ../blu-grid/docs/scripts/modules/qr-encoder.js
+import { global } from "./kernel.js";
+
+// ../blu-grid/docs/scripts/modules/common.js
+import { global as global2, runtime, state, register } from "./kernel.js";
+
+// ../blu-grid/docs/scripts/modules/rich.js
+import { global as global3, runtime as runtime2, state as state2, register as register2 } from "./kernel.js";
+var shared = /* @__PURE__ */ state2("rich", () => ({ instances: /* @__PURE__ */ new Map(), serial: 0 }));
+function el(tag, cls, value) {
+  var n = document.createElement(tag);
+  if (cls) n.className = cls;
+  if (value !== void 0) n.textContent = value;
+  return n;
+}
+function attr(n, k, v) {
+  n.setAttribute(k, String(v));
+  return n;
+}
+function num(v, d, min, max) {
+  v = v === void 0 ? d : Number(v);
+  return Number.isFinite(v) ? Math.min(max, Math.max(min, v)) : d;
+}
+function url(v) {
+  if (!v) return "";
+  var u = new URL(String(v), document.baseURI);
+  if (!/^https?:$/.test(u.protocol) && u.protocol !== "blob:") throw Error("Use an HTTP(S), relative or blob URL.");
+  return u.href;
+}
+function report(s, e) {
+  var message = e ? e.message || String(e) : "";
+  s.error.textContent = message;
+  s.error.hidden = !message;
+  if (message && message !== s.lastError) {
+    s.lastError = message;
+    if (s.events.Error) try {
+      s.events.Error(message);
+    } catch (_) {
+    }
+  }
+}
+function image(src, alt, eager) {
+  var n = el("img");
+  n.alt = alt || "";
+  n.loading = eager ? "eager" : "lazy";
+  n.decoding = "async";
+  if (src) n.src = url(src);
+  return n;
+}
+function destroy(key) {
+  var s = shared.instances.get(key);
+  if (!s || s.destroying) return;
+  s.destroying = true;
+  if (s.beforeDestroy) s.beforeDestroy();
+  s.dead = true;
+  s.cleanup.forEach(function(f) {
+    f();
+  });
+  if (s.pause) s.pause();
+  if (s.modal) runtime2.Modal.destroy(s.uid + "-modal");
+  if (s.observer) s.observer.disconnect();
+  if (s.resize) s.resize.disconnect();
+  if (s.frame) cancelAnimationFrame(s.frame);
+  Object.keys(s.slots).forEach(function(k) {
+    s.host.append(s.slots[k]);
+  });
+  s.root.remove();
+  if (s.modal) s.modal.remove();
+  if (s.host._bluRichOwner === key) delete s.host._bluRichOwner;
+  shared.instances.delete(key);
+}
+function define(kind, slug, init, update) {
+  return { sync: function(id, options, events, key) {
+    var host = document.getElementById(id);
+    if (!host) return "Component host was not found.";
+    key = key || id;
+    var s = shared.instances.get(key);
+    if (s && (s.host !== host || s.kind !== kind)) {
+      destroy(key);
+      s = null;
+    }
+    if (host._bluRichOwner && host._bluRichOwner !== key) destroy(host._bluRichOwner);
+    if (!s) {
+      s = { host, key, kind, uid: "blu-rich-" + ++shared.serial, cleanup: [], slots: {}, events: {}, options: {} };
+      Array.from(host.children).forEach(function(n) {
+        var match = n.className && String(n.className).match(/blu-common-slot--(\w+)/);
+        if (match) s.slots[match[1]] = n;
+      });
+      s.root = el("div", "blu-rich blu-" + slug);
+      s.body = el("div", "blu-rich-body");
+      s.error = attr(el("p", "blu-rich-error"), "role", "alert");
+      s.error.hidden = true;
+      s.root.append(s.body, s.error);
+      host.append(s.root);
+      shared.instances.set(key, s);
+      s.fresh = true;
+    }
+    host._bluRichOwner = key;
+    s.options = options || {};
+    s.events = events || {};
+    var preview = host.nextElementSibling;
+    if (preview && preview.classList.contains("blu-component-preview")) preview.hidden = true;
+    if (s.options.AccessibleLabel) {
+      attr(s.root, "aria-label", s.options.AccessibleLabel);
+      attr(s.root, "role", "group");
+    } else {
+      s.root.removeAttribute("aria-label");
+      s.root.removeAttribute("role");
+    }
+    try {
+      if (s.fresh) {
+        init(s);
+        s.fresh = false;
+      }
+      update(s);
+      report(s, null);
+      return "";
+    } catch (e) {
+      report(s, e);
+      return e.message || String(e);
+    }
+  }, destroy };
+}
+function installQuoteCard() {
+  return register2("QuoteCard", () => define("QuoteCard", "quote-card", function(s) {
+  }, function(s) {
+    var o = s.options;
+    s.body.replaceChildren();
+    var quote = el("figure"), rating = num(o.Rating, 0, 0, 5);
+    if (rating) {
+      var stars = el("p", "blu-quote-card__rating", "\u2605".repeat(Math.round(rating)));
+      attr(stars, "role", "img");
+      attr(stars, "aria-label", rating + " out of 5 stars");
+      quote.append(stars);
+    }
+    quote.append(el("blockquote", "", o.Quote || ""));
+    var caption = el("figcaption");
+    if (o.AvatarUrl) caption.append(image(o.AvatarUrl, "", false));
+    var who = el("div");
+    who.append(el("strong", "", o.Name || ""), el("span", "", o.Role || ""));
+    caption.append(who);
+    if (o.LogoUrl) {
+      var logo = image(o.LogoUrl, o.Role || "Organization", false);
+      logo.className = "blu-quote-card__logo";
+      caption.append(logo);
+    }
+    quote.append(caption);
+    s.body.append(quote);
+  }));
+}
+export {
+  installQuoteCard
+};

package/src/runtime/shape-mask.d.ts

@@ -0,0 +1 @@
+export function installShapeMask(): unknown;

package/src/runtime/shape-mask.js

@@ -0,0 +1,211 @@
+// ../blu-grid/docs/scripts/advanced/shared.js
+import { state, register } from "./kernel.js";
+var shared = state("advanced", () => ({ instances: /* @__PURE__ */ new Map(), serial: 0 }));
+var uid = () => `blu-advanced-${++shared.serial}`;
+function node(tag, cls, text) {
+  const el = document.createElement(tag);
+  if (cls) el.className = cls;
+  if (text !== void 0) el.textContent = String(text);
+  return el;
+}
+function attr(el, name, value) {
+  if (value === null || value === void 0) el.removeAttribute(name);
+  else el.setAttribute(name, String(value));
+  return el;
+}
+function emit(s, name, ...args) {
+  if (s.dead) return;
+  try {
+    Promise.resolve(s.events[name]?.(...args)).catch((e) => report(s, e));
+  } catch (e) {
+    report(s, e);
+  }
+}
+function report(s, error) {
+  if (s.dead) return;
+  const message = error?.message || String(error);
+  s.notice.textContent = message;
+  if (s.lastError !== message) {
+    s.lastError = message;
+    emit(s, "Error", message);
+  }
+}
+function assetUrl(value) {
+  const url = new URL(String(value), document.baseURI);
+  if (!["https:", "http:"].includes(url.protocol)) throw Error("Use a relative or HTTP(S) asset URL.");
+  return url.href;
+}
+function createAPI(kind, init, update) {
+  const destroy = (key) => {
+    const s = shared.instances.get(key);
+    if (!s || s.kind !== kind) return;
+    s.dead = true;
+    s.dispose?.();
+    s.root.remove();
+    s.notice.remove();
+    if (s.host._bluAdvancedOwner === key) delete s.host._bluAdvancedOwner;
+    shared.instances.delete(key);
+  };
+  return register(kind, () => ({ sync(id, options = {}, events = {}, owner) {
+    const host = document.getElementById(id);
+    if (!host) return kind + " host was not found.";
+    const key = owner || id;
+    let s = shared.instances.get(key);
+    if (s && (s.host !== host || s.kind !== kind)) {
+      s.destroy(s.key);
+      s = null;
+    }
+    const previous = shared.instances.get(host._bluAdvancedOwner);
+    if (previous && previous !== s) previous.destroy(previous.key);
+    if (!s) {
+      s = { key, host, kind, uid: uid(), options, events, dead: false, destroy };
+      s.root = node("div");
+      s.notice = attr(node("div", "blu-advanced-sr"), "role", "status");
+      attr(s.notice, "aria-atomic", "true");
+      host.append(s.root, s.notice);
+      shared.instances.set(key, s);
+      host._bluAdvancedOwner = key;
+      try {
+        init(s);
+      } catch (e) {
+        destroy(key);
+        throw e;
+      }
+    }
+    s.options = options;
+    s.events = events;
+    try {
+      update(s);
+      host.dataset.bluRuntimeReady = "true";
+      return "";
+    } catch (e) {
+      report(s, e);
+      return e.message || String(e);
+    }
+  }, destroy }));
+}
+
+// ../blu-grid/docs/scripts/advanced/shape-mask.js
+var shapes = {
+  Circle: "circle(48%)",
+  Oval: "ellipse(48% 36%)",
+  Diamond: "polygon(50% 0,100% 50%,50% 100%,0 50%)",
+  Hexagon: "polygon(25% 0,75% 0,100% 50%,75% 100%,25% 100%,0 50%)",
+  Arch: "inset(0 round 50% 50% 0 0)",
+  Organic: "inset(0 round 40% 60% 61% 39% / 48% 35% 65% 52%)",
+  None: "none",
+  Custom: "none"
+};
+function resetMask(s) {
+  s.mask.style.maskImage = "none";
+  s.mask.style.webkitMaskImage = "none";
+  s.mask.style.clipPath = "none";
+}
+function animate(s) {
+  s.motion?.cancel();
+  s.motion = null;
+  if (s.reduced.matches || s.options.Animation === "None" || !s.options.Animation) return;
+  const keyframes = s.options.Animation === "Zoom" ? [{ scale: "1.06" }, { scale: "1" }] : [{ opacity: 0 }, { opacity: 1 }];
+  s.motion = s.media.animate(keyframes, { duration: Math.max(0, Math.min(2e3, Number(s.options.AnimationDuration ?? 500))), easing: "ease-out" });
+}
+function installShapeMask() {
+  return createAPI("ShapeMask", (s) => {
+    s.root.className = "blu-shape-mask";
+    s.mask = node("div", "blu-shape-mask__mask");
+    s.media = node("div", "blu-shape-mask__media");
+    s.mask.append(s.media);
+    s.root.append(s.mask);
+    s.content = s.host.querySelector(".blu-common-slot--content");
+    if (!s.content) throw Error("ShapeMask requires a Content slot.");
+    s.marker = document.createComment("ShapeMask content");
+    s.content.before(s.marker);
+    s.media.append(s.content);
+    s.reduced = matchMedia("(prefers-reduced-motion: reduce)");
+    s.motionChange = () => {
+      if (s.reduced.matches) s.motion?.cancel();
+    };
+    s.reduced.addEventListener("change", s.motionChange);
+    s.dispose = () => {
+      s.sequence = (s.sequence || 0) + 1;
+      if (s.image) s.image.onload = s.image.onerror = null;
+      s.motion?.cancel();
+      s.observer?.disconnect();
+      s.reduced.removeEventListener("change", s.motionChange);
+      s.marker.replaceWith(s.content);
+    };
+    s.sequence = 0;
+  }, (s) => {
+    const o = s.options, shape = o.Shape || "Arch";
+    if (!(shape in shapes)) throw Error("Unknown ShapeMask preset.");
+    const ratio = String(o.AspectRatio || "1 / 1");
+    if (!/^(?:\d+(?:\.\d+)?)(?:\s*\/\s*\d+(?:\.\d+)?)?$/.test(ratio) || ratio.split("/").some((n) => Number(n) <= 0)) throw Error("AspectRatio must be positive, for example 4 / 3.");
+    const rotation = Number(o.Rotation || 0), size = Number(o.MaskSize ?? 100), x = Number(o.PositionX ?? 50), y = Number(o.PositionY ?? 50);
+    if (![rotation, size, x, y].every(Number.isFinite) || size < 10 || size > 150 || x < 0 || x > 100 || y < 0 || y > 100) throw Error("MaskSize must be 10\u2013150; PositionX and PositionY must be 0\u2013100.");
+    s.root.style.aspectRatio = ratio;
+    s.root.style.setProperty("--blu-mask-size", size + "%");
+    s.root.style.setProperty("--blu-mask-x", x + "%");
+    s.root.style.setProperty("--blu-mask-y", y + "%");
+    const flipX = o.FlipHorizontal ? -1 : 1, flipY = o.FlipVertical ? -1 : 1;
+    s.mask.style.transform = `translate(-50%,-50%) rotate(${rotation}deg) scale(${flipX},${flipY})`;
+    const ratioParts = ratio.split("/").map(Number), aspect = ratioParts[0] / (ratioParts[1] || 1), angle = rotation * Math.PI / 180, cover = Math.max(Math.abs(Math.cos(angle)) + Math.abs(Math.sin(angle)) / aspect, Math.abs(Math.cos(angle)) + Math.abs(Math.sin(angle)) * aspect);
+    s.media.style.transform = `scale(${flipX},${flipY}) rotate(${-rotation}deg) scale(${cover})`;
+    const url = String(o.MaskUrl || "").trim(), signature = JSON.stringify([shape, url]);
+    if (signature !== s.maskSignature) {
+      s.maskSignature = signature;
+      const sequence = ++s.sequence;
+      if (s.image) s.image.onload = s.image.onerror = null;
+      resetMask(s);
+      if (shape === "Custom" || url) {
+        if (!url) throw Error("MaskUrl is required for the Custom shape.");
+        const source = assetUrl(url), image = new Image();
+        s.image = image;
+        s.host.dataset.maskStatus = "loading";
+        image.crossOrigin = "anonymous";
+        image.onload = () => {
+          if (s.dead || sequence !== s.sequence) return;
+          const value = "url(" + JSON.stringify(source) + ")";
+          s.mask.style.maskImage = value;
+          s.mask.style.webkitMaskImage = value;
+          s.host.dataset.maskStatus = "loaded";
+          s.notice.textContent = "";
+          s.lastError = "";
+          emit(s, "Loaded", source);
+        };
+        image.onerror = () => {
+          if (s.dead || sequence !== s.sequence) return;
+          resetMask(s);
+          s.host.dataset.maskStatus = "error";
+          report(s, "MaskUrl could not load. Content remains visible without a mask. Check the URL and cross-origin access.");
+        };
+        image.src = source;
+      } else {
+        s.mask.style.clipPath = shapes[shape];
+        s.host.dataset.maskStatus = "loaded";
+        s.notice.textContent = "";
+        s.lastError = "";
+      }
+    }
+    const animation = ["None", "Reveal", "Zoom"].includes(o.Animation) ? o.Animation : "None", motionKey = JSON.stringify([animation, o.AnimationKey || ""]);
+    if (s.motionKey !== motionKey) {
+      s.motionKey = motionKey;
+      s.motion?.cancel();
+      s.observer?.disconnect();
+      s.options.Animation = animation;
+      if (animation !== "None" && !s.reduced.matches) {
+        if ("IntersectionObserver" in window) {
+          s.observer = new IntersectionObserver((entries) => {
+            if (entries.some((e) => e.isIntersecting)) {
+              s.observer.disconnect();
+              animate(s);
+            }
+          }, { threshold: 0.1 });
+          s.observer.observe(s.root);
+        } else animate(s);
+      }
+    }
+    attr(s.root, "data-shape", shape);
+  });
+}
+export {
+  installShapeMask
+};

package/src/runtime/sparkline.d.ts

@@ -0,0 +1 @@
+export function installSparkline(): any;

package/src/runtime/sparkline.js

@@ -0,0 +1,197 @@
+// ../blu-grid/docs/scripts/modules/foundations.js
+import { global, runtime, state, register } from "./kernel.js";
+var shared = /* @__PURE__ */ state("foundations", () => ({ instances: /* @__PURE__ */ new Map(), serial: 0 }));
+function el(tag, cls, text) {
+  var n = document.createElement(tag);
+  if (cls) n.className = cls;
+  if (text !== void 0) n.textContent = text;
+  return n;
+}
+function attr(n, key, value) {
+  n.setAttribute(key, String(value));
+  return n;
+}
+function report(s, message) {
+  if (!s.error) {
+    s.error = attr(el("p", "blu-common-error"), "role", "alert");
+    s.host.append(s.error);
+  }
+  s.error.textContent = message;
+  s.error.hidden = !message;
+  if (message && s.lastError !== message && s.events.Error) {
+    s.lastError = message;
+    try {
+      s.events.Error(message);
+    } catch (_) {
+    }
+  }
+  if (!message) s.lastError = "";
+}
+function integer(value, fallback, min, max) {
+  value = value === void 0 ? fallback : Number(value);
+  if (!Number.isInteger(value) || value < min || value > max) throw Error("Expected an integer between " + min + " and " + max + ".");
+  return value;
+}
+function destroy(key) {
+  var s = shared.instances.get(key);
+  if (!s) return;
+  s.dead = true;
+  s.cleanup.forEach(function(f) {
+    f();
+  });
+  s.owned.forEach(function(n) {
+    n.remove();
+  });
+  if (s.host._bluFoundationOwner === key) {
+    delete s.host._bluFoundationOwner;
+    s.host.removeAttribute("data-blu-ready");
+  }
+  shared.instances.delete(key);
+}
+function own(s, node) {
+  s.owned.push(node);
+  return node;
+}
+function geometry(raw, height) {
+  var rows = typeof raw === "string" ? JSON.parse(raw || "[]") : raw || [];
+  if (!Array.isArray(rows) || rows.length > 1e4) throw Error("Points must be a list with at most 10,000 items.");
+  var values = rows.map(function(p) {
+    if (!p || typeof p.Value !== "number" || !Number.isFinite(p.Value)) throw Error("Every Sparkline point needs a finite numeric Value.");
+    return p.Value;
+  });
+  if (!values.length) return { rows, coordinates: [], line: "", area: "" };
+  var min = Math.min.apply(null, values), max = Math.max.apply(null, values), range = max - min;
+  var scale = Math.max(Math.abs(min), Math.abs(max), 1), low = min / scale, spread = max / scale - low;
+  var coordinates = values.map(function(value, index) {
+    return [values.length === 1 ? 150 : 6 + index * 288 / (values.length - 1), spread ? height - 6 - (value / scale - low) / spread * (height - 12) : height / 2];
+  });
+  var line = coordinates.map(function(p, i) {
+    return (i ? "L" : "M") + p[0].toFixed(3) + " " + p[1].toFixed(3);
+  }).join(" ");
+  return { rows, coordinates, line, area: line + " L" + coordinates[coordinates.length - 1][0] + " " + (height - 4) + " L" + coordinates[0][0] + " " + (height - 4) + " Z", min, max, first: values[0], last: values[values.length - 1] };
+}
+function sparkline(s) {
+  var o = s.options, signature = JSON.stringify(o);
+  if (s.renderSignature === signature) return;
+  var height = integer(o.Height, 64, 24, 240), geometryKey = JSON.stringify([o.PointsJson, height]);
+  var g = s.geometryKey === geometryKey ? s.geometry : geometry(o.PointsJson, height);
+  s.geometryKey = geometryKey;
+  s.geometry = g;
+  var color = String(o.Color || "Primary").toLowerCase();
+  if ("default primary secondary success processing warning error danger magenta red volcano orange gold lime green cyan blue geekblue purple".split(" ").indexOf(color) < 0) throw Error("Unknown ComponentColor.");
+  if (!s.body) {
+    s.body = own(s, el("div", "blu-sparkline"));
+    s.host.append(s.body);
+  }
+  var body = s.body, wasOpen = !!(body.querySelector("details") && body.querySelector("details").open), hadFocus = body.contains(document.activeElement);
+  while (body.firstChild) body.removeChild(body.firstChild);
+  body.style.setProperty("--blu-sparkline-color", "var(--bluui-color-" + color + "-text)");
+  body.style.setProperty("--blu-sparkline-height", height + "px");
+  if (!g.rows.length) {
+    body.append(el("p", "blu-sparkline__empty", o.EmptyText || "No trend data."));
+    s.renderSignature = signature;
+    return;
+  }
+  var ns = "http://www.w3.org/2000/svg", svg = document.createElementNS(ns, "svg");
+  attr(svg, "viewBox", "0 0 300 " + height);
+  attr(svg, "preserveAspectRatio", "none");
+  attr(svg, "role", "img");
+  var summary = o.SummaryText || g.rows.length + " points. " + (g.last > g.first ? "Rising" : g.last < g.first ? "Falling" : "Unchanged") + " from " + g.first + " to " + g.last + ". Minimum " + g.min + ", maximum " + g.max + ".";
+  attr(svg, "aria-label", (o.AccessibleLabel || "Trend") + ". " + summary);
+  var title = document.createElementNS(ns, "title");
+  title.textContent = (o.AccessibleLabel || "Trend") + ". " + summary;
+  svg.append(title);
+  if (o.ShowArea !== false && g.rows.length > 1) {
+    var area = document.createElementNS(ns, "path");
+    attr(area, "d", g.area);
+    attr(area, "class", "blu-sparkline__area");
+    svg.append(area);
+  }
+  if (o.AnimateGlow === true && g.rows.length > 1) {
+    var glow = document.createElementNS(ns, "path");
+    attr(glow, "d", g.line);
+    attr(glow, "class", "blu-sparkline__glow");
+    attr(glow, "vector-effect", "non-scaling-stroke");
+    attr(glow, "aria-hidden", "true");
+    svg.append(glow);
+  }
+  var path = document.createElementNS(ns, "path");
+  attr(path, "d", g.line);
+  attr(path, "class", "blu-sparkline__line");
+  attr(path, "vector-effect", "non-scaling-stroke");
+  svg.append(path);
+  if (o.ShowEndMarker !== false || g.rows.length === 1) {
+    var p = g.coordinates[g.coordinates.length - 1], circle = document.createElementNS(ns, "circle");
+    attr(circle, "cx", p[0]);
+    attr(circle, "cy", p[1]);
+    attr(circle, "r", 3);
+    attr(circle, "class", "blu-sparkline__point");
+    svg.append(circle);
+  }
+  body.append(svg);
+  if (o.ShowDataTable) {
+    let buildTable = function() {
+      if (!details.open || tableBuilt) return;
+      var table = el("table"), caption = el("caption", "", o.AccessibleLabel || "Trend"), thead = el("thead"), headings = el("tr");
+      headings.append(attr(el("th", "", "Point"), "scope", "col"), attr(el("th", "", "Value"), "scope", "col"));
+      thead.append(headings);
+      table.append(caption, thead);
+      var tbody = el("tbody");
+      g.rows.forEach(function(row, index) {
+        var tr = el("tr");
+        tr.append(attr(el("th", "", row.Label || String(index + 1)), "scope", "row"), el("td", "", String(row.Value)));
+        tbody.append(tr);
+      });
+      table.append(tbody);
+      details.append(table);
+      tableBuilt = true;
+    };
+    var details = el("details", "blu-sparkline__data");
+    details.open = wasOpen;
+    details.append(el("summary", "", "View trend data"));
+    var tableBuilt = false;
+    details.addEventListener("toggle", buildTable);
+    body.append(details);
+    buildTable();
+    if (hadFocus) details.querySelector("summary").focus();
+  }
+  s.renderSignature = signature;
+}
+function api(kind, render) {
+  return { sync: function(id, options, events, key) {
+    var host = document.getElementById(id);
+    if (!host) return "Component host was not found.";
+    key = key || id;
+    var s = shared.instances.get(key);
+    if (s && s.host !== host) {
+      destroy(key);
+      s = null;
+    }
+    if (host._bluFoundationOwner && host._bluFoundationOwner !== key) destroy(host._bluFoundationOwner);
+    if (!s) {
+      s = { host, key, uid: "blu-foundation-" + ++shared.serial, owned: [], cleanup: [] };
+      shared.instances.set(key, s);
+    }
+    var preview = host.nextElementSibling;
+    if (preview && preview.classList.contains("blu-component-preview")) preview.hidden = true;
+    host._bluFoundationOwner = key;
+    s.options = options || {};
+    s.events = events || {};
+    attr(host, "data-blu-ready", "true");
+    try {
+      render(s);
+      report(s, "");
+      return "";
+    } catch (e) {
+      s.renderSignature = void 0;
+      report(s, e.message || String(e));
+      return e.message || String(e);
+    }
+  }, destroy };
+}
+function installSparkline() {
+  return register("Sparkline", () => Object.assign(api("Sparkline", sparkline), { geometry }));
+}
+export {
+  installSparkline
+};

package/src/runtime/split-section.d.ts

@@ -0,0 +1 @@
+export function installSplitSection(): any;