@zettelgeist/cli 0.1.0

package/dist/viewer-bundle/chunk-UVRE3R6A.js

@@ -0,0 +1,1039 @@
+import {
+  require_dist
+} from "./chunk-G3PPZWPW.js";
+import {
+  assignWithDepth_default,
+  common_default,
+  detectType,
+  directiveRegex,
+  sanitizeDirective
+} from "./chunk-7NZMPQDX.js";
+import {
+  Stack_default,
+  Uint8Array_default,
+  arrayLikeKeys_default,
+  baseFor_default,
+  baseGetTag_default,
+  eq_default,
+  getNative_default,
+  identity_default,
+  isArguments_default,
+  isArrayLike_default,
+  isArray_default,
+  isBuffer_default,
+  isFunction_default,
+  isIndex_default,
+  isObjectLike_default,
+  isObject_default,
+  isPrototype_default,
+  isTypedArray_default,
+  memoize_default,
+  overArg_default,
+  root_default
+} from "./chunk-YEU62MVS.js";
+import {
+  __name,
+  basisClosed_default,
+  basisOpen_default,
+  basis_default,
+  bumpX,
+  bumpY,
+  bundle_default,
+  cardinalClosed_default,
+  cardinalOpen_default,
+  cardinal_default,
+  catmullRomClosed_default,
+  catmullRomOpen_default,
+  catmullRom_default,
+  linearClosed_default,
+  linear_default,
+  log,
+  monotoneX,
+  monotoneY,
+  natural_default,
+  select_default,
+  stepAfter,
+  stepBefore,
+  step_default
+} from "./chunk-CZHJHAOR.js";
+import {
+  __toESM
+} from "./chunk-DI52DQAC.js";
+
+// ../../node_modules/.pnpm/mermaid@11.14.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-5PVQY5BW.mjs
+var import_sanitize_url = __toESM(require_dist(), 1);
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_defineProperty.js
+var defineProperty = function() {
+  try {
+    var func = getNative_default(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+}();
+var defineProperty_default = defineProperty;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseAssignValue.js
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && defineProperty_default) {
+    defineProperty_default(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var baseAssignValue_default = baseAssignValue;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_assignMergeValue.js
+function assignMergeValue(object, key, value) {
+  if (value !== void 0 && !eq_default(object[key], value) || value === void 0 && !(key in object)) {
+    baseAssignValue_default(object, key, value);
+  }
+}
+var assignMergeValue_default = assignMergeValue;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneBuffer.js
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer = moduleExports ? root_default.Buffer : void 0;
+var allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) {
+    return buffer.slice();
+  }
+  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+  buffer.copy(result);
+  return result;
+}
+var cloneBuffer_default = cloneBuffer;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneArrayBuffer.js
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array_default(result).set(new Uint8Array_default(arrayBuffer));
+  return result;
+}
+var cloneArrayBuffer_default = cloneArrayBuffer;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneTypedArray.js
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var cloneTypedArray_default = cloneTypedArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copyArray.js
+function copyArray(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+var copyArray_default = copyArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseCreate.js
+var objectCreate = Object.create;
+var baseCreate = /* @__PURE__ */ function() {
+  function object() {
+  }
+  return function(proto) {
+    if (!isObject_default(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = void 0;
+    return result;
+  };
+}();
+var baseCreate_default = baseCreate;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getPrototype.js
+var getPrototype = overArg_default(Object.getPrototypeOf, Object);
+var getPrototype_default = getPrototype;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_initCloneObject.js
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !isPrototype_default(object) ? baseCreate_default(getPrototype_default(object)) : {};
+}
+var initCloneObject_default = initCloneObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isArrayLikeObject.js
+function isArrayLikeObject(value) {
+  return isObjectLike_default(value) && isArrayLike_default(value);
+}
+var isArrayLikeObject_default = isArrayLikeObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isPlainObject.js
+var objectTag = "[object Object]";
+var funcProto = Function.prototype;
+var objectProto = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var objectCtorString = funcToString.call(Object);
+function isPlainObject(value) {
+  if (!isObjectLike_default(value) || baseGetTag_default(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype_default(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+}
+var isPlainObject_default = isPlainObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_safeGet.js
+function safeGet(object, key) {
+  if (key === "constructor" && typeof object[key] === "function") {
+    return;
+  }
+  if (key == "__proto__") {
+    return;
+  }
+  return object[key];
+}
+var safeGet_default = safeGet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_assignValue.js
+var objectProto2 = Object.prototype;
+var hasOwnProperty2 = objectProto2.hasOwnProperty;
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty2.call(object, key) && eq_default(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue_default(object, key, value);
+  }
+}
+var assignValue_default = assignValue;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copyObject.js
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue_default(object, key, newValue);
+    } else {
+      assignValue_default(object, key, newValue);
+    }
+  }
+  return object;
+}
+var copyObject_default = copyObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_nativeKeysIn.js
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var nativeKeysIn_default = nativeKeysIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseKeysIn.js
+var objectProto3 = Object.prototype;
+var hasOwnProperty3 = objectProto3.hasOwnProperty;
+function baseKeysIn(object) {
+  if (!isObject_default(object)) {
+    return nativeKeysIn_default(object);
+  }
+  var isProto = isPrototype_default(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty3.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var baseKeysIn_default = baseKeysIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/keysIn.js
+function keysIn(object) {
+  return isArrayLike_default(object) ? arrayLikeKeys_default(object, true) : baseKeysIn_default(object);
+}
+var keysIn_default = keysIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/toPlainObject.js
+function toPlainObject(value) {
+  return copyObject_default(value, keysIn_default(value));
+}
+var toPlainObject_default = toPlainObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseMergeDeep.js
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+  var objValue = safeGet_default(object, key), srcValue = safeGet_default(source, key), stacked = stack.get(srcValue);
+  if (stacked) {
+    assignMergeValue_default(object, key, stacked);
+    return;
+  }
+  var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
+  var isCommon = newValue === void 0;
+  if (isCommon) {
+    var isArr = isArray_default(srcValue), isBuff = !isArr && isBuffer_default(srcValue), isTyped = !isArr && !isBuff && isTypedArray_default(srcValue);
+    newValue = srcValue;
+    if (isArr || isBuff || isTyped) {
+      if (isArray_default(objValue)) {
+        newValue = objValue;
+      } else if (isArrayLikeObject_default(objValue)) {
+        newValue = copyArray_default(objValue);
+      } else if (isBuff) {
+        isCommon = false;
+        newValue = cloneBuffer_default(srcValue, true);
+      } else if (isTyped) {
+        isCommon = false;
+        newValue = cloneTypedArray_default(srcValue, true);
+      } else {
+        newValue = [];
+      }
+    } else if (isPlainObject_default(srcValue) || isArguments_default(srcValue)) {
+      newValue = objValue;
+      if (isArguments_default(objValue)) {
+        newValue = toPlainObject_default(objValue);
+      } else if (!isObject_default(objValue) || isFunction_default(objValue)) {
+        newValue = initCloneObject_default(srcValue);
+      }
+    } else {
+      isCommon = false;
+    }
+  }
+  if (isCommon) {
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack["delete"](srcValue);
+  }
+  assignMergeValue_default(object, key, newValue);
+}
+var baseMergeDeep_default = baseMergeDeep;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseMerge.js
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  baseFor_default(source, function(srcValue, key) {
+    stack || (stack = new Stack_default());
+    if (isObject_default(srcValue)) {
+      baseMergeDeep_default(object, source, key, srcIndex, baseMerge, customizer, stack);
+    } else {
+      var newValue = customizer ? customizer(safeGet_default(object, key), srcValue, key + "", object, source, stack) : void 0;
+      if (newValue === void 0) {
+        newValue = srcValue;
+      }
+      assignMergeValue_default(object, key, newValue);
+    }
+  }, keysIn_default);
+}
+var baseMerge_default = baseMerge;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_apply.js
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0:
+      return func.call(thisArg);
+    case 1:
+      return func.call(thisArg, args[0]);
+    case 2:
+      return func.call(thisArg, args[0], args[1]);
+    case 3:
+      return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+var apply_default = apply;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_overRest.js
+var nativeMax = Math.max;
+function overRest(func, start, transform) {
+  start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+  return function() {
+    var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+    while (++index < length) {
+      array[index] = args[start + index];
+    }
+    index = -1;
+    var otherArgs = Array(start + 1);
+    while (++index < start) {
+      otherArgs[index] = args[index];
+    }
+    otherArgs[start] = transform(array);
+    return apply_default(func, this, otherArgs);
+  };
+}
+var overRest_default = overRest;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/constant.js
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+var constant_default = constant;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseSetToString.js
+var baseSetToString = !defineProperty_default ? identity_default : function(func, string) {
+  return defineProperty_default(func, "toString", {
+    "configurable": true,
+    "enumerable": false,
+    "value": constant_default(string),
+    "writable": true
+  });
+};
+var baseSetToString_default = baseSetToString;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_shortOut.js
+var HOT_COUNT = 800;
+var HOT_SPAN = 16;
+var nativeNow = Date.now;
+function shortOut(func) {
+  var count = 0, lastCalled = 0;
+  return function() {
+    var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+    lastCalled = stamp;
+    if (remaining > 0) {
+      if (++count >= HOT_COUNT) {
+        return arguments[0];
+      }
+    } else {
+      count = 0;
+    }
+    return func.apply(void 0, arguments);
+  };
+}
+var shortOut_default = shortOut;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_setToString.js
+var setToString = shortOut_default(baseSetToString_default);
+var setToString_default = setToString;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseRest.js
+function baseRest(func, start) {
+  return setToString_default(overRest_default(func, start, identity_default), func + "");
+}
+var baseRest_default = baseRest;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_isIterateeCall.js
+function isIterateeCall(value, index, object) {
+  if (!isObject_default(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == "number" ? isArrayLike_default(object) && isIndex_default(index, object.length) : type == "string" && index in object) {
+    return eq_default(object[index], value);
+  }
+  return false;
+}
+var isIterateeCall_default = isIterateeCall;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_createAssigner.js
+function createAssigner(assigner) {
+  return baseRest_default(function(object, sources) {
+    var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
+    customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
+    if (guard && isIterateeCall_default(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? void 0 : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+var createAssigner_default = createAssigner;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/merge.js
+var merge = createAssigner_default(function(object, source, srcIndex) {
+  baseMerge_default(object, source, srcIndex);
+});
+var merge_default = merge;
+
+// ../../node_modules/.pnpm/mermaid@11.14.0/node_modules/mermaid/dist/chunks/mermaid.core/chunk-5PVQY5BW.mjs
+var ZERO_WIDTH_SPACE = "\u200B";
+var d3CurveTypes = {
+  curveBasis: basis_default,
+  curveBasisClosed: basisClosed_default,
+  curveBasisOpen: basisOpen_default,
+  curveBumpX: bumpX,
+  curveBumpY: bumpY,
+  curveBundle: bundle_default,
+  curveCardinalClosed: cardinalClosed_default,
+  curveCardinalOpen: cardinalOpen_default,
+  curveCardinal: cardinal_default,
+  curveCatmullRomClosed: catmullRomClosed_default,
+  curveCatmullRomOpen: catmullRomOpen_default,
+  curveCatmullRom: catmullRom_default,
+  curveLinear: linear_default,
+  curveLinearClosed: linearClosed_default,
+  curveMonotoneX: monotoneX,
+  curveMonotoneY: monotoneY,
+  curveNatural: natural_default,
+  curveStep: step_default,
+  curveStepAfter: stepAfter,
+  curveStepBefore: stepBefore
+};
+var directiveWithoutOpen = /\s*(?:(\w+)(?=:):|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi;
+var detectInit = /* @__PURE__ */ __name(function(text, config) {
+  const inits = detectDirective(text, /(?:init\b)|(?:initialize\b)/);
+  let results = {};
+  if (Array.isArray(inits)) {
+    const args = inits.map((init) => init.args);
+    sanitizeDirective(args);
+    results = assignWithDepth_default(results, [...args]);
+  } else {
+    results = inits.args;
+  }
+  if (!results) {
+    return;
+  }
+  let type = detectType(text, config);
+  const prop = "config";
+  if (results[prop] !== void 0) {
+    if (type === "flowchart-v2") {
+      type = "flowchart";
+    }
+    results[type] = results[prop];
+    delete results[prop];
+  }
+  return results;
+}, "detectInit");
+var detectDirective = /* @__PURE__ */ __name(function(text, type = null) {
+  try {
+    const commentWithoutDirectives = new RegExp(
+      `[%]{2}(?![{]${directiveWithoutOpen.source})(?=[}][%]{2}).*
+`,
+      "ig"
+    );
+    text = text.trim().replace(commentWithoutDirectives, "").replace(/'/gm, '"');
+    log.debug(
+      `Detecting diagram directive${type !== null ? " type:" + type : ""} based on the text:${text}`
+    );
+    let match;
+    const result = [];
+    while ((match = directiveRegex.exec(text)) !== null) {
+      if (match.index === directiveRegex.lastIndex) {
+        directiveRegex.lastIndex++;
+      }
+      if (match && !type || type && match[1]?.match(type) || type && match[2]?.match(type)) {
+        const type2 = match[1] ? match[1] : match[2];
+        const args = match[3] ? match[3].trim() : match[4] ? JSON.parse(match[4].trim()) : null;
+        result.push({ type: type2, args });
+      }
+    }
+    if (result.length === 0) {
+      return { type: text, args: null };
+    }
+    return result.length === 1 ? result[0] : result;
+  } catch (error) {
+    log.error(
+      `ERROR: ${error.message} - Unable to parse directive type: '${type}' based on the text: '${text}'`
+    );
+    return { type: void 0, args: null };
+  }
+}, "detectDirective");
+var removeDirectives = /* @__PURE__ */ __name(function(text) {
+  return text.replace(directiveRegex, "");
+}, "removeDirectives");
+var isSubstringInArray = /* @__PURE__ */ __name(function(str, arr) {
+  for (const [i, element] of arr.entries()) {
+    if (element.match(str)) {
+      return i;
+    }
+  }
+  return -1;
+}, "isSubstringInArray");
+function interpolateToCurve(interpolate, defaultCurve) {
+  if (!interpolate) {
+    return defaultCurve;
+  }
+  const curveName = `curve${interpolate.charAt(0).toUpperCase() + interpolate.slice(1)}`;
+  return d3CurveTypes[curveName] ?? defaultCurve;
+}
+__name(interpolateToCurve, "interpolateToCurve");
+function formatUrl(linkStr, config) {
+  const url = linkStr.trim();
+  if (!url) {
+    return void 0;
+  }
+  if (config.securityLevel !== "loose") {
+    return (0, import_sanitize_url.sanitizeUrl)(url);
+  }
+  return url;
+}
+__name(formatUrl, "formatUrl");
+var runFunc = /* @__PURE__ */ __name((functionName, ...params) => {
+  const arrPaths = functionName.split(".");
+  const len = arrPaths.length - 1;
+  const fnName = arrPaths[len];
+  let obj = window;
+  for (let i = 0; i < len; i++) {
+    obj = obj[arrPaths[i]];
+    if (!obj) {
+      log.error(`Function name: ${functionName} not found in window`);
+      return;
+    }
+  }
+  obj[fnName](...params);
+}, "runFunc");
+function distance(p1, p2) {
+  if (!p1 || !p2) {
+    return 0;
+  }
+  return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+}
+__name(distance, "distance");
+function traverseEdge(points) {
+  let prevPoint;
+  let totalDistance = 0;
+  points.forEach((point) => {
+    totalDistance += distance(point, prevPoint);
+    prevPoint = point;
+  });
+  const remainingDistance = totalDistance / 2;
+  return calculatePoint(points, remainingDistance);
+}
+__name(traverseEdge, "traverseEdge");
+function calcLabelPosition(points) {
+  if (points.length === 1) {
+    return points[0];
+  }
+  return traverseEdge(points);
+}
+__name(calcLabelPosition, "calcLabelPosition");
+var roundNumber = /* @__PURE__ */ __name((num, precision = 2) => {
+  const factor = Math.pow(10, precision);
+  return Math.round(num * factor) / factor;
+}, "roundNumber");
+var calculatePoint = /* @__PURE__ */ __name((points, distanceToTraverse) => {
+  let prevPoint = void 0;
+  let remainingDistance = distanceToTraverse;
+  for (const point of points) {
+    if (prevPoint) {
+      const vectorDistance = distance(point, prevPoint);
+      if (vectorDistance === 0) {
+        return prevPoint;
+      }
+      if (vectorDistance < remainingDistance) {
+        remainingDistance -= vectorDistance;
+      } else {
+        const distanceRatio = remainingDistance / vectorDistance;
+        if (distanceRatio <= 0) {
+          return prevPoint;
+        }
+        if (distanceRatio >= 1) {
+          return { x: point.x, y: point.y };
+        }
+        if (distanceRatio > 0 && distanceRatio < 1) {
+          return {
+            x: roundNumber((1 - distanceRatio) * prevPoint.x + distanceRatio * point.x, 5),
+            y: roundNumber((1 - distanceRatio) * prevPoint.y + distanceRatio * point.y, 5)
+          };
+        }
+      }
+    }
+    prevPoint = point;
+  }
+  throw new Error("Could not find a suitable point for the given distance");
+}, "calculatePoint");
+var calcCardinalityPosition = /* @__PURE__ */ __name((isRelationTypePresent, points, initialPosition) => {
+  log.info(`our points ${JSON.stringify(points)}`);
+  if (points[0] !== initialPosition) {
+    points = points.reverse();
+  }
+  const distanceToCardinalityPoint = 25;
+  const center = calculatePoint(points, distanceToCardinalityPoint);
+  const d = isRelationTypePresent ? 10 : 5;
+  const angle = Math.atan2(points[0].y - center.y, points[0].x - center.x);
+  const cardinalityPosition = { x: 0, y: 0 };
+  cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2;
+  cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2;
+  return cardinalityPosition;
+}, "calcCardinalityPosition");
+function calcTerminalLabelPosition(terminalMarkerSize, position, _points) {
+  const points = structuredClone(_points);
+  log.info("our points", points);
+  if (position !== "start_left" && position !== "start_right") {
+    points.reverse();
+  }
+  const distanceToCardinalityPoint = 25 + terminalMarkerSize;
+  const center = calculatePoint(points, distanceToCardinalityPoint);
+  const d = 10 + terminalMarkerSize * 0.5;
+  const angle = Math.atan2(points[0].y - center.y, points[0].x - center.x);
+  const cardinalityPosition = { x: 0, y: 0 };
+  if (position === "start_left") {
+    cardinalityPosition.x = Math.sin(angle + Math.PI) * d + (points[0].x + center.x) / 2;
+    cardinalityPosition.y = -Math.cos(angle + Math.PI) * d + (points[0].y + center.y) / 2;
+  } else if (position === "end_right") {
+    cardinalityPosition.x = Math.sin(angle - Math.PI) * d + (points[0].x + center.x) / 2 - 5;
+    cardinalityPosition.y = -Math.cos(angle - Math.PI) * d + (points[0].y + center.y) / 2 - 5;
+  } else if (position === "end_left") {
+    cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2 - 5;
+    cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2 - 5;
+  } else {
+    cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2;
+    cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2;
+  }
+  return cardinalityPosition;
+}
+__name(calcTerminalLabelPosition, "calcTerminalLabelPosition");
+function getStylesFromArray(arr) {
+  let style = "";
+  let labelStyle = "";
+  for (const element of arr) {
+    if (element !== void 0) {
+      if (element.startsWith("color:") || element.startsWith("text-align:")) {
+        labelStyle = labelStyle + element + ";";
+      } else {
+        style = style + element + ";";
+      }
+    }
+  }
+  return { style, labelStyle };
+}
+__name(getStylesFromArray, "getStylesFromArray");
+var cnt = 0;
+var generateId = /* @__PURE__ */ __name(() => {
+  cnt++;
+  return "id-" + Math.random().toString(36).substr(2, 12) + "-" + cnt;
+}, "generateId");
+function makeRandomHex(length) {
+  let result = "";
+  const characters = "0123456789abcdef";
+  const charactersLength = characters.length;
+  for (let i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+__name(makeRandomHex, "makeRandomHex");
+var random = /* @__PURE__ */ __name((options) => {
+  return makeRandomHex(options.length);
+}, "random");
+var getTextObj = /* @__PURE__ */ __name(function() {
+  return {
+    x: 0,
+    y: 0,
+    fill: void 0,
+    anchor: "start",
+    style: "#666",
+    width: 100,
+    height: 100,
+    textMargin: 0,
+    rx: 0,
+    ry: 0,
+    valign: void 0,
+    text: ""
+  };
+}, "getTextObj");
+var drawSimpleText = /* @__PURE__ */ __name(function(elem, textData) {
+  const nText = textData.text.replace(common_default.lineBreakRegex, " ");
+  const [, _fontSizePx] = parseFontSize(textData.fontSize);
+  const textElem = elem.append("text");
+  textElem.attr("x", textData.x);
+  textElem.attr("y", textData.y);
+  textElem.style("text-anchor", textData.anchor);
+  textElem.style("font-family", textData.fontFamily);
+  textElem.style("font-size", _fontSizePx);
+  textElem.style("font-weight", textData.fontWeight);
+  textElem.attr("fill", textData.fill);
+  if (textData.class !== void 0) {
+    textElem.attr("class", textData.class);
+  }
+  const span = textElem.append("tspan");
+  span.attr("x", textData.x + textData.textMargin * 2);
+  span.attr("fill", textData.fill);
+  span.text(nText);
+  return textElem;
+}, "drawSimpleText");
+var wrapLabel = memoize_default(
+  (label, maxWidth, config) => {
+    if (!label) {
+      return label;
+    }
+    config = Object.assign(
+      { fontSize: 12, fontWeight: 400, fontFamily: "Arial", joinWith: "<br/>" },
+      config
+    );
+    if (common_default.lineBreakRegex.test(label)) {
+      return label;
+    }
+    const words = label.split(" ").filter(Boolean);
+    const completedLines = [];
+    let nextLine = "";
+    words.forEach((word, index) => {
+      const wordLength = calculateTextWidth(`${word} `, config);
+      const nextLineLength = calculateTextWidth(nextLine, config);
+      if (wordLength > maxWidth) {
+        const { hyphenatedStrings, remainingWord } = breakString(word, maxWidth, "-", config);
+        completedLines.push(nextLine, ...hyphenatedStrings);
+        nextLine = remainingWord;
+      } else if (nextLineLength + wordLength >= maxWidth) {
+        completedLines.push(nextLine);
+        nextLine = word;
+      } else {
+        nextLine = [nextLine, word].filter(Boolean).join(" ");
+      }
+      const currentWord = index + 1;
+      const isLastWord = currentWord === words.length;
+      if (isLastWord) {
+        completedLines.push(nextLine);
+      }
+    });
+    return completedLines.filter((line) => line !== "").join(config.joinWith);
+  },
+  (label, maxWidth, config) => `${label}${maxWidth}${config.fontSize}${config.fontWeight}${config.fontFamily}${config.joinWith}`
+);
+var breakString = memoize_default(
+  (word, maxWidth, hyphenCharacter = "-", config) => {
+    config = Object.assign(
+      { fontSize: 12, fontWeight: 400, fontFamily: "Arial", margin: 0 },
+      config
+    );
+    const characters = [...word];
+    const lines = [];
+    let currentLine = "";
+    characters.forEach((character, index) => {
+      const nextLine = `${currentLine}${character}`;
+      const lineWidth = calculateTextWidth(nextLine, config);
+      if (lineWidth >= maxWidth) {
+        const currentCharacter = index + 1;
+        const isLastLine = characters.length === currentCharacter;
+        const hyphenatedNextLine = `${nextLine}${hyphenCharacter}`;
+        lines.push(isLastLine ? nextLine : hyphenatedNextLine);
+        currentLine = "";
+      } else {
+        currentLine = nextLine;
+      }
+    });
+    return { hyphenatedStrings: lines, remainingWord: currentLine };
+  },
+  (word, maxWidth, hyphenCharacter = "-", config) => `${word}${maxWidth}${hyphenCharacter}${config.fontSize}${config.fontWeight}${config.fontFamily}`
+);
+function calculateTextHeight(text, config) {
+  return calculateTextDimensions(text, config).height;
+}
+__name(calculateTextHeight, "calculateTextHeight");
+function calculateTextWidth(text, config) {
+  return calculateTextDimensions(text, config).width;
+}
+__name(calculateTextWidth, "calculateTextWidth");
+var calculateTextDimensions = memoize_default(
+  (text, config) => {
+    const { fontSize = 12, fontFamily = "Arial", fontWeight = 400 } = config;
+    if (!text) {
+      return { width: 0, height: 0 };
+    }
+    const [, _fontSizePx] = parseFontSize(fontSize);
+    const fontFamilies = ["sans-serif", fontFamily];
+    const lines = text.split(common_default.lineBreakRegex);
+    const dims = [];
+    const body = select_default("body");
+    if (!body.remove) {
+      return { width: 0, height: 0, lineHeight: 0 };
+    }
+    const g = body.append("svg");
+    for (const fontFamily2 of fontFamilies) {
+      let cHeight = 0;
+      const dim = { width: 0, height: 0, lineHeight: 0 };
+      for (const line of lines) {
+        const textObj = getTextObj();
+        textObj.text = line || ZERO_WIDTH_SPACE;
+        const textElem = drawSimpleText(g, textObj).style("font-size", _fontSizePx).style("font-weight", fontWeight).style("font-family", fontFamily2);
+        const bBox = (textElem._groups || textElem)[0][0].getBBox();
+        if (bBox.width === 0 && bBox.height === 0) {
+          throw new Error("svg element not in render tree");
+        }
+        dim.width = Math.round(Math.max(dim.width, bBox.width));
+        cHeight = Math.round(bBox.height);
+        dim.height += cHeight;
+        dim.lineHeight = Math.round(Math.max(dim.lineHeight, cHeight));
+      }
+      dims.push(dim);
+    }
+    g.remove();
+    const index = isNaN(dims[1].height) || isNaN(dims[1].width) || isNaN(dims[1].lineHeight) || dims[0].height > dims[1].height && dims[0].width > dims[1].width && dims[0].lineHeight > dims[1].lineHeight ? 0 : 1;
+    return dims[index];
+  },
+  (text, config) => `${text}${config.fontSize}${config.fontWeight}${config.fontFamily}`
+);
+var InitIDGenerator = class {
+  constructor(deterministic = false, seed) {
+    this.count = 0;
+    this.count = seed ? seed.length : 0;
+    this.next = deterministic ? () => this.count++ : () => Date.now();
+  }
+  static {
+    __name(this, "InitIDGenerator");
+  }
+};
+var decoder;
+var entityDecode = /* @__PURE__ */ __name(function(html) {
+  decoder = decoder || document.createElement("div");
+  html = escape(html).replace(/%26/g, "&").replace(/%23/g, "#").replace(/%3B/g, ";");
+  decoder.innerHTML = html;
+  return unescape(decoder.textContent);
+}, "entityDecode");
+function isDetailedError(error) {
+  return "str" in error;
+}
+__name(isDetailedError, "isDetailedError");
+var insertTitle = /* @__PURE__ */ __name((parent, cssClass, titleTopMargin, title) => {
+  if (!title) {
+    return;
+  }
+  const bounds = parent.node()?.getBBox();
+  if (!bounds) {
+    return;
+  }
+  parent.append("text").text(title).attr("text-anchor", "middle").attr("x", bounds.x + bounds.width / 2).attr("y", -titleTopMargin).attr("class", cssClass);
+}, "insertTitle");
+var parseFontSize = /* @__PURE__ */ __name((fontSize) => {
+  if (typeof fontSize === "number") {
+    return [fontSize, fontSize + "px"];
+  }
+  const fontSizeNumber = parseInt(fontSize ?? "", 10);
+  if (Number.isNaN(fontSizeNumber)) {
+    return [void 0, void 0];
+  } else if (fontSize === String(fontSizeNumber)) {
+    return [fontSizeNumber, fontSize + "px"];
+  } else {
+    return [fontSizeNumber, fontSize];
+  }
+}, "parseFontSize");
+function cleanAndMerge(defaultData, data) {
+  return merge_default({}, defaultData, data);
+}
+__name(cleanAndMerge, "cleanAndMerge");
+var utils_default = {
+  assignWithDepth: assignWithDepth_default,
+  wrapLabel,
+  calculateTextHeight,
+  calculateTextWidth,
+  calculateTextDimensions,
+  cleanAndMerge,
+  detectInit,
+  detectDirective,
+  isSubstringInArray,
+  interpolateToCurve,
+  calcLabelPosition,
+  calcCardinalityPosition,
+  calcTerminalLabelPosition,
+  formatUrl,
+  getStylesFromArray,
+  generateId,
+  random,
+  runFunc,
+  entityDecode,
+  insertTitle,
+  isLabelCoordinateInPath,
+  parseFontSize,
+  InitIDGenerator
+};
+var encodeEntities = /* @__PURE__ */ __name(function(text) {
+  let txt = text;
+  txt = txt.replace(/style.*:\S*#.*;/g, function(s) {
+    return s.substring(0, s.length - 1);
+  });
+  txt = txt.replace(/classDef.*:\S*#.*;/g, function(s) {
+    return s.substring(0, s.length - 1);
+  });
+  txt = txt.replace(/#\w+;/g, function(s) {
+    const innerTxt = s.substring(1, s.length - 1);
+    const isInt = /^\+?\d+$/.test(innerTxt);
+    if (isInt) {
+      return "\uFB02\xB0\xB0" + innerTxt + "\xB6\xDF";
+    } else {
+      return "\uFB02\xB0" + innerTxt + "\xB6\xDF";
+    }
+  });
+  return txt;
+}, "encodeEntities");
+var decodeEntities = /* @__PURE__ */ __name(function(text) {
+  return text.replace(/fl°°/g, "&#").replace(/fl°/g, "&").replace(/¶ß/g, ";");
+}, "decodeEntities");
+var getEdgeId = /* @__PURE__ */ __name((from, to, {
+  counter = 0,
+  prefix,
+  suffix
+}, id) => {
+  if (id) {
+    return id;
+  }
+  return `${prefix ? `${prefix}_` : ""}${from}_${to}_${counter}${suffix ? `_${suffix}` : ""}`;
+}, "getEdgeId");
+function handleUndefinedAttr(attrValue) {
+  return attrValue ?? null;
+}
+__name(handleUndefinedAttr, "handleUndefinedAttr");
+function isLabelCoordinateInPath(point, dAttr) {
+  const roundedX = Math.round(point.x);
+  const roundedY = Math.round(point.y);
+  const sanitizedD = dAttr.replace(
+    /(\d+\.\d+)/g,
+    (match) => Math.round(parseFloat(match)).toString()
+  );
+  return sanitizedD.includes(roundedX.toString()) || sanitizedD.includes(roundedY.toString());
+}
+__name(isLabelCoordinateInPath, "isLabelCoordinateInPath");
+
+export {
+  baseAssignValue_default,
+  cloneBuffer_default,
+  cloneArrayBuffer_default,
+  cloneTypedArray_default,
+  copyArray_default,
+  getPrototype_default,
+  initCloneObject_default,
+  isArrayLikeObject_default,
+  assignValue_default,
+  copyObject_default,
+  keysIn_default,
+  overRest_default,
+  constant_default,
+  setToString_default,
+  baseRest_default,
+  isIterateeCall_default,
+  merge_default,
+  ZERO_WIDTH_SPACE,
+  removeDirectives,
+  interpolateToCurve,
+  getStylesFromArray,
+  generateId,
+  random,
+  wrapLabel,
+  calculateTextHeight,
+  calculateTextWidth,
+  isDetailedError,
+  parseFontSize,
+  cleanAndMerge,
+  utils_default,
+  encodeEntities,
+  decodeEntities,
+  getEdgeId,
+  handleUndefinedAttr
+};
+//# sourceMappingURL=chunk-UVRE3R6A.js.map