@picked/client 0.0.1-dev.1788925875333 → 0.0.1-next.1

package/dist/esm/plugins/create-experience/index.js

@@ -1,490 +1,398 @@
-import { t as e } from "../../../id-Bo4RBeOs.js";
-//#region src/plugins/create-experience/serialization.ts
-var t = {
-	serialize(e) {
-		return JSON.stringify(e);
-	},
-	deserialize(e) {
-		return JSON.parse(e);
-	}
-}, n = (e) => ({
-	name: "create-experience",
-	setup: (n) => {
-		e.experiences.forEach((e) => {
-			let r = e.serialize(), i = t.deserialize(r);
-			i.component = e.component;
-			let { steps: a, conditions: o, fields: s, ...c } = i;
-			n.registerExperience(c), s.forEach((e) => {
-				n.registerField(e);
-			}), a.forEach((e) => {
-				n.registerStep(e);
-			}), o.forEach((e) => {
-				n.registerCondition(e);
-			});
-		});
-	}
-}), r = (n, r) => ({
-	id: e("node"),
-	experience: r,
-	type: "action",
-	action: n.action,
-	addNext(e) {
-		if (!e.node) throw Error("Cannot connect to node");
-		let t = s({
-			sourceNode: this,
-			destinationNode: e.node,
-			sourceHandle: null
-		}, r);
-		r.edges.push(t);
-	},
-	onSuccess(e) {
-		if (!e.node) throw Error("Cannot connect to node");
-		let t = s({
-			sourceNode: this,
-			destinationNode: e.node,
-			sourceHandle: "true"
-		}, r);
-		r.edges.push(t);
-	},
-	onFail(e) {
-		if (!e.node) throw Error("Cannot connect to node");
-		let t = s({
-			sourceNode: this,
-			destinationNode: e.node,
-			sourceHandle: "false"
-		}, r);
-		r.edges.push(t);
-	},
-	serialize() {
-		return t.serialize({
-			id: this.id,
-			type: this.type,
-			actionKey: this.action
-		});
-	}
-}), i = (t) => {
-	let n = t.name, r = t.id ?? e("step");
-	return {
-		id: r,
-		name: n,
-		key: t.key ?? r,
-		fields: t.fields ?? [],
-		addField(e) {
-			let t = "serialize" in e ? e : l(e);
-			return this.fields.includes(t) || this.fields.push(t), t;
-		}
-	};
-}, a = (n, r) => {
-	let i = n.name, a = n.id ?? e("step"), s = {
-		id: a,
-		name: i,
-		key: n.key ?? a,
-		experience: r,
-		fields: n.fields ?? [],
-		node: null,
-		nextStep(e) {
-			return this.experience.addStep(e, this);
-		},
-		nextCondition(e) {
-			return this.experience.addCondition(e, this);
-		},
-		nextConditional(e) {
-			return this.nextCondition(e);
-		},
-		addNextExperience(e) {
-			return this.experience.addExperience(e, this);
-		},
-		addField(e) {
-			return this.experience.addField(e, this);
-		},
-		serialize() {
-			return t.serialize({
-				id: this.id,
-				key: this.key,
-				name: this.name,
-				fieldKeys: this.fields.map((e) => e.key)
-			});
-		}
-	};
-	return o({
-		step: s,
-		type: "step"
-	}, r), s;
-}, o = (n, r) => {
-	let i = {
-		id: e("node"),
-		experience: r
-	};
-	if (n.type === "step") {
-		let e = {
-			...i,
-			type: "step",
-			connectedStep: n.step,
-			serialize() {
-				return t.serialize({
-					id: this.id,
-					type: this.type,
-					stepId: this.connectedStep.id,
-					name: this.connectedStep.name
-				});
-			}
-		};
-		return e.connectedStep.node = e, e;
-	}
-	if (n.type === "condition") {
-		let e = {
-			...i,
-			type: "condition",
-			connectedCondition: n.condition,
-			serialize() {
-				return t.serialize({
-					id: this.id,
-					type: this.type,
-					conditionId: this.connectedCondition.id
-				});
-			}
-		};
-		return e.connectedCondition.node = e, e;
-	}
-	return n.type === "experience" ? {
-		...i,
-		type: "experience",
-		connectedExperience: n.experience,
-		serialize() {
-			return t.serialize({
-				id: this.id,
-				type: this.type,
-				experienceId: this.connectedExperience.id,
-				experienceKey: this.connectedExperience.key
-			});
-		}
-	} : {
-		...i,
-		type: "origin",
-		serialize() {
-			return t.serialize({
-				id: this.id,
-				type: this.type
-			});
-		}
-	};
-}, s = (n, r) => ({
-	id: e("edge"),
-	sourceNode: n.sourceNode,
-	sourceHandle: n.sourceHandle,
-	destinationNode: n.destinationNode,
-	experience: r,
-	serialize() {
-		return t.serialize({
-			id: this.id,
-			sourceHandle: this.sourceHandle ?? void 0,
-			sourceNodeId: this.sourceNode.id,
-			destinationNodeId: this.destinationNode.id
-		});
-	}
-}), c = (n, r) => {
-	let i = e("conditional"), a = n.name ?? n.label ?? i, c = {
-		id: i,
-		key: n.key ?? i,
-		name: a,
-		label: n.label,
-		logic: n.condition,
-		node: null,
-		experience: r,
-		addTrue(e) {
-			if (!this.node || !e.node) throw Error("todo no node");
-			let t = s({
-				sourceNode: this.node,
-				destinationNode: e.node,
-				sourceHandle: "true"
-			}, this.experience);
-			this.experience.edges.push(t);
-		},
-		addFalse(e) {
-			if (!this.node || !e.node) throw Error("todo no node");
-			let t = s({
-				sourceNode: this.node,
-				destinationNode: e.node,
-				sourceHandle: "false"
-			}, this.experience);
-			this.experience.edges.push(t);
-		},
-		serialize() {
-			return t.serialize({
-				id: this.id,
-				key: this.key,
-				name: this.name,
-				logic: this.logic
-			});
-		}
-	};
-	return o({
-		condition: c,
-		type: "condition"
-	}, r), c;
-}, l = (n) => {
-	let r = n.id ?? e("field");
-	return {
-		id: r,
-		key: n.key ?? r,
-		name: n.name,
-		type: n.type,
-		label: n.label,
-		placeholder: n.placeholder,
-		description: n.description,
-		helpText: n.helpText,
-		defaultValue: n.defaultValue ?? null,
-		multiple: n.multiple,
-		validation: n.validation ?? {},
-		condition: n.condition,
-		required: n.required,
-		options: n.options?.map((t) => ({
-			id: "id" in t ? t.id : e("option"),
-			...t
-		})) ?? null,
-		policies: n.policies,
-		serialize() {
-			let e = {
-				id: this.id,
-				key: this.key,
-				name: this.name,
-				label: this.label,
-				placeholder: this.placeholder,
-				required: this.required,
-				description: this.description,
-				helpText: this.helpText,
-				validation: this.validation,
-				condition: this.condition,
-				policies: this.policies
-			}, n = typeof this.defaultValue == "string" ? this.defaultValue : void 0, r = typeof this.defaultValue == "number" ? this.defaultValue : void 0, i = typeof this.defaultValue == "boolean" ? this.defaultValue : void 0;
-			switch (this.type) {
-				case "text":
-					if (this.multiple) {
-						let n;
-						if (Array.isArray(this.defaultValue)) {
-							n = [];
-							for (let e of this.defaultValue) typeof e == "string" && n.push(e);
-							n.length === 0 && (n = void 0);
-						}
-						return t.serialize({
-							...e,
-							type: "text",
-							multiple: !0,
-							defaultValue: n,
-							options: this.options ? this.options.map((e) => ({
-								id: e.id,
-								label: e.label,
-								value: `${e.value}`,
-								condition: e.condition
-							})) : null
-						});
-					}
-					return t.serialize({
-						...e,
-						type: "text",
-						multiple: !1,
-						defaultValue: n,
-						options: this.options ? this.options.map((e) => ({
-							id: e.id,
-							label: e.label,
-							value: `${e.value}`,
-							condition: e.condition
-						})) : null
-					});
-				case "number":
-					if (this.multiple) {
-						let n;
-						if (Array.isArray(this.defaultValue)) {
-							n = [];
-							for (let e of this.defaultValue) typeof e == "number" && n.push(e);
-							n.length === 0 && (n = void 0);
-						}
-						return t.serialize({
-							...e,
-							type: "number",
-							multiple: !0,
-							defaultValue: n,
-							options: this.options ? this.options.map((e) => ({
-								id: e.id,
-								label: e.label,
-								value: Number(e.value),
-								condition: e.condition
-							})) : null
-						});
-					}
-					return t.serialize({
-						...e,
-						type: "number",
-						multiple: !1,
-						defaultValue: r,
-						options: this.options ? this.options.map((e) => ({
-							id: e.id,
-							label: e.label,
-							value: Number(e.value),
-							condition: e.condition
-						})) : null
-					});
-				case "boolean":
-					if (this.multiple) {
-						let n;
-						if (Array.isArray(this.defaultValue)) {
-							n = [];
-							for (let e of this.defaultValue) typeof e == "boolean" && n.push(e);
-							n.length === 0 && (n = void 0);
-						}
-						return t.serialize({
-							...e,
-							type: "boolean",
-							multiple: !0,
-							defaultValue: n,
-							options: this.options ? this.options.map((e) => ({
-								id: e.id,
-								label: e.label,
-								value: !!e.value,
-								condition: e.condition
-							})) : null
-						});
-					}
-					return t.serialize({
-						...e,
-						type: "boolean",
-						multiple: !1,
-						defaultValue: i,
-						options: this.options ? this.options.map((e) => ({
-							id: e.id,
-							label: e.label,
-							value: !!e.value,
-							condition: e.condition
-						})) : null
-					});
-				case "object": return this.multiple ? t.serialize({
-					...e,
-					type: "object",
-					multiple: !0,
-					defaultValue: this.defaultValue,
-					options: this.options ? this.options.map((e) => ({
-						id: e.id,
-						label: e.label,
-						description: e.description,
-						value: e.value,
-						condition: e.condition
-					})) : null
-				}) : t.serialize({
-					...e,
-					type: "object",
-					multiple: !1,
-					defaultValue: this.defaultValue,
-					options: this.options ? this.options.map((e) => ({
-						id: e.id,
-						label: e.label,
-						description: e.description,
-						value: e.value,
-						condition: e.condition
-					})) : null
-				});
-				default: throw Error("Unsupported field type");
-			}
-		}
-	};
-}, u = (e) => ({
-	id: e.id,
-	key: e.key ?? e.id,
-	component: e.component,
-	name: e.name,
-	initializeOpen: e.initializeOpen,
-	condition: e.condition,
-	targets: e.targets,
-	steps: [],
-	nodes: [],
-	edges: [],
-	fields: [],
-	conditions: [],
-	addStep(e, t) {
-		let n = t?.node;
-		this.nodes.length === 0 && (n = o({ type: "origin" }, this), this.nodes.push(n));
-		let r = "serialize" in e ? e : a(e, this);
-		if (n) {
-			if (!r.node) throw Error("todo no node");
-			let e = s({
-				sourceNode: n,
-				destinationNode: r.node,
-				sourceHandle: null
-			}, this);
-			this.edges.push(e);
-		}
-		return r.fields.length > 0 && r.fields.forEach((e) => {
-			this.fields.includes(e) || this.fields.push(e);
-		}), this.steps.includes(r) || (this.steps.push(r), r.node && this.nodes.push(r.node)), r;
-	},
-	addAction(e, t) {
-		let n = t?.node;
-		this.nodes.length === 0 && (n = o({ type: "origin" }, this), this.nodes.push(n));
-		let i = "serialize" in e ? e : r(e, this);
-		if (n) {
-			let e = s({
-				sourceNode: n,
-				destinationNode: i,
-				sourceHandle: null
-			}, this);
-			this.edges.push(e);
-		}
-		return this.nodes.push(i), i;
-	},
-	addCondition(e, t) {
-		let n = t?.node;
-		this.nodes.length === 0 && (n = o({ type: "origin" }, this), this.nodes.push(n));
-		let r = "serialize" in e ? e : c(e, this);
-		if (n) {
-			if (!r.node) throw Error("todo no node");
-			let e = s({
-				sourceNode: n,
-				destinationNode: r.node,
-				sourceHandle: null
-			}, this);
-			this.edges.push(e);
-		}
-		return this.conditions.includes(r) || (this.conditions.push(r), r.node && this.nodes.push(r.node)), r;
-	},
-	addConditional(e, t) {
-		return this.addCondition(e, t);
-	},
-	addExperience(e, t) {
-		let n = t?.node;
-		this.nodes.length === 0 && (n = o({ type: "origin" }, this), this.nodes.push(n));
-		let r = o({
-			type: "experience",
-			experience: e
-		}, this);
-		if (this.nodes.push(r), n) {
-			let e = s({
-				sourceNode: n,
-				destinationNode: r,
-				sourceHandle: null
-			}, this);
-			this.edges.push(e);
-		}
-		return e;
-	},
-	addField(e, t) {
-		let n = "serialize" in e ? e : l(e);
-		return t && t.fields.push(n), this.fields.includes(n) || this.fields.push(n), n;
-	},
-	serialize() {
-		return t.serialize({
-			id: this.id,
-			key: this.key,
-			component: this.component,
-			name: this.name,
-			initializeOpen: this.initializeOpen,
-			condition: this.condition,
-			targets: this.targets,
-			steps: this.steps.map((e) => t.deserialize(e.serialize())),
-			nodes: this.nodes.map((e) => t.deserialize(e.serialize())),
-			edges: this.edges.map((e) => t.deserialize(e.serialize())),
-			conditions: this.conditions.map((e) => t.deserialize(e.serialize())),
-			fields: this.fields.map((e) => t.deserialize(e.serialize()))
-		});
-	}
-});
-//#endregion
-export { c as createCondition, s as createEdge, u as createExperience, n as createExperiencePlugin, l as createField, o as createNode, i as createStep };
+import { g as h } from "../../../id-BW-g3y32.js";
+const l = {
+  serialize(i) {
+    return JSON.stringify(i);
+  },
+  deserialize(i) {
+    return JSON.parse(i);
+  }
+}, b = (i) => ({
+  name: "create-experience",
+  setup: (a) => {
+    i.experiences.forEach((d) => {
+      const s = d.serialize(), o = l.deserialize(s);
+      o.component = d.component, a.registerExperience(o), o.fields.forEach((c) => {
+        a.registerField(c);
+      });
+    });
+  }
+}), m = (i, a) => {
+  const d = {
+    id: h("step"),
+    label: i.label,
+    experience: a,
+    fields: [],
+    node: null,
+    nextStep(s) {
+      return this.experience.addStep(s, this);
+    },
+    nextConditional(s) {
+      return this.experience.addConditional(s, this);
+    },
+    addNextExperience(s) {
+      return this.experience.addExperience(s, this);
+    },
+    addField(s) {
+      return this.experience.addField(s, this);
+    },
+    serialize() {
+      return l.serialize({
+        id: this.id,
+        label: this.label,
+        fieldIds: this.fields.map((s) => s.id)
+      });
+    }
+  };
+  return u({ step: d, type: "step" }, a), d;
+}, y = () => [0, 0], u = (i, a) => {
+  const d = {
+    id: h("node"),
+    position: y(),
+    experience: a
+  };
+  if (i.type === "step") {
+    const o = {
+      ...d,
+      type: "step",
+      connectedStep: i.step,
+      serialize() {
+        return l.serialize({
+          id: this.id,
+          type: this.type,
+          stepId: this.connectedStep.id,
+          position: this.position,
+          label: this.connectedStep.label
+        });
+      }
+    };
+    return o.connectedStep.node = o, o;
+  }
+  if (i.type === "conditional") {
+    const o = {
+      ...d,
+      type: "conditional",
+      connectedConditional: i.conditional,
+      serialize() {
+        return l.serialize({
+          id: this.id,
+          type: this.type,
+          conditionalId: this.connectedConditional.id,
+          position: this.position
+        });
+      }
+    };
+    return o.connectedConditional.node = o, o;
+  }
+  return i.type === "experience" ? {
+    ...d,
+    type: "experience",
+    connectedExperience: i.experience,
+    serialize() {
+      return l.serialize({
+        id: this.id,
+        type: this.type,
+        experienceId: this.connectedExperience.id,
+        position: this.position
+      });
+    }
+  } : {
+    ...d,
+    type: "origin",
+    serialize() {
+      return l.serialize({
+        id: this.id,
+        type: this.type,
+        position: this.position
+      });
+    }
+  };
+}, f = (i, a) => ({
+  id: h("edge"),
+  sourceNode: i.sourceNode,
+  sourceNodeHandle: i.sourceNodeHandle,
+  destinationNode: i.destinationNode,
+  experience: a,
+  serialize() {
+    return l.serialize({
+      id: this.id,
+      sourceNodeHandle: this.sourceNodeHandle ?? void 0,
+      sourceNodeId: this.sourceNode.id,
+      destinationNodeId: this.destinationNode.id
+    });
+  }
+}), N = (i, a) => {
+  const d = {
+    id: h("conditional"),
+    condition: i.condition,
+    node: null,
+    experience: a,
+    addTrue(s) {
+      if (!this.node || !s.node)
+        throw new Error("todo no node");
+      const o = f(
+        { sourceNode: this.node, destinationNode: s.node, sourceNodeHandle: "true" },
+        this.experience
+      );
+      this.experience.edges.push(o);
+    },
+    addFalse(s) {
+      if (!this.node || !s.node)
+        throw new Error("todo no node");
+      const o = f(
+        { sourceNode: this.node, destinationNode: s.node, sourceNodeHandle: "false" },
+        this.experience
+      );
+      this.experience.edges.push(o);
+    },
+    serialize() {
+      return l.serialize({
+        id: this.id,
+        condition: this.condition
+      });
+    }
+  };
+  return u({ conditional: d, type: "conditional" }, a), d;
+}, z = (i) => {
+  var d;
+  return {
+    id: h("field"),
+    name: i.name,
+    type: i.type,
+    label: i.label,
+    placeholder: i.placeholder,
+    description: i.description,
+    helpText: i.helpText,
+    defaultValue: i.defaultValue,
+    multiple: i.multiple,
+    validation: i.validation,
+    required: i.required,
+    options: ((d = i.options) == null ? void 0 : d.map((s) => ({
+      ...s,
+      id: h("option")
+    }))) || null,
+    policies: i.policies,
+    serialize() {
+      const s = {
+        id: this.id,
+        name: this.name,
+        label: this.label,
+        placeholder: this.placeholder,
+        required: this.required,
+        description: this.description,
+        helpText: this.helpText,
+        validation: this.validation,
+        policies: this.policies
+      }, o = typeof this.defaultValue == "string" ? this.defaultValue : null, c = typeof this.defaultValue == "number" ? this.defaultValue : null, n = typeof this.defaultValue == "boolean" ? this.defaultValue : null;
+      switch (this.type) {
+        case "text":
+          if (this.multiple) {
+            let e = null;
+            if (Array.isArray(this.defaultValue)) {
+              e = [];
+              for (const t of this.defaultValue)
+                typeof t == "string" && e.push(t);
+              e.length === 0 && (e = null);
+            }
+            return l.serialize({
+              ...s,
+              type: "text",
+              multiple: !0,
+              defaultValue: e,
+              options: this.options ? this.options.map((t) => ({
+                id: t.id,
+                label: t.label,
+                value: `${t.value}`
+              })) : null
+            });
+          }
+          return l.serialize({
+            ...s,
+            type: "text",
+            multiple: !1,
+            defaultValue: o,
+            options: this.options ? this.options.map((e) => ({
+              id: e.id,
+              label: e.label,
+              value: `${e.value}`
+            })) : null
+          });
+        case "number":
+          if (this.multiple) {
+            let e = null;
+            if (Array.isArray(this.defaultValue)) {
+              e = [];
+              for (const t of this.defaultValue)
+                typeof t == "number" && e.push(t);
+              e.length === 0 && (e = null);
+            }
+            return l.serialize({
+              ...s,
+              type: "number",
+              multiple: !0,
+              defaultValue: e,
+              options: this.options ? this.options.map((t) => ({
+                id: t.id,
+                label: t.label,
+                value: Number(t.value)
+              })) : null
+            });
+          }
+          return l.serialize({
+            ...s,
+            type: "number",
+            multiple: !1,
+            defaultValue: c,
+            options: this.options ? this.options.map((e) => ({
+              id: e.id,
+              label: e.label,
+              value: Number(e.value)
+            })) : null
+          });
+        case "boolean":
+          if (this.multiple) {
+            let e = null;
+            if (Array.isArray(this.defaultValue)) {
+              e = [];
+              for (const t of this.defaultValue)
+                typeof t == "boolean" && e.push(t);
+              e.length === 0 && (e = null);
+            }
+            return l.serialize({
+              ...s,
+              type: "boolean",
+              multiple: !0,
+              defaultValue: e,
+              options: this.options ? this.options.map((t) => ({
+                id: t.id,
+                label: t.label,
+                value: !!t.value
+              })) : null
+            });
+          }
+          return l.serialize({
+            ...s,
+            type: "boolean",
+            multiple: !1,
+            defaultValue: n,
+            options: this.options ? this.options.map((e) => ({
+              id: e.id,
+              label: e.label,
+              value: !!e.value
+            })) : null
+          });
+        //  todo: support for object type fields
+        // case 'object':
+        //   if (this.multiple) {
+        //     return serialization.serialize({
+        //       ...baseField,
+        //       type: 'object',
+        //       multiple: true,
+        //       defaultValue: this.defaultValue,
+        //       options: this.options,
+        //     })
+        //   }
+        // return serialization.serialize({
+        //   ...baseField,
+        //   type: 'object',
+        //   multiple: false,
+        //   defaultValue: this.defaultValue,
+        //   options: this.options,
+        // })
+        default:
+          throw new Error("Unsupported field type");
+      }
+    }
+  };
+}, x = (i) => {
+  const a = [], d = [], s = [], o = [], c = [];
+  return {
+    id: i.id,
+    component: i.component,
+    type: i.type,
+    name: i.name,
+    decide: i.decide,
+    targets: i.targets,
+    steps: a,
+    nodes: d,
+    edges: s,
+    fields: c,
+    conditionals: o,
+    addStep(n, e) {
+      let t = e == null ? void 0 : e.node;
+      this.nodes.length === 0 && (t = u({ type: "origin" }, this), this.nodes.push(t));
+      const r = "serialize" in n ? n : m(n, this);
+      if (t) {
+        if (!r.node)
+          throw new Error("todo no node");
+        const p = f(
+          { sourceNode: t, destinationNode: r.node, sourceNodeHandle: null },
+          this
+        );
+        this.edges.push(p);
+      }
+      return this.steps.includes(r) || (this.steps.push(r), r.node && this.nodes.push(r.node)), r;
+    },
+    addConditional(n, e) {
+      let t = e == null ? void 0 : e.node;
+      this.nodes.length === 0 && (t = u({ type: "origin" }, this), this.nodes.push(t));
+      const r = "serialize" in n ? n : N(n, this);
+      if (t) {
+        if (!r.node)
+          throw new Error("todo no node");
+        const p = f(
+          { sourceNode: t, destinationNode: r.node, sourceNodeHandle: null },
+          this
+        );
+        this.edges.push(p);
+      }
+      return this.conditionals.includes(r) || (this.conditionals.push(r), r.node && this.nodes.push(r.node)), r;
+    },
+    addExperience(n, e) {
+      let t = e == null ? void 0 : e.node;
+      this.nodes.length === 0 && (t = u({ type: "origin" }, this), this.nodes.push(t));
+      const r = u(
+        { type: "experience", experience: n },
+        this
+      );
+      if (this.nodes.push(r), t) {
+        const p = f(
+          { sourceNode: t, destinationNode: r, sourceNodeHandle: null },
+          this
+        );
+        this.edges.push(p);
+      }
+      return n;
+    },
+    addField(n, e) {
+      const t = "serialize" in n ? n : z(n);
+      return e && e.fields.push(t), this.fields.includes(t) || this.fields.push(t), t;
+    },
+    serialize() {
+      return l.serialize({
+        id: this.id,
+        type: this.type,
+        component: this.component,
+        name: this.name,
+        decide: this.decide,
+        targets: this.targets,
+        steps: this.steps.map((n) => l.deserialize(n.serialize())),
+        nodes: this.nodes.map((n) => l.deserialize(n.serialize())),
+        edges: this.edges.map((n) => l.deserialize(n.serialize())),
+        conditionals: this.conditionals.map(
+          (n) => l.deserialize(n.serialize())
+        ),
+        fields: this.fields.map((n) => l.deserialize(n.serialize()))
+      });
+    }
+  };
+};
+export {
+  N as createConditional,
+  f as createEdge,
+  x as createExperience,
+  b as createExperiencePlugin,
+  z as createField,
+  u as createNode,
+  m as createStep,
+  l as serialization
+};