@bitflow/core 0.6.0 → 0.7.0

package/dist/index.cjs.js

@@ -1,725 +0,0 @@
-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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// 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
-});
-module.exports = __toCommonJS(src_exports);
-
-// ../../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;
-}
-//# sourceMappingURL=index.cjs.js.map