@ls-stack/utils 3.65.0 → 3.67.0

package/dist/testUtils.cjs

@@ -1,1490 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/testUtils.ts
-var testUtils_exports = {};
-__export(testUtils_exports, {
-  compactSnapshot: () => compactSnapshot,
-  createLoggerStore: () => createLoggerStore,
-  getResultFn: () => getResultFn,
-  waitController: () => waitController
-});
-module.exports = __toCommonJS(testUtils_exports);
-
-// src/typeGuards.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  if (proto === null) {
-    return true;
-  }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  if (Ctor === Object) return true;
-  const objectCtorString = Object.prototype.constructor.toString();
-  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
-}
-
-// src/assertions.ts
-var isObject2 = isObject;
-
-// src/arrayUtils.ts
-function filterAndMap(array, mapFilter) {
-  const result = [];
-  let i = -1;
-  for (const item of array) {
-    i += 1;
-    const filterResult = mapFilter(item, i);
-    if (filterResult !== false) {
-      result.push(filterResult);
-    }
-  }
-  return result;
-}
-function sortBy(arr, sortByValue, props = "asc") {
-  const order = Array.isArray(props) || typeof props === "string" ? props : props.order ?? "asc";
-  return [...arr].sort((a, b) => {
-    const _aPriority = sortByValue(a);
-    const _bPriority = sortByValue(b);
-    const aPriority = Array.isArray(_aPriority) ? _aPriority : [_aPriority];
-    const bPriority = Array.isArray(_bPriority) ? _bPriority : [_bPriority];
-    for (let i = 0; i < aPriority.length; i++) {
-      const levelOrder = typeof order === "string" ? order : order[i] ?? "asc";
-      const aP = aPriority[i] ?? 0;
-      const bP = bPriority[i] ?? 0;
-      if (aP === bP) {
-        continue;
-      }
-      if (bP === Infinity || aP === -Infinity || aP < bP) {
-        return levelOrder === "asc" ? -1 : 1;
-      }
-      if (aP === Infinity || bP === -Infinity || aP > bP) {
-        return levelOrder === "asc" ? 1 : -1;
-      }
-    }
-    return 0;
-  });
-}
-function arrayWithPrevAndIndex(array) {
-  return array.map((item, i) => ({
-    item,
-    prev: array[i - 1] ?? null,
-    index: i
-  }));
-}
-
-// src/deepEqual.ts
-var has = Object.prototype.hasOwnProperty;
-function find(iter, tar, maxDepth) {
-  for (const key of iter.keys()) {
-    if (deepEqual(key, tar, maxDepth)) return key;
-  }
-}
-function deepEqual(foo, bar, maxDepth = 20) {
-  let ctor, len, tmp;
-  if (foo === bar) return true;
-  if (maxDepth && maxDepth <= 0) return false;
-  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-    if (ctor === Date)
-      return deepEqual(foo.getTime(), bar.getTime(), maxDepth - 1);
-    if (ctor === RegExp) return foo.toString() === bar.toString();
-    if (ctor === Array) {
-      if ((len = foo.length) === bar.length) {
-        while (len-- && deepEqual(foo[len], bar[len], maxDepth - 1)) ;
-      }
-      return len === -1;
-    }
-    if (ctor === Set) {
-      if (foo.size !== bar.size) {
-        return false;
-      }
-      for (len of foo) {
-        tmp = len;
-        if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp, maxDepth - 1);
-          if (!tmp) return false;
-        }
-        if (!bar.has(tmp)) return false;
-      }
-      return true;
-    }
-    if (ctor === Map) {
-      if (foo.size !== bar.size) {
-        return false;
-      }
-      for (len of foo) {
-        tmp = len[0];
-        if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp, maxDepth - 1);
-          if (!tmp) return false;
-        }
-        if (!deepEqual(len[1], bar.get(tmp), maxDepth - 1)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (!ctor || typeof foo === "object") {
-      len = 0;
-      for (ctor in foo) {
-        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor], maxDepth - 1))
-          return false;
-      }
-      return Object.keys(bar).length === len;
-    }
-  }
-  return foo !== foo && bar !== bar;
-}
-
-// src/deepReplaceValues.ts
-function applyValueReplacements(value, replaceValues, visited, currentPath) {
-  function processValue(val, path) {
-    const replacement = replaceValues(val, path);
-    if (replacement !== false) {
-      return replacement.newValue;
-    }
-    if (Array.isArray(val)) {
-      if (visited.has(val)) {
-        throw new Error("Circular reference detected in array");
-      }
-      visited.add(val);
-      try {
-        return val.map((item, index) => {
-          const itemPath = path ? `${path}[${index}]` : `[${index}]`;
-          return processValue(item, itemPath);
-        });
-      } finally {
-        visited.delete(val);
-      }
-    }
-    if (isPlainObject(val)) {
-      if (visited.has(val)) {
-        throw new Error("Circular reference detected in object");
-      }
-      visited.add(val);
-      try {
-        const result = {};
-        for (const [key, itemValue] of Object.entries(val)) {
-          const itemPath = path ? `${path}.${key}` : key;
-          result[key] = processValue(itemValue, itemPath);
-        }
-        return result;
-      } finally {
-        visited.delete(val);
-      }
-    }
-    return val;
-  }
-  return processValue(value, currentPath);
-}
-function deepReplaceValues(value, replaceValues) {
-  return applyValueReplacements(value, replaceValues, /* @__PURE__ */ new Set(), "");
-}
-
-// src/filterObjectOrArrayKeys.ts
-var ID_PROP_REGEXP = /^(id_|key_|id-|key-)|(_id|_key|-id|-key)$/i;
-function filterObjectOrArrayKeys(objOrArray, {
-  filterKeys,
-  rejectKeys,
-  rejectEmptyObjectsInArray = true,
-  sortKeys = "simpleValuesFirst",
-  sortPatterns
-}) {
-  function getNestedValue(obj, path) {
-    const parts = path.split(".");
-    let current = obj;
-    for (const part of parts) {
-      if (current == null || typeof current !== "object") {
-        return void 0;
-      }
-      current = current[part];
-    }
-    return current;
-  }
-  function evaluateCondition(item, condition) {
-    const value = getNestedValue(item, condition.property);
-    let valueStr = String(value);
-    if (condition.caseInsensitive) {
-      valueStr = valueStr.toLowerCase();
-    }
-    const processValue = (v) => condition.caseInsensitive ? v.toLowerCase() : v;
-    switch (condition.operator) {
-      case "=":
-        return condition.values.some((v) => valueStr === processValue(v));
-      case "!=":
-        return condition.values.every((v) => valueStr !== processValue(v));
-      case "*=":
-        return condition.values.some((v) => valueStr.includes(processValue(v)));
-      case "!*=":
-        return condition.values.every(
-          (v) => !valueStr.includes(processValue(v))
-        );
-      case "^=":
-        return condition.values.some(
-          (v) => valueStr.startsWith(processValue(v))
-        );
-      case "!^=":
-        return condition.values.every(
-          (v) => !valueStr.startsWith(processValue(v))
-        );
-      case "$=":
-        return condition.values.some((v) => valueStr.endsWith(processValue(v)));
-      case "!$=":
-        return condition.values.every(
-          (v) => !valueStr.endsWith(processValue(v))
-        );
-      default:
-        return false;
-    }
-  }
-  const toArray = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
-  const filterPatternsRaw = toArray(filterKeys);
-  const rejectPatternsRaw = toArray(rejectKeys);
-  const hasFilters = filterPatternsRaw.length > 0;
-  const hasRejects = rejectPatternsRaw.length > 0;
-  const expandedFilterPatterns = filterPatternsRaw.flatMap(expandPatterns);
-  const expandedRejectPatterns = rejectPatternsRaw.flatMap(expandPatterns);
-  const { filterOnlyPatterns, combinedPatterns } = separateFilterPatterns(
-    expandedFilterPatterns
-  );
-  const filterPatterns = filterOnlyPatterns.map(parsePattern);
-  const rejectPatterns = expandedRejectPatterns.map(parsePattern);
-  const sortPatternsRaw = toArray(sortPatterns);
-  const expandedSortPatterns = sortPatternsRaw.flatMap(expandPatterns);
-  const sortPatternsParsed = expandedSortPatterns.map(parsePattern);
-  let dataToProcess = objOrArray;
-  if (combinedPatterns.length > 0) {
-    const groupedByFilter = /* @__PURE__ */ new Map();
-    for (const { filterPart, fieldPart } of combinedPatterns) {
-      if (!groupedByFilter.has(filterPart)) {
-        groupedByFilter.set(filterPart, []);
-      }
-      groupedByFilter.get(filterPart).push(fieldPart);
-    }
-    const combinedResult = Array.isArray(objOrArray) ? [] : {};
-    for (const [filterPart, fieldParts] of groupedByFilter) {
-      const filteredResult = filterObjectOrArrayKeys(objOrArray, {
-        filterKeys: [filterPart],
-        rejectKeys,
-        rejectEmptyObjectsInArray
-      });
-      const fieldSelectedResult = filterObjectOrArrayKeys(filteredResult, {
-        filterKeys: fieldParts,
-        rejectEmptyObjectsInArray
-      });
-      if (Array.isArray(combinedResult) && Array.isArray(fieldSelectedResult)) {
-        combinedResult.push(...fieldSelectedResult);
-      } else if (!Array.isArray(combinedResult) && !Array.isArray(fieldSelectedResult)) {
-        Object.assign(combinedResult, fieldSelectedResult);
-      }
-    }
-    if (filterOnlyPatterns.length === 0) {
-      return combinedResult;
-    }
-    dataToProcess = combinedResult;
-  }
-  function matchPath(path, pattern, value) {
-    function rec(pi, pti) {
-      if (pti >= pattern.length) return pi === path.length;
-      const pt = pattern[pti];
-      if (pt.type === "WILDCARD_ANY") {
-        if (rec(pi, pti + 1)) return true;
-        if (pi < path.length) return rec(pi + 1, pti);
-        return false;
-      }
-      if (pt.type === "WILDCARD_ONE") {
-        let j = pi;
-        let sawKey = false;
-        while (j < path.length) {
-          if (path[j].type === "KEY") sawKey = true;
-          if (sawKey && rec(j, pti + 1)) return true;
-          j += 1;
-        }
-        return false;
-      }
-      if (pi >= path.length) return false;
-      const ct = path[pi];
-      switch (pt.type) {
-        case "KEY":
-          if (ct.type === "KEY" && ct.name === pt.name)
-            return rec(pi + 1, pti + 1);
-          if (ct.type === "INDEX") return rec(pi + 1, pti);
-          return false;
-        case "INDEX":
-          if (ct.type === "INDEX" && ct.index === pt.index)
-            return rec(pi + 1, pti + 1);
-          return false;
-        case "INDEX_ANY":
-          if (ct.type === "INDEX") return rec(pi + 1, pti + 1);
-          return false;
-        case "INDEX_RANGE":
-          if (ct.type === "INDEX") {
-            const okLower = ct.index >= pt.start;
-            const okUpper = pt.end === null ? true : ct.index <= pt.end;
-            if (okLower && okUpper) return rec(pi + 1, pti + 1);
-          }
-          return false;
-        case "INDEX_FILTER":
-          if (ct.type === "INDEX" && value !== void 0) {
-            const results = pt.conditions.map(
-              (cond) => evaluateCondition(value, cond)
-            );
-            const matches = pt.logic === "AND" ? results.every((r) => r) : results.some((r) => r);
-            if (matches) return rec(pi + 1, pti + 1);
-          }
-          return false;
-      }
-    }
-    return rec(0, 0);
-  }
-  const matchesAnyFilter = (path, value) => filterPatterns.some((p) => matchPath(path, p, value));
-  const matchesAnyReject = (path, value) => rejectPatterns.some((p) => matchPath(path, p, value));
-  function getSortPriority(path) {
-    for (let i = 0; i < sortPatternsParsed.length; i++) {
-      if (matchPath(path, sortPatternsParsed[i])) {
-        return i;
-      }
-    }
-    return sortPatternsParsed.length;
-  }
-  function applySortKeys(keys, obj, sortOrder) {
-    if (sortOrder === "asc") {
-      return [...keys].sort();
-    }
-    if (sortOrder === "desc") {
-      return [...keys].sort().reverse();
-    }
-    return sortBy(
-      sortBy(keys, (k) => k),
-      (key) => {
-        const value = obj[key];
-        if (value !== void 0 && value !== null) {
-          if (Array.isArray(value) && value.length === 0) return 0;
-          if (isPlainObject(value)) {
-            const objLength = Object.keys(value).length;
-            return 1.99 + objLength * -1e-3;
-          }
-          if (Array.isArray(value)) {
-            const allItemsArePrimitives = value.every(
-              (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null || item === void 0
-            );
-            if (allItemsArePrimitives) {
-              return 1.9 + value.length * -1e-3;
-            } else {
-              return 1.5 + value.length * -0.01;
-            }
-          }
-          if (key === "id" || key === "key") return 5;
-          if (ID_PROP_REGEXP.test(key)) return 4.5;
-          if (typeof value === "boolean") return 4;
-          if (typeof value === "number") return 3.5;
-          if (typeof value === "string" && value.length < 20) return 3;
-          return 2;
-        }
-        return 0;
-      },
-      "desc"
-    );
-  }
-  function sortKeysWithPatterns(keys_, obj, currentPath) {
-    if (!sortKeys && sortPatternsParsed.length === 0) {
-      return keys_;
-    }
-    let keysToSort = keys_;
-    if (sortKeys) {
-      keysToSort = applySortKeys(keysToSort, obj, sortKeys);
-    }
-    const sortedKeys = [...keysToSort].sort((a, b) => {
-      const pathA = currentPath.concat({ type: "KEY", name: a });
-      const pathB = currentPath.concat({ type: "KEY", name: b });
-      const priorityA = getSortPriority(pathA);
-      const priorityB = getSortPriority(pathB);
-      if (priorityA !== priorityB) {
-        return priorityA - priorityB;
-      }
-      if (sortKeys === "desc") {
-        return b.localeCompare(a);
-      }
-      if (sortKeys === "asc") {
-        return a.localeCompare(b);
-      }
-      return 0;
-    });
-    return sortedKeys;
-  }
-  const build = (value, path, allowedByFilter, stack2, isRoot, parentIsArray) => {
-    if (Array.isArray(value)) {
-      if (stack2.has(value)) {
-        throw new TypeError("Circular references are not supported");
-      }
-      stack2.add(value);
-      const out = [];
-      const includeAllChildren = allowedByFilter || !hasFilters;
-      for (let index = 0; index < value.length; index += 1) {
-        const childPath = path.concat({ type: "INDEX", index });
-        const child = value[index];
-        if (hasRejects && matchesAnyReject(childPath, child)) continue;
-        const directInclude = hasFilters ? matchesAnyFilter(childPath, child) : true;
-        const childAllowed = includeAllChildren || directInclude;
-        if (isPlainObject(child) || Array.isArray(child)) {
-          const builtChild = build(
-            child,
-            childPath,
-            childAllowed,
-            stack2,
-            false,
-            true
-          );
-          if (builtChild !== void 0) {
-            out.push(builtChild);
-          }
-        } else {
-          if (childAllowed) {
-            out.push(child);
-          }
-        }
-      }
-      stack2.delete(value);
-      const filteredOut = rejectEmptyObjectsInArray ? out.filter(
-        (item) => !(isPlainObject(item) && Object.keys(item).length === 0)
-      ) : out;
-      if (filteredOut.length === 0 && !allowedByFilter && !isRoot)
-        return void 0;
-      return filteredOut;
-    }
-    if (isPlainObject(value)) {
-      if (stack2.has(value)) {
-        throw new TypeError("Circular references are not supported");
-      }
-      stack2.add(value);
-      const result = {};
-      const includeAllChildren = allowedByFilter || !hasFilters;
-      const sortedKeys = sortKeysWithPatterns(Object.keys(value), value, path);
-      for (const key of sortedKeys) {
-        const childPath = path.concat({ type: "KEY", name: key });
-        if (hasRejects && matchesAnyReject(childPath)) continue;
-        const val = value[key];
-        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
-        const childAllowed = includeAllChildren || directInclude;
-        if (isPlainObject(val) || Array.isArray(val)) {
-          const builtChild = build(
-            val,
-            childPath,
-            childAllowed,
-            stack2,
-            false,
-            false
-          );
-          if (builtChild === void 0) {
-            continue;
-          }
-          if (Array.isArray(builtChild) && builtChild.length === 0 && !childAllowed) {
-            continue;
-          }
-          if (isPlainObject(builtChild) && Object.keys(builtChild).length === 0 && !childAllowed) {
-            continue;
-          }
-          result[key] = builtChild;
-        } else {
-          if (childAllowed) {
-            result[key] = val;
-          }
-        }
-      }
-      stack2.delete(value);
-      if (Object.keys(result).length === 0 && !allowedByFilter && !isRoot) {
-        if (parentIsArray && !rejectEmptyObjectsInArray) {
-          return {};
-        }
-        return void 0;
-      }
-      return result;
-    }
-    return allowedByFilter || !hasFilters ? value : void 0;
-  };
-  const startPath = [];
-  const initialAllowed = !hasFilters;
-  const stack = /* @__PURE__ */ new WeakSet();
-  const built = build(
-    dataToProcess,
-    startPath,
-    initialAllowed,
-    stack,
-    true,
-    false
-  );
-  if (built === void 0) return Array.isArray(dataToProcess) ? [] : {};
-  return built;
-}
-function parseFilterConditions(filterContent) {
-  const conditions = [];
-  let logic = "AND";
-  const caseInsensitive = filterContent.startsWith("i");
-  const content = caseInsensitive ? filterContent.slice(1) : filterContent;
-  const hasAnd = content.includes("&&");
-  const hasOr = content.includes(" || ");
-  if (hasAnd && hasOr) {
-    throw new Error(
-      "Mixing && and || operators in the same filter is not supported. Use separate filter patterns instead."
-    );
-  }
-  const andGroups = content.split("&&").map((s) => s.trim());
-  for (const andGroup of andGroups) {
-    if (andGroup.includes(" || ")) {
-      logic = "OR";
-      const orConditions = andGroup.split(" || ").map((s) => s.trim());
-      for (const orCondition of orConditions) {
-        const parsed = parseSingleCondition(orCondition, caseInsensitive);
-        if (parsed) {
-          conditions.push(parsed);
-        }
-      }
-    } else {
-      const parsed = parseSingleCondition(andGroup, caseInsensitive);
-      if (parsed) {
-        conditions.push(parsed);
-      }
-    }
-  }
-  if (conditions.length === 0) {
-    return null;
-  }
-  return {
-    type: "INDEX_FILTER",
-    conditions,
-    logic
-  };
-}
-function parseSingleCondition(condition, caseInsensitive = false) {
-  const cleanCondition = condition.startsWith("%") ? condition.slice(1) : condition;
-  let operator = null;
-  let operatorIndex = -1;
-  let operatorLength = 0;
-  const operators = [
-    ["!*=", "!*="],
-    ["!^=", "!^="],
-    ["!$=", "!$="],
-    ["!=", "!="],
-    ["*=", "*="],
-    ["^=", "^="],
-    ["$=", "$="],
-    ["=", "="]
-  ];
-  for (const [op, opType] of operators) {
-    const index = cleanCondition.indexOf(op);
-    if (index !== -1) {
-      operator = opType;
-      operatorIndex = index;
-      operatorLength = op.length;
-      break;
-    }
-  }
-  if (operator === null || operatorIndex === -1) {
-    return null;
-  }
-  const property = cleanCondition.slice(0, operatorIndex).trim();
-  const valueStr = cleanCondition.slice(operatorIndex + operatorLength).trim();
-  const values = [];
-  if (valueStr.includes(" | ")) {
-    const parts = valueStr.split(" | ");
-    for (const part of parts) {
-      const trimmed = part.trim();
-      const value = trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1) : trimmed;
-      values.push(value);
-    }
-  } else {
-    const trimmed = valueStr.trim();
-    const value = trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1) : trimmed;
-    values.push(value);
-  }
-  return {
-    property,
-    operator,
-    values,
-    caseInsensitive
-  };
-}
-function separateFilterPatterns(patterns) {
-  const filterOnlyPatterns = [];
-  const combinedPatterns = [];
-  for (const pattern of patterns) {
-    const filterMatch = pattern.match(/^(.+\[[i%][^[\]]*\])\.(.+)$/);
-    if (filterMatch?.[1] && filterMatch[2]) {
-      const filterPart = filterMatch[1];
-      const fieldPart = filterMatch[2];
-      const baseArrayPath = filterPart.replace(/\[[i%][^[\]]*\]/, "[*]");
-      combinedPatterns.push({
-        filterPart,
-        fieldPart: `${baseArrayPath}.${fieldPart}`
-      });
-    } else {
-      filterOnlyPatterns.push(pattern);
-    }
-  }
-  return { filterOnlyPatterns, combinedPatterns };
-}
-function expandPatterns(pattern) {
-  function expandSingle(str) {
-    const start = str.indexOf("(");
-    if (start === -1) {
-      return [str];
-    }
-    const end = str.indexOf(")", start);
-    if (end === -1) {
-      return [str];
-    }
-    const before = str.slice(0, start);
-    const inside = str.slice(start + 1, end);
-    const after = str.slice(end + 1);
-    if (!inside.includes("|")) {
-      return expandSingle(before + inside + after);
-    }
-    const options = inside.split("|").filter((option) => option.trim().length > 0);
-    const results = [];
-    for (const option of options) {
-      const newStr = before + option + after;
-      results.push(...expandSingle(newStr));
-    }
-    return results;
-  }
-  return expandSingle(pattern);
-}
-function parsePattern(pattern) {
-  const tokens = [];
-  let i = 0;
-  const n = pattern.length;
-  const pushKey = (name) => {
-    if (name.length === 0) return;
-    tokens.push({ type: "KEY", name });
-  };
-  while (i < n) {
-    const ch = pattern[i];
-    if (ch === ".") {
-      i += 1;
-      continue;
-    }
-    if (ch === "[") {
-      const end = pattern.indexOf("]", i + 1);
-      const inside = end === -1 ? pattern.slice(i + 1) : pattern.slice(i + 1, end);
-      if (inside.startsWith("%") || inside.startsWith("i%")) {
-        let filterContent;
-        if (inside.startsWith("i%")) {
-          filterContent = `i${inside.slice(2)}`;
-        } else if (inside.startsWith("%")) {
-          filterContent = inside.slice(1);
-        } else {
-          filterContent = inside;
-        }
-        const filterToken = parseFilterConditions(filterContent);
-        if (filterToken) {
-          tokens.push(filterToken);
-        }
-      } else if (inside === "*") {
-        tokens.push({ type: "INDEX_ANY" });
-      } else if (inside.includes("-")) {
-        const parts = inside.split("-");
-        const startStr = parts[0] ?? "";
-        const endStr = parts[1] ?? "";
-        const start = parseInt(startStr, 10);
-        const endNum = endStr === "*" ? null : parseInt(endStr, 10);
-        tokens.push({
-          type: "INDEX_RANGE",
-          start,
-          end: endNum === null || Number.isFinite(endNum) ? endNum : null
-        });
-      } else if (inside.length > 0) {
-        const idx = parseInt(inside, 10);
-        tokens.push({ type: "INDEX", index: idx });
-      }
-      i = end === -1 ? n : end + 1;
-      continue;
-    }
-    if (ch === "*") {
-      if (pattern[i + 1] === "*") {
-        tokens.push({ type: "WILDCARD_ANY" });
-        i += 2;
-        let j2 = i;
-        while (j2 < n) {
-          const c = pattern[j2];
-          if (c === "." || c === "[") break;
-          j2 += 1;
-        }
-        if (j2 > i) {
-          pushKey(pattern.slice(i, j2));
-          i = j2;
-        }
-        continue;
-      } else {
-        tokens.push({ type: "WILDCARD_ONE" });
-        i += 1;
-        continue;
-      }
-    }
-    let j = i;
-    while (j < n) {
-      const c = pattern[j];
-      if (c === "." || c === "[") break;
-      j += 1;
-    }
-    pushKey(pattern.slice(i, j));
-    i = j;
-  }
-  return tokens;
-}
-
-// src/mathUtils.ts
-function clampMin(value, min) {
-  return value < min ? min : value;
-}
-
-// src/objUtils.ts
-var import_t_result = require("t-result");
-function pick(obj, keys) {
-  const result = {};
-  for (const key of keys) {
-    result[key] = obj[key];
-  }
-  return result;
-}
-function omit(obj, keys) {
-  const result = {};
-  for (const key of Object.keys(obj)) {
-    if (!keys.includes(key)) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-
-// src/promiseUtils.ts
-function defer() {
-  let resolve;
-  let reject;
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  return { resolve, reject, promise };
-}
-
-// src/conversions.ts
-function bytesToHumanReadable(bytes) {
-  if (bytes < 1024) {
-    return `${bytes} B`;
-  }
-  const kb = bytes / 1024;
-  if (kb < 1024) {
-    return `${kb.toFixed(2)} KB`;
-  }
-  const mb = kb / 1024;
-  if (mb < 1024) {
-    return `${mb.toFixed(2)} MB`;
-  }
-  const gb = mb / 1024;
-  return `${gb.toFixed(2)} GB`;
-}
-
-// src/stringUtils.ts
-function truncateString(str, length, ellipsis = "\u2026") {
-  if (str.length <= length) return str;
-  return str.slice(0, length - 1) + ellipsis;
-}
-
-// src/yamlStringify.ts
-function yamlStringify(obj, {
-  maxLineLength = 100,
-  showUndefined,
-  maxDepth = 50,
-  collapseObjects = false,
-  addRootObjSpaces = "beforeAndAfter"
-} = {}) {
-  if (isObject(obj) || Array.isArray(obj) || typeof obj === "function") {
-    return `${stringifyValue(obj, "", maxLineLength, !!showUndefined, maxDepth, 0, collapseObjects, addRootObjSpaces, false)}
-`;
-  }
-  return JSON.stringify(obj) || "undefined";
-}
-function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, depth, collapseObjects, addObjSpaces, isArrayItem) {
-  let result = "";
-  const childIndent = `${indent}  `;
-  if (isPlainObject(value)) {
-    if (Object.keys(value).length === 0) {
-      return "{}";
-    }
-    if (collapseObjects && depth > 0) {
-      const entries = Object.entries(value).filter(
-        ([, val]) => val !== void 0 || showUndefined
-      );
-      const isSimpleObject = entries.every(([, val]) => {
-        if (typeof val === "string") {
-          return !val.includes("'") && !val.includes('"') && !val.includes("\\");
-        }
-        return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
-      });
-      const shouldCollapse = isArrayItem ? entries.length > 1 : entries.length > 0;
-      if (isSimpleObject && shouldCollapse) {
-        let line = "{ ";
-        line += entries.map(([key, val]) => {
-          let valueStr;
-          if (typeof val === "string") {
-            if (val.includes("'") && !val.includes('"')) {
-              valueStr = `"${val}"`;
-            } else if (val.includes('"') && !val.includes("'")) {
-              valueStr = `'${val}'`;
-            } else if (val.includes("'") && val.includes('"')) {
-              valueStr = `"${val.replace(/"/g, '\\"')}"`;
-            } else {
-              valueStr = `'${val}'`;
-            }
-          } else {
-            valueStr = String(val);
-          }
-          return `${key}: ${valueStr}`;
-        }).join(", ");
-        line += " }";
-        if (line.length <= maxLineLength) {
-          return line;
-        }
-      }
-    }
-    let prevValue;
-    let afterSpaceWasAdded = false;
-    for (let [key, objVal] of Object.entries(value)) {
-      if (objVal === void 0 && !showUndefined) {
-        continue;
-      }
-      if (depth > maxDepth) {
-        objVal = `{max depth reached}`;
-      }
-      const normalizedValue2 = normalizeValue(objVal);
-      if (normalizedValue2 !== null) {
-        objVal = normalizedValue2[1];
-        key = `${key}{${normalizedValue2[0]}}`;
-      }
-      const valueString = stringifyValue(
-        objVal,
-        childIndent,
-        maxLineLength,
-        showUndefined,
-        maxDepth,
-        depth + 1,
-        collapseObjects,
-        addObjSpaces,
-        false
-      );
-      const willBeCollapsed = isObject(objVal) && (Object.keys(objVal).length === 0 || collapseObjects && depth + 1 > 0 && (() => {
-        const filteredEntries = Object.entries(objVal).filter(
-          ([, val]) => val !== void 0 || showUndefined
-        );
-        const shouldCollapseThis = isArrayItem ? filteredEntries.length > 1 : filteredEntries.length > 0;
-        return shouldCollapseThis && filteredEntries.every(([, val]) => {
-          if (typeof val === "string") {
-            return !val.includes("'") && !val.includes('"') && !val.includes("\\");
-          }
-          return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
-        });
-      })());
-      const prevWasCollapsed = prevValue && isObject(prevValue) && (Object.keys(prevValue).length === 0 || collapseObjects && depth + 1 > 0 && (() => {
-        const filteredEntries = Object.entries(prevValue).filter(
-          ([, val]) => val !== void 0 || showUndefined
-        );
-        const shouldCollapseThis = isArrayItem ? filteredEntries.length > 1 : filteredEntries.length > 0;
-        return shouldCollapseThis && filteredEntries.every(([, val]) => {
-          if (typeof val === "string") {
-            return !val.includes("'") && !val.includes('"') && !val.includes("\\");
-          }
-          return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
-        });
-      })());
-      if (!afterSpaceWasAdded && indent === "" && isObject(objVal) && !willBeCollapsed && prevValue && !prevWasCollapsed && (addObjSpaces === "before" || addObjSpaces === "beforeAndAfter")) {
-        result += "\n";
-      }
-      if (Array.isArray(objVal)) {
-        const arrayIsSingleLine = valueString.split("\n").length === 1;
-        if (arrayIsSingleLine && !valueString.trim().startsWith("-")) {
-          result += `${indent}${key}: `;
-        } else {
-          result += `${indent}${key}:
-`;
-        }
-      } else if (isObject(objVal)) {
-        const isCollapsedObject = valueString.startsWith("{") && !valueString.includes("\n");
-        if (Object.keys(objVal).length === 0 || isCollapsedObject) {
-          result += `${indent}${key}: `;
-        } else {
-          result += `${indent}${key}:
-`;
-        }
-      } else {
-        result += `${indent}${key}: `;
-      }
-      result += valueString;
-      result += "\n";
-      if (indent === "") {
-        const isCollapsedObject = valueString.startsWith("{") && !valueString.includes("\n") && valueString.length > 2;
-        if (isObject(objVal) && !isCollapsedObject) {
-          if (addObjSpaces === "after" || addObjSpaces === "beforeAndAfter") {
-            result += "\n";
-            afterSpaceWasAdded = true;
-          } else {
-            afterSpaceWasAdded = false;
-          }
-        }
-      }
-      prevValue = objVal;
-    }
-    return result.trimEnd();
-  }
-  if (Array.isArray(value)) {
-    let arrayWasAdded = false;
-    if (value.length === 0 || value.every(
-      (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null || item === void 0
-    )) {
-      let line = "";
-      line += `[`;
-      line += value.map((item) => {
-        let valueToUse = item;
-        if (depth > maxDepth) {
-          valueToUse = `{max depth reached}`;
-        }
-        if (typeof valueToUse === "string" && valueToUse.includes("\n")) {
-          valueToUse = valueToUse.replace(/\n/g, "\\n");
-        }
-        return stringifyValue(
-          valueToUse,
-          "",
-          maxLineLength,
-          showUndefined,
-          maxDepth,
-          depth + 1,
-          collapseObjects,
-          addObjSpaces,
-          true
-        );
-      }).join(", ");
-      line += "]";
-      if (line.length <= maxLineLength) {
-        result += line;
-        arrayWasAdded = true;
-      }
-    }
-    if (!arrayWasAdded) {
-      for (let item of value) {
-        if (depth > maxDepth) {
-          item = `{max depth reached}`;
-        }
-        result += `${indent}- `;
-        if (Array.isArray(item) || isObject(item)) {
-          let arrayString = stringifyValue(
-            item,
-            childIndent,
-            maxLineLength,
-            showUndefined,
-            maxDepth,
-            depth + 1,
-            collapseObjects,
-            addObjSpaces,
-            true
-          );
-          arrayString = arrayString.trimStart();
-          result += arrayString;
-        } else {
-          result += stringifyValue(
-            item,
-            childIndent,
-            maxLineLength,
-            showUndefined,
-            maxDepth,
-            depth + 1,
-            collapseObjects,
-            addObjSpaces,
-            true
-          );
-        }
-        result += "\n";
-      }
-    }
-    return result.trimEnd();
-  }
-  if (typeof value === "string") {
-    if (value.includes("\n")) {
-      const lines = value.split("\n");
-      for (const [i, line] of lines.entries()) {
-        if (i === 0) {
-          if (value.endsWith("\n")) {
-            result += `|`;
-          } else {
-            result += `|-`;
-          }
-          result += `
-${indent}${line}
-`;
-        } else {
-          result += `${indent}${line}
-`;
-        }
-      }
-    } else {
-      if (value.includes("'") && !value.includes('"')) {
-        result += `"${value}"`;
-      } else if (value.includes('"') && !value.includes("'")) {
-        result += `'${value}'`;
-      } else if (value.includes("'") && value.includes('"')) {
-        result += `"${value.replace(/"/g, '\\"')}"`;
-      } else {
-        result += `'${value}'`;
-      }
-    }
-    return result.trimEnd();
-  }
-  if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
-    return String(value).trimEnd();
-  }
-  const normalizedValue = normalizeValue(value);
-  if (normalizedValue !== null) {
-    return stringifyValue(
-      {
-        [`${normalizedValue[0]}#`]: normalizedValue[1]
-      },
-      indent,
-      maxLineLength,
-      showUndefined,
-      maxDepth,
-      depth + 1,
-      collapseObjects,
-      addObjSpaces,
-      false
-    );
-  }
-  return JSON.stringify(value);
-}
-function normalizeValue(value) {
-  if (value === null || isPlainObject(value) || Array.isArray(value)) {
-    return null;
-  }
-  if (value instanceof Map) {
-    const mapEntries = Array.from(value.entries());
-    let mapValue;
-    if (mapEntries.every(([key]) => typeof key === "string")) {
-      const mapObjValue = {};
-      for (const [key, val] of mapEntries) {
-        mapObjValue[key] = val;
-      }
-      mapValue = mapObjValue;
-    } else {
-      mapValue = mapEntries.map(([key, val]) => ({
-        key,
-        value: val
-      }));
-    }
-    return ["Map", mapValue];
-  }
-  if (value instanceof Set) {
-    const setValue = Array.from(value);
-    return ["Set", setValue];
-  }
-  if (value instanceof Date) {
-    return ["Date", value.toISOString()];
-  }
-  if (value instanceof RegExp) {
-    return ["RegExp", value.toString()];
-  }
-  if (value instanceof Error) {
-    return [
-      "Error",
-      {
-        message: value.message,
-        name: value.name,
-        stack: value.stack
-      }
-    ];
-  }
-  if (value instanceof File) {
-    return [
-      "File",
-      {
-        name: value.name,
-        type: value.type,
-        lastModified: new Date(value.lastModified).toISOString(),
-        size: bytesToHumanReadable(value.size)
-      }
-    ];
-  }
-  if (typeof value === "object") {
-    if ("toJSON" in value && typeof value.toJSON === "function") {
-      return [value.constructor.name, value.toJSON()];
-    }
-    if ("toString" in value && typeof value.toString === "function") {
-      const stringValue = value.toString();
-      if (stringValue.toString() !== "[object Object]") {
-        return [value.constructor.name, stringValue];
-      }
-    }
-    const objectValue = { ...value };
-    const displayValue = {};
-    let addedKeys = 0;
-    for (const [key, item] of Object.entries(objectValue)) {
-      if (addedKeys > 4) {
-        displayValue["...and more properties"] = Object.keys(objectValue).length - 4;
-        break;
-      }
-      if (typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null || item === void 0) {
-        displayValue[key] = item;
-        addedKeys++;
-      }
-    }
-    return [String(value.constructor.name), displayValue];
-  }
-  if (typeof value === "function") {
-    const functionString = value.toString();
-    return [
-      `Function`,
-      functionString.includes("\n") ? truncateString(functionString.split("\n").join(""), 40) : functionString
-    ];
-  }
-  return null;
-}
-
-// src/testUtils.ts
-function createLoggerStore({
-  filterKeys: defaultFilterKeys,
-  rejectKeys: defaultRejectKeys,
-  splitLongLines: defaultSplitLongLines = true,
-  maxLineLengthBeforeSplit: defaultMaxLineLengthBeforeSplit = 80,
-  fromLastSnapshot: defaultFromLastSnapshot = false,
-  arrays: defaultArrays = { firstNItems: 1 },
-  changesOnly: defaultChangesOnly = false,
-  useEmojiForBooleans: defaultUseEmojiForBooleans = true
-} = {}) {
-  let logs = [];
-  let logsTime = [];
-  let startTime = Date.now();
-  let onNextLog = () => {
-  };
-  function reset(keepLastRender = false) {
-    logs = keepLastRender ? [logs.at(-1)] : [];
-    logsTime = [];
-    startTime = Date.now();
-  }
-  function add(render) {
-    if (!isObject2(render)) {
-      for (const [i, r] of render.entries()) {
-        logs.push({
-          i: i + 1,
-          ...r
-        });
-        logsTime.push(Date.now() - startTime);
-      }
-    } else {
-      logs.push(render);
-      logsTime.push(Date.now() - startTime);
-    }
-    onNextLog();
-    if (logs.length > 100) {
-      throw new Error("Too many logs");
-    }
-  }
-  function logsCount() {
-    return logs.filter((item) => !item._lastSnapshotMark).length;
-  }
-  async function waitNextLog(timeout = 50) {
-    return new Promise((resolve) => {
-      const timeoutId = setTimeout(() => {
-        throw new Error("Timeout");
-      }, timeout);
-      onNextLog = () => {
-        clearTimeout(timeoutId);
-        resolve();
-      };
-    });
-  }
-  function getSnapshot({
-    arrays = defaultArrays,
-    changesOnly = defaultChangesOnly,
-    filterKeys = defaultFilterKeys,
-    rejectKeys = defaultRejectKeys,
-    includeLastSnapshotEndMark = true,
-    splitLongLines = defaultSplitLongLines,
-    maxLineLengthBeforeSplit = defaultMaxLineLengthBeforeSplit,
-    fromLastSnapshot = defaultFromLastSnapshot,
-    useEmojiForBooleans = defaultUseEmojiForBooleans
-  } = {}) {
-    let rendersToUse = logs;
-    if (changesOnly || filterKeys || rejectKeys) {
-      rendersToUse = [];
-      for (let { item, prev } of arrayWithPrevAndIndex(logs)) {
-        if (item._lastSnapshotMark || item._mark) {
-          rendersToUse.push(item);
-          continue;
-        }
-        if (filterKeys) {
-          prev = prev && pick(prev, filterKeys);
-          item = pick(item, filterKeys);
-        }
-        if (rejectKeys) {
-          prev = prev && omit(prev, rejectKeys);
-          item = omit(item, rejectKeys);
-        }
-        if (!deepEqual(prev, item)) {
-          rendersToUse.push(item);
-        }
-      }
-    }
-    if (fromLastSnapshot) {
-      const lastSnapshotMark = rendersToUse.findLastIndex(
-        (item) => item._lastSnapshotMark === true
-      );
-      rendersToUse = rendersToUse.slice(clampMin(lastSnapshotMark, 0));
-    }
-    logs.push({ _lastSnapshotMark: true });
-    const propDivider = "\u22C5";
-    const snapShot = `
-${filterAndMap(rendersToUse, (render, i) => {
-      if (render._lastSnapshotMark) {
-        if (includeLastSnapshotEndMark) {
-          if (rendersToUse.length === 1) {
-            return "\u22C5\u22C5\u22C5";
-          }
-          if (i !== rendersToUse.length - 1) {
-            return "\u22C5\u22C5\u22C5";
-          }
-          return false;
-        } else {
-          return false;
-        }
-      }
-      if (render._mark) {
-        const prevIsLastSnapshotMark = rendersToUse[i - 1]?._lastSnapshotMark;
-        let mark = `${prevIsLastSnapshotMark ? "" : "\n"}>>> ${String(render._mark)}`;
-        const nextRender = rendersToUse[i + 1];
-        if (nextRender && !nextRender._mark && !nextRender._lastSnapshotMark) {
-          mark = `${mark}
-`;
-        }
-        return mark;
-      }
-      let line = "";
-      for (const [key, _value] of Object.entries(render)) {
-        let value = _value;
-        if (Array.isArray(value)) {
-          if (arrays === "length") {
-            value = `Array(${value.length})`;
-          } else if (arrays === "firstAndLast" && value.length > 2) {
-            const intermediateSize = clampMin(value.length - 2, 0);
-            value = [value[0], `\u2026(${intermediateSize} between)`, value.at(-1)];
-          } else if (typeof arrays === "object" && value.length > 2) {
-            value = [
-              ...value.slice(0, arrays.firstNItems),
-              `\u2026(${value.length - arrays.firstNItems} more)`
-            ];
-          }
-        }
-        if (typeof value === "boolean" && useEmojiForBooleans) {
-          value = value ? "\u2705" : "\u274C";
-        }
-        if (value === "") {
-          value = `''`;
-        }
-        if (typeof value === "object" && value !== null) {
-          value = JSON.stringify(value).replace(/:true/g, ":\u2705").replace(/:false/g, ":\u274C").replace(/:""/g, ":''").replace(/"/g, "").replace(/,/g, ", ");
-        }
-        line += `${key}: ${value} ${propDivider} `;
-      }
-      line = line.slice(0, (propDivider.length + 2) * -1);
-      if (splitLongLines && line.length > maxLineLengthBeforeSplit) {
-        const parts = line.split(` ${propDivider} `);
-        if (parts.length === 1) {
-          return line;
-        }
-        line = "";
-        const propDividerML = "\u22C5";
-        for (const { item, index } of arrayWithPrevAndIndex(parts)) {
-          if (index === 0) {
-            line += `\u250C\u2500
-${propDividerML} `;
-          } else if (index === parts.length - 1) {
-            line += `${propDividerML} `;
-          } else {
-            line += `${propDividerML} `;
-          }
-          line += `${item}
-`;
-          if (index === parts.length - 1) {
-            line += "\u2514\u2500";
-          }
-        }
-      } else {
-        line = `-> ${line}`;
-      }
-      return line;
-    }).join("\n")}
-`;
-    return snapShot === `
-\u22C5\u22C5\u22C5
-` ? "\u22C5\u22C5\u22C5empty\u22C5\u22C5\u22C5" : snapShot;
-  }
-  function addMark(label) {
-    add({ _mark: label });
-  }
-  return {
-    add,
-    reset,
-    getSnapshot,
-    waitNextLog,
-    get changesSnapshot() {
-      return getSnapshot({ changesOnly: true });
-    },
-    get snapshot() {
-      return getSnapshot();
-    },
-    get snapshotFromLast() {
-      return getSnapshot({ fromLastSnapshot: true });
-    },
-    logsCount,
-    get rendersTime() {
-      return logsTime;
-    },
-    addMark
-  };
-}
-function getResultFn(fnGetter, wrapper) {
-  return (...args) => {
-    const fn = fnGetter();
-    if (wrapper) {
-      return wrapper(fn(...args));
-    } else {
-      return fn(...args);
-    }
-  };
-}
-function waitController() {
-  const { promise, resolve } = defer();
-  return {
-    wait: promise,
-    stopWaiting: () => {
-      resolve();
-    },
-    stopWaitingAfter: (ms) => {
-      setTimeout(() => {
-        resolve();
-      }, ms);
-    }
-  };
-}
-function compactSnapshot(value, {
-  collapseObjects = true,
-  maxLineLength = 100,
-  showUndefined = false,
-  showBooleansAs = true,
-  replaceValues,
-  rejectKeys,
-  filterKeys,
-  sortKeys,
-  sortPatterns,
-  ...options
-} = {}) {
-  let processedValue = value;
-  if (rejectKeys || filterKeys) {
-    if (isPlainObject(processedValue) || Array.isArray(processedValue)) {
-      processedValue = filterObjectOrArrayKeys(processedValue, {
-        rejectKeys,
-        filterKeys,
-        sortKeys,
-        sortPatterns
-      });
-    }
-  }
-  if (replaceValues) {
-    processedValue = deepReplaceValues(processedValue, replaceValues);
-  }
-  processedValue = showBooleansAs ? replaceBooleansWithEmoji(processedValue, showBooleansAs) : processedValue;
-  return `
-${yamlStringify(processedValue, {
-    collapseObjects,
-    maxLineLength,
-    showUndefined,
-    ...options
-  })}`;
-}
-function replaceBooleansWithEmoji(value, showBooleansAs, visited = /* @__PURE__ */ new Set()) {
-  if (showBooleansAs === false) {
-    return value;
-  }
-  const defaultTrueText = "\u2705";
-  const defaultFalseText = "\u274C";
-  const config = typeof showBooleansAs === "boolean" ? { trueText: defaultTrueText, falseText: defaultFalseText } : {
-    trueText: showBooleansAs.trueText ?? defaultTrueText,
-    falseText: showBooleansAs.falseText ?? defaultFalseText,
-    props: showBooleansAs.props ?? {},
-    ignoreProps: showBooleansAs.ignoreProps ?? []
-  };
-  function processValue(val, propName) {
-    if (typeof val === "boolean") {
-      if (propName && config.ignoreProps?.includes(propName)) {
-        return val;
-      }
-      if (propName && config.props?.[propName]) {
-        const propConfig = config.props[propName];
-        if (propConfig === true) {
-          return val ? config.trueText : config.falseText;
-        }
-        return val ? propConfig.trueText ?? config.trueText : propConfig.falseText ?? config.falseText;
-      }
-      return val ? config.trueText : config.falseText;
-    }
-    if (Array.isArray(val)) {
-      if (visited.has(val)) {
-        throw new Error("Circular reference detected in array");
-      }
-      visited.add(val);
-      try {
-        return val.map((item) => processValue(item));
-      } finally {
-        visited.delete(val);
-      }
-    }
-    if (isPlainObject(val)) {
-      if (visited.has(val)) {
-        throw new Error("Circular reference detected in object");
-      }
-      visited.add(val);
-      try {
-        const result = {};
-        for (const [key, itemValue] of Object.entries(val)) {
-          result[key] = processValue(itemValue, key);
-        }
-        return result;
-      } finally {
-        visited.delete(val);
-      }
-    }
-    return val;
-  }
-  return processValue(value);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  compactSnapshot,
-  createLoggerStore,
-  getResultFn,
-  waitController
-});