"use strict";Object.defineProperty(exports, "__esModule", {value: true});



var _chunk7K74W2G3js = require('./chunk-7K74W2G3.js');



var _chunkF6EGFU3Wjs = require('./chunk-F6EGFU3W.js');


var _chunkQC33EBBCjs = require('./chunk-QC33EBBC.js');


var _chunkTGVEPLW2js = require('./chunk-TGVEPLW2.js');




var _chunkQ2LZCTWPjs = require('./chunk-Q2LZCTWP.js');



var _chunkEBISTSVAjs = require('./chunk-EBISTSVA.js');











var _chunkOTKMOSH2js = require('./chunk-OTKMOSH2.js');






var _chunkSQA7G4TEjs = require('./chunk-SQA7G4TE.js');


var _chunk6C3VEZWHjs = require('./chunk-6C3VEZWH.js');

// src/ReadonlyNonEmptyArray.ts
var ReadonlyNonEmptyArray_exports = {};
_chunk6C3VEZWHjs.__export.call(void 0, ReadonlyNonEmptyArray_exports, {
  Alt: () => Alt,
  Applicative: () => Applicative,
  Apply: () => Apply,
  Chain: () => Chain,
  Comonad: () => Comonad,
  Do: () => Do,
  Foldable: () => Foldable,
  FoldableWithIndex: () => FoldableWithIndex,
  Functor: () => Functor,
  FunctorWithIndex: () => FunctorWithIndex,
  Monad: () => Monad,
  Pointed: () => Pointed,
  Traversable: () => Traversable,
  TraversableWithIndex: () => TraversableWithIndex,
  URI: () => URI,
  alt: () => alt,
  altW: () => altW,
  ap: () => ap,
  apFirst: () => apFirst2,
  apS: () => apS2,
  apSecond: () => apSecond2,
  append: () => append,
  appendW: () => appendW,
  bind: () => bind2,
  bindTo: () => bindTo2,
  chain: () => chain,
  chainFirst: () => chainFirst2,
  chainWithIndex: () => chainWithIndex,
  chop: () => chop,
  chunksOf: () => chunksOf,
  concat: () => concat,
  concatAll: () => concatAll,
  concatW: () => concatW,
  cons: () => cons,
  duplicate: () => duplicate,
  empty: () => empty,
  extend: () => extend,
  extract: () => extract,
  filter: () => filter,
  filterWithIndex: () => filterWithIndex,
  flap: () => flap2,
  flatMap: () => flatMap,
  flatten: () => flatten,
  fold: () => fold,
  foldMap: () => foldMap,
  foldMapWithIndex: () => foldMapWithIndex,
  fromArray: () => fromArray,
  fromReadonlyArray: () => fromReadonlyArray,
  getEq: () => getEq,
  getSemigroup: () => getSemigroup,
  getShow: () => getShow,
  getUnionSemigroup: () => getUnionSemigroup,
  group: () => group,
  groupBy: () => groupBy,
  groupSort: () => groupSort,
  head: () => head2,
  init: () => init,
  insertAt: () => insertAt,
  intercalate: () => intercalate,
  intersperse: () => intersperse,
  isNonEmpty: () => isNonEmpty2,
  isOutOfBound: () => isOutOfBound,
  last: () => last,
  let: () => let_2,
  makeBy: () => makeBy,
  map: () => map,
  mapWithIndex: () => mapWithIndex,
  matchLeft: () => matchLeft,
  matchRight: () => matchRight,
  max: () => max2,
  min: () => min2,
  modifyAt: () => modifyAt,
  modifyHead: () => modifyHead,
  modifyLast: () => modifyLast,
  of: () => of,
  prepend: () => prepend,
  prependAll: () => prependAll,
  prependToAll: () => prependToAll,
  prependW: () => prependW,
  range: () => range,
  readonlyNonEmptyArray: () => readonlyNonEmptyArray,
  reduce: () => reduce,
  reduceRight: () => reduceRight,
  reduceRightWithIndex: () => reduceRightWithIndex,
  reduceWithIndex: () => reduceWithIndex,
  replicate: () => replicate,
  reverse: () => reverse,
  rotate: () => rotate,
  sequence: () => sequence,
  snoc: () => snoc,
  sort: () => sort,
  sortBy: () => sortBy,
  splitAt: () => splitAt,
  tail: () => tail2,
  traverse: () => traverse,
  traverseWithIndex: () => traverseWithIndex,
  unappend: () => unappend,
  uncons: () => uncons,
  union: () => union,
  uniq: () => uniq,
  unprepend: () => unprepend,
  unsafeInsertAt: () => unsafeInsertAt,
  unsafeUpdateAt: () => unsafeUpdateAt,
  unsnoc: () => unsnoc,
  unzip: () => unzip,
  updateAt: () => updateAt,
  updateHead: () => updateHead,
  updateLast: () => updateLast,
  zip: () => zip,
  zipWith: () => zipWith
});
var empty = _chunkOTKMOSH2js.emptyReadonlyArray;
var isNonEmpty2 = _chunkOTKMOSH2js.isNonEmpty;
var isOutOfBound = (i, as) => i < 0 || i >= as.length;
var prependW = (head3) => (tail3) => [head3, ...tail3];
var prepend = prependW;
var appendW = (end) => (init2) => [...init2, end];
var append = appendW;
var unsafeInsertAt = (i, a, as) => {
  if (isNonEmpty2(as)) {
    const xs = _chunkOTKMOSH2js.fromReadonlyNonEmptyArray.call(void 0, as);
    xs.splice(i, 0, a);
    return xs;
  }
  return [a];
};
var unsafeUpdateAt = (i, a, as) => {
  if (as[i] === a) {
    return as;
  } else {
    const xs = _chunkOTKMOSH2js.fromReadonlyNonEmptyArray.call(void 0, as);
    xs[i] = a;
    return xs;
  }
};
var uniq = (E) => (as) => {
  if (as.length === 1) {
    return as;
  }
  const out = [head2(as)];
  const rest = tail2(as);
  for (const a of rest) {
    if (out.every((o) => !E.equals(o, a))) {
      out.push(a);
    }
  }
  return out;
};
var sortBy = (ords) => {
  if (isNonEmpty2(ords)) {
    const M = _chunkQC33EBBCjs.getMonoid.call(void 0, );
    return sort(ords.reduce(M.concat, M.empty));
  }
  return _chunkSQA7G4TEjs.identity;
};
var union = (E) => {
  const uniqE = uniq(E);
  return (second) => (first) => uniqE(_chunkSQA7G4TEjs.pipe.call(void 0, first, concat(second)));
};
var rotate = (n) => (as) => {
  const len = as.length;
  const m = Math.round(n) % len;
  if (isOutOfBound(Math.abs(m), as) || m === 0) {
    return as;
  }
  if (m < 0) {
    const [f, s] = splitAt(-m)(as);
    return _chunkSQA7G4TEjs.pipe.call(void 0, s, concat(f));
  } else {
    return rotate(m - len)(as);
  }
};
var fromReadonlyArray = (as) => isNonEmpty2(as) ? _chunkOTKMOSH2js.some.call(void 0, as) : _chunkOTKMOSH2js.none;
var makeBy = (f) => (n) => {
  const j = Math.max(0, Math.floor(n));
  const out = [f(0)];
  for (let i = 1; i < j; i++) {
    out.push(f(i));
  }
  return out;
};
var replicate = (a) => makeBy(() => a);
var range = (start, end) => start <= end ? makeBy((i) => start + i)(end - start + 1) : [start];
var unprepend = (as) => [head2(as), tail2(as)];
var unappend = (as) => [init(as), last(as)];
var fromArray = (as) => fromReadonlyArray(as.slice());
function concatW(second) {
  return (first) => first.concat(second);
}
function concat(x, y) {
  return y ? x.concat(y) : (y2) => y2.concat(x);
}
var reverse = (as) => as.length === 1 ? as : [last(as), ...as.slice(0, -1).reverse()];
function group(E) {
  return (as) => {
    const len = as.length;
    if (len === 0) {
      return empty;
    }
    const out = [];
    let head3 = as[0];
    let nea = [head3];
    for (let i = 1; i < len; i++) {
      const a = as[i];
      if (E.equals(a, head3)) {
        nea.push(a);
      } else {
        out.push(nea);
        head3 = a;
        nea = [head3];
      }
    }
    out.push(nea);
    return out;
  };
}
var groupBy = (f) => (as) => {
  const out = {};
  for (const a of as) {
    const k = f(a);
    if (_chunkOTKMOSH2js.has.call(out, k)) {
      out[k].push(a);
    } else {
      out[k] = [a];
    }
  }
  return out;
};
var sort = (O) => (as) => as.length === 1 ? as : as.slice().sort(O.compare);
var updateAt = (i, a) => modifyAt(i, () => a);
var modifyAt = (i, f) => (as) => isOutOfBound(i, as) ? _chunkOTKMOSH2js.none : _chunkOTKMOSH2js.some.call(void 0, unsafeUpdateAt(i, f(as[i]), as));
var zipWith = (as, bs, f) => {
  const cs = [f(as[0], bs[0])];
  const len = Math.min(as.length, bs.length);
  for (let i = 1; i < len; i++) {
    cs[i] = f(as[i], bs[i]);
  }
  return cs;
};
function zip(as, bs) {
  if (bs === void 0) {
    return (bs2) => zip(bs2, as);
  }
  return zipWith(as, bs, (a, b) => [a, b]);
}
var unzip = (abs) => {
  const fa = [abs[0][0]];
  const fb = [abs[0][1]];
  for (let i = 1; i < abs.length; i++) {
    fa[i] = abs[i][0];
    fb[i] = abs[i][1];
  }
  return [fa, fb];
};
var prependAll = (middle) => (as) => {
  const out = [middle, as[0]];
  for (let i = 1; i < as.length; i++) {
    out.push(middle, as[i]);
  }
  return out;
};
var intersperse = (middle) => (as) => {
  const rest = tail2(as);
  return isNonEmpty2(rest) ? _chunkSQA7G4TEjs.pipe.call(void 0, rest, prependAll(middle), prepend(head2(as))) : as;
};
var chainWithIndex = (f) => (as) => {
  const out = _chunkOTKMOSH2js.fromReadonlyNonEmptyArray.call(void 0, f(0, head2(as)));
  for (let i = 1; i < as.length; i++) {
    out.push(...f(i, as[i]));
  }
  return out;
};
var chop = (f) => (as) => {
  const [b, rest] = f(as);
  const out = [b];
  let next = rest;
  while (isNonEmpty2(next)) {
    const [b2, rest2] = f(next);
    out.push(b2);
    next = rest2;
  }
  return out;
};
var splitAt = (n) => (as) => {
  const m = Math.max(1, n);
  return m >= as.length ? [as, empty] : [_chunkSQA7G4TEjs.pipe.call(void 0, as.slice(1, m), prepend(head2(as))), as.slice(m)];
};
var chunksOf = (n) => chop(splitAt(n));
var _map = (fa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, map(f));
var _mapWithIndex = (fa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, mapWithIndex(f));
var _ap = (fab, fa) => _chunkSQA7G4TEjs.pipe.call(void 0, fab, ap(fa));
var _extend = (wa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, wa, extend(f));
var _reduce = (fa, b, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, reduce(b, f));
var _foldMap = (M) => {
  const foldMapM = foldMap(M);
  return (fa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, foldMapM(f));
};
var _reduceRight = (fa, b, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, reduceRight(b, f));
var _traverse = (F) => {
  const traverseF = traverse(F);
  return (ta, f) => _chunkSQA7G4TEjs.pipe.call(void 0, ta, traverseF(f));
};
var _alt = (fa, that) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, alt(that));
var _reduceWithIndex = (fa, b, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, reduceWithIndex(b, f));
var _foldMapWithIndex = (M) => {
  const foldMapWithIndexM = foldMapWithIndex(M);
  return (fa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, foldMapWithIndexM(f));
};
var _reduceRightWithIndex = (fa, b, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, reduceRightWithIndex(b, f));
var _traverseWithIndex = (F) => {
  const traverseWithIndexF = traverseWithIndex(F);
  return (ta, f) => _chunkSQA7G4TEjs.pipe.call(void 0, ta, traverseWithIndexF(f));
};
var of = _chunkOTKMOSH2js.singleton;
var altW = (that) => (as) => _chunkSQA7G4TEjs.pipe.call(void 0, as, concatW(that()));
var alt = altW;
var ap = (as) => flatMap((f) => _chunkSQA7G4TEjs.pipe.call(void 0, as, map(f)));
var flatMap = /* @__PURE__ */ _chunkSQA7G4TEjs.dual.call(void 0, 
  2,
  (ma, f) => _chunkSQA7G4TEjs.pipe.call(void 0, 
    ma,
    chainWithIndex((i, a) => f(a, i))
  )
);
var extend = (f) => (as) => {
  let next = tail2(as);
  const out = [f(as)];
  while (isNonEmpty2(next)) {
    out.push(f(next));
    next = tail2(next);
  }
  return out;
};
var duplicate = /* @__PURE__ */ extend(_chunkSQA7G4TEjs.identity);
var flatten = /* @__PURE__ */ flatMap(_chunkSQA7G4TEjs.identity);
var map = (f) => mapWithIndex((_, a) => f(a));
var mapWithIndex = (f) => (as) => {
  const out = [f(0, head2(as))];
  for (let i = 1; i < as.length; i++) {
    out.push(f(i, as[i]));
  }
  return out;
};
var reduce = (b, f) => reduceWithIndex(b, (_, b2, a) => f(b2, a));
var foldMap = (S) => (f) => (as) => as.slice(1).reduce((s, a) => S.concat(s, f(a)), f(as[0]));
var reduceRight = (b, f) => reduceRightWithIndex(b, (_, b2, a) => f(b2, a));
var reduceWithIndex = (b, f) => (as) => as.reduce((b2, a, i) => f(i, b2, a), b);
var foldMapWithIndex = (S) => (f) => (as) => as.slice(1).reduce((s, a, i) => S.concat(s, f(i + 1, a)), f(0, as[0]));
var reduceRightWithIndex = (b, f) => (as) => as.reduceRight((b2, a, i) => f(i, a, b2), b);
var traverse = (F) => {
  const traverseWithIndexF = traverseWithIndex(F);
  return (f) => traverseWithIndexF((_, a) => f(a));
};
var sequence = (F) => traverseWithIndex(F)(_chunkSQA7G4TEjs.SK);
var traverseWithIndex = (F) => (f) => (as) => {
  let out = F.map(f(0, head2(as)), of);
  for (let i = 1; i < as.length; i++) {
    out = F.ap(
      F.map(out, (bs) => (b) => _chunkSQA7G4TEjs.pipe.call(void 0, bs, append(b))),
      f(i, as[i])
    );
  }
  return out;
};
var extract = _chunkOTKMOSH2js.head;
var URI = "ReadonlyNonEmptyArray";
var getShow = (S) => ({
  show: (as) => `[${as.map(S.show).join(", ")}]`
});
var getSemigroup = () => ({
  concat
});
var getEq = (E) => _chunkTGVEPLW2js.fromEquals.call(void 0, (xs, ys) => xs.length === ys.length && xs.every((x, i) => E.equals(x, ys[i])));
var getUnionSemigroup = (E) => {
  const unionE = union(E);
  return {
    concat: (first, second) => unionE(second)(first)
  };
};
var Functor = {
  URI,
  map: _map
};
var flap2 = /* @__PURE__ */ _chunk7K74W2G3js.flap.call(void 0, Functor);
var Pointed = {
  URI,
  of
};
var FunctorWithIndex = {
  URI,
  map: _map,
  mapWithIndex: _mapWithIndex
};
var Apply = {
  URI,
  map: _map,
  ap: _ap
};
var apFirst2 = /* @__PURE__ */ _chunkQ2LZCTWPjs.apFirst.call(void 0, Apply);
var apSecond2 = /* @__PURE__ */ _chunkQ2LZCTWPjs.apSecond.call(void 0, Apply);
var Applicative = {
  URI,
  map: _map,
  ap: _ap,
  of
};
var Chain = {
  URI,
  map: _map,
  ap: _ap,
  chain: flatMap
};
var chainFirst2 = /* @__PURE__ */ _chunkEBISTSVAjs.chainFirst.call(void 0, Chain);
var Monad = {
  URI,
  map: _map,
  ap: _ap,
  of,
  chain: flatMap
};
var Foldable = {
  URI,
  reduce: _reduce,
  foldMap: _foldMap,
  reduceRight: _reduceRight
};
var FoldableWithIndex = {
  URI,
  reduce: _reduce,
  foldMap: _foldMap,
  reduceRight: _reduceRight,
  reduceWithIndex: _reduceWithIndex,
  foldMapWithIndex: _foldMapWithIndex,
  reduceRightWithIndex: _reduceRightWithIndex
};
var Traversable = {
  URI,
  map: _map,
  reduce: _reduce,
  foldMap: _foldMap,
  reduceRight: _reduceRight,
  traverse: _traverse,
  sequence
};
var TraversableWithIndex = {
  URI,
  map: _map,
  mapWithIndex: _mapWithIndex,
  reduce: _reduce,
  foldMap: _foldMap,
  reduceRight: _reduceRight,
  traverse: _traverse,
  sequence,
  reduceWithIndex: _reduceWithIndex,
  foldMapWithIndex: _foldMapWithIndex,
  reduceRightWithIndex: _reduceRightWithIndex,
  traverseWithIndex: _traverseWithIndex
};
var Alt = {
  URI,
  map: _map,
  alt: _alt
};
var Comonad = {
  URI,
  map: _map,
  extend: _extend,
  extract
};
var Do = /* @__PURE__ */ of(_chunkOTKMOSH2js.emptyRecord);
var bindTo2 = /* @__PURE__ */ _chunk7K74W2G3js.bindTo.call(void 0, Functor);
var let_2 = /* @__PURE__ */ _chunk7K74W2G3js.let_.call(void 0, Functor);
var bind2 = /* @__PURE__ */ _chunkEBISTSVAjs.bind.call(void 0, Chain);
var apS2 = /* @__PURE__ */ _chunkQ2LZCTWPjs.apS.call(void 0, Apply);
var head2 = extract;
var tail2 = _chunkOTKMOSH2js.tail;
var last = (as) => as[as.length - 1];
var init = (as) => as.slice(0, -1);
var min2 = (O) => {
  const S = _chunkF6EGFU3Wjs.min.call(void 0, O);
  return (as) => as.reduce(S.concat);
};
var max2 = (O) => {
  const S = _chunkF6EGFU3Wjs.max.call(void 0, O);
  return (as) => as.reduce(S.concat);
};
var concatAll = (S) => (as) => as.reduce(S.concat);
var matchLeft = (f) => (as) => f(head2(as), tail2(as));
var matchRight = (f) => (as) => f(init(as), last(as));
var modifyHead = (f) => (as) => [f(head2(as)), ...tail2(as)];
var updateHead = (a) => modifyHead(() => a);
var modifyLast = (f) => (as) => _chunkSQA7G4TEjs.pipe.call(void 0, init(as), append(f(last(as))));
var updateLast = (a) => modifyLast(() => a);
var intercalate = (S) => {
  const concatAllS = concatAll(S);
  return (middle) => _chunkSQA7G4TEjs.flow.call(void 0, intersperse(middle), concatAllS);
};
var chain = flatMap;
function groupSort(O) {
  const sortO = sort(O);
  const groupO = group(O);
  return (as) => isNonEmpty2(as) ? groupO(sortO(as)) : empty;
}
function filter(predicate) {
  return filterWithIndex((_, a) => predicate(a));
}
var filterWithIndex = (predicate) => (as) => fromReadonlyArray(as.filter((a, i) => predicate(i, a)));
var uncons = unprepend;
var unsnoc = unappend;
function cons(head3, tail3) {
  return tail3 === void 0 ? prepend(head3) : _chunkSQA7G4TEjs.pipe.call(void 0, tail3, prepend(head3));
}
var snoc = (init2, end) => _chunkSQA7G4TEjs.pipe.call(void 0, init2, concat([end]));
var insertAt = (i, a) => (as) => i < 0 || i > as.length ? _chunkOTKMOSH2js.none : _chunkOTKMOSH2js.some.call(void 0, unsafeInsertAt(i, a, as));
var prependToAll = prependAll;
var fold = concatAll;
var readonlyNonEmptyArray = {
  URI,
  of,
  map: _map,
  mapWithIndex: _mapWithIndex,
  ap: _ap,
  chain: flatMap,
  extend: _extend,
  extract,
  reduce: _reduce,
  foldMap: _foldMap,
  reduceRight: _reduceRight,
  traverse: _traverse,
  sequence,
  reduceWithIndex: _reduceWithIndex,
  foldMapWithIndex: _foldMapWithIndex,
  reduceRightWithIndex: _reduceRightWithIndex,
  traverseWithIndex: _traverseWithIndex,
  alt: _alt
};

















































































































exports.empty = empty; exports.isNonEmpty = isNonEmpty2; exports.isOutOfBound = isOutOfBound; exports.prependW = prependW; exports.prepend = prepend; exports.appendW = appendW; exports.append = append; exports.unsafeInsertAt = unsafeInsertAt; exports.unsafeUpdateAt = unsafeUpdateAt; exports.uniq = uniq; exports.sortBy = sortBy; exports.union = union; exports.rotate = rotate; exports.fromReadonlyArray = fromReadonlyArray; exports.makeBy = makeBy; exports.replicate = replicate; exports.range = range; exports.unprepend = unprepend; exports.unappend = unappend; exports.fromArray = fromArray; exports.concatW = concatW; exports.concat = concat; exports.reverse = reverse; exports.group = group; exports.groupBy = groupBy; exports.sort = sort; exports.updateAt = updateAt; exports.modifyAt = modifyAt; exports.zipWith = zipWith; exports.zip = zip; exports.unzip = unzip; exports.prependAll = prependAll; exports.intersperse = intersperse; exports.chainWithIndex = chainWithIndex; exports.chop = chop; exports.splitAt = splitAt; exports.chunksOf = chunksOf; exports.of = of; exports.altW = altW; exports.alt = alt; exports.ap = ap; exports.flatMap = flatMap; exports.extend = extend; exports.duplicate = duplicate; exports.flatten = flatten; exports.map = map; exports.mapWithIndex = mapWithIndex; exports.reduce = reduce; exports.foldMap = foldMap; exports.reduceRight = reduceRight; exports.reduceWithIndex = reduceWithIndex; exports.foldMapWithIndex = foldMapWithIndex; exports.reduceRightWithIndex = reduceRightWithIndex; exports.traverse = traverse; exports.sequence = sequence; exports.traverseWithIndex = traverseWithIndex; exports.extract = extract; exports.URI = URI; exports.getShow = getShow; exports.getSemigroup = getSemigroup; exports.getEq = getEq; exports.getUnionSemigroup = getUnionSemigroup; exports.Functor = Functor; exports.flap = flap2; exports.Pointed = Pointed; exports.FunctorWithIndex = FunctorWithIndex; exports.Apply = Apply; exports.apFirst = apFirst2; exports.apSecond = apSecond2; exports.Applicative = Applicative; exports.Chain = Chain; exports.chainFirst = chainFirst2; exports.Monad = Monad; exports.Foldable = Foldable; exports.FoldableWithIndex = FoldableWithIndex; exports.Traversable = Traversable; exports.TraversableWithIndex = TraversableWithIndex; exports.Alt = Alt; exports.Comonad = Comonad; exports.Do = Do; exports.bindTo = bindTo2; exports.let_ = let_2; exports.bind = bind2; exports.apS = apS2; exports.head = head2; exports.tail = tail2; exports.last = last; exports.init = init; exports.min = min2; exports.max = max2; exports.concatAll = concatAll; exports.matchLeft = matchLeft; exports.matchRight = matchRight; exports.modifyHead = modifyHead; exports.updateHead = updateHead; exports.modifyLast = modifyLast; exports.updateLast = updateLast; exports.intercalate = intercalate; exports.chain = chain; exports.groupSort = groupSort; exports.filter = filter; exports.filterWithIndex = filterWithIndex; exports.uncons = uncons; exports.unsnoc = unsnoc; exports.cons = cons; exports.snoc = snoc; exports.insertAt = insertAt; exports.prependToAll = prependToAll; exports.fold = fold; exports.readonlyNonEmptyArray = readonlyNonEmptyArray; exports.ReadonlyNonEmptyArray_exports = ReadonlyNonEmptyArray_exports;
