@woosh/meep-engine 3.15.0 → 3.16.0

package/src/shade/renderer/particles/graph/particle_graph_authoring.js

@@ -1,108 +1,121 @@
-import { PortDirection } from "../../../../core/model/node-graph/node/PortDirection.js";
-import { get_particle_node_description, PARTICLE_NODE_OUTPUT_PORT } from "./ParticleNodeRegistry.js";
-
-/**
- * Authoring sugar for building particle effects on a plain
- * {@link ../../../../core/model/node-graph/NodeGraph.js NodeGraph}.
- *
- * These are convenience wrappers only — the graph, its nodes and its connections are the standard
- * node-graph model, so the editor, serializers and graph utilities all work on particle effects
- * unchanged. Everything downstream (see {@link ./compile_particle_graph.js}) consumes `NodeGraph`
- * directly and never sees these helpers.
- */
-
-/**
- * Add a node to a particle graph.
- *
- * @param {NodeGraph} graph
- * @param {string} type a node type name registered in {@link ./ParticleNodeRegistry.js}
- * @param {object} [parameters] static parameters (attribute name, builtin id, constant value, …)
- * @returns {number} the new node instance id
- */
-export function particle_node(graph, type, parameters = {}) {
-    const description = get_particle_node_description(type);
-
-    const id = graph.createNode(description);
-
-    graph.getNodeSafe(id).setParameters(parameters);
-
-    return id;
-}
-
-/**
- * Bind an input port of a node to a source, replacing whatever was bound to it before.
- *
- * The source may be:
- * - a node id (number) → that node's `out` port,
- * - `{ node, port }` → an explicit port,
- * - a number array → a literal `vec4`, materialised as a `const` node (scalar broadcast is NOT
- *   applied; `[5]` means `[5,0,0,0]`).
- *
- * @param {NodeGraph} graph
- * @param {number} node_id
- * @param {string} port input port name
- * @param {number|number[]|{node: number, port?: string}} source
- * @returns {number} connection id
- */
-export function particle_wire(graph, node_id, port, source) {
-    const node = graph.getNodeSafe(node_id);
-
-    const port_object = node.description.findPortByNameAndDirection(port, PortDirection.In);
-
-    if (port_object === undefined) {
-        throw new Error(`Node ${node_id} (${node.description.name}) has no input port '${port}'`);
-    }
-
-    // snapshot before connecting, so the replacement is only committed once the new wiring holds
-    const previous = node.getEndpoint(port_object.id).inConnections;
-
-    const resolved = resolve_source(graph, source);
-
-    const connection_id = graph.createConnectionByPortName(
-        resolved.node, resolved.port,
-        node_id, port
-    );
-
-    // an input may have at most one source, so binding it again replaces rather than adds
-    for (const connection of previous) {
-        graph.deleteConnection(connection.id);
-    }
-
-    return connection_id;
-}
-
-/**
- * @param {NodeGraph} graph
- * @param {number|number[]|{node: number, port?: string}} source
- * @returns {{node: number, port: string}}
- */
-function resolve_source(graph, source) {
-    if (typeof source === "number") {
-        // Could be a node id or a scalar literal — ambiguous, so literals must use the array form.
-        return { node: source, port: PARTICLE_NODE_OUTPUT_PORT };
-    }
-
-    if (Array.isArray(source)) {
-        const value = [source[0] ?? 0, source[1] ?? 0, source[2] ?? 0, source[3] ?? 0];
-
-        return {
-            node: particle_node(graph, "const", { value }),
-            port: PARTICLE_NODE_OUTPUT_PORT
-        };
-    }
-
-    if (source !== null && typeof source === "object" && typeof source.node === "number") {
-        return { node: source.node, port: source.port ?? PARTICLE_NODE_OUTPUT_PORT };
-    }
-
-    throw new Error(`Invalid input source: ${JSON.stringify(source)}`);
-}
-
-/**
- * Wrap a scalar or vector as a literal source (so it is unambiguous vs. a node id).
- * @param {...number} components
- * @returns {number[]}
- */
-export function literal(...components) {
-    return components;
-}
+import { PortDirection } from "../../../../core/model/node-graph/node/PortDirection.js";
+import { get_particle_library_description } from "./particle_node_library.js";
+import { particle_node_default_parameters } from "./particle_node_parameters.js";
+import { is_particle_group_description } from "./ParticleNodeGroup.js";
+import { PARTICLE_NODE_OUTPUT_PORT } from "./ParticleNodeRegistry.js";
+
+/**
+ * Authoring sugar for building particle effects on a plain
+ * {@link ../../../../core/model/node-graph/NodeGraph.js NodeGraph}.
+ *
+ * These are convenience wrappers only — the graph, its nodes and its connections are the standard
+ * node-graph model, so the editor, serializers and graph utilities all work on particle effects
+ * unchanged. Everything downstream (see {@link ./compile_particle_graph.js}) consumes `NodeGraph`
+ * directly and never sees these helpers.
+ */
+
+/**
+ * Add a node to a particle graph.
+ *
+ * Parameters the caller leaves out take the type's defaults (see
+ * {@link ./particle_node_parameters.js particle_node_default_parameters}), so what lands in the
+ * graph is a node that compiles — the same footing a node dropped from the editor's palette
+ * starts on. An attribute reference has no default worth having and is left empty.
+ *
+ * @param {NodeGraph} graph
+ * @param {string} type a node type name from the library — a stock type or a
+ *   {@link ./ParticleNodeGroup.js group}
+ * @param {object} [parameters] static parameters (attribute name, builtin id, constant value, …)
+ * @returns {number} the new node instance id
+ */
+export function particle_node(graph, type, parameters = {}) {
+    const description = get_particle_library_description(type);
+
+    const id = graph.createNode(description);
+
+    // a group declares no parameters of its own; its configuration is the wiring inside it
+    const defaults = is_particle_group_description(description)
+        ? {}
+        : particle_node_default_parameters(type);
+
+    graph.getNodeSafe(id).setParameters({ ...defaults, ...parameters });
+
+    return id;
+}
+
+/**
+ * Bind an input port of a node to a source, replacing whatever was bound to it before.
+ *
+ * The source may be:
+ * - a node id (number) → that node's `out` port,
+ * - `{ node, port }` → an explicit port,
+ * - a number array → a literal, materialised as a `const` node as wide as the array: `[5]` is a
+ *   scalar, and a scalar meeting a vector input broadcasts; `[5, 0, 0]` is a `vec3`.
+ *
+ * @param {NodeGraph} graph
+ * @param {number} node_id
+ * @param {string} port input port name
+ * @param {number|number[]|{node: number, port?: string}} source
+ * @returns {number} connection id
+ */
+export function particle_wire(graph, node_id, port, source) {
+    const node = graph.getNodeSafe(node_id);
+
+    const port_object = node.description.findPortByNameAndDirection(port, PortDirection.In);
+
+    if (port_object === undefined) {
+        throw new Error(`Node ${node_id} (${node.description.name}) has no input port '${port}'`);
+    }
+
+    // snapshot before connecting, so the replacement is only committed once the new wiring holds
+    const previous = node.getEndpoint(port_object.id).inConnections;
+
+    const resolved = resolve_source(graph, source);
+
+    const connection_id = graph.createConnectionByPortName(
+        resolved.node, resolved.port,
+        node_id, port
+    );
+
+    // an input may have at most one source, so binding it again replaces rather than adds
+    for (const connection of previous) {
+        graph.deleteConnection(connection.id);
+    }
+
+    return connection_id;
+}
+
+/**
+ * @param {NodeGraph} graph
+ * @param {number|number[]|{node: number, port?: string}} source
+ * @returns {{node: number, port: string}}
+ */
+function resolve_source(graph, source) {
+    if (typeof source === "number") {
+        // Could be a node id or a scalar literal — ambiguous, so literals must use the array form.
+        return { node: source, port: PARTICLE_NODE_OUTPUT_PORT };
+    }
+
+    if (Array.isArray(source)) {
+        return {
+            node: particle_node(graph, "const", { value: source.slice() }),
+            port: PARTICLE_NODE_OUTPUT_PORT
+        };
+    }
+
+    if (source !== null && typeof source === "object" && typeof source.node === "number") {
+        return { node: source.node, port: source.port ?? PARTICLE_NODE_OUTPUT_PORT };
+    }
+
+    throw new Error(`Invalid input source: ${JSON.stringify(source)}`);
+}
+
+/**
+ * Wrap a scalar or vector as a literal source (so it is unambiguous vs. a node id). One component
+ * is a scalar, two to four a vector of that many lanes.
+ * @param {...number} components
+ * @returns {number[]}
+ */
+export function literal(...components) {
+    return components;
+}

package/src/shade/renderer/particles/graph/particle_graph_diagnostic.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What a check of a particle graph has to say about it, one finding at a time.
+ *
+ * Findings come from more than one place — the structural checks in
+ * {@link ./validate_particle_graph.js} and the type resolution in
+ * {@link ./infer_particle_graph_types.js} — and go to one place, a view that marks nodes and
+ * lists messages. This is the shape they agree on, kept where both can import it without either
+ * importing the other.
+ */
+/**
+ * One problem with a graph.
+ *
+ * @typedef {object} ParticleGraphDiagnostic
+ * @property {number} node the offending node's id, or -1 for a problem with the graph as a whole
+ * @property {string} message
+ * @property {string} severity {@link PARTICLE_GRAPH_ERROR} — the graph will not compile — or
+ *   {@link PARTICLE_GRAPH_WARNING}
+ */
+/** @type {string} */
+export const PARTICLE_GRAPH_ERROR: string;
+/** @type {string} */
+export const PARTICLE_GRAPH_WARNING: string;
+/**
+ * One problem with a graph.
+ */
+export type ParticleGraphDiagnostic = {
+    /**
+     * the offending node's id, or -1 for a problem with the graph as a whole
+     */
+    node: number;
+    message: string;
+    /**
+     * {@link PARTICLE_GRAPH_ERROR } — the graph will not compile — or
+     * {@link PARTICLE_GRAPH_WARNING }
+     */
+    severity: string;
+};
+//# sourceMappingURL=particle_graph_diagnostic.d.ts.map

package/src/shade/renderer/particles/graph/particle_graph_diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_graph_diagnostic.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_graph_diagnostic.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AAEH,qBAAqB;AACrB,mCADW,MAAM,CAC2B;AAE5C,qBAAqB;AACrB,qCADW,MAAM,CAC+B;;;;;;;;UAVlC,MAAM;aACN,MAAM;;;;;cACN,MAAM"}

package/src/shade/renderer/particles/graph/particle_graph_diagnostic.js

@@ -0,0 +1,25 @@
+/**
+ * What a check of a particle graph has to say about it, one finding at a time.
+ *
+ * Findings come from more than one place — the structural checks in
+ * {@link ./validate_particle_graph.js} and the type resolution in
+ * {@link ./infer_particle_graph_types.js} — and go to one place, a view that marks nodes and
+ * lists messages. This is the shape they agree on, kept where both can import it without either
+ * importing the other.
+ */
+
+/**
+ * One problem with a graph.
+ *
+ * @typedef {object} ParticleGraphDiagnostic
+ * @property {number} node the offending node's id, or -1 for a problem with the graph as a whole
+ * @property {string} message
+ * @property {string} severity {@link PARTICLE_GRAPH_ERROR} — the graph will not compile — or
+ *   {@link PARTICLE_GRAPH_WARNING}
+ */
+
+/** @type {string} */
+export const PARTICLE_GRAPH_ERROR = "error";
+
+/** @type {string} */
+export const PARTICLE_GRAPH_WARNING = "warning";

package/src/shade/renderer/particles/graph/particle_graph_distributions.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A uniform draw in `[-1, 1)`, one independent value per lane.
+ *
+ * @param {NodeGraph} graph
+ * @param {number} [components] how many lanes, each its own draw; one is a scalar
+ * @returns {number} node id of the result
+ */
+export function particle_uniform_signed(graph: NodeGraph, components?: number): number;
+/**
+ * A uniformly distributed point in the unit disk, a `vec2`.
+ *
+ * `sqrt` on the radius is what makes it uniform by area rather than crowded at the centre.
+ *
+ * @param {NodeGraph} graph
+ * @returns {number} node id of the result
+ */
+export function particle_unit_disk(graph: NodeGraph): number;
+/**
+ * A uniformly distributed point on the unit sphere, a `vec3`.
+ *
+ * Archimedes' hat-box: the projection of the sphere onto its bounding cylinder preserves area, so a
+ * uniform height and a uniform angle around it give a uniform point. It is also the only shape of
+ * sampler this VM can run — rejection sampling needs a loop, and there is no control flow.
+ *
+ * @param {NodeGraph} graph
+ * @returns {number} node id of the result
+ */
+export function particle_unit_sphere(graph: NodeGraph): number;
+//# sourceMappingURL=particle_graph_distributions.d.ts.map

package/src/shade/renderer/particles/graph/particle_graph_distributions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_graph_distributions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_graph_distributions.js"],"names":[],"mappings":"AA2CA;;;;;;GAMG;AACH,uEAHW,MAAM,GACJ,MAAM,CAWlB;AAED;;;;;;;GAOG;AACH,sDAFa,MAAM,CAalB;AAED;;;;;;;;;GASG;AACH,wDAFa,MAAM,CAyClB"}

package/src/shade/renderer/particles/graph/particle_graph_distributions.js

@@ -0,0 +1,170 @@
+import { particle_node, particle_wire } from "./particle_graph_authoring.js";
+
+/**
+ * Shaped random distributions, built out of the particle node library.
+ *
+ * The VM's `RANDOM` opcode is one uniform draw in `[0, 1)` per lane and nothing else. It used to
+ * carry a distribution mode — signed, unit disk, unit sphere — and the modes went because every one
+ * of them is arithmetic over that draw, and there is no principled place to stop adding the next
+ * one. A sampler is still a useful thing to have, so it lives here, one level up, where it is a
+ * graph an author can open and change rather than a switch arm in the interpreter.
+ *
+ * These are ordinary functions over {@link ./particle_graph_authoring.js}: they add nodes to a
+ * graph and return the id of the one carrying the result. Nothing downstream knows they were used.
+ *
+ * ## Shape
+ *
+ * Each result has the type its shape has: a disk is a `vec2`, a sphere a `vec3`. What is wired
+ * past that is a conversion the compiler makes and the validator names — a disk written to a
+ * three-component position reads zero in `z`, as it always did — and what is wired narrower keeps
+ * its leading lanes. A scalar draw meeting a vector broadcasts, so a signed draw that is meant to
+ * differ per lane says how many lanes it wants.
+ *
+ * ## What they cost
+ *
+ * As the graph compiler lowers them: a disk is 10 instructions and a sphere 19, against a section
+ * budget of {@link ../ParticleConstants.js PARTICLE_VM_MAX_INSTRUCTIONS}. The vector constructors
+ * are what brought that down from 15 and 24: assembling `(cos a, sin a)` used to take a broadcast
+ * of each and a masked select, and is now a `MOV` per lane. Writing the disk to a three-component
+ * attribute is one more, the zero for `z`. {@link ../optimizer/optimize_particle_program.js} takes
+ * the sphere to 17 on top of that; hand-written assembly does the same work in 7 and 10.
+ *
+ * ## Draw order
+ *
+ * A composition consumes the same number of draws the opcode mode did (two for the geometric ones,
+ * one per lane for {@link particle_uniform_signed}), but *which* draw feeds which term is now the
+ * compiler's scheduling of two independent `random` nodes rather than a fixed order inside an
+ * opcode. Samples therefore differ from the old modes' even from the same seed; the distributions
+ * do not.
+ */
+
+/** @type {number} */
+const TWO_PI = Math.PI * 2;
+
+/**
+ * A uniform draw in `[-1, 1)`, one independent value per lane.
+ *
+ * @param {NodeGraph} graph
+ * @param {number} [components] how many lanes, each its own draw; one is a scalar
+ * @returns {number} node id of the result
+ */
+export function particle_uniform_signed(graph, components = 1) {
+    const uniform = particle_node(graph, "random", { components });
+    const signed = particle_node(graph, "mad");
+
+    particle_wire(graph, signed, "a", uniform);
+    particle_wire(graph, signed, "b", [2]);
+    particle_wire(graph, signed, "c", [-1]);
+
+    return signed;
+}
+
+/**
+ * A uniformly distributed point in the unit disk, a `vec2`.
+ *
+ * `sqrt` on the radius is what makes it uniform by area rather than crowded at the centre.
+ *
+ * @param {NodeGraph} graph
+ * @returns {number} node id of the result
+ */
+export function particle_unit_disk(graph) {
+    const radius = particle_node(graph, "sqrt");
+
+    particle_wire(graph, radius, "x", particle_node(graph, "random", { components: 1 }));
+
+    const point = particle_node(graph, "scale");
+
+    particle_wire(graph, point, "v", unit_circle(graph));
+    particle_wire(graph, point, "s", radius);
+
+    return point;
+}
+
+/**
+ * A uniformly distributed point on the unit sphere, a `vec3`.
+ *
+ * Archimedes' hat-box: the projection of the sphere onto its bounding cylinder preserves area, so a
+ * uniform height and a uniform angle around it give a uniform point. It is also the only shape of
+ * sampler this VM can run — rejection sampling needs a loop, and there is no control flow.
+ *
+ * @param {NodeGraph} graph
+ * @returns {number} node id of the result
+ */
+export function particle_unit_sphere(graph) {
+    // height, uniform in [-1, 1)
+    const height = particle_uniform_signed(graph, 1);
+
+    // radius of the circle of latitude at that height: sqrt(1 - z^2)
+    const height_squared = particle_node(graph, "mul");
+
+    particle_wire(graph, height_squared, "a", height);
+    particle_wire(graph, height_squared, "b", height);
+
+    const radius_squared = particle_node(graph, "sub");
+
+    particle_wire(graph, radius_squared, "a", [1]);
+    particle_wire(graph, radius_squared, "b", height_squared);
+
+    const radius = particle_node(graph, "sqrt");
+
+    particle_wire(graph, radius, "x", radius_squared);
+
+    // the point on that circle, and the height dropped in beside it
+    const { cosine, sine } = unit_angle(graph);
+
+    const x = particle_node(graph, "mul");
+
+    particle_wire(graph, x, "a", cosine);
+    particle_wire(graph, x, "b", radius);
+
+    const y = particle_node(graph, "mul");
+
+    particle_wire(graph, y, "a", sine);
+    particle_wire(graph, y, "b", radius);
+
+    const point = particle_node(graph, "vec3");
+
+    particle_wire(graph, point, "x", x);
+    particle_wire(graph, point, "y", y);
+    particle_wire(graph, point, "z", height);
+
+    return point;
+}
+
+/**
+ * A uniformly distributed point on the unit circle, a `vec2`.
+ *
+ * @param {NodeGraph} graph
+ * @returns {number} node id of the result
+ */
+function unit_circle(graph) {
+    const { cosine, sine } = unit_angle(graph);
+
+    const circle = particle_node(graph, "vec2");
+
+    particle_wire(graph, circle, "x", cosine);
+    particle_wire(graph, circle, "y", sine);
+
+    return circle;
+}
+
+/**
+ * The cosine and sine of a uniform angle, as two scalars off one draw.
+ *
+ * @param {NodeGraph} graph
+ * @returns {{cosine: number, sine: number}} node ids
+ */
+function unit_angle(graph) {
+    const angle = particle_node(graph, "mul");
+
+    particle_wire(graph, angle, "a", particle_node(graph, "random", { components: 1 }));
+    particle_wire(graph, angle, "b", [TWO_PI]);
+
+    const cosine = particle_node(graph, "cos");
+    const sine = particle_node(graph, "sin");
+
+    particle_wire(graph, cosine, "x", angle);
+    particle_wire(graph, sine, "x", angle);
+
+    return { cosine, sine };
+}

package/src/shade/renderer/particles/graph/particle_graph_json.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Read and write a particle {@link NodeGraph} as JSON.
+ *
+ * The engine's generic graph serializer writes each {@link NodeDescription} out by value. That
+ * cannot work here: a {@link ./ParticleNodeDescription.js} carries an `emit` closure, which is the
+ * whole of what the node *is*, and no amount of JSON brings a closure back. So a particle node is
+ * written as its **type name** and looked up in the library on the way in — the same thing authoring
+ * does, and the reason node type names, not ids, are the stable identity of the library.
+ *
+ * Ports are written by name for the same reason. A particle node's ports are uniquely named within
+ * a direction, so a name survives the library gaining a port where a positional id would not.
+ *
+ * Node positions ride along when a {@link NodeGraphVisualData} is supplied. An effect whose layout
+ * is not saved with it is an effect that has to be re-arranged every time it is opened, so they
+ * belong in the same document even though one is model and the other is presentation.
+ */
+/**
+ * @typedef {object} ParticleGraphJSON
+ * @property {Array<{id: number, type: string, parameters: object, x?: number, y?: number}>} nodes
+ * @property {Array<{from: number, fromPort: string, to: number, toPort: string}>} connections
+ */
+/**
+ * @param {object} params
+ * @param {NodeGraph} params.graph
+ * @param {NodeGraphVisualData} [params.visual] source of node positions; omitted, no positions are written
+ * @returns {ParticleGraphJSON}
+ */
+export function serialize_particle_graph({ graph, visual }: {
+    graph: NodeGraph;
+    visual?: NodeGraphVisualData;
+}): ParticleGraphJSON;
+/**
+ * Fill a graph from JSON, replacing whatever it held.
+ *
+ * Node ids are preserved exactly, holes and all: an author who deleted a node left a gap in the
+ * numbering, and everything written alongside — connections, positions — is written against the ids
+ * that survived it.
+ *
+ * @param {object} params
+ * @param {ParticleGraphJSON} params.json
+ * @param {NodeGraph} params.graph filled in place
+ * @param {NodeGraphVisualData} [params.visual] receives the saved positions
+ * @param {NodeDescriptionVisualRegistry} [params.visualRegistry] required when `visual` is given
+ * @param {function(string):(ParticleNodeDescription|undefined)} [params.resolve] types this document
+ *        carries of its own — the groups an author made — consulted before the standard library. A
+ *        group is addressed by name exactly as a stock type is, and one that lives in the file
+ *        rather than in the library has to be found somewhere.
+ * @returns {NodeGraph} `graph`
+ */
+export function deserialize_particle_graph({ json, graph, visual, visualRegistry, resolve }: {
+    json: ParticleGraphJSON;
+    graph: NodeGraph;
+    visual?: NodeGraphVisualData;
+    visualRegistry?: NodeDescriptionVisualRegistry;
+    resolve?: (arg0: string) => (ParticleNodeDescription | undefined);
+}): NodeGraph;
+/**
+ * Whether a graph can be written and read back — every node a particle node whose type the library
+ * still has, and every type's ports uniquely named within a direction so a connection can be
+ * written by name. Used to fail an export with something an author can act on rather than at the
+ * far end of a load.
+ *
+ * @param {NodeGraph} graph
+ * @param {object} [options]
+ * @param {function(string):(ParticleNodeDescription|undefined)} [options.resolve] the document's own
+ *        types, as in {@link deserialize_particle_graph}
+ * @returns {string[]} one message per problem; empty when the graph is serializable
+ */
+export function particle_graph_serialization_problems(graph: NodeGraph, { resolve }?: {
+    resolve?: (arg0: string) => (ParticleNodeDescription | undefined);
+}): string[];
+export type ParticleGraphJSON = {
+    nodes: Array<{
+        id: number;
+        type: string;
+        parameters: object;
+        x?: number;
+        y?: number;
+    }>;
+    connections: Array<{
+        from: number;
+        fromPort: string;
+        to: number;
+        toPort: string;
+    }>;
+};
+//# sourceMappingURL=particle_graph_json.d.ts.map

package/src/shade/renderer/particles/graph/particle_graph_json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_graph_json.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_graph_json.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AACH;IAJ6B,KAAK;IACM,MAAM;IACjC,iBAAiB,CAiC7B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH;IAVqC,IAAI,EAA9B,iBAAiB;IACC,KAAK;IACM,MAAM;IACI,cAAc;IACS,OAAO,UAA5D,MAAM,KAAE,CAAC,0BAAwB,SAAS,CAAC;cAwD9D;AAED;;;;;;;;;;;GAWG;AACH;IAJ0E,OAAO,UAA7D,MAAM,KAAE,CAAC,0BAAwB,SAAS,CAAC;IAElD,MAAM,EAAE,CA6CpB;;WAxKa,MAAM;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;iBAC7E,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC"}