shaders 3.2.475 → 4.0.0

package/dist/core/std/lists.d.ts

@@ -1,28 +1,58 @@
 import { Expr } from '../gpu/contract';
 
-/** One item's field accessors at a loop index (the packed vec4 lane, decoded per kind). */
+/** One item's fields at a loop index, read by field name and kind. */
 export interface ListItemAt {
-    /** `position` fields: vec2 in the stored (x, 1−y) convention — what a position uniform holds. */
+    /** A `position` field as `vec2f`, in the engine's stored form (y flipped: 1 − the authored y). */
     position: (field: string) => Expr;
-    /** `color` fields: linear rgba vec4. */
+    /** A `color` field as `vec4f`, linear RGB with alpha. */
     color: (field: string) => Expr;
-    /** `number` / `boolean` fields: f32 (booleans are ±1). */
+    /** A `number` or `boolean` field as `f32` (true is 1, false is −1). */
     number: (field: string) => Expr;
 }
+/** A list prop bound for reading: the live item count and each item's fields. */
 export interface ListRef {
-    /** The live item count (f32 uniform). */
+    /** How many items the list holds right now, as an `f32`. */
     count: Expr;
-    /** Field accessors for item `i` (an Expr indexing the lane arrays). */
+    /** The fields of item `i`. */
     at: (i: Expr) => ListItemAt;
 }
-/** Bind a list prop's uniforms. */
+/**
+ * Read a list prop inside a hand-written builder: its live item count and each item's fields.
+ *
+ * `listOf(params, 'lights')` gives `count` and `at(i)`, whose `.position('position')`,
+ * `.color('color')` and `.number('intensity')` read item `i` by field name. Throws when
+ * `prop` is not a list prop or a field name is not in its item spec. Loop with `accumulate`.
+ *
+ * @example
+ * ```ts
+ * const lights = listOf(params, 'lights')
+ * const rgb = accumulate(lights, (i) => mul(lights.at(i).color('color').member('rgb'), lights.at(i).number('intensity')), {zero: 'vec3f'})
+ * ```
+ * @tip A position field's y is stored flipped; use `sub(1, pos.member('y'))` to compare it with `uv`.
+ * @see accumulate
+ */
 export declare function listOf(params: {
     uniforms: Record<string, Expr>;
 }, prop: string): ListRef;
 /**
- * Sum a per-item expression over a list: `var acc = zero; for (i < count) { acc += body(i) }`.
- * `zero` sets the accumulator type (`'f32'` or `'vec3f'`). Statement machinery — see the module
- * header for the hoisting rule.
+ * Add up a per-item value over every item of a list, in a real GPU loop over the live count.
+ *
+ * `body(i)` returns the value for item `i`. `zero` picks the sum's type: `'f32'` (default) or
+ * `'vec3f'` for a color. Anything the body reads that was computed outside the loop (a
+ * normal, a surface point) goes in `deps`, so it is emitted once before the loop instead of
+ * inside it. `hint` names the sum in the generated code.
+ *
+ * @example
+ * ```ts
+ * const lights = listOf(params, 'lights')
+ * const rgb = accumulate(lights, (i) => {
+ *   const light = lights.at(i)
+ *   const pos = light.position('position')
+ *   const d = length(sub(uv, vec2(pos.member('x'), sub(1, pos.member('y')))))
+ *   return mul(light.color('color').member('rgb'), div(light.number('intensity'), add(1, mul(d, d))))
+ * }, {zero: 'vec3f', deps: [uv], hint: 'lightSum'})
+ * ```
+ * @see listOf
  */
 export declare function accumulate(list: ListRef, body: (i: Expr) => Expr, opts?: {
     zero?: 'f32' | 'vec3f';

package/dist/core/std/lists.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lists.d.ts","sourceRoot":"","sources":["../../src/std/lists.ts"],"names":[],"mappings":"AAYA,OAAO,EAAC,IAAI,EAAC,MAAM,iBAAiB,CAAA;AAOpC,2FAA2F;AAC3F,MAAM,WAAW,UAAU;IACvB,iGAAiG;IACjG,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,wCAAwC;IACxC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9B,0DAA0D;IAC1D,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAClC;AAED,MAAM,WAAW,OAAO;IACpB,yCAAyC;IACzC,KAAK,EAAE,IAAI,CAAA;IACX,uEAAuE;IACvE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,UAAU,CAAA;CAC9B;AAED,mCAAmC;AACnC,wBAAgB,MAAM,CAAC,MAAM,EAAE;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAgBtF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACtB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,IAAI,EACvB,IAAI,GAAE;IAAC,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAM,GAClE,IAAI,CA4BN"}
+{"version":3,"file":"lists.d.ts","sourceRoot":"","sources":["../../src/std/lists.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAC,IAAI,EAAC,MAAM,iBAAiB,CAAA;AAOpC,sEAAsE;AACtE,MAAM,WAAW,UAAU;IACvB,kGAAkG;IAClG,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,yDAAyD;IACzD,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9B,uEAAuE;IACvE,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAClC;AAED,iFAAiF;AACjF,MAAM,WAAW,OAAO;IACpB,4DAA4D;IAC5D,KAAK,EAAE,IAAI,CAAA;IACX,8BAA8B;IAC9B,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,UAAU,CAAA;CAC9B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAgBtF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,wBAAgB,UAAU,CACtB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,IAAI,EACvB,IAAI,GAAE;IAAC,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAM,GAClE,IAAI,CA4BN"}

package/dist/core/std/lower.d.ts

@@ -2,6 +2,78 @@ import { ComponentProps } from '../types';
 import { GpuShaderDefinition } from '../gpu/contract';
 import { StdDefinition } from './types';
 
-/** Lower a std definition to the engine contract. */
+/**
+ * The same function as `defineShader`, under the name the library's own shaders call it by.
+ *
+ * @internal
+ */
 export declare function defineStd<T extends ComponentProps>(definition: StdDefinition<T>): GpuShaderDefinition<T>;
+/**
+ * Define a shader component from a plain object: its props, and one field that says what it draws.
+ *
+ * The field carrying the per-pixel work decides what kind of component you get. `paint:`
+ * makes a generator: it paints from coordinates and needs nothing inside it. `effect:` makes
+ * a filter over the layer inside it (the child). A `wgsl` body that only reads `child` edits
+ * one pixel at a time; one that samples `childTexture` reads neighbours through its own
+ * render pass. `map:` makes a distortion from one coordinate function, `shape:` a 2D shape
+ * with fill and stroke, `gpu:` a raw builder. Give exactly one. `role` and `species` are
+ * optional and may only restate what the field already says.
+ *
+ * `props` are the component's attributes. Each has a `default`, an optional `transform`
+ * (`transformColor`, `transformPosition`, …), optional `ui` metadata for editors, and
+ * `compileTime: true` when a change should rebuild the shader (or `recompile: crosses(0)` to
+ * rebuild only at a threshold). A prop name must be a plain identifier and must not be one
+ * of the layer props every component already has — `blendMode`, `opacity`, `visible`, `id`,
+ * `maskSource`, `maskType`, `renderOrder`, `transform`, `boundingBox`, `flow`, `absolute`,
+ * `children`, `ref`, `key`, `src` — nor a name the renderer manages itself (`_animTime`,
+ * `_opacity`, or anything starting `_pad`, `_bbox_`, `_map_`). Those throw when the
+ * definition is built. `animatedTime: {speed: 'speed'}` gives the layer its own clock, scaled by that prop
+ * (0 pauses it); `time` in a `wgsl` body and `animatedTime(params)` in a builder read it.
+ *
+ * The returned definition is what you hand to `<CustomShader src={Halo}>` in React, Vue,
+ * Svelte or Solid, to `registerShader`, or to `createShader(canvas, preset, {components:
+ * [Halo]})` so preset JSON can name it by `type`.
+ *
+ * @example
+ * ```ts
+ * import {defineShader, wgsl, transformColor, transformPosition} from 'shaders/std'
+ *
+ * export const Halo = defineShader({
+ *   name: 'Halo',
+ *   animatedTime: {speed: 'speed'},
+ *   props: {
+ *     inner: {default: '#ffd166', transform: transformColor},
+ *     outer: {default: '#0b132b', transform: transformColor},
+ *     center: {default: {x: 0.5, y: 0.5}, transform: transformPosition},
+ *     radius: {default: 0.6},
+ *     bands: {default: 4},
+ *     speed: {default: 1},
+ *   },
+ *   paint: wgsl`
+ *     let d = length((uv - center) * vec2f(aspect, 1.0)) / radius;
+ *     let wave = 0.5 + 0.5 * cos(d * bands * 6.2831853 - time * 2.0);
+ *     return vec4f(mix(outer.rgb, inner.rgb, wave * (1.0 - smoothstep(0.7, 1.0, d))), 1.0);
+ *   `,
+ * })
+ * ```
+ * @example
+ * ```ts
+ * // A filter composed from std words, skipped entirely while `intensity` is 0.
+ * export const Vignette = defineShader({
+ *   name: 'Vignette',
+ *   props: {
+ *     color: {default: '#000000', transform: transformColor},
+ *     center: {default: {x: 0.5, y: 0.5}, transform: transformPosition},
+ *     radius: {default: 0.5},
+ *     falloff: {default: 0.5},
+ *     intensity: {default: 1, recompile: crosses(0)},
+ *   },
+ *   effect: tintToward(p('color'), {amount: radialMask({center: p('center'), radius: p('radius'), falloff: p('falloff')}).times(p('intensity'))}),
+ *   identityWhen: isZero('intensity'),
+ * })
+ * ```
+ * @tip A prop the engine never sends to the GPU (a URL string, a shape object, a list) cannot be read in a `wgsl` body; reference it and WGSL reports the name as undefined.
+ * @see wgsl, registerShader, p, crosses, isZero, listOf
+ */
+export declare const defineShader: typeof defineStd;
 //# sourceMappingURL=lower.d.ts.map

package/dist/core/std/lower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../../src/std/lower.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAC,cAAc,EAAa,MAAM,UAAU,CAAA;AACxD,OAAO,KAAK,EAA0B,mBAAmB,EAAa,MAAM,iBAAiB,CAAA;AAO7F,OAAO,KAAK,EAGR,aAAa,EAQhB,MAAM,SAAS,CAAA;AAgOhB,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,CAAC,SAAS,cAAc,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAWxG"}
+{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../../src/std/lower.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH,OAAO,KAAK,EAAC,cAAc,EAAa,MAAM,UAAU,CAAA;AACxD,OAAO,KAAK,EAA0B,mBAAmB,EAAa,MAAM,iBAAiB,CAAA;AAO7F,OAAO,KAAK,EAGR,aAAa,EAShB,MAAM,SAAS,CAAA;AA2VhB;;;;GAIG;AAGH,wBAAgB,SAAS,CAAC,CAAC,SAAS,cAAc,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAKxG;AA8DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAGH,eAAO,MAAM,YAAY,EAAE,OAAO,SAAqB,CAAA"}

package/dist/core/std/mask.d.ts

@@ -2,10 +2,18 @@ import { Expr } from '../gpu/contract';
 import { PropRef, Scalar } from './values';
 
 /**
- * An asymmetric soft band around a line/curve: a sharp fade-in on one side, a long fade-out
- * on the other. `distance` is the signed distance from the line (negative = below);
- * `below` fades coverage in across `[from, to]`, `above` fades it out across
- * `[from ?? 0, to]`. The band concept under curtains, horizons, beam falloffs, underlines.
+ * A soft band around a line, sharp on one side and long on the other.
+ *
+ * `distance` is the signed distance from the line: negative below it, positive above.
+ * Coverage rises from 0 to 1 as the distance crosses `below.from` to `below.to`, then falls
+ * back to 0 as it crosses `above.from` (default 0) to `above.to`. The shape under curtains,
+ * horizons and underlines.
+ *
+ * @example
+ * ```ts
+ * const curtain = mask.softBand({distance: sub(uv.member('y'), pathY), below: {from: -0.04, to: 0.015}, above: {to: height}})
+ * ```
+ * @see softDisc, crispStroke
  */
 export declare function softBand(opts: {
     distance: Expr;
@@ -19,10 +27,18 @@ export declare function softBand(opts: {
     };
 }): Expr;
 /**
- * Disc coverage with a soft, gamma-curved edge: a smoothstep band of half-width
- * `softness.width` around `radius`, raised through `softness.curve`. The soft cousin of the
- * kit's crisp `aa.discCoverage` — this one is a LOOK dial (blobs, orbs, glow dots), not an
- * anti-aliasing footprint.
+ * A filled disc with a soft, shaped edge.
+ *
+ * `dist` is the distance from the disc's center and `radius` its size, both in the same
+ * units. The edge fades over `softness.width` either side of the radius, and
+ * `softness.curve` bends that fade: 1 is even, higher values pull it tighter toward the
+ * rim. The look of blobs, orbs and glow dots.
+ *
+ * @example
+ * ```ts
+ * const orb = mask.softDisc({dist, radius: params.uniforms.size, softness: {width: 0.08, curve: 1.5}})
+ * ```
+ * @see crispFill, softBand
  */
 export declare function softDisc(opts: {
     dist: Expr;
@@ -33,19 +49,35 @@ export declare function softDisc(opts: {
     };
 }): Expr;
 /**
- * Crisp fill of a signed-distance field: 1 inside (`distance < 0`), 0 outside, feathered
- * across one `footprint` (a pixel in field units for anti-aliasing; wider for a deliberate
- * soft edge). The concept-level "fill this shape" word for any paint that draws SDFs
- * outside the shape scaffold (bars, blocks, curve envelopes).
+ * A clean fill of a shape: 1 inside, 0 outside.
+ *
+ * `distance` is a signed distance, negative inside the shape, such as one from the `shape`
+ * words. `footprint` is how wide the edge blends. One pixel in the distance's units gives an
+ * anti-aliased edge. A wider value gives a deliberate soft edge.
+ *
+ * @example
+ * ```ts
+ * const bar = mask.crispFill({distance: shape.roundedRect(x, y, w, h, rounding), footprint: px})
+ * ```
+ * @tip One pixel in uv is `div(1, viewport.member('y'))`, with `viewport` from `frames.surfaceOf`.
+ * @see crispStroke, softDisc
  */
 export declare function crispFill(opts: {
     distance: Expr;
     footprint: Expr | number;
 }): Expr;
 /**
- * Crisp stroke of a signed-distance field: a band of `width` centred on the zero contour,
- * feathered across `footprint`. Sugar over {@link crispFill} on `|distance| − width/2` — the
- * "outline this shape / draw this curve" word.
+ * A clean outline of a shape, or a drawn curve, of a given width.
+ *
+ * `distance` is a signed distance to the shape's edge or to the curve. The stroke is
+ * centered on the edge and `width` wide, in the distance's units. `footprint` blends the
+ * stroke's own edges, as in `crispFill`.
+ *
+ * @example
+ * ```ts
+ * const outline = mask.crispStroke({distance: shape.circle(x, y, radius), width: params.uniforms.lineWidth, footprint: px})
+ * ```
+ * @see crispFill
  */
 export declare function crispStroke(opts: {
     distance: Expr;
@@ -53,8 +85,19 @@ export declare function crispStroke(opts: {
     footprint: Expr | number;
 }): Expr;
 /**
- * Aspect-corrected radial falloff: 0 inside `radius`, rising to 1 at `radius + falloff`.
- * `center` binds a position prop (transformPosition-stored). Body: `fields.radialFalloffMask`.
+ * An amount that is 0 near a center and grows to 1 with distance, for an effect's strength.
+ *
+ * Coverage stays 0 inside `radius` and reaches 1 at `radius + falloff`, measured in uv with
+ * the aspect corrected so the ring is round. Every slot takes a prop: `center` is a position
+ * prop, `radius` and `falloff` are numbers in uv. Chain `.times(p('intensity'))` to scale
+ * it.
+ *
+ * @example
+ * ```ts
+ * effect: tintToward(p('color'), {amount: radialMask({center: p('center'), radius: p('radius'), falloff: p('falloff')}).times(p('intensity'))})
+ * ```
+ * @tip Also exported at the top level of `shaders/std`, so `radialMask` works without the `mask.` prefix.
+ * @see softDisc
  */
 export declare function radialMask(slots: {
     center: PropRef;

package/dist/core/std/mask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mask.d.ts","sourceRoot":"","sources":["../../src/std/mask.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,iBAAiB,CAAA;AAEzC,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,UAAU,CAAA;AACrC,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAA;AAE/B;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAC3B,QAAQ,EAAE,IAAI,CAAA;IACd,KAAK,EAAE;QAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,EAAE,EAAE,IAAI,GAAG,MAAM,CAAA;KAAC,CAAA;IAC/C,KAAK,EAAE;QAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,EAAE,EAAE,IAAI,GAAG,MAAM,CAAA;KAAC,CAAA;CACnD,GAAG,IAAI,CAKP;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAC3B,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,IAAI,GAAG,MAAM,CAAA;IACrB,QAAQ,EAAE;QAAC,KAAK,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,KAAK,EAAE,IAAI,GAAG,MAAM,CAAA;KAAC,CAAA;CACzD,GAAG,IAAI,CAGP;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAAA;CAAC,GAAG,IAAI,CAGhF;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAAA;CAAC,GAAG,IAAI,CAExG;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,GAAG,MAAM,CAE9F"}
+{"version":3,"file":"mask.d.ts","sourceRoot":"","sources":["../../src/std/mask.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,iBAAiB,CAAA;AAEzC,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,UAAU,CAAA;AACrC,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAA;AAE/B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAC3B,QAAQ,EAAE,IAAI,CAAA;IACd,KAAK,EAAE;QAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,EAAE,EAAE,IAAI,GAAG,MAAM,CAAA;KAAC,CAAA;IAC/C,KAAK,EAAE;QAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,EAAE,EAAE,IAAI,GAAG,MAAM,CAAA;KAAC,CAAA;CACnD,GAAG,IAAI,CAKP;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAC3B,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,IAAI,GAAG,MAAM,CAAA;IACrB,QAAQ,EAAE;QAAC,KAAK,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,KAAK,EAAE,IAAI,GAAG,MAAM,CAAA;KAAC,CAAA;CACzD,GAAG,IAAI,CAMP;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAAA;CAAC,GAAG,IAAI,CAGhF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAAA;CAAC,GAAG,IAAI,CAGxG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,GAAG,MAAM,CAG9F"}