@bitflow/core 0.5.2 → 0.5.3

package/dist/index.cjs.js

@@ -0,0 +1,732 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AndConditionSchema: () => AndConditionSchema,
+  ConditionSchema: () => ConditionSchema,
+  ControlFlowNodeSchema: () => ControlFlowNodeSchema,
+  EndSchema: () => EndSchema,
+  EqualConditionSchema: () => EqualConditionSchema,
+  FeedbackMessageSchema: () => FeedbackMessageSchema,
+  FlowCheckpointNodeSchema: () => FlowCheckpointNodeSchema,
+  FlowEdgeSchema: () => FlowEdgeSchema,
+  FlowPortalInputNodeSchema: () => FlowPortalInputNodeSchema,
+  FlowPortalOutputNodeSchema: () => FlowPortalOutputNodeSchema,
+  FlowSplitAnswerNodeSchema: () => FlowSplitAnswerNodeSchema,
+  FlowSplitPointsNodeSchema: () => FlowSplitPointsNodeSchema,
+  FlowSplitRandomNodeSchema: () => FlowSplitRandomNodeSchema,
+  FlowSplitResultNodeSchema: () => FlowSplitResultNodeSchema,
+  FlowSynchronizeNodeSchema: () => FlowSynchronizeNodeSchema,
+  GreaterConditionSchema: () => GreaterConditionSchema,
+  InConditionSchema: () => InConditionSchema,
+  InputSchema: () => InputSchema,
+  LessConditionSchema: () => LessConditionSchema,
+  OrConditionSchema: () => OrConditionSchema,
+  PortalInputSchema: () => PortalInputSchema,
+  PortalOutputSchema: () => PortalOutputSchema,
+  PrimitiveConditionSchema: () => PrimitiveConditionSchema,
+  SplitAnswerSchema: () => SplitAnswerSchema,
+  SplitPointsSchema: () => SplitPointsSchema,
+  SplitResultSchema: () => SplitResultSchema,
+  StartSchema: () => StartSchema,
+  TaskAnswerSchema: () => TaskAnswerSchema,
+  TaskResultSchema: () => TaskResultSchema,
+  TaskSchema: () => TaskSchema,
+  TaskStatisticSchema: () => TaskStatisticSchema,
+  TitleSchema: () => TitleSchema,
+  TrueConditionSchema: () => TrueConditionSchema,
+  extractInteractiveFlowPublicNode: () => extractInteractiveFlowPublicNode,
+  findLast: () => findLast,
+  finishDoTry: () => finishDoTry,
+  groupBy: () => groupBy,
+  isControlFlowNode: () => isControlFlowNode,
+  isDoFinishedTry: () => isDoFinishedTry,
+  isDoSkippedTry: () => isDoSkippedTry,
+  isDoStartedTry: () => isDoStartedTry,
+  isFlowEndNode: () => isFlowEndNode,
+  isFlowInputNode: () => isFlowInputNode,
+  isFlowPortalInputNode: () => isFlowPortalInputNode,
+  isFlowPortalOutputNode: () => isFlowPortalOutputNode,
+  isFlowSplitAnswerNode: () => isFlowSplitAnswerNode,
+  isFlowSplitPointsNode: () => isFlowSplitPointsNode,
+  isFlowSplitRandomNode: () => isFlowSplitRandomNode,
+  isFlowSplitResultNode: () => isFlowSplitResultNode,
+  isFlowStartNode: () => isFlowStartNode,
+  isFlowTaskNode: () => isFlowTaskNode,
+  isFlowTitleNode: () => isFlowTitleNode,
+  isInteractiveFlowNode: () => isInteractiveFlowNode,
+  lerpColor: () => lerpColor,
+  levenshtein: () => levenshtein,
+  makeDoBaseTrySchema: () => makeDoBaseTrySchema,
+  makeDoFinishedTry: () => makeDoFinishedTry,
+  makeDoSkippedTry: () => makeDoSkippedTry,
+  makeDoStartedTry: () => makeDoStartedTry,
+  makeEvaluate: () => makeEvaluate,
+  makeFlowEndNodeSchema: () => makeFlowEndNodeSchema,
+  makeFlowInputNodeSchema: () => makeFlowInputNodeSchema,
+  makeFlowNodeSchema: () => makeFlowNodeSchema,
+  makeFlowSchema: () => makeFlowSchema,
+  makeFlowStartNodeSchema: () => makeFlowStartNodeSchema,
+  makeFlowTaskNodeSchema: () => makeFlowTaskNodeSchema,
+  makeFlowTitleNodeSchema: () => makeFlowTitleNodeSchema,
+  makeInteractiveFlowNodeSchema: () => makeInteractiveFlowNodeSchema,
+  retryDoTry: () => retryDoTry,
+  skipDoTry: () => skipDoTry,
+  uuidv4: () => uuidv4
+});
+
+// ../../scripts/emotion-shim.js
+var import_react = require("@emotion/react");
+
+// src/bits.ts
+var makeEvaluate = (evaluateMap) => ({ task, answer }) => {
+  const subtype = task.subtype;
+  const evaluate = evaluateMap[subtype];
+  if (!evaluate) {
+    throw new Error("subtype not supported");
+  }
+  return evaluate({ answer, task });
+};
+
+// src/bitsSchema.ts
+var z = __toESM(require("zod"));
+var FeedbackMessageSchema = z.object({
+  message: z.string(),
+  severity: z.enum(["error", "warning", "info", "success"])
+});
+var TaskSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  subtype: z.string(),
+  view: z.record(z.any()),
+  evaluation: z.object({
+    mode: z.enum(["auto", "skip", "manual"]),
+    enableRetry: z.boolean(),
+    showFeedback: z.boolean()
+  }),
+  feedback: z.record(z.any()).optional()
+});
+var TaskStatisticSchema = z.object({
+  subtype: z.string(),
+  count: z.number()
+});
+var TaskAnswerSchema = z.object({
+  subtype: z.string()
+});
+var TaskResultSchema = z.object({
+  subtype: z.string(),
+  state: z.enum(["unknown", "manual", "correct", "wrong"]),
+  allowRetry: z.boolean().optional(),
+  feedback: z.any()
+});
+var InputSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  subtype: z.string(),
+  view: z.object({})
+});
+var TitleSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  subtype: z.string(),
+  view: z.object({})
+});
+var StartSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  subtype: z.string(),
+  view: z.object({})
+});
+var EndSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  subtype: z.string(),
+  view: z.object({})
+});
+
+// src/do.ts
+var isDoStartedTry = (d) => {
+  return d.status === "started";
+};
+var isDoFinishedTry = (d) => {
+  return d.status === "finished";
+};
+var isDoSkippedTry = (d) => {
+  return d.status === "skipped";
+};
+var skipDoTry = (doResult, evaluation = { mode: "skip" }) => {
+  const { tries } = doResult;
+  let { maxPoints } = doResult;
+  const currentTry = tries[tries.length - 1];
+  const hasTry = tries.find((doTry) => doTry.node.id === currentTry.node.id && doTry.status !== "started");
+  if (!hasTry && (evaluation == null ? void 0 : evaluation.mode) !== "skip") {
+    maxPoints += 1;
+  }
+  tries[tries.length - 1] = __spreadProps(__spreadValues({}, currentTry), {
+    evaluation,
+    status: "skipped",
+    endDate: new Date()
+  });
+  return __spreadProps(__spreadValues({}, doResult), {
+    maxPoints,
+    tries
+  });
+};
+var finishDoTry = (doResult, answer, result) => {
+  var _a, _b;
+  const { tries } = doResult;
+  let { points, maxPoints } = doResult;
+  const currentTry = tries[tries.length - 1];
+  const hasTry = tries.find((doTry) => doTry.node.id === currentTry.node.id && doTry.status !== "started");
+  if (!hasTry && (result == null ? void 0 : result.state) !== "unknown") {
+    maxPoints += 1;
+  }
+  tries[tries.length - 1] = __spreadProps(__spreadValues({}, currentTry), {
+    status: "finished",
+    endDate: new Date(),
+    answer,
+    result
+  });
+  const lastTry = tries.filter(isDoFinishedTry).find((doTry) => doTry.node.id === currentTry.node.id && currentTry.try - 1 === doTry.try);
+  if (!lastTry && (result == null ? void 0 : result.state) === "correct") {
+    points += 1;
+  } else if (((_a = lastTry == null ? void 0 : lastTry.result) == null ? void 0 : _a.state) === "correct" && (result == null ? void 0 : result.state) !== "correct") {
+    points -= 1;
+  } else if (((_b = lastTry == null ? void 0 : lastTry.result) == null ? void 0 : _b.state) !== "correct" && (result == null ? void 0 : result.state) === "correct") {
+    points += 1;
+  }
+  return __spreadProps(__spreadValues({}, doResult), {
+    maxPoints,
+    points,
+    tries
+  });
+};
+var retryDoTry = (doResult) => {
+  const { tries } = doResult;
+  const lastTry = tries[tries.length - 1];
+  tries.push({
+    status: "started",
+    try: lastTry.try + 1,
+    startDate: new Date(),
+    node: __spreadValues({}, lastTry.node)
+  });
+  return __spreadProps(__spreadValues({}, doResult), { tries });
+};
+
+// src/doSchema.ts
+var import_zod2 = require("zod");
+
+// src/flowSchema.ts
+var import_zod = require("zod");
+var NodeBaseSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  position: import_zod.z.object({
+    x: import_zod.z.number(),
+    y: import_zod.z.number()
+  })
+});
+var FlowCheckpointNodeSchema = NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("checkpoint")
+}));
+var FlowSynchronizeNodeSchema = NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("synchronize"),
+  data: import_zod.z.object({
+    unlocked: import_zod.z.boolean()
+  })
+}));
+var makeFlowTaskNodeSchema = (task) => NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("task"),
+  data: task
+}));
+var makeFlowStartNodeSchema = (start) => NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("start"),
+  data: start
+}));
+var makeFlowEndNodeSchema = (end) => NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("end"),
+  data: end
+}));
+var makeFlowInputNodeSchema = (input) => NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("input"),
+  data: input
+}));
+var makeFlowTitleNodeSchema = (title) => NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("title"),
+  data: title
+}));
+var EqualConditionSchema = import_zod.z.object({
+  type: import_zod.z.literal("equal"),
+  not: import_zod.z.boolean(),
+  nodeId: import_zod.z.string(),
+  key: import_zod.z.string(),
+  value: import_zod.z.union([import_zod.z.string(), import_zod.z.number()])
+});
+var TrueConditionSchema = import_zod.z.object({
+  type: import_zod.z.literal("true"),
+  not: import_zod.z.boolean(),
+  nodeId: import_zod.z.string(),
+  key: import_zod.z.string()
+});
+var GreaterConditionSchema = import_zod.z.object({
+  type: import_zod.z.literal("greater"),
+  include: import_zod.z.boolean(),
+  not: import_zod.z.boolean(),
+  nodeId: import_zod.z.string(),
+  key: import_zod.z.string(),
+  value: import_zod.z.number()
+});
+var LessConditionSchema = import_zod.z.object({
+  type: import_zod.z.literal("less"),
+  include: import_zod.z.boolean(),
+  not: import_zod.z.boolean(),
+  nodeId: import_zod.z.string(),
+  key: import_zod.z.string(),
+  value: import_zod.z.number()
+});
+var InConditionSchema = import_zod.z.object({
+  type: import_zod.z.literal("in"),
+  not: import_zod.z.boolean(),
+  nodeId: import_zod.z.string(),
+  key: import_zod.z.string(),
+  value: import_zod.z.array(import_zod.z.union([import_zod.z.string(), import_zod.z.number()]))
+});
+var PrimitiveConditionSchema = import_zod.z.union([
+  EqualConditionSchema,
+  TrueConditionSchema,
+  GreaterConditionSchema,
+  LessConditionSchema,
+  InConditionSchema
+]);
+var AndConditionSchema = import_zod.z.object({
+  type: import_zod.z.literal("and"),
+  conditions: import_zod.z.array(PrimitiveConditionSchema)
+});
+var OrConditionSchema = import_zod.z.object({
+  type: import_zod.z.literal("or"),
+  conditions: import_zod.z.array(PrimitiveConditionSchema)
+});
+var ConditionSchema = import_zod.z.union([
+  PrimitiveConditionSchema,
+  AndConditionSchema,
+  OrConditionSchema
+]);
+var SplitAnswerSchema = import_zod.z.object({
+  condition: ConditionSchema
+});
+var FlowSplitAnswerNodeSchema = NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("split-answer"),
+  data: SplitAnswerSchema
+}));
+var SplitResultSchema = import_zod.z.object({
+  condition: ConditionSchema
+});
+var FlowSplitResultNodeSchema = NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("split-result"),
+  data: SplitResultSchema
+}));
+var SplitPointsSchema = import_zod.z.object({
+  points: import_zod.z.number()
+});
+var FlowSplitPointsNodeSchema = NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("split-points"),
+  data: SplitPointsSchema
+}));
+var PortalInputSchema = import_zod.z.object({
+  portal: import_zod.z.string(),
+  description: import_zod.z.string()
+});
+var PortalOutputSchema = import_zod.z.object({
+  portal: import_zod.z.string(),
+  description: import_zod.z.string()
+});
+var FlowPortalInputNodeSchema = NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("portal-input"),
+  data: PortalInputSchema
+}));
+var FlowPortalOutputNodeSchema = NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("portal-output"),
+  data: PortalOutputSchema
+}));
+var FlowSplitRandomNodeSchema = NodeBaseSchema.merge(import_zod.z.object({
+  type: import_zod.z.literal("split-random")
+}));
+var ControlFlowNodeSchema = import_zod.z.union([
+  FlowSplitAnswerNodeSchema,
+  FlowSplitResultNodeSchema,
+  FlowSplitPointsNodeSchema,
+  FlowSplitRandomNodeSchema,
+  FlowPortalInputNodeSchema,
+  FlowPortalOutputNodeSchema
+]);
+var makeInteractiveFlowNodeSchema = ({
+  start,
+  end,
+  input,
+  title,
+  task
+}) => import_zod.z.union([
+  makeFlowStartNodeSchema(start),
+  makeFlowEndNodeSchema(end),
+  makeFlowInputNodeSchema(input),
+  makeFlowTaskNodeSchema(task),
+  makeFlowTitleNodeSchema(title),
+  FlowSynchronizeNodeSchema,
+  FlowCheckpointNodeSchema
+]);
+var FlowEdgeSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  source: import_zod.z.string(),
+  sourceHandle: import_zod.z.union([
+    import_zod.z.literal("a"),
+    import_zod.z.literal("b"),
+    import_zod.z.literal("c"),
+    import_zod.z.literal("d"),
+    import_zod.z.literal("e"),
+    import_zod.z.literal("f")
+  ]).optional(),
+  target: import_zod.z.string()
+});
+var makeFlowNodeSchema = ({
+  end,
+  input,
+  start,
+  task,
+  title
+}) => import_zod.z.union([
+  FlowSplitAnswerNodeSchema,
+  FlowSplitResultNodeSchema,
+  FlowSplitPointsNodeSchema,
+  FlowSplitRandomNodeSchema,
+  FlowPortalInputNodeSchema,
+  FlowPortalOutputNodeSchema,
+  FlowSynchronizeNodeSchema,
+  FlowCheckpointNodeSchema,
+  makeFlowEndNodeSchema(end),
+  makeFlowInputNodeSchema(input),
+  makeFlowStartNodeSchema(start),
+  makeFlowTaskNodeSchema(task),
+  makeFlowTitleNodeSchema(title)
+]);
+var makeFlowSchema = ({
+  end,
+  input,
+  start,
+  task,
+  title
+}) => import_zod.z.object({
+  name: import_zod.z.string(),
+  description: import_zod.z.string(),
+  language: import_zod.z.enum(["en", "de", "fr", "es", "nl", "pt", "tr", "it"]),
+  visibility: import_zod.z.enum(["public", "private", "unlisted"]),
+  draft: import_zod.z.boolean(),
+  nodes: import_zod.z.array(makeFlowNodeSchema({ start, end, input, title, task })),
+  edges: import_zod.z.array(FlowEdgeSchema),
+  zoom: import_zod.z.number().positive().default(1),
+  position: import_zod.z.tuple([import_zod.z.number(), import_zod.z.number()]).default([0, 0])
+}).refine((data) => {
+  const ids = data.nodes.map((n) => n.id);
+  for (let edge of data.edges) {
+    if (!ids.includes(edge.source) || !ids.includes(edge.target)) {
+      return false;
+    }
+  }
+  return true;
+}, { message: "Target and source of an edge need to be valid node ids." });
+
+// src/doSchema.ts
+var makeDoBaseTrySchema = (flowNodeSchemas) => import_zod2.z.object({
+  node: makeInteractiveFlowNodeSchema(flowNodeSchemas),
+  startDate: import_zod2.z.date(),
+  try: import_zod2.z.number(),
+  status: import_zod2.z.string()
+});
+var makeDoStartedTry = (flowNodeSchemas) => makeDoBaseTrySchema(flowNodeSchemas).merge(import_zod2.z.object({
+  status: import_zod2.z.literal("started")
+}));
+var makeDoFinishedTry = (flowNodeSchemas) => makeDoBaseTrySchema(flowNodeSchemas).merge(import_zod2.z.object({
+  status: import_zod2.z.literal("finished"),
+  endDate: import_zod2.z.date(),
+  answer: TaskAnswerSchema.optional(),
+  result: TaskResultSchema.optional()
+}));
+var makeDoSkippedTry = (flowNodeSchemas) => makeDoBaseTrySchema(flowNodeSchemas).merge(import_zod2.z.object({
+  status: import_zod2.z.literal("skipped"),
+  endDate: import_zod2.z.date()
+}));
+
+// src/findLast.ts
+function findLast(array, predicate) {
+  let l = array.length;
+  while (l--) {
+    if (predicate(array[l], l, array))
+      return array[l];
+  }
+  return null;
+}
+
+// src/flow.ts
+var isFlowTaskNode = (n) => {
+  if (n.type === "task") {
+    return true;
+  }
+  return false;
+};
+var isFlowStartNode = (n) => {
+  if (n.type === "start") {
+    return true;
+  }
+  return false;
+};
+var isFlowEndNode = (n) => {
+  if (n.type === "end") {
+    return true;
+  }
+  return false;
+};
+var isFlowInputNode = (n) => {
+  if (n.type === "input") {
+    return true;
+  }
+  return false;
+};
+var isFlowTitleNode = (n) => {
+  if (n.type === "title") {
+    return true;
+  }
+  return false;
+};
+var isFlowSplitAnswerNode = (n) => {
+  return n.type === "split-answer";
+};
+var isFlowSplitResultNode = (n) => {
+  return n.type === "split-result";
+};
+var isFlowSplitPointsNode = (n) => {
+  return n.type === "split-points";
+};
+var isFlowPortalInputNode = (n) => {
+  return n.type === "portal-input";
+};
+var isFlowPortalOutputNode = (n) => {
+  return n.type === "portal-output";
+};
+var isFlowSplitRandomNode = (n) => {
+  return n.type === "split-random";
+};
+var isControlFlowNode = (n) => {
+  return n.type === "portal-input" || n.type === "portal-output" || n.type === "split-answer" || n.type === "split-points" || n.type === "split-random" || n.type === "split-result";
+};
+var isInteractiveFlowNode = (n) => {
+  if (n.type === "checkpoint" || n.type === "end" || n.type === "input" || n.type === "start" || n.type === "synchronize" || n.type === "task" || n.type === "title") {
+    return true;
+  }
+  return false;
+};
+var extractInteractiveFlowPublicNode = (n) => {
+  if (n.type === "task") {
+    return {
+      id: n.id,
+      type: n.type,
+      data: {
+        name: n.data.name,
+        subtype: n.data.subtype,
+        view: n.data.view
+      }
+    };
+  } else if (n.type === "synchronize" || n.type === "checkpoint") {
+    return {
+      id: n.id,
+      type: n.type
+    };
+  } else if (n.type === "input") {
+    return {
+      id: n.id,
+      type: n.type,
+      data: n.data
+    };
+  } else if (n.type === "end") {
+    return {
+      id: n.id,
+      type: n.type,
+      data: n.data
+    };
+  } else if (n.type === "start") {
+    return {
+      id: n.id,
+      type: n.type,
+      data: n.data
+    };
+  }
+  return {
+    id: n.id,
+    type: n.type,
+    data: n.data
+  };
+};
+
+// src/groupBy.ts
+function groupBy(array, by) {
+  const grouped = [];
+  let index = 0;
+  const indexes = {};
+  let l = 0;
+  while (l < array.length) {
+    const value = array[l];
+    const key = by(value);
+    if (indexes[key] === void 0) {
+      indexes[key] = index;
+      index++;
+    }
+    if (!grouped[indexes[key]]) {
+      grouped[indexes[key]] = [value];
+    } else {
+      grouped[indexes[key]].push(value);
+    }
+    l++;
+  }
+  return grouped;
+}
+
+// src/lerpColor.ts
+function lerpColor(a, b, amount) {
+  let ah = +a.replace("#", "0x"), ar = ah >> 16, ag = ah >> 8 & 255, ab = ah & 255, bh = +b.replace("#", "0x"), br = bh >> 16, bg = bh >> 8 & 255, bb = bh & 255, rr = ar + amount * (br - ar), rg = ag + amount * (bg - ag), rb = ab + amount * (bb - ab);
+  return "#" + ((1 << 24) + (rr << 16) + (rg << 8) + rb | 0).toString(16).slice(1);
+}
+
+// src/levenshtein.ts
+function _min(d0, d1, d2, bx, ay) {
+  return d0 < d1 || d2 < d1 ? d0 > d2 ? d2 + 1 : d0 + 1 : bx === ay ? d1 : d1 + 1;
+}
+var levenshtein = (a, b) => {
+  if (a === b) {
+    return 0;
+  }
+  if (a.length > b.length) {
+    var tmp = a;
+    a = b;
+    b = tmp;
+  }
+  var la = a.length;
+  var lb = b.length;
+  while (la > 0 && a.charCodeAt(la - 1) === b.charCodeAt(lb - 1)) {
+    la--;
+    lb--;
+  }
+  var offset = 0;
+  while (offset < la && a.charCodeAt(offset) === b.charCodeAt(offset)) {
+    offset++;
+  }
+  la -= offset;
+  lb -= offset;
+  if (la === 0 || lb < 3) {
+    return lb;
+  }
+  let x = 0;
+  let y;
+  let d0;
+  let d1;
+  let d2;
+  let d3;
+  let dd = 0;
+  let dy;
+  let ay;
+  let bx0;
+  let bx1;
+  let bx2;
+  let bx3;
+  let vector = [];
+  for (y = 0; y < la; y++) {
+    vector.push(y + 1);
+    vector.push(a.charCodeAt(offset + y));
+  }
+  let len = vector.length - 1;
+  for (; x < lb - 3; ) {
+    bx0 = b.charCodeAt(offset + (d0 = x));
+    bx1 = b.charCodeAt(offset + (d1 = x + 1));
+    bx2 = b.charCodeAt(offset + (d2 = x + 2));
+    bx3 = b.charCodeAt(offset + (d3 = x + 3));
+    dd = x += 4;
+    for (y = 0; y < len; y += 2) {
+      dy = vector[y];
+      ay = vector[y + 1];
+      d0 = _min(dy, d0, d1, bx0, ay);
+      d1 = _min(d0, d1, d2, bx1, ay);
+      d2 = _min(d1, d2, d3, bx2, ay);
+      dd = _min(d2, d3, dd, bx3, ay);
+      vector[y] = dd;
+      d3 = d2;
+      d2 = d1;
+      d1 = d0;
+      d0 = dy;
+    }
+  }
+  for (; x < lb; ) {
+    bx0 = b.charCodeAt(offset + (d0 = x));
+    dd = ++x;
+    for (y = 0; y < len; y += 2) {
+      dy = vector[y];
+      vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]);
+      d0 = dy;
+    }
+  }
+  return dd;
+};
+
+// src/uuid.ts
+function uuidv4() {
+  var uuid = "", i, random;
+  for (i = 0; i < 32; i++) {
+    random = Math.random() * 16 | 0;
+    if (i == 8 || i == 12 || i == 16 || i == 20) {
+      uuid += "-";
+    }
+    uuid += (i == 12 ? 4 : i == 16 ? random & 3 | 8 : random).toString(16);
+  }
+  return uuid;
+}
+module.exports = __toCommonJS(src_exports);
+//# sourceMappingURL=index.cjs.js.map