tokens.forEach((token) => {
    const { image } = token;

    if (bracketsCount === 0 && image !== '(' && image !== ')') {
      output.push(token);
      return;
    }

    temp.push(token);
    if (image === '(') {
      bracketsCount += 1;
    } else if (image === ')') {
      bracketsCount -= 1;

      if (bracketsCount === 0) {
        // recursive clean within parenthesis, unnests one layer
        const cleaned = cleanOperators(temp.slice(1, -1));
        if (cleaned.length) {
          // Length check means this is fine
          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
          output.push(R.head(temp)!, ...cleaned, R.last(temp)!);
        }
        temp = [];
      }
    }
  });

export const getAttachmentImg = (res): string => {
	if (res) {
		const attachment: any = R.head(R.values(res['_attachments']));
		return `data:${attachment.content_type};base64,${attachment.data}`
	}

	return undefined;
};

    wrap(text: string, columns: number): string {
        const wrap = s => this.wrap(s, columns);
        const splitAtColumns = R.splitAt(columns);

        if (R.length(text) <= columns) {
            return text;
        }

        if (R.not(containsSpaces(text))) {
            return R.head(splitAtColumns(text)) + NEW_LINE + wrap(R.last(splitAtColumns(text)));
        }

        if (SPACE === text[columns]) {
            return R.head(splitAtColumns(text)) + NEW_LINE + wrap(R.trim(splitAtColumns(text)[1]));
        }

        return replaceLastSpace(R.head(splitAtColumns(text))) + wrap(R.last(splitAtColumns(text)));
    }

 .then(([travels, reservations]: [Travel[], Reservation[]]) => {
     if (R.isArrayLike(travels) && R.isArrayLike(reservations) && !R.isEmpty(travels)) {
         const travel = R.head(travels);
         if ((reservation.travelType === "OUT" && canOut(reservations)) || (reservation.travelType === "IN" && canIn(reservations, travel.placeLimit))) {
             return Promise.resolve(this.respository.save(reservation));
         }
         return Promise.reject(getError(new Error("Place limit")));
     }
     return Promise.reject(getError(new Error("Travel not exist")));
 }, rejected => {

const buildJoiSpec = (joi: Joi, { parameters = [], consumes = [] }) => {
    const spec = parameters.reduce(
        (acc, paramConf: swaggerParam) =>
            R.assocPath(R.props(['in', 'name'], paramConf), buildParameter(joi, paramConf), acc),
        { continueOnError: true }
    );

    if (R.prop('body', spec) && consumes.length > 0) {
        spec.type = R.head(consumes).split('/')[1];
    }

    return spec;
};

    public static sort(unsorted: number [] = []): number[] {

        if (unsorted.length !== 0) {
            const sorted = [];
            const m = R.head(unsorted);

            const {l, h} = R.groupBy(curr => R.gte(curr, m) ? 'h' : 'l', R.drop(1, unsorted))

            sorted.push(...QuickSort.sort(l));
            sorted.push(m);
            sorted.push(...QuickSort.sort(h));
            return sorted;
        } else
            return unsorted;
    }

 fields.forEach(field => {
   if (!toFilter) {
     if (R.is(Object, field)) {
       const key = R.head(R.keys(field));
       const value = R.values(field);
       if (key === 'eq') {
         toFilter = (obj[value] === query);
       }
     } else {
       if (!R.isNil(obj[field])) {
         toFilter = obj[field].toString()
           .toLowerCase().indexOf(query) > -1
       }
     }
   }
 });

export const pinNumbers = (observed: string): Array<String> => {
  const lookUp = ['08', '124', '1235', '236', '1457', '24568', '3569', '478', '57890', '689'];

  let obsHead: string = head(observed);

  const heads = lookUp[obsHead];

  if (observed.length <= 1)
    return split('', heads);

  const result = [];
  for (const h of heads) {
    for (const t of pinNumbers(drop(1, observed))) {
      result.push(h + t)
    }
  }
  return result
};

 /* tslint:disable-next-line:no-any */
 public getCurrentExercise(): Maybe<AbstractExercise<any, any, any>> {
   return head(this.exercises);
 }