@nastechai-research/ui 0.13.2

package/dist/ui/components/tier-card.js

@@ -0,0 +1,146 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+import { ImageDistortion } from "./image-distortion.js";
+import { Typography } from "./typography/index.js";
+export function TierCard({
+  badge,
+  bullets,
+  className,
+  image,
+  isCurrent = false,
+  onSelect,
+  overlay,
+  price,
+  selected = false,
+  tint,
+  tintStrength,
+  title
+}) {
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      className: cn(
+        "group relative flex w-full cursor-pointer flex-col border border-current/20",
+        "text-left transition-colors duration-300",
+        selected && "border-midground/60",
+        isCurrent && !selected && "border-midground/30",
+        className
+      ),
+      onClick: onSelect,
+      type: "button",
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            "aria-hidden": true,
+            className: cn(
+              "arc-border transition-opacity duration-200",
+              selected ? "opacity-100" : "opacity-0 group-hover:opacity-100"
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "relative aspect-[3/4] min-h-0 w-full flex-1 overflow-hidden",
+            style: { backgroundColor: "var(--background)" },
+            children: [
+              /* @__PURE__ */ jsx(
+                ImageDistortion,
+                {
+                  active: selected,
+                  src: image,
+                  tint,
+                  tintStrength
+                }
+              ),
+              overlay && /* @__PURE__ */ jsx(
+                "div",
+                {
+                  className: "pointer-events-none absolute inset-0",
+                  style: { backgroundColor: overlay, mixBlendMode: "color" }
+                }
+              ),
+              /* @__PURE__ */ jsxs("div", { className: "pointer-events-none absolute inset-0 z-[1] flex flex-col justify-between p-3", children: [
+                /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-0.5", children: [
+                  /* @__PURE__ */ jsxs(
+                    Typography,
+                    {
+                      variant: "sm",
+                      className: cn(
+                        "block drop-shadow-[0_1px_2px_rgba(0,0,0,0.5)] text-[1.2rem]",
+                        "transition-colors",
+                        selected && "text-midground"
+                      ),
+                      style: selected ? { mixBlendMode: "plus-lighter" } : void 0,
+                      children: [
+                        title,
+                        badge && /* @__PURE__ */ jsx("span", { className: "ml-1 opacity-50", children: badge })
+                      ]
+                    }
+                  ),
+                  price.secondary ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsxs(
+                      Typography,
+                      {
+                        className: "block text-md line-through opacity-50 drop-shadow-[0_1px_3px_rgba(0,0,0,0.6)]",
+                        expanded: true,
+                        style: { mixBlendMode: "plus-lighter" },
+                        children: [
+                          price.secondary,
+                          price.secondarySuffix && /* @__PURE__ */ jsx("span", { className: "text-[1rem]", children: price.secondarySuffix })
+                        ]
+                      }
+                    ),
+                    /* @__PURE__ */ jsxs(
+                      Typography,
+                      {
+                        className: "block text-xl font-bold drop-shadow-[0_1px_3px_rgba(0,0,0,0.6)]",
+                        expanded: true,
+                        style: { mixBlendMode: "plus-lighter" },
+                        children: [
+                          price.primary,
+                          price.primarySuffix && /* @__PURE__ */ jsxs("span", { className: "text-[1rem] opacity-60", children: [
+                            " ",
+                            price.primarySuffix
+                          ] })
+                        ]
+                      }
+                    )
+                  ] }) : /* @__PURE__ */ jsxs(
+                    Typography,
+                    {
+                      className: "block text-xl font-bold drop-shadow-[0_1px_3px_rgba(0,0,0,0.6)]",
+                      expanded: true,
+                      style: { mixBlendMode: "plus-lighter" },
+                      children: [
+                        price.primary,
+                        price.primarySuffix && /* @__PURE__ */ jsx("span", { className: "text-[1rem] opacity-60", children: price.primarySuffix })
+                      ]
+                    }
+                  )
+                ] }),
+                bullets.length > 0 && /* @__PURE__ */ jsx("ul", { className: "flex flex-col gap-1", children: bullets.map((bullet, i) => /* @__PURE__ */ jsxs(
+                  "li",
+                  {
+                    className: cn(
+                      "font-courier text-display text-[1rem] leading-tight tracking-tight",
+                      "drop-shadow-[0_1px_2px_rgba(0,0,0,0.5)]"
+                    ),
+                    children: [
+                      "\xB7 ",
+                      bullet
+                    ]
+                  },
+                  typeof bullet === "string" ? bullet : i
+                )) })
+              ] })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { cn } from '../../utils'\n\nimport { ImageDistortion } from './image-distortion'\nimport { Typography } from './typography'\nimport { Small } from './typography/small'\n\n/**\n * Selectable tier / pricing card. Full-bleed distorted image background,\n * readable overlay text, and an animated `.arc-border` shimmer on the\n * selected state. Fully presentational \u2014 the consumer owns the data\n * (tier schema, price formatting, tier imagery / tints).\n *\n * Visual states:\n * - `selected`: brightens the distortion, activates `.arc-border`, and\n *   composites the headline / price with `mix-blend-mode: plus-lighter`\n *   so the text lifts off the image regardless of tint.\n * - `isCurrent`: subtle midground-tinted border hint (suppressed when\n *   `selected` wins).\n * - `overlay`: optional top-layer color blended with `mix-blend-mode:\n *   color` \u2014 used for the \"highest tier\" red treatment on top of any\n *   base tint.\n */\nexport function TierCard({\n  badge,\n  bullets,\n  className,\n  image,\n  isCurrent = false,\n  onSelect,\n  overlay,\n  price,\n  selected = false,\n  tint,\n  tintStrength,\n  title\n}: TierCardProps) {\n  return (\n    <button\n      className={cn(\n        'group relative flex w-full cursor-pointer flex-col border border-current/20',\n        'text-left transition-colors duration-300',\n        selected && 'border-midground/60',\n        isCurrent && !selected && 'border-midground/30',\n        className\n      )}\n      onClick={onSelect}\n      type=\"button\"\n    >\n      <span\n        aria-hidden\n        className={cn(\n          'arc-border transition-opacity duration-200',\n          selected ? 'opacity-100' : 'opacity-0 group-hover:opacity-100'\n        )}\n      />\n\n      <div\n        className=\"relative aspect-[3/4] min-h-0 w-full flex-1 overflow-hidden\"\n        style={{ backgroundColor: 'var(--background)' }}\n      >\n        <ImageDistortion\n          active={selected}\n          src={image}\n          tint={tint}\n          tintStrength={tintStrength}\n        />\n\n        {overlay && (\n          <div\n            className=\"pointer-events-none absolute inset-0\"\n            style={{ backgroundColor: overlay, mixBlendMode: 'color' }}\n          />\n        )}\n\n        <div className=\"pointer-events-none absolute inset-0 z-[1] flex flex-col justify-between p-3\">\n          <div className=\"flex flex-col gap-0.5\">\n            <Typography variant=\"sm\" \n              className={cn(\n                'block drop-shadow-[0_1px_2px_rgba(0,0,0,0.5)] text-[1.2rem]',\n                'transition-colors',\n                selected && 'text-midground'\n              )}\n              style={selected ? { mixBlendMode: 'plus-lighter' } : undefined}\n            >\n              {title}\n              {badge && <span className=\"ml-1 opacity-50\">{badge}</span>}\n            </Typography>\n\n            {price.secondary ? (\n              <>\n                <Typography\n                  className=\"block text-md line-through opacity-50 drop-shadow-[0_1px_3px_rgba(0,0,0,0.6)]\"\n                  expanded\n                  style={{ mixBlendMode: 'plus-lighter' }}\n                >\n                  {price.secondary}\n                  {price.secondarySuffix && (\n                    <span className=\"text-[1rem]\">\n                      {price.secondarySuffix}\n                    </span>\n                  )}\n                </Typography>\n\n                <Typography\n                  className=\"block text-xl font-bold drop-shadow-[0_1px_3px_rgba(0,0,0,0.6)]\"\n                  expanded\n                  style={{ mixBlendMode: 'plus-lighter' }}\n                >\n                  {price.primary}\n                  {price.primarySuffix && (\n                    <span className=\"text-[1rem] opacity-60\">\n                      {' '}\n                      {price.primarySuffix}\n                    </span>\n                  )}\n                </Typography>\n              </>\n            ) : (\n              <Typography\n                className=\"block text-xl font-bold drop-shadow-[0_1px_3px_rgba(0,0,0,0.6)]\"\n                expanded\n                style={{ mixBlendMode: 'plus-lighter' }}\n              >\n                {price.primary}\n                {price.primarySuffix && (\n                  <span className=\"text-[1rem] opacity-60\">\n                    {price.primarySuffix}\n                  </span>\n                )}\n              </Typography>\n            )}\n          </div>\n\n          {bullets.length > 0 && (\n            <ul className=\"flex flex-col gap-1\">\n              {bullets.map((bullet, i) => (\n                <li\n                  className={cn(\n                    'font-courier text-display text-[1rem] leading-tight tracking-tight',\n                    'drop-shadow-[0_1px_2px_rgba(0,0,0,0.5)]',\n                  )}\n                  key={typeof bullet === 'string' ? bullet : i}\n                >\n                  \u00B7 {bullet}\n                </li>\n              ))}\n            </ul>\n          )}\n        </div>\n      </div>\n    </button>\n  )\n}\n\nexport interface TierCardPrice {\n  /** Headline price, e.g. `\"$20\"` or `\"Free\"`. */\n  primary: string\n  /** Small suffix rendered after `primary`, e.g. `\"/mo\"` or `\"first payment\"`. */\n  primarySuffix?: string\n  /** Optional struck-through comparison price rendered above `primary`, e.g. `\"$30\"`. */\n  secondary?: string\n  /** Small suffix rendered after `secondary`. */\n  secondarySuffix?: string\n}\n\nexport interface TierCardProps {\n  /** Small annotation after the title, e.g. `\"(current)\"`. */\n  badge?: React.ReactNode\n  /** Feature list rendered under the price. */\n  bullets: React.ReactNode[]\n  className?: string\n  /** Background image URL. */\n  image: string\n  /** Applies the \"current plan\" border hint when not `selected`. */\n  isCurrent?: boolean\n  onSelect?: () => void\n  /** Color blended with `mix-blend-mode: color` over the image (used for the highest-tier red treatment). */\n  overlay?: string\n  price: TierCardPrice\n  /** Applies selected chrome (arc-border shimmer, active distortion, plus-lighter text blend). */\n  selected?: boolean\n  /** Shader tint passed through to `ImageDistortion`. */\n  tint?: string\n  /** Active / inactive tint strength passed through to `ImageDistortion`. */\n  tintStrength?: { active: number; inactive: number }\n  /** Tier name / headline. */\n  title: React.ReactNode\n}\n"],
  "mappings": ";AAkDM,SAyCQ,UAzCR,KA4BM,YA5BN;AAhDN,SAAS,UAAU;AAEnB,SAAS,uBAAuB;AAChC,SAAS,kBAAkB;AAmBpB,gBAAS,SAAS;AAAA,EACvB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY;AAAA,EACZ;AAAA,EACA;AAAA,EACA;AAAA,EACA,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA;AACF,GAAkB;AAChB,SACE;AAAA,IAAC;AAAA;AAAA,MACC,WAAW;AAAA,QACT;AAAA,QACA;AAAA,QACA,YAAY;AAAA,QACZ,aAAa,CAAC,YAAY;AAAA,QAC1B;AAAA,MACF;AAAA,MACA,SAAS;AAAA,MACT,MAAK;AAAA,MAEL;AAAA;AAAA,UAAC;AAAA;AAAA,YACC,eAAW;AAAA,YACX,WAAW;AAAA,cACT;AAAA,cACA,WAAW,gBAAgB;AAAA,YAC7B;AAAA;AAAA,QACF;AAAA,QAEA;AAAA,UAAC;AAAA;AAAA,YACC,WAAU;AAAA,YACV,OAAO,EAAE,iBAAiB,oBAAoB;AAAA,YAE9C;AAAA;AAAA,gBAAC;AAAA;AAAA,kBACC,QAAQ;AAAA,kBACR,KAAK;AAAA,kBACL;AAAA,kBACA;AAAA;AAAA,cACF;AAAA,cAEC,WACC;AAAA,gBAAC;AAAA;AAAA,kBACC,WAAU;AAAA,kBACV,OAAO,EAAE,iBAAiB,SAAS,cAAc,QAAQ;AAAA;AAAA,cAC3D;AAAA,cAGF,qBAAC,SAAI,WAAU,gFACb;AAAA,qCAAC,SAAI,WAAU,yBACb;AAAA;AAAA,oBAAC;AAAA;AAAA,sBAAW,SAAQ;AAAA,sBAClB,WAAW;AAAA,wBACT;AAAA,wBACA;AAAA,wBACA,YAAY;AAAA,sBACd;AAAA,sBACA,OAAO,WAAW,EAAE,cAAc,eAAe,IAAI;AAAA,sBAEpD;AAAA;AAAA,wBACA,SAAS,oBAAC,UAAK,WAAU,mBAAmB,iBAAM;AAAA;AAAA;AAAA,kBACrD;AAAA,kBAEC,MAAM,YACL,iCACE;AAAA;AAAA,sBAAC;AAAA;AAAA,wBACC,WAAU;AAAA,wBACV,UAAQ;AAAA,wBACR,OAAO,EAAE,cAAc,eAAe;AAAA,wBAErC;AAAA,gCAAM;AAAA,0BACN,MAAM,mBACL,oBAAC,UAAK,WAAU,eACb,gBAAM,iBACT;AAAA;AAAA;AAAA,oBAEJ;AAAA,oBAEA;AAAA,sBAAC;AAAA;AAAA,wBACC,WAAU;AAAA,wBACV,UAAQ;AAAA,wBACR,OAAO,EAAE,cAAc,eAAe;AAAA,wBAErC;AAAA,gCAAM;AAAA,0BACN,MAAM,iBACL,qBAAC,UAAK,WAAU,0BACb;AAAA;AAAA,4BACA,MAAM;AAAA,6BACT;AAAA;AAAA;AAAA,oBAEJ;AAAA,qBACF,IAEA;AAAA,oBAAC;AAAA;AAAA,sBACC,WAAU;AAAA,sBACV,UAAQ;AAAA,sBACR,OAAO,EAAE,cAAc,eAAe;AAAA,sBAErC;AAAA,8BAAM;AAAA,wBACN,MAAM,iBACL,oBAAC,UAAK,WAAU,0BACb,gBAAM,eACT;AAAA;AAAA;AAAA,kBAEJ;AAAA,mBAEJ;AAAA,gBAEC,QAAQ,SAAS,KAChB,oBAAC,QAAG,WAAU,uBACX,kBAAQ,IAAI,CAAC,QAAQ,MACpB;AAAA,kBAAC;AAAA;AAAA,oBACC,WAAW;AAAA,sBACT;AAAA,sBACA;AAAA,oBACF;AAAA,oBAED;AAAA;AAAA,sBACI;AAAA;AAAA;AAAA,kBAFE,OAAO,WAAW,WAAW,SAAS;AAAA,gBAG7C,CACD,GACH;AAAA,iBAEJ;AAAA;AAAA;AAAA,QACF;AAAA;AAAA;AAAA,EACF;AAEJ;",
  "names": []
}


package/dist/ui/components/toast.d.ts

@@ -0,0 +1,8 @@
+export declare function Toast({ toast }: ToastProps): import("react").ReactPortal | null;
+interface ToastProps {
+    toast: {
+        message: string;
+        type: 'error' | 'success';
+    } | null;
+}
+export {};

package/dist/ui/components/toast.js

@@ -0,0 +1,39 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { cn } from "../../utils/index.js";
+export function Toast({ toast }) {
+  const [visible, setVisible] = useState(false);
+  const [current, setCurrent] = useState(toast);
+  useEffect(() => {
+    if (toast) {
+      setCurrent(toast);
+      setVisible(true);
+    } else {
+      setVisible(false);
+      const timer = setTimeout(() => setCurrent(null), 200);
+      return () => clearTimeout(timer);
+    }
+  }, [toast]);
+  if (!current || typeof document === "undefined") return null;
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        "aria-live": "polite",
+        className: cn(
+          "fixed top-16 right-4 z-50 border px-4 py-2.5 font-courier text-xs tracking-wider uppercase backdrop-blur-sm",
+          current.type === "success" ? "bg-success/15 text-success border-success/30" : "bg-destructive/15 text-destructive border-destructive/30"
+        ),
+        role: "status",
+        style: {
+          animation: visible ? "toast-in 200ms ease-out forwards" : "toast-out 200ms ease-in forwards"
+        },
+        children: current.message
+      }
+    ),
+    document.body
+  );
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/tv.d.ts

@@ -0,0 +1,3 @@
+export declare function TV({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/ui/components/tv.js

@@ -0,0 +1,239 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+const VERT = (
+  /* glsl */
+  `attribute vec2 a;void main(){gl_Position=vec4(a,0,1);}`
+);
+const FRAG = (
+  /* glsl */
+  `precision highp float;
+uniform float t;
+uniform vec2 r;
+
+const float FBM_STR = .08;
+
+float h(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+
+float n2(vec2 p) {
+  vec2 i = floor(p), f = fract(p);
+  f = f * f * (3. - 2. * f);
+
+  return mix(
+    mix(h(i), h(i + vec2(1, 0)), f.x),
+    mix(h(i + vec2(0, 1)), h(i + vec2(1, 1)), f.x),
+    f.y
+  );
+}
+
+float fbm(vec2 p) {
+  float v = 0., a = .5;
+
+  for (int i = 0; i < 4; i++) {
+    v += a * n2(p);
+    p *= 2.1;
+    a *= .45;
+  }
+
+  return v;
+}
+
+float drift(float speed, float s) {
+  return fract(t * speed + s + .02 * sin(t * .4 + s * 3.));
+}
+
+float brushAt(vec2 uv, float y, float th, float s) {
+  float hw = .34 + .08 * h(vec2(s, 77.));
+  float cx = .5;
+  float xn = (uv.x - (cx - hw)) / (2. * hw);
+  float env = smoothstep(0., .03, xn) * smoothstep(1., .97, xn);
+  float localTh = th * env;
+
+  if (localTh < .002) return 0.;
+
+  float morph = floor(t * 8.) * .7 + s;
+  float top = y - localTh * .5 + fbm(vec2(uv.x * 6., morph)) * FBM_STR;
+  float bot = y + localTh * .5 - fbm(vec2(uv.x * 6., morph + 30.)) * FBM_STR;
+  float x0 = cx - hw + fbm(vec2(uv.y * 8., morph + 60.)) * FBM_STR;
+  float x1 = cx + hw - fbm(vec2(uv.y * 8., morph + 90.)) * FBM_STR;
+
+  float dMin = min(min(uv.y - top, bot - uv.y), min(uv.x - x0, x1 - uv.x));
+
+  float bristle = n2(vec2(uv.x * 60., uv.y * 8. + s)) * .4
+    + n2(vec2(uv.x * 25., (uv.y - y) * 120. + s)) * .35
+    + n2(vec2(uv.x * 90., uv.y * 3. + s * 2.)) * .25;
+
+  float eaten = smoothstep(.03, 0., dMin) * (1. - smoothstep(.2, .5, bristle));
+
+  return clamp(smoothstep(0., .003, dMin) * (1. - eaten), 0., 1.);
+}
+
+void main() {
+  vec2 uv = gl_FragCoord.xy / r;
+  uv = vec2(uv.x * cos(.095) - uv.y * sin(.095), uv.x * sin(.095) + uv.y * cos(.095));
+  uv += vec2(fbm(uv * 4. + t * .06), fbm(uv * 4. + 8. + t * .05)) * .012;
+
+  vec3 c = vec3(.992, .992, .051);
+
+  float smScroll = -drift(.04, 5.) * 2.;
+  float sm = 0.;
+
+  for (int i = 0; i < 20; i++) {
+    sm = max(sm, brushAt(uv, mod(float(i) * .1 + smScroll, 2.) - .5, .04, float(i) + 10.));
+  }
+
+  float d1 = drift(.15, 1.), d2 = drift(.15, 1.37), d3 = drift(.15, 1.58), d4 = drift(.15, 1.82);
+  float big = max(
+    max(brushAt(uv, 1.1 - d1 * 1.4, .28, 1.), brushAt(uv, 1.1 - d2 * 1.4, .18, 2.)),
+    max(brushAt(uv, 1.1 - d3 * 1.4, .3, 3.), brushAt(uv, 1.1 - d4 * 1.4, .15, 4.))
+  );
+
+  c = mix(c, vec3(0.), clamp(max(sm, big), 0., 1.));
+  c *= .94 + .06 * sin(uv.y * r.y * 6.283);
+
+  vec2 raw = gl_FragCoord.xy / r;
+  float dx = min(raw.x - .22, .90 - raw.x);
+  float dy = min(raw.y - .29, .86 - raw.y);
+  float cycle = floor(t * .4);
+  float edge = mix(smoothstep(.22, 0., max(min(dx, dy), 0.)), 1., step(.75, h(vec2(cycle, 13.))))
+    * smoothstep(.85, 1., sin(t * 2.5) * .5 + .5)
+    * (.7 + .3 * h(vec2(cycle, 7.)));
+
+  float scanY = floor(gl_FragCoord.y);
+  float rowNoise = h(vec2(scanY, floor(t * 30.)));
+  c *= 1. - edge * max(step(.45, rowNoise), step(.3, h(vec2(gl_FragCoord.x + scanY * 7., floor(t * 45.)))) * step(.2, rowNoise));
+
+  gl_FragColor = vec4(clamp(c, 0., 1.), 1.);
+}`
+);
+function useGL(ref) {
+  const raf = useRef(0);
+  useEffect(() => {
+    const c = ref.current;
+    if (!c) {
+      return;
+    }
+    const gl = c.getContext("webgl");
+    if (!gl) {
+      return;
+    }
+    const sh = (type, src) => {
+      const s = gl.createShader(type);
+      gl.shaderSource(s, src);
+      gl.compileShader(s);
+      return s;
+    };
+    const p = gl.createProgram();
+    gl.attachShader(p, sh(gl.VERTEX_SHADER, VERT));
+    gl.attachShader(p, sh(gl.FRAGMENT_SHADER, FRAG));
+    gl.linkProgram(p);
+    gl.useProgram(p);
+    gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+    gl.bufferData(
+      gl.ARRAY_BUFFER,
+      new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
+      gl.STATIC_DRAW
+    );
+    const a = gl.getAttribLocation(p, "a");
+    gl.enableVertexAttribArray(a);
+    gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0);
+    const uT = gl.getUniformLocation(p, "t");
+    const uR = gl.getUniformLocation(p, "r");
+    const resize = () => {
+      const rect = c.getBoundingClientRect();
+      const dpr = Math.min(devicePixelRatio, 2);
+      c.width = rect.width * dpr;
+      c.height = rect.height * dpr;
+      gl.viewport(0, 0, c.width, c.height);
+    };
+    resize();
+    const ro = new ResizeObserver(resize);
+    ro.observe(c);
+    const t0 = performance.now();
+    let visible = !document.hidden;
+    let inView = true;
+    let raf2 = 0;
+    const tick = () => {
+      gl.uniform1f(uT, (performance.now() - t0) / 1e3);
+      gl.uniform2f(uR, c.width, c.height);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+      raf2 = requestAnimationFrame(tick);
+    };
+    const start = () => {
+      if (visible && inView && !raf2) {
+        raf2 = requestAnimationFrame(tick);
+      }
+    };
+    const stop = () => {
+      if (raf2) {
+        cancelAnimationFrame(raf2);
+        raf2 = 0;
+      }
+    };
+    const onVisibility = () => {
+      visible = !document.hidden;
+      visible ? start() : stop();
+    };
+    const io = new IntersectionObserver(
+      (entries) => {
+        inView = entries.some((e) => e.isIntersecting);
+        inView ? start() : stop();
+      },
+      { threshold: 0 }
+    );
+    io.observe(c);
+    document.addEventListener("visibilitychange", onVisibility);
+    start();
+    raf.current = raf2;
+    return () => {
+      stop();
+      io.disconnect();
+      document.removeEventListener("visibilitychange", onVisibility);
+      ro.disconnect();
+    };
+  }, [ref]);
+}
+export function TV({ className }) {
+  const canvasRef = useRef(null);
+  useGL(canvasRef);
+  return /* @__PURE__ */ jsxs("div", { className: ["relative", className].filter(Boolean).join(" "), children: [
+    /* @__PURE__ */ jsxs("svg", { className: "relative h-full w-full", fill: "none", viewBox: "0 0 210 173", children: [
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M30.8342 2.44471 6.08268 36.683c-.24437.338-.38254.7412-.39689 1.158L1.57754 157.126c-.03891 1.129.82339 2.087 1.95096 2.167l162.4835 11.463c.433.031.866-.074 1.238-.3l35.718-21.69c.607-.369.986-1.02 1.008-1.73l4.102-130.9871c.035-1.1269-.826-2.0806-1.951-2.1604L32.6847 1.58029c-.7248-.05144-1.4247.27551-1.8505.86442Z",
+          fill: "#FDFD0D",
+          stroke: "#FDFD0D",
+          strokeWidth: "3.15"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M203.09 17.1483 35.6844 5.83395l-4.2 121.94805 168.4906 13.076z",
+          fill: "#000",
+          stroke: "#FDFD0D",
+          strokeWidth: "4.2"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M190.491 29.7483 48.2859 18.434l-4.2 98.848 143.2901 10.976z",
+          fill: "#FDFD0D"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      "canvas",
+      {
+        className: "absolute inset-0 h-full w-full",
+        ref: canvasRef,
+        style: {
+          clipPath: "polygon(23% 10.65%, 90.71% 17.2%, 89.23% 74.13%, 20.99% 67.79%)"
+        }
+      }
+    )
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { useEffect, useRef } from 'react'\n\nconst VERT = /* glsl */ `attribute vec2 a;void main(){gl_Position=vec4(a,0,1);}`\n\nconst FRAG = /* glsl */ `precision highp float;\nuniform float t;\nuniform vec2 r;\n\nconst float FBM_STR = .08;\n\nfloat h(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }\n\nfloat n2(vec2 p) {\n  vec2 i = floor(p), f = fract(p);\n  f = f * f * (3. - 2. * f);\n\n  return mix(\n    mix(h(i), h(i + vec2(1, 0)), f.x),\n    mix(h(i + vec2(0, 1)), h(i + vec2(1, 1)), f.x),\n    f.y\n  );\n}\n\nfloat fbm(vec2 p) {\n  float v = 0., a = .5;\n\n  for (int i = 0; i < 4; i++) {\n    v += a * n2(p);\n    p *= 2.1;\n    a *= .45;\n  }\n\n  return v;\n}\n\nfloat drift(float speed, float s) {\n  return fract(t * speed + s + .02 * sin(t * .4 + s * 3.));\n}\n\nfloat brushAt(vec2 uv, float y, float th, float s) {\n  float hw = .34 + .08 * h(vec2(s, 77.));\n  float cx = .5;\n  float xn = (uv.x - (cx - hw)) / (2. * hw);\n  float env = smoothstep(0., .03, xn) * smoothstep(1., .97, xn);\n  float localTh = th * env;\n\n  if (localTh < .002) return 0.;\n\n  float morph = floor(t * 8.) * .7 + s;\n  float top = y - localTh * .5 + fbm(vec2(uv.x * 6., morph)) * FBM_STR;\n  float bot = y + localTh * .5 - fbm(vec2(uv.x * 6., morph + 30.)) * FBM_STR;\n  float x0 = cx - hw + fbm(vec2(uv.y * 8., morph + 60.)) * FBM_STR;\n  float x1 = cx + hw - fbm(vec2(uv.y * 8., morph + 90.)) * FBM_STR;\n\n  float dMin = min(min(uv.y - top, bot - uv.y), min(uv.x - x0, x1 - uv.x));\n\n  float bristle = n2(vec2(uv.x * 60., uv.y * 8. + s)) * .4\n    + n2(vec2(uv.x * 25., (uv.y - y) * 120. + s)) * .35\n    + n2(vec2(uv.x * 90., uv.y * 3. + s * 2.)) * .25;\n\n  float eaten = smoothstep(.03, 0., dMin) * (1. - smoothstep(.2, .5, bristle));\n\n  return clamp(smoothstep(0., .003, dMin) * (1. - eaten), 0., 1.);\n}\n\nvoid main() {\n  vec2 uv = gl_FragCoord.xy / r;\n  uv = vec2(uv.x * cos(.095) - uv.y * sin(.095), uv.x * sin(.095) + uv.y * cos(.095));\n  uv += vec2(fbm(uv * 4. + t * .06), fbm(uv * 4. + 8. + t * .05)) * .012;\n\n  vec3 c = vec3(.992, .992, .051);\n\n  float smScroll = -drift(.04, 5.) * 2.;\n  float sm = 0.;\n\n  for (int i = 0; i < 20; i++) {\n    sm = max(sm, brushAt(uv, mod(float(i) * .1 + smScroll, 2.) - .5, .04, float(i) + 10.));\n  }\n\n  float d1 = drift(.15, 1.), d2 = drift(.15, 1.37), d3 = drift(.15, 1.58), d4 = drift(.15, 1.82);\n  float big = max(\n    max(brushAt(uv, 1.1 - d1 * 1.4, .28, 1.), brushAt(uv, 1.1 - d2 * 1.4, .18, 2.)),\n    max(brushAt(uv, 1.1 - d3 * 1.4, .3, 3.), brushAt(uv, 1.1 - d4 * 1.4, .15, 4.))\n  );\n\n  c = mix(c, vec3(0.), clamp(max(sm, big), 0., 1.));\n  c *= .94 + .06 * sin(uv.y * r.y * 6.283);\n\n  vec2 raw = gl_FragCoord.xy / r;\n  float dx = min(raw.x - .22, .90 - raw.x);\n  float dy = min(raw.y - .29, .86 - raw.y);\n  float cycle = floor(t * .4);\n  float edge = mix(smoothstep(.22, 0., max(min(dx, dy), 0.)), 1., step(.75, h(vec2(cycle, 13.))))\n    * smoothstep(.85, 1., sin(t * 2.5) * .5 + .5)\n    * (.7 + .3 * h(vec2(cycle, 7.)));\n\n  float scanY = floor(gl_FragCoord.y);\n  float rowNoise = h(vec2(scanY, floor(t * 30.)));\n  c *= 1. - edge * max(step(.45, rowNoise), step(.3, h(vec2(gl_FragCoord.x + scanY * 7., floor(t * 45.)))) * step(.2, rowNoise));\n\n  gl_FragColor = vec4(clamp(c, 0., 1.), 1.);\n}`\n\nfunction useGL(ref: React.RefObject<HTMLCanvasElement | null>) {\n  const raf = useRef(0)\n\n  useEffect(() => {\n    const c = ref.current\n\n    if (!c) {\n      return\n    }\n\n    const gl = c.getContext('webgl')\n\n    if (!gl) {\n      return\n    }\n\n    const sh = (type: number, src: string) => {\n      const s = gl.createShader(type)!\n      gl.shaderSource(s, src)\n      gl.compileShader(s)\n\n      return s\n    }\n\n    const p = gl.createProgram()!\n    gl.attachShader(p, sh(gl.VERTEX_SHADER, VERT))\n    gl.attachShader(p, sh(gl.FRAGMENT_SHADER, FRAG))\n    gl.linkProgram(p)\n    gl.useProgram(p)\n\n    gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer())\n    gl.bufferData(\n      gl.ARRAY_BUFFER,\n      new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),\n      gl.STATIC_DRAW\n    )\n\n    const a = gl.getAttribLocation(p, 'a')\n    gl.enableVertexAttribArray(a)\n    gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0)\n\n    const uT = gl.getUniformLocation(p, 't')\n    const uR = gl.getUniformLocation(p, 'r')\n\n    const resize = () => {\n      const rect = c.getBoundingClientRect()\n      const dpr = Math.min(devicePixelRatio, 2)\n\n      c.width = rect.width * dpr\n      c.height = rect.height * dpr\n\n      gl.viewport(0, 0, c.width, c.height)\n    }\n\n    resize()\n\n    const ro = new ResizeObserver(resize)\n    ro.observe(c)\n\n    const t0 = performance.now()\n\n    let visible = !document.hidden\n    let inView = true\n    let raf2 = 0\n\n    const tick = () => {\n      gl.uniform1f(uT, (performance.now() - t0) / 1e3)\n      gl.uniform2f(uR, c.width, c.height)\n      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4)\n\n      raf2 = requestAnimationFrame(tick)\n    }\n\n    const start = () => {\n      if (visible && inView && !raf2) {\n        raf2 = requestAnimationFrame(tick)\n      }\n    }\n\n    const stop = () => {\n      if (raf2) {\n        cancelAnimationFrame(raf2)\n        raf2 = 0\n      }\n    }\n\n    const onVisibility = () => {\n      visible = !document.hidden\n      visible ? start() : stop()\n    }\n\n    const io = new IntersectionObserver(\n      entries => {\n        inView = entries.some(e => e.isIntersecting)\n        inView ? start() : stop()\n      },\n      { threshold: 0 }\n    )\n\n    io.observe(c)\n    document.addEventListener('visibilitychange', onVisibility)\n\n    start()\n    raf.current = raf2\n\n    return () => {\n      stop()\n      io.disconnect()\n      document.removeEventListener('visibilitychange', onVisibility)\n      ro.disconnect()\n    }\n  }, [ref])\n}\n\nexport function TV({ className }: { className?: string }) {\n  const canvasRef = useRef<HTMLCanvasElement>(null)\n  useGL(canvasRef)\n\n  return (\n    <div className={['relative', className].filter(Boolean).join(' ')}>\n      <svg className=\"relative h-full w-full\" fill=\"none\" viewBox=\"0 0 210 173\">\n        <path\n          d=\"M30.8342 2.44471 6.08268 36.683c-.24437.338-.38254.7412-.39689 1.158L1.57754 157.126c-.03891 1.129.82339 2.087 1.95096 2.167l162.4835 11.463c.433.031.866-.074 1.238-.3l35.718-21.69c.607-.369.986-1.02 1.008-1.73l4.102-130.9871c.035-1.1269-.826-2.0806-1.951-2.1604L32.6847 1.58029c-.7248-.05144-1.4247.27551-1.8505.86442Z\"\n          fill=\"#FDFD0D\"\n          stroke=\"#FDFD0D\"\n          strokeWidth=\"3.15\"\n        />\n\n        <path\n          d=\"M203.09 17.1483 35.6844 5.83395l-4.2 121.94805 168.4906 13.076z\"\n          fill=\"#000\"\n          stroke=\"#FDFD0D\"\n          strokeWidth=\"4.2\"\n        />\n\n        <path\n          d=\"M190.491 29.7483 48.2859 18.434l-4.2 98.848 143.2901 10.976z\"\n          fill=\"#FDFD0D\"\n        />\n      </svg>\n\n      <canvas\n        className=\"absolute inset-0 h-full w-full\"\n        ref={canvasRef}\n        style={{\n          clipPath:\n            'polygon(23% 10.65%, 90.71% 17.2%, 89.23% 74.13%, 20.99% 67.79%)'\n        }}\n      />\n    </div>\n  )\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/typography/h1.d.ts

@@ -0,0 +1,11 @@
+export declare const H1: import("react").ForwardRefExoticComponent<{
+    as?: "h1" | undefined;
+} & {
+    expanded?: boolean | null | undefined;
+    compressed?: boolean | null | undefined;
+    courier?: boolean | null | undefined;
+    mondwest?: boolean | null | undefined;
+    mono?: boolean | null | undefined;
+    sans?: boolean | null | undefined;
+    variant?: "lg" | "md" | "sm" | "xl" | null | undefined;
+} & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref">, "as" | "expanded" | "compressed" | "courier" | "mondwest" | "mono" | "sans" | "variant"> & import("react").RefAttributes<HTMLHeadingElement>>;

package/dist/ui/components/typography/h1.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { cn } from "../../../utils/index.js";
+import { Typography } from "./index.js";
+export const H1 = forwardRef(
+  ({ className, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      Typography,
+      {
+        as: "h1",
+        className: cn("font-bold", className),
+        variant: "xl",
+        ...{ ref, ...props }
+      }
+    );
+  }
+);
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHsgZm9yd2FyZFJlZiB9IGZyb20gJ3JlYWN0J1xuXG5pbXBvcnQgeyBjbiB9IGZyb20gJy4uLy4uLy4uL3V0aWxzJ1xuXG5pbXBvcnQgeyBUeXBvZ3JhcGh5LCB0eXBlIFR5cG9ncmFwaHlQcm9wcyB9IGZyb20gJy4nXG5cbmV4cG9ydCBjb25zdCBIMSA9IGZvcndhcmRSZWY8SFRNTEhlYWRpbmdFbGVtZW50LCBUeXBvZ3JhcGh5UHJvcHM8J2gxJz4+KFxuICAoeyBjbGFzc05hbWUsIC4uLnByb3BzIH0sIHJlZikgPT4ge1xuICAgIHJldHVybiAoXG4gICAgICA8VHlwb2dyYXBoeVxuICAgICAgICBhcz1cImgxXCJcbiAgICAgICAgY2xhc3NOYW1lPXtjbignZm9udC1ib2xkJywgY2xhc3NOYW1lKX1cbiAgICAgICAgdmFyaWFudD1cInhsXCJcbiAgICAgICAgey4uLnsgcmVmLCAuLi5wcm9wcyB9fVxuICAgICAgLz5cbiAgICApXG4gIH1cbilcbiJdLAogICJtYXBwaW5ncyI6ICJBQVNNO0FBVE4sU0FBUyxrQkFBa0I7QUFFM0IsU0FBUyxVQUFVO0FBRW5CLFNBQVMsa0JBQXdDO0FBRTFDLGFBQU0sS0FBSztBQUFBLEVBQ2hCLENBQUMsRUFBRSxXQUFXLEdBQUcsTUFBTSxHQUFHLFFBQVE7QUFDaEMsV0FDRTtBQUFBLE1BQUM7QUFBQTtBQUFBLFFBQ0MsSUFBRztBQUFBLFFBQ0gsV0FBVyxHQUFHLGFBQWEsU0FBUztBQUFBLFFBQ3BDLFNBQVE7QUFBQSxRQUNQLEdBQUcsRUFBRSxLQUFLLEdBQUcsTUFBTTtBQUFBO0FBQUEsSUFDdEI7QUFBQSxFQUVKO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/ui/components/typography/h2.d.ts

@@ -0,0 +1,11 @@
+export declare const H2: import("react").ForwardRefExoticComponent<{
+    as?: "h2" | undefined;
+} & {
+    expanded?: boolean | null | undefined;
+    compressed?: boolean | null | undefined;
+    courier?: boolean | null | undefined;
+    mondwest?: boolean | null | undefined;
+    mono?: boolean | null | undefined;
+    sans?: boolean | null | undefined;
+    variant?: "lg" | "md" | "sm" | "xl" | null | undefined;
+} & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref">, "as" | "expanded" | "compressed" | "courier" | "mondwest" | "mono" | "sans" | "variant"> & import("react").RefAttributes<HTMLHeadingElement>>;

package/dist/ui/components/typography/h2.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { cn } from "../../../utils/index.js";
+import { Typography } from "./index.js";
+export const H2 = forwardRef(
+  ({ className, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      Typography,
+      {
+        as: "h2",
+        className: cn("font-bold", className),
+        variant: "lg",
+        ...{ ref, ...props }
+      }
+    );
+  }
+);
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHsgZm9yd2FyZFJlZiB9IGZyb20gJ3JlYWN0J1xuXG5pbXBvcnQgeyBjbiB9IGZyb20gJy4uLy4uLy4uL3V0aWxzJ1xuXG5pbXBvcnQgeyBUeXBvZ3JhcGh5LCB0eXBlIFR5cG9ncmFwaHlQcm9wcyB9IGZyb20gJy4nXG5cbmV4cG9ydCBjb25zdCBIMiA9IGZvcndhcmRSZWY8SFRNTEhlYWRpbmdFbGVtZW50LCBUeXBvZ3JhcGh5UHJvcHM8J2gyJz4+KFxuICAoeyBjbGFzc05hbWUsIC4uLnByb3BzIH0sIHJlZikgPT4ge1xuICAgIHJldHVybiAoXG4gICAgICA8VHlwb2dyYXBoeVxuICAgICAgICBhcz1cImgyXCJcbiAgICAgICAgY2xhc3NOYW1lPXtjbignZm9udC1ib2xkJywgY2xhc3NOYW1lKX1cbiAgICAgICAgdmFyaWFudD1cImxnXCJcbiAgICAgICAgey4uLnsgcmVmLCAuLi5wcm9wcyB9fVxuICAgICAgLz5cbiAgICApXG4gIH1cbilcbiJdLAogICJtYXBwaW5ncyI6ICJBQVNNO0FBVE4sU0FBUyxrQkFBa0I7QUFFM0IsU0FBUyxVQUFVO0FBRW5CLFNBQVMsa0JBQXdDO0FBRTFDLGFBQU0sS0FBSztBQUFBLEVBQ2hCLENBQUMsRUFBRSxXQUFXLEdBQUcsTUFBTSxHQUFHLFFBQVE7QUFDaEMsV0FDRTtBQUFBLE1BQUM7QUFBQTtBQUFBLFFBQ0MsSUFBRztBQUFBLFFBQ0gsV0FBVyxHQUFHLGFBQWEsU0FBUztBQUFBLFFBQ3BDLFNBQVE7QUFBQSxRQUNQLEdBQUcsRUFBRSxLQUFLLEdBQUcsTUFBTTtBQUFBO0FBQUEsSUFDdEI7QUFBQSxFQUVKO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/ui/components/typography/index.d.ts

@@ -0,0 +1,15 @@
+import { type VariantProps } from 'class-variance-authority';
+import { type PolyProps } from '../../../utils';
+declare const typographyVariants: (props?: ({
+    compressed?: boolean | null | undefined;
+    courier?: boolean | null | undefined;
+    expanded?: boolean | null | undefined;
+    mondwest?: boolean | null | undefined;
+    mono?: boolean | null | undefined;
+    sans?: boolean | null | undefined;
+    variant?: "lg" | "md" | "sm" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const Typography: import("../../..").PolyComponent<"span", OwnProps>;
+type OwnProps = VariantProps<typeof typographyVariants>;
+export type TypographyProps<T extends React.ElementType = 'span'> = PolyProps<T, OwnProps>;
+export {};

package/dist/ui/components/typography/index.js

@@ -0,0 +1,41 @@
+import { cva } from "class-variance-authority";
+import { createElement } from "react";
+import { cn, polyRef } from "../../../utils/index.js";
+const typographyVariants = cva("font-sans", {
+  variants: {
+    compressed: { true: "font-compressed" },
+    courier: { true: "font-courier" },
+    expanded: { true: "font-expanded" },
+    mondwest: { true: "font-mondwest tracking-[0.1875rem]" },
+    mono: { true: "font-mono" },
+    sans: { true: "font-sans" },
+    variant: {
+      lg: "text-[2.625rem] leading-[1] tracking-[0.0525rem]",
+      md: "text-[2.625rem] leading-[1] tracking-[0.0525rem]",
+      sm: "leading-1.4 text-[.9375rem] tracking-[0.1875rem]",
+      xl: "text-[4.5rem] leading-[1] tracking-[0.135rem]"
+    }
+  }
+});
+export const Typography = polyRef(
+  ({
+    as,
+    className,
+    compressed,
+    courier,
+    expanded,
+    mondwest,
+    mono,
+    variant,
+    ...rest
+  }, ref) => {
+    const fonts = { compressed, courier, expanded, mondwest, mono };
+    const fontVariant = { ...fonts, sans: !Object.values(fonts).some(Boolean) };
+    return createElement(as ?? "span", {
+      ...rest,
+      className: cn(typographyVariants({ ...fontVariant, variant }), className),
+      ref
+    });
+  }
+);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/typography/legend.d.ts

@@ -0,0 +1,6 @@
+export declare function Legend({ children, className, label, sub, ...props }: LegendProps): import("react").JSX.Element;
+interface LegendProps extends React.ComponentProps<'hgroup'> {
+    label: React.ReactNode;
+    sub?: React.ReactNode;
+}
+export {};

package/dist/ui/components/typography/legend.js

@@ -0,0 +1,20 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../../utils/index.js";
+import { Small } from "./small.js";
+export function Legend({
+  children,
+  className,
+  label,
+  sub,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs("hgroup", { className: cn("flex flex-col gap-2", className), ...props, children: [
+    /* @__PURE__ */ jsx(Small, { children: label }),
+    sub && /* @__PURE__ */ jsxs(Small, { className: "opacity-50", children: [
+      "- ",
+      sub
+    ] }),
+    children
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHsgY24gfSBmcm9tICcuLi8uLi8uLi91dGlscydcblxuaW1wb3J0IHsgU21hbGwgfSBmcm9tICcuL3NtYWxsJ1xuXG5leHBvcnQgZnVuY3Rpb24gTGVnZW5kKHtcbiAgY2hpbGRyZW4sXG4gIGNsYXNzTmFtZSxcbiAgbGFiZWwsXG4gIHN1YixcbiAgLi4ucHJvcHNcbn06IExlZ2VuZFByb3BzKSB7XG4gIHJldHVybiAoXG4gICAgPGhncm91cCBjbGFzc05hbWU9e2NuKCdmbGV4IGZsZXgtY29sIGdhcC0yJywgY2xhc3NOYW1lKX0gey4uLnByb3BzfT5cbiAgICAgIDxTbWFsbD57bGFiZWx9PC9TbWFsbD5cbiAgICAgIHtzdWIgJiYgPFNtYWxsIGNsYXNzTmFtZT1cIm9wYWNpdHktNTBcIj4tIHtzdWJ9PC9TbWFsbD59XG4gICAgICB7Y2hpbGRyZW59XG4gICAgPC9oZ3JvdXA+XG4gIClcbn1cblxuaW50ZXJmYWNlIExlZ2VuZFByb3BzIGV4dGVuZHMgUmVhY3QuQ29tcG9uZW50UHJvcHM8J2hncm91cCc+IHtcbiAgbGFiZWw6IFJlYWN0LlJlYWN0Tm9kZVxuICBzdWI/OiBSZWFjdC5SZWFjdE5vZGVcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQWFNLGNBQ1EsWUFEUjtBQWJOLFNBQVMsVUFBVTtBQUVuQixTQUFTLGFBQWE7QUFFZixnQkFBUyxPQUFPO0FBQUEsRUFDckI7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBLEdBQUc7QUFDTCxHQUFnQjtBQUNkLFNBQ0UscUJBQUMsWUFBTyxXQUFXLEdBQUcsdUJBQXVCLFNBQVMsR0FBSSxHQUFHLE9BQzNEO0FBQUEsd0JBQUMsU0FBTyxpQkFBTTtBQUFBLElBQ2IsT0FBTyxxQkFBQyxTQUFNLFdBQVUsY0FBYTtBQUFBO0FBQUEsTUFBRztBQUFBLE9BQUk7QUFBQSxJQUM1QztBQUFBLEtBQ0g7QUFFSjsiLAogICJuYW1lcyI6IFtdCn0K