crostab/dist/index.esm.js

import { Mx, Ob, Samples, clone, Ar, Pivot, PivotModes } from 'veho';
import { Comparer, StatMx } from 'borel';
import { totx } from 'xbrief';
import { Num, Typ } from 'typen';

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function _classPrivateMethodGet(receiver, privateSet, fn) {
  if (!privateSet.has(receiver)) {
    throw new TypeError("attempted to get private field on non-instance");
  }

  return fn;
}

/**
 * If y >= 0 then sort rows, else (e.g. y===undefined) sort keys.
 * @param {*[]} keys
 * @param {*[][]} rows
 * @param {function(*,*):number} comparer
 * @param {number} [y]
 * @returns {[*[], *[][]]}
 */
const sortAlong = (keys, rows, comparer, y) => {
  const comp = (a, b) => comparer(a[0], b[0]),
        ks = Array(keys.length),
        rs = y >= 0 ? rows.map((r, i) => [r[y], keys[i], r]).sort(comp).map(([, k, r], i) => {
    ks[i] = k;
    return r;
  }) : rows.map((r, i) => [keys[i], r]).sort(comp).map(([k, r], i) => {
    ks[i] = k;
    return r;
  });

  return [ks, rs];
};

class CrosTab {
  /**
   *
   * @param {*[]} side
   * @param {*[]} banner
   * @param {*[][]} matrix
   * @param {string} [title]
   */
  constructor(side, banner, matrix, title) {
    _defineProperty(this, "side", void 0);

    _defineProperty(this, "banner", void 0);

    _defineProperty(this, "matrix", void 0);

    _defineProperty(this, "title", void 0);

    this.side = side;
    this.banner = banner;
    this.matrix = matrix;
    this.title = title || '';
  }
  /**
   * Shallow copy
   * @param {*[]} side
   * @param {*[]} banner
   * @param {*[][]} matrix
   * @param {string} [title]
   * @return {CrosTab}
   */


  static from({
    side,
    banner,
    matrix,
    title
  }) {
    return new CrosTab(side, banner, matrix, title);
  }
  /**
   * Shallow copy
   * @param {*[]} side
   * @param {*[]} banner
   * @param {function(number,number):*} func
   * @param {string} [title]
   * @return {CrosTab}
   */


  static ini({
    side,
    banner,
    func,
    title
  }) {
    const matrix = Mx.ini(side === null || side === void 0 ? void 0 : side.length, banner === null || banner === void 0 ? void 0 : banner.length, (x, y) => func(x, y));
    return CrosTab.from({
      side,
      banner,
      matrix,
      title
    });
  }
  /**
   *
   * @param {*[]|boolean} [side]
   * @param {*[]|boolean} [banner]
   * @returns {*}
   */


  toSamples({
    side,
    banner
  }) {
    const [sideIsArr, bannerIsArr] = [Array.isArray(side) && side.length || side === true, Array.isArray(banner) && banner.length || banner === true];

    if (sideIsArr) {
      if (bannerIsArr) {
        var _side$map;

        const entries = banner.map(x => [x, this.coin(x)]);
        return (_side$map = side.map(x => this.matrix[this.roin(x)]), Mx.transpose(_side$map)).map(col => Ob.fromEntries(entries, i => col[i]));
      } else {
        var _this$matrix;

        const entries = side.map(x => [x, this.roin(x)]);
        return (_this$matrix = this.matrix, Mx.transpose(_this$matrix)).map(col => Ob.fromEntries(entries, i => col[i]));
      }
    } else {
      if (bannerIsArr) {
        const entries = banner.map(x => [x, this.coin(x)]);
        return this.matrix.map(row => Ob.fromEntries(entries, i => row[i]));
      } else {
        return Samples.fromCrosTab(this);
      }
    }
  }

  get toJson() {
    var _this$matrix2;

    return {
      side: this.side.slice(),
      banner: this.banner.slice(),
      matrix: (_this$matrix2 = this.matrix, clone(_this$matrix2)),
      title: this.title
    };
  }

  get columns() {
    return Mx.transpose(this.matrix);
  }
  /**
   *
   * @param {*[][]} [newMatrix]
   * @param {*[]} [newSide]
   * @param {*[]} [newBanner]
   * @returns {CrosTab}
   */


  reboot(newMatrix, newSide, newBanner) {
    if (newMatrix) this.matrix = newMatrix;
    if (newSide) this.side = newSide;
    if (newBanner) this.banner = newBanner;
    return this;
  }
  /**
   * Shallow copy
   * @param {*[][]} [newMatrix]
   * @param {*[]} [newSide]
   * @param {*[]} [newBanner]
   * @return {CrosTab}
   */


  clone(newMatrix, newSide, newBanner) {
    return new CrosTab(newSide || this.side.slice(), newBanner || this.banner.slice(), newMatrix || Mx.clone(this.matrix), this.title);
  }

  get size() {
    return Mx.size(this.matrix);
  }

  get ht() {
    var _this$side;

    return (_this$side = this.side) === null || _this$side === void 0 ? void 0 : _this$side.length;
  }

  get wd() {
    var _this$banner;

    return (_this$banner = this.banner) === null || _this$banner === void 0 ? void 0 : _this$banner.length;
  }

  cell(x, y) {
    return this.matrix[x][y];
  }

  queryCell(r, c) {
    const x = this.side.indexOf(r),
          y = this.banner.indexOf(c);
    return x < 0 || y < 0 ? null : this.matrix[x][y];
  }

  queryCoordinate(r, c) {
    return {
      x: this.side.indexOf(r),
      y: this.banner.indexOf(c)
    };
  }

  roin(r) {
    return Number.isInteger(r) && 0 <= r && r < this.ht ? r : this.side.indexOf(r);
  }

  coin(c) {
    return Number.isInteger(c) && 0 <= c && c < this.wd ? c : this.banner.indexOf(c);
  }

  row(r) {
    const x = this.roin(r);
    return this.matrix[x];
  }

  column(c) {
    const y = this.coin(c);
    return this.matrix.map(row => row[y]);
  }

  setRow(r, newRow) {
    const x = this.roin(r);
    this.matrix[x] = newRow;
    return this;
  }

  setColumn(c, newColumn) {
    const y = this.coin(c);
    this.matrix.forEach((row, i) => {
      row[y] = newColumn[i];
    });
    return this;
  }

  map(fn, {
    mutate = true
  } = {}) {
    const matrix = Mx.map(this.matrix, fn);
    return mutate ? this.reboot(matrix) : this.clone(matrix);
  }
  /**
   * Push row into this and return this.
   * No shallow nor deep copy of the matrix.
   * @param {*} field
   * @param {*[]} row
   * @return {CrosTab}
   */


  pushRow(field, row) {
    this.side.push(field);
    this.matrix.push(row);
    return this;
  }
  /**
   * Unshift row into this and return this.
   * No shallow nor deep copy of the matrix.
   * @param {*} field
   * @param {*[]} row
   * @return {CrosTab}
   */


  unshiftRow(field, row) {
    this.side.unshift(field);
    this.matrix.unshift(row);
    return this;
  }
  /**
   * Push column into this and return this.
   * No shallow nor deep copy of the matrix.
   * @param {*} field
   * @param {*[]} col
   * @return {CrosTab}
   */


  pushCol(field, col) {
    this.banner.push(field);
    this.matrix.forEach((row, i) => row.push(col[i]));
    return this;
  }
  /**
   * Unshift column into this and return this.
   * No shallow nor deep copy of the matrix.
   * @param {*} field
   * @param {*[]} col
   * @return {CrosTab}
   */


  unshiftCol(field, col) {
    this.banner.unshift(field);
    this.matrix.forEach((row, i) => row.unshift(col[i]));
    return this;
  }

  select({
    side: s,
    banner: b
  } = {}, {
    mutate = true
  } = {}) {
    let {
      matrix,
      side,
      banner
    } = this;

    if (s && s.length) {
      const roins = s.map(x => this.roin(x));
      matrix = Ar.select(matrix, roins);
      side = s;
    }

    if (b && b.length) {
      const coins = b.map(x => this.coin(x));
      matrix = Mx.select(matrix, coins);
      banner = b;
    }

    return mutate ? this.reboot(matrix, side, banner) : this.clone(matrix, side, banner);
  }

  slice({
    rows = {
      begin: undefined,
      end: undefined
    },
    cols = {
      begin: undefined,
      end: undefined
    }
  }, {
    mutate = true
  } = {}) {
    let {
      side,
      banner,
      matrix
    } = this;
    let begin, end;

    if (rows) {
      ({
        begin,
        end
      } = rows);
      side = side.slice(begin, end);
      matrix = matrix.slice(begin, end);
    }

    if (cols) {
      ({
        begin,
        end
      } = cols);
      banner = this.banner.slice(begin, end);
      matrix = matrix.map(row => row.slice(begin, end));
    }

    return mutate ? this.reboot(matrix, side, banner) : this.clone(matrix, side, banner);
  }

  sort(by = 'rows', field, comparer, {
    mutate = true
  } = {}) {
    var _matrix, _matrix2;

    let {
      side,
      banner,
      matrix
    } = this;

    switch (by.charAt(0)) {
      case 'c':
        const x = this.roin(field);
        [banner, matrix] = sortAlong(banner, (_matrix = matrix, Mx.transpose(_matrix)), comparer, x);
        matrix = (_matrix2 = matrix, Mx.transpose(_matrix2));
        break;

      case 'r':
      default:
        const y = this.coin(field);
        [side, matrix] = sortAlong(side, matrix, comparer, y);
        break;
    }

    return mutate ? this.reboot(matrix, side, banner) : this.clone(matrix, side, banner);
  }

  sortLabel(by = 'rows', comparer) {
    var _matrix3, _matrix4;

    let {
      side,
      banner,
      matrix,
      title
    } = this;

    switch (by.charAt(0)) {
      case 'c':
        side = side.slice();
        [banner, matrix] = sortAlong(banner, (_matrix3 = matrix, Mx.transpose(_matrix3)), comparer);
        matrix = (_matrix4 = matrix, Mx.transpose(_matrix4));
        break;

      case 'r':
      default:
        banner = banner.slice();
        [side, matrix] = sortAlong(side, matrix, comparer);
        break;
    }

    return new CrosTab(side, banner, matrix, title);
  }

  transpose(newTitle, {
    mutate = true
  } = {}) {
    const {
      banner: side,
      side: banner,
      columns: matrix
    } = this;
    return mutate ? this.reboot(matrix, side, banner) : this.clone(matrix, side, banner);
  }

}

const {
  inferData
} = Num;

class ArrTyp {
  /**
   *
   * @param {*[]} column
   * @return {string|unknown}
   */
  static infer(column) {
    if (column.length) {
      const types = column.map(inferData);
      const dist = new Set(types);

      switch (dist.size) {
        case 1:
          return types[0];

        case 2:
          return dist.has('number') && dist.has('numstr') ? 'numstr' : 'misc';

        default:
          return 'misc';
      }
    } else {
      return 'null';
    }
  }

}

/**
 *
 * @type {{intersect: number, left: number, union: number, right: number}}
 */
const JoinT = {
  intersect: -1,
  union: 0,
  left: 1,
  right: 2
};

const {
  spliceCols,
  size
} = Mx;
const {
  select,
  ini: ar
} = Ar;

const locInd = (mx, ys, vs, hi) => mx.findIndex(row => {
  for (let i = 0; i < hi; i++) if (row[ys[i]] !== vs[i]) return false;

  return true;
});
/**
 *
 * @param joinT
 * @returns {
 * (function({mx: *[][], ys: number[]}, {mx: *[][], ys: number[]}): *[][])
 * |(function({mx: *[][], ys: number[]}, {mx: *[][], ys: number[]}, *=): *[][])
 * }
 */


const joiner = joinT => {
  switch (joinT) {
    case JoinT.union:
      return MxJoin.joinUnion;

    case JoinT.left:
      return MxJoin.joinLeft;

    case JoinT.right:
      return MxJoin.joinRight;

    case JoinT.intersect:
    default:
      return MxJoin.joinIntersect;
  }
};

class MxJoin {}

_defineProperty(MxJoin, "joinUnion", ({
  mx: mxL,
  ys: ysL
}, {
  mx: mxR,
  ys: ysR
}, fillEmpty) => {
  const hL = mxL.length,
        hR = mxR.length,
        hi = ysR.length,
        mx = Array(hL),
        mxL2 = spliceCols(Mx.copy(mxL), ysL.slice().sort(Comparer.numberAscending)),
        [, wL] = size(mxL2),
        mxR2 = spliceCols(Mx.copy(mxR), ysR.slice().sort(Comparer.numberAscending)),
        [, wR] = size(mxR2),
        idxRiLs = new Set();

  for (let i = 0, x, vsL; i < hL; i++) {
    vsL = select(mxL[i], ysL, hi);
    x = locInd(mxR, ysR, vsL, hi);

    if (x < 0) {
      mx[i] = vsL.concat(mxL2[i], ar(wR, fillEmpty));
    } else {
      mx[i] = vsL.concat(mxL2[i], mxR2[x]);
      idxRiLs.add(x);
    }
  }

  for (let i = 0, x, vsR; i < hR; i++) {
    var _vsR$concat;

    if (idxRiLs.has(i)) {
      continue;
    }

    vsR = select(mxR[i], ysR, hi);
    x = locInd(mxL, ysL, vsR, hi);
    if (x < 0) _vsR$concat = vsR.concat(ar(wL, fillEmpty), mxR2[i]), mx.push(_vsR$concat);
  }

  return mx;
});

_defineProperty(MxJoin, "joinLeft", ({
  mx: mxL,
  ys: ysL
}, {
  mx: mxR,
  ys: ysR
}, fillEmpty) => {
  const hL = mxL.length,
        hi = ysL.length,
        mx = Array(hL),
        mxL2 = spliceCols(Mx.copy(mxL), ysL.slice().sort(Comparer.numberAscending)),
        mxR2 = spliceCols(Mx.copy(mxR), ysR.slice().sort(Comparer.numberAscending)),
        [, wR] = size(mxR2);

  for (let i = 0, x, vsL; i < hL; i++) {
    vsL = select(mxL[i], ysL, hi);
    x = locInd(mxR, ysR, vsL, hi);
    mx[i] = x < 0 ? vsL.concat(mxL2[i], ar(wR, fillEmpty)) : vsL.concat(mxL2[i], mxR2[x]);
  }

  return mx;
});

_defineProperty(MxJoin, "joinRight", ({
  mx: mxL,
  ys: ysL
}, {
  mx: mxR,
  ys: ysR
}, fillEmpty) => {
  const hR = mxR.length,
        hi = ysR.length,
        mx = Array(hR),
        mxL2 = spliceCols(Mx.copy(mxL), ysL.slice().sort(Comparer.numberAscending)),
        [, wL] = size(mxL2),
        mxR2 = spliceCols(Mx.copy(mxR), ysR.slice().sort(Comparer.numberAscending));

  for (let i = 0, x, vsR; i < hR; i++) {
    vsR = select(mxR[i], ysR, hi);
    x = locInd(mxL, ysL, vsR, hi);
    mx[i] = x < 0 ? vsR.concat(ar(wL, fillEmpty), mxR2[i]) : vsR.concat(mxL2[x], mxR2[i]);
  }

  return mx;
});

_defineProperty(MxJoin, "joinIntersect", ({
  mx: mxL,
  ys: ysL
}, {
  mx: mxR,
  ys: ysR
}) => {
  const hL = mxL.length,
        hi = ysL.length,
        mx = [],
        mxL2 = spliceCols(Mx.copy(mxL), ysL.slice().sort(Comparer.numberAscending)),
        mxR2 = spliceCols(Mx.copy(mxR), ysR.slice().sort(Comparer.numberAscending));

  for (let i = 0, x, vsL; i < hL; i++) {
    vsL = select(mxL[i], ysL, hi);
    x = locInd(mxR, ysR, vsL, hi);
    if (x < 0) continue;
    mx.push(vsL.concat(mxL2[i], mxR2[x]));
  }

  return mx;
});

const pivotMode = stat => {
  return typeof stat === 'string' ? PivotModes[stat] || (stat === 'cnt' ? PivotModes.count : PivotModes.array) : PivotModes.array;
};

Pivot.prototype.pivotStat = function ([x, y], [index, stat], {
  boot
} = {}) {
  var _stat;

  const mode = (_stat = stat, pivotMode(_stat));
  let {
    side,
    banner,
    matrix
  } = this.pivot([x, y, index], {
    mode,
    boot
  });
  if (mode === PivotModes.array) matrix = Mx.map(matrix, stat);
  return {
    side,
    banner,
    matrix
  };
};
/**
 *
 * @param {number} x
 * @param {number} y
 * @param {{index:number,stat:string|function(*[]):number}[]}fields
 */


Pivot.prototype.pivotMatrices = function ([x, y], fields) {
  const hi = fields.length;
  let {
    side,
    banner,
    matrix
  } = this.pivotStat([x, y], fields[0], {
    boot: true
  });
  const matrices = [matrix];

  for (let i = 1; i < hi; i++) {
    var _this$pivotStat$matri;

    _this$pivotStat$matri = this.pivotStat([x, y], fields[i], {
      boot: false
    }).matrix, matrices.push(_this$pivotStat$matri);
  }

  return {
    side,
    banner,
    matrix: Mx.zip(matrices)
  };
};
/**
 *
 * @param {Table} table
 * @param {TableSpec} spec
 * @param {string} spec.side side
 * @param {string} spec.banner banner
 * @param {Object<string|number,function(*):boolean>} spec.filter
 * @param {string|string[]|Object<string|number,function(*[]):number>} spec.cell
 * @param {function():number} spec.calc - (field1,field2,...)=>number
 * @returns {CrosTab}
 */


const crosTabFut = (table, spec) => {
  var _spec$side, _spec$banner, _field;

  // spec |> console.log
  table = table.filter(spec.filter, {
    mutate: false
  });
  const pvt = new Pivot(table.matrix),
        coin = table.coin.bind(table),
        cellEntries = Object.entries(spec.cell),
        [x, y] = [(_spec$side = spec.side, coin(_spec$side)), (_spec$banner = spec.banner, coin(_spec$banner))];
  let side, banner, matrix;

  switch (cellEntries.length) {
    case 0:
      ({
        side,
        banner,
        matrix
      } = pvt.pivot([x, y], {
        mode: PivotModes.count
      }));
      break;

    case 1:
      const [[field, stat]] = cellEntries;
      ({
        side,
        banner,
        matrix
      } = pvt.pivotStat([x, y], [(_field = field, coin(_field)), stat]));
      break;

    default:
      ({
        side,
        banner,
        matrix
      } = pvt.pivotMulti([x, y], cellEntries.map(([field, stat]) => {
        var _field2;

        return [(_field2 = field, coin(_field2)), stat];
      })));
  }

  const {
    calc
  } = spec;

  if (calc) {
    const fn = ar => calc.apply(null, ar);

    matrix = Mx.map(matrix, fn);
  }

  return CrosTab.from({
    side,
    banner,
    matrix,
    spec: spec.title
  });
};

class Table {
  /**
   *
   * @param {*[]} [banner]
   * @param {*[][]} [matrix]
   * @param {string} [title]
   * @param {*[]} [types]
   */
  constructor(_banner, matrix, title, types) {
    _fieldIndexes.add(this);

    this.banner = _banner || [];
    this.matrix = matrix || [[]];
    this.title = title || '';
    this.types = types;
  }
  /**
   *
   * @returns {[]|Array}
   */


  get types() {
    return this._types;
  }
  /**
   *
   * @param {Array} [value]
   */


  set types(value) {
    this._types = Ar.isEmpty(value) ? [] : value;
  }
  /**
   *
   * @param {*[]} [banner]
   * @param {*[][]} [matrix]
   * @param {string} [title]
   * @param {string[]} [types]
   * @return {Table}
   */


  static from({
    banner,
    matrix,
    title,
    types
  }) {
    return new Table(banner, matrix, title, types);
  }
  /**
   *
   * @param {string|number|[*,*]} [fields]
   * @returns {Object<*, *>[]}
   */


  toSamples(fields) {
    if (!(fields === null || fields === void 0 ? void 0 : fields.length)) return this.matrix.map(row => Ob.ini(this.banner, row));
    const entries = fields.map(x => Array.isArray(x) ? [[x[1]], this.coin(x[0])] : [x, this.coin(x)]);
    return this.matrix.map(row => Ob.fromEntries(entries, i => row[i]));
  }
  /**
   *
   * @param {boolean} [mutate=true]
   * @returns {*}
   */


  toJson(mutate = true) {
    var _matrix;

    const {
      banner,
      matrix,
      title
    } = this;
    return mutate ? {
      banner,
      matrix,
      title
    } : {
      banner: banner.slice(),
      matrix: (_matrix = matrix, Mx.clone(_matrix)),
      title: title.slice()
    };
  }
  /**
   *
   * @param {{}[]} samples
   * @param {*[]|[*,*][]} [fields]
   * @param {string} [title]
   * @param {*[]} [types]
   * @return {Table}
   */


  static fromSamples(samples, {
    fields,
    title,
    types
  } = {}) {
    const {
      head,
      rows
    } = Samples.toTable(samples, {
      fields
    });
    return new Table(head, rows, title, types);
  }
  /**
   * Return 'this' by loading a new matrix
   * @param {*[][]} newMx
   * @param {*[]} [newBanner]
   * @param {string[]} [newTypes]
   * @return {Table}
   */


  reboot(newMx, newBanner, newTypes) {
    this.matrix = newMx;
    if (newBanner) this.banner = newBanner;
    if (newTypes) this.types = newTypes;
    return this;
  }
  /**
   *
   * @param {*[][]} [newMx]
   * @param {*[]} [newBanner]
   * @param {*[]} [newTypes]
   * @return {Table}
   */


  clone(newMx, newBanner, newTypes) {
    var _this$matrix;

    return new Table(newBanner || this.banner.slice(), newMx || (_this$matrix = this.matrix, Mx.clone(_this$matrix)), this.title, newTypes || this.types.slice());
  }
  /**
   *
   * @param {*[]|[*,*][]} fields
   * @returns {{indexes: [], banner: []}|{indexes: *, banner: *}}
   */


  /**
   *
   * @param {*[]|[*,*][]} fields
   * @param {boolean=true} [mutate]
   * @returns {Table}
   */
  select(fields, {
    mutate = true
  } = {}) {
    if (!(fields === null || fields === void 0 ? void 0 : fields.length)) return mutate ? this : this.clone();

    const {
      indexes,
      banner
    } = _classPrivateMethodGet(this, _fieldIndexes, _fieldIndexes2).call(this, fields);

    const matrix = Mx.select(this.matrix, indexes);
    return mutate ? this.reboot(matrix, banner) : this.clone(matrix, banner);
  }
  /**
   *
   * @param {*[]|[*,*][]} fields
   * @param {boolean=true} [mutate]
   * @returns {Table}
   */


  spliceColumns(fields, {
    mutate = true
  } = {}) {
    var _matrix2;

    const ys = fields.map(c => this.coin(c)).sort(Comparer.numberAscending),
          {
      matrix,
      banner
    } = this;
    return mutate ? this.reboot(Mx.spliceCols(matrix, ys), Ar.splices(banner, ys)) : this.clone(Mx.spliceCols((_matrix2 = matrix, Mx.copy(_matrix2)), ys), Ar.splices(banner.slice(), ys));
  }

  map(fn, {
    mutate = true
  } = {}) {
    let {
      matrix
    } = this;
    matrix = Mx.map(matrix, fn);
    return mutate ? this.reboot(matrix) : this.clone(matrix);
  }

  mapBanner(fn, {
    mutate = true
  } = {}) {
    let {
      banner,
      matrix
    } = this;
    banner = banner.map(fn);
    return mutate ? this.reboot(matrix, banner) : this.clone(matrix, banner);
  }
  /**
   *
   * @param {Table} another
   * @param {string[]|number[]} indexFields
   * @param {number} joinType - union:0,left:1,right:2,intersect:-1
   * @param {*} [fillEmpty]
   * @returns {Table}
   */


  join(another, indexFields, joinType = JoinT.intersect, fillEmpty = null) {
    return TableJoin.join(this, another, indexFields, joinType, fillEmpty);
  }

  get size() {
    return Mx.size(this.matrix);
  }

  get ht() {
    var _this$matrix2;

    return (_this$matrix2 = this.matrix) === null || _this$matrix2 === void 0 ? void 0 : _this$matrix2.length;
  }

  get wd() {
    var _this$banner;

    return (_this$banner = this.banner) === null || _this$banner === void 0 ? void 0 : _this$banner.length;
  }

  get columns() {
    return Mx.transpose(this.matrix);
  } // set types (value) {
  //
  // }


  cell(x, y) {
    return this.matrix[x][y];
  }
  /**
   *
   * @param {string|number} c
   */


  coin(c) {
    return Number.isInteger(c) && 0 <= c && c < this.wd ? c : this.banner.indexOf(c);
  }

  column(c) {
    const y = this.coin(c);
    return this.matrix.map(row => row[y]);
  }

  setColumn(c, newColumn) {
    const y = this.coin(c),
          {
      ht,
      matrix
    } = this;

    for (let i = 0; i < ht; i++) matrix[i][y] = newColumn[i];

    return this;
  }
  /**
   *
   * @param {string|number} c
   * @param {function} ject
   */


  setColumnBy(c, ject) {
    const y = this.coin(c);

    for (let row of this.matrix) row[y] = ject(row[y]);

    return this;
  }
  /**
   * Push row into this and return this.
   * No shallow nor deep copy of the matrix.
   * @param {*[]} row
   * @return {Table}
   */


  pushRow(row) {
    this.matrix.push(row);
    return this;
  }
  /**
   * Unshift row into this and return this.
   * No shallow nor deep copy of the matrix.
   * @param {*[]} row
   * @return {Table}
   */


  unshiftRow(row) {
    this.matrix.unshift(row);
    return this;
  }
  /**
   * Push column into this and return this.
   * No shallow nor deep copy of the matrix.
   * @param {*} name
   * @param {*[]} col
   * @return {Table}
   */


  pushCol(name, col) {
    this.banner.push(name);
    this.matrix.forEach((row, i) => row.push(col[i]));
    return this;
  }
  /**
   * Unshift column into this and return this.
   * No shallow nor deep copy of the matrix.
   * @param {*} name
   * @param {*[]} col
   * @return {Table}
   */


  unshiftCol(name, col) {
    this.banner.unshift(name);
    this.matrix.forEach((row, i) => row.unshift(col[i]));
    return this;
  }
  /**
   *
   * Specify the type of a column. No return
   * @param {string|number} field accept both column name in string or column index in integer
   * @param {string} typeName string | (number, float) | integer | boolean
   */


  changeType(field, typeName) {
    const y = this.coin(field);
    let column = Mx.column(this.matrix, y);

    switch (typeName) {
      case 'string':
        column = column.map(totx);
        break;

      case 'number':
      case 'float':
        column = column.map(Number.parseFloat);
        break;

      case 'integer':
        column = column.map(Number.parseInt);
        break;

      case 'boolean':
        column = column.map(Boolean);
        break;

      default:
        typeName = this._types[y];
        break;
    }

    this.setColumn(field, column);
    this._types[y] = typeName;
    return this;
  }
  /**
   * Re-generate this._types based on DPTyp.inferArr method.
   * Cautious: This method will change all elements of this._types.
   * @return {string[]}
   */


  inferTypes() {
    const {
      infer
    } = ArrTyp;
    this.types = this.columns.map(infer);

    for (let [i, typ] of this.types.entries()) {
      switch (typ) {
        case 'numstr':
          this.changeType(i, 'number');
          break;

        case 'misc':
          this.changeType(i, 'string');
          break;
      }
    }

    return this.types;
  }
  /**
   *
   * @param {Object<string|number,function(*):boolean>} filters
   * @param {boolean} [mutate=true]
   * @return {Table}
   */


  filter(filters, {
    mutate = true
  } = {}) {
    let mx = this.matrix,
        y;

    for (let [field, crit] of Object.entries(filters)) {
      y = this.coin(field);
      if (y >= 0) mx = mx.filter(row => crit(row[y]));
    }

    return mutate ? this.reboot(mx) : this.clone(mx);
  }

  distinct(fields, {
    mutate = true
  } = {}) {
    let mx = this.matrix;

    for (let field of fields) mx = StatMx.distinct(mx, this.coin(field));

    return mutate ? this.reboot(mx) : this.clone(mx);
  }
  /**
   *
   * @param {string|number} field
   * @param {boolean} [count=false]
   * @param {string|boolean} [sort=false] - When sort is function, sort must be a comparer between two point element.
   * @returns {[any, any][]|[]|any[]|*}
   */


  distinctCol(field, {
    count = false,
    sort = false
  } = {}) {
    const y = this.coin(field);
    return StatMx.distinctCol(this.matrix, y, {
      count,
      sort
    });
  }

  sort(field, comparer, {
    mutate = true
  } = {}) {
    const y = this.coin(field),
          comp = (a, b) => comparer(a[y], b[y]),
          mx = this.matrix.slice().sort(comp);

    return mutate ? this.reboot(mx) : this.clone(mx);
  }
  /**
   *
   * @param {function(*,*):number} comparer - Comparer of banner elements
   * @param {boolean} mutate
   * @returns {Table|*}
   */


  sortLabel(comparer, {
    mutate = true
  } = {}) {
    var _columns, _columns2;

    let {
      banner,
      columns
    } = this;
    [banner, columns] = sortAlong(banner, columns, comparer);
    return mutate ? this.reboot((_columns = columns, Mx.transpose(_columns)), banner) : this.clone((_columns2 = columns, Mx.transpose(_columns2)), banner);
  }
  /**
   *
   * @param {TableSpec} spec
   * @param {string} spec.side side
   * @param {string} spec.banner banner
   * @param {{field:string, crit:function(*):boolean}[]} spec.filter
   * @param {{field:string, stat:function([]):number}[]} spec.cell
   * @param {function({}):number} spec.calc - ({col1,col2,...})=>number
   * @returns {CrosTab}
   */


  crosTab(spec) {
    return crosTabFut(this, spec);
  }
  /**
   *
   * @param {TableSpec} spec
   * @param {string} spec.side side
   * @param {string} spec.banner banner
   * @param {{field:string, crit:function(*):boolean}[]} spec.filter
   * @param {{field:string, stat:function([]):number}[]} spec.cell
   * @param {function({}):number} spec.calc - ({col1,col2,...})=>number
   * @returns {CrosTab}
   */


  figure(spec) {
    return crosTabFut(this, spec);
  }

}

var _fieldIndexes = new WeakSet();

var _fieldIndexes2 = function _fieldIndexes2(fields) {
  const hi = fields === null || fields === void 0 ? void 0 : fields.length;
  if (!hi) return {
    indexes: [],
    banner: []
  };
  const [indexes, banner] = [Array(hi), Array(hi)];

  for (let i = 0, x; i < hi; i++) {
    x = fields[i];
    [indexes[i], banner[i]] = Array.isArray(x) ? [this.coin(x[0]), x[1]] : [this.coin(x), x];
  }

  return {
    indexes,
    banner
  };
};

class TableJoin {
  /**
   *
   * @param {Table} table
   * @param {Table} another
   * @param {string[]|number[]} indexFields
   * @param {number} [joinType=-1] - union:0,left:1,right:2,intersect:-1
   * @param {*} [fillEmpty]
   * @returns {Table}
   */
  static join(table, another, indexFields, joinType = JoinT.intersect, fillEmpty = null) {
    const ysL = indexFields.map(x => table.coin(x)),
          ysR = indexFields.map(x => another.coin(x)),
          joinFn = joiner(joinType),
          matrix = joinFn({
      mx: table.matrix,
      ys: ysL
    }, {
      mx: another.matrix,
      ys: ysR
    }, fillEmpty),
          banner = Ar.select(table.banner, ysL).concat(Ar.splices(table.banner.slice(), ysL.slice().sort(Comparer.numberAscending)), Ar.splices(another.banner.slice(), ysL.slice().sort(Comparer.numberAscending)));
    return new Table(banner, matrix, `${table.title} ${another.title}`);
  }

}

// Create an object type Er
class Er extends Error {
  constructor(name, message) {
    super();
    this.name = name;
    this.message = message;
  }

  static r({
    name,
    message
  }) {
    return new Er(name || 'Error', message || '');
  } // Make the exception convert to a pretty string when used as
  // a string (e.g. by the error console)


  toString() {
    return `${this.name}: "${this.message}"`;
  }

}

/**
 *
 * @param {string|string[]|Object<string|number,function(*[]):number>} cell
 * @private
 */

const createCell = cell => {
  if (!cell) return {};

  switch (Typ.infer(cell)) {
    case 'string':
      return Ob.of([cell, 'sum']);

    case 'object':
      return Ob.mapValues(cell, x => x || 'sum');

    case 'array':
      return cell.length ? cell.map(el => typeof el === 'string' ? Ob.of([el, 'sum']) : Ob.of([el.field || '', el.stat || 'sum'])) : {};

    default:
      throw Er.r({
        message: 'Input is neither string nor array'
      });
  }
};
/***
 *
 * @property {string} side - side, a string
 * @property {string} banner - banner, a string
 * @property {Object<string|number,function(*):boolean>} [filter] - filter definition
 * @property {Object<string|number,function(*[]):number>} [cell] - cell definition
 * @property {function():number} [calc] - calc definition: function<field1,field2,...,number>
 */


class TableSpec {
  constructor(side, banner, cell, filter, calc) {
    var _cell;

    if (typeof side !== 'string') throw Er.r({
      message: 'Side is not string'
    });
    if (typeof banner !== 'string') throw Er.r({
      message: 'Banner is not string'
    });
    this.side = side;
    this.banner = banner;
    this.cell = (_cell = cell, createCell(_cell));
    this.filter = filter || {};
    this.calc = calc;
  }

  static from({
    side,
    banner,
    cell,
    filter,
    calc
  }) {
    return new TableSpec(side, banner, cell, filter, calc);
  }

  get title() {
    return `${this.side} * ${this.banner} · ${this.fields}`;
  }

  get fields() {
    return Object.keys(this.cell);
  }

  get filterFields() {
    return Object.keys(this.filter);
  }

  get toJson() {
    const {
      side,
      banner,
      cell,
      filter,
      calc
    } = this;
    return {
      side,
      banner,
      cell,
      filter,
      calc
    };
  }

}

export { CrosTab, JoinT, Table, TableJoin, TableSpec };