How to use the error-stack-parser.parse function in error-stack-parser

function assertStack (err, expected) {
    // HACK: stackParser can't handle empty stacks correctly
    // (it treats error messages as stack frames).
    // Therefore we add this dummy stack frame to make things work
    if (!expected.stackTop)
        err.stack += '\n    at (:1:1)';

    const parsedStack = stackParser.parse(err);

    if (expected.stackTop) {
        const expectedStackTop = Array.isArray(expected.stackTop) ? expected.stackTop : [expected.stackTop];

        parsedStack.forEach(function (frame, idx) {
            const filename   = frame.fileName;
            const isInternal = frame.fileName.indexOf('internal/') === 0 ||
                               frame.fileName.indexOf(sep) < 0;

            // NOTE: assert that stack is clean from internals
            expect(isInternal).to.be.false;
            expect(filename).not.to.contain(sep + 'babel-');
            expect(filename).not.to.contain(sep + 'babylon' + sep);
            expect(filename).not.to.contain(sep + 'core-js' + sep);

            if (expectedStackTop[idx])

export function getErrorStackString(e) {
  // Handle passing in an Array of pre-parsed frames for testing
  const frames = e instanceof Array ? e : ErrorStackParser.parse(e);
  const outputFrames = [];

  for (const frame of frames) {
    if (frame.fileName !== undefined) {
      const parts = frame.fileName.split("/");
      if (parts[parts.length - 1].startsWith("iodide.eval-frame")) {
        break;
      }
    }
    outputFrames.push(frame.toString());
  }

  return `${e.name}: ${e.message}\n${outputFrames.join("\n")}`;
}

const pushTestResult = function pushTestResult(test) {
      console.log('++++pushTestResult', test);
      console.log('++++pushTestResult _trace', test._trace);
      if (!test || !test._trace) {
        console.log('++++test trace is empty', test);
        return;
      }
      const traceObjects = ErrorStackParser.parse(test._trace)
        .filter(stackTraceObject => stackTraceObject.fileName === outputFilePath);
      console.log('++++traceObjects', traceObjects);
      const traceObject = traceObjects.length > 0 ? traceObjects[0] : traceObjects;
      if (!traceObject) {
        console.log('++++traceObject is empty', test);
        return;
      }

      console.log('++++trace', traceObject);
      if (!test.state) {
        test.state = 'skipped';
      }
      messages.push({
        state: test.state,
        title: test.title,
        error: test.err,

function sourceMappedError(error) {
  const original = error.stack.split('\n');
  const parsed = ErrorStack.parse(error);

  const newStack = [original[0]];

  for (let i = 0; i < parsed.length; i++) {
    const { fileName } = parsed[i];
    if (fileName === bundleFileName) newStack.push(frameToStr(parsed[i]));
    else newStack.push(original[i + 1]);
  }

  error.stack = newStack.join('\n');
  return error;
}

renderFrames() {
    console.log('error', this.props.error);
    console.log('parsed error', ErrorStackParser.parse(this.props.error));
    return ErrorStackParser.parse(this.props.error).map((f) => {
      const link = `${ f.fileName }:${ f.lineNumber }:${ f.columnNumber }`;

      return (
        <div>
          <div>{ f.functionName }</div>
          <div>
            <a href="{">{ link }</a>
          </div>
        </div>
      );
    });
  }

export function logError(error: Error) {
  const {name, message, stack} = error;

  log(formatErrorMarker(name), ': ', message);

  error.stack = cleanStack(stack);

  forEach(ErrorStackParser.parse(error), ({functionName = 'unknown', fileName, lineNumber, columnNumber}) => {
    log('  • ', ...formatLine(functionName, fileName, lineNumber, columnNumber));
  });
}

Dispatcher.useState(null);
      Dispatcher.useReducer((s, a) => s, null);
      Dispatcher.useRef(null);
      Dispatcher.useLayoutEffect(() => {});
      Dispatcher.useEffect(() => {});
      Dispatcher.useImperativeHandle(undefined, () => null);
      Dispatcher.useDebugValue(null);
      Dispatcher.useCallback(() => {});
      Dispatcher.useMemo(() => null);
    } finally {
      readHookLog = hookLog;
      hookLog = [];
    }
    for (let i = 0; i < readHookLog.length; i++) {
      let hook = readHookLog[i];
      cache.set(hook.primitive, ErrorStackParser.parse(hook.stackError));
    }
    primitiveStackCache = cache;
  }
  return primitiveStackCache;
}

ref: Ref,
  currentDispatcher: CurrentDispatcherRef,
): HooksTree {
  let previousDispatcher = currentDispatcher.current;
  let readHookLog;
  currentDispatcher.current = Dispatcher;
  let ancestorStackError;
  try {
    ancestorStackError = new Error();
    renderFunction(props, ref);
  } finally {
    readHookLog = hookLog;
    hookLog = [];
    currentDispatcher.current = previousDispatcher;
  }
  let rootStack = ErrorStackParser.parse(ancestorStackError);
  return buildTree(rootStack, readHookLog);
}

createStackTraces (errorEvent) {
    var stackTraceService = this
    var error = errorEvent.error

    var stackTraces
    if (error) {
      try {
        stackTraces = errorStackParser.parse(error)
      } catch (e) {
        this._loggingService.debug('Parsing error stack failed!', e)
      }
    }

    if (!stackTraces || stackTraces.length === 0) {
      stackTraces = [
        {
          fileName: errorEvent.filename,
          lineNumber: errorEvent.lineno,
          columnNumber: errorEvent.colno
        }
      ]
    }

    stackTraces = ErrorStackNormalizer(stackTraces)