Initial commit

2021-10-23 19:59:20 +10:00
commit ba4c9a7d7a
1851 changed files with 1250444 additions and 0 deletions
--- a/node_modules/currency.js/dist/currency.d.ts
+++ b/node_modules/currency.js/dist/currency.d.ts
@@ -0,0 +1,42 @@
+declare module 'currency.js' {
+  namespace currency {
+    type Any = number | string | currency;
+    type Format = (currency?: currency, opts?: Options) => string;
+    interface Constructor {
+      (value: currency.Any, opts?: currency.Options): currency,
+      new(value: currency.Any, opts?: currency.Options): currency
+    }
+    interface Options {
+      symbol?: string,
+      separator?: string,
+      decimal?: string,
+      errorOnInvalid?: boolean,
+      precision?: number,
+      increment?: number,
+      useVedic?: boolean,
+      pattern?: string,
+      negativePattern?: string,
+      format?: currency.Format,
+      fromCents?: boolean
+    }
+  }
+
+  interface currency {
+    add(number: currency.Any): currency;
+    subtract(number: currency.Any): currency;
+    multiply(number: currency.Any): currency;
+    divide(number: currency.Any): currency;
+    distribute(count: number): Array<currency>;
+    dollars(): number;
+    cents(): number;
+    format(opts?: currency.Options | currency.Format): string;
+    toString(): string;
+    toJSON(): number;
+    readonly intValue: number;
+    readonly value: number;
+  }
+
+  const currency: currency.Constructor;
+
+  export = currency;
+}
--- a/node_modules/currency.js/dist/currency.es.js
+++ b/node_modules/currency.js/dist/currency.es.js
@@ -0,0 +1,254 @@
+/*!
+ * currency.js - v2.0.4
+ * http://scurker.github.io/currency.js
+ *
+ * Copyright (c) 2021 Jason Wilson
+ * Released under MIT license
+ */
+
+var defaults = {
+  symbol: '$',
+  separator: ',',
+  decimal: '.',
+  errorOnInvalid: false,
+  precision: 2,
+  pattern: '!#',
+  negativePattern: '-!#',
+  format: format,
+  fromCents: false
+};
+
+var round = function round(v) {
+  return Math.round(v);
+};
+
+var pow = function pow(p) {
+  return Math.pow(10, p);
+};
+
+var rounding = function rounding(value, increment) {
+  return round(value / increment) * increment;
+};
+
+var groupRegex = /(\d)(?=(\d{3})+\b)/g;
+var vedicRegex = /(\d)(?=(\d\d)+\d\b)/g;
+/**
+ * Create a new instance of currency.js
+ * @param {number|string|currency} value
+ * @param {object} [opts]
+ */
+
+function currency(value, opts) {
+  var that = this;
+
+  if (!(that instanceof currency)) {
+    return new currency(value, opts);
+  }
+
+  var settings = Object.assign({}, defaults, opts),
+      precision = pow(settings.precision),
+      v = parse(value, settings);
+  that.intValue = v;
+  that.value = v / precision; // Set default incremental value
+
+  settings.increment = settings.increment || 1 / precision; // Support vedic numbering systems
+  // see: https://en.wikipedia.org/wiki/Indian_numbering_system
+
+  if (settings.useVedic) {
+    settings.groups = vedicRegex;
+  } else {
+    settings.groups = groupRegex;
+  } // Intended for internal usage only - subject to change
+
+
+  this.s = settings;
+  this.p = precision;
+}
+
+function parse(value, opts) {
+  var useRounding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var v = 0,
+      decimal = opts.decimal,
+      errorOnInvalid = opts.errorOnInvalid,
+      decimals = opts.precision,
+      fromCents = opts.fromCents,
+      precision = pow(decimals),
+      isNumber = typeof value === 'number',
+      isCurrency = value instanceof currency;
+
+  if (isCurrency && fromCents) {
+    return value.intValue;
+  }
+
+  if (isNumber || isCurrency) {
+    v = isCurrency ? value.value : value;
+  } else if (typeof value === 'string') {
+    var regex = new RegExp('[^-\\d' + decimal + ']', 'g'),
+        decimalString = new RegExp('\\' + decimal, 'g');
+    v = value.replace(/\((.*)\)/, '-$1') // allow negative e.g. (1.99)
+    .replace(regex, '') // replace any non numeric values
+    .replace(decimalString, '.'); // convert any decimal values
+
+    v = v || 0;
+  } else {
+    if (errorOnInvalid) {
+      throw Error('Invalid Input');
+    }
+
+    v = 0;
+  }
+
+  if (!fromCents) {
+    v *= precision; // scale number to integer value
+
+    v = v.toFixed(4); // Handle additional decimal for proper rounding.
+  }
+
+  return useRounding ? round(v) : v;
+}
+/**
+ * Formats a currency object
+ * @param currency
+ * @param {object} [opts]
+ */
+
+
+function format(currency, settings) {
+  var pattern = settings.pattern,
+      negativePattern = settings.negativePattern,
+      symbol = settings.symbol,
+      separator = settings.separator,
+      decimal = settings.decimal,
+      groups = settings.groups,
+      split = ('' + currency).replace(/^-/, '').split('.'),
+      dollars = split[0],
+      cents = split[1];
+  return (currency.value >= 0 ? pattern : negativePattern).replace('!', symbol).replace('#', dollars.replace(groups, '$1' + separator) + (cents ? decimal + cents : ''));
+}
+
+currency.prototype = {
+  /**
+   * Adds values together.
+   * @param {number} number
+   * @returns {currency}
+   */
+  add: function add(number) {
+    var intValue = this.intValue,
+        _settings = this.s,
+        _precision = this.p;
+    return currency((intValue += parse(number, _settings)) / (_settings.fromCents ? 1 : _precision), _settings);
+  },
+
+  /**
+   * Subtracts value.
+   * @param {number} number
+   * @returns {currency}
+   */
+  subtract: function subtract(number) {
+    var intValue = this.intValue,
+        _settings = this.s,
+        _precision = this.p;
+    return currency((intValue -= parse(number, _settings)) / (_settings.fromCents ? 1 : _precision), _settings);
+  },
+
+  /**
+   * Multiplies values.
+   * @param {number} number
+   * @returns {currency}
+   */
+  multiply: function multiply(number) {
+    var intValue = this.intValue,
+        _settings = this.s;
+    return currency((intValue *= number) / (_settings.fromCents ? 1 : pow(_settings.precision)), _settings);
+  },
+
+  /**
+   * Divides value.
+   * @param {number} number
+   * @returns {currency}
+   */
+  divide: function divide(number) {
+    var intValue = this.intValue,
+        _settings = this.s;
+    return currency(intValue /= parse(number, _settings, false), _settings);
+  },
+
+  /**
+   * Takes the currency amount and distributes the values evenly. Any extra pennies
+   * left over from the distribution will be stacked onto the first set of entries.
+   * @param {number} count
+   * @returns {array}
+   */
+  distribute: function distribute(count) {
+    var intValue = this.intValue,
+        _precision = this.p,
+        _settings = this.s,
+        distribution = [],
+        split = Math[intValue >= 0 ? 'floor' : 'ceil'](intValue / count),
+        pennies = Math.abs(intValue - split * count),
+        precision = _settings.fromCents ? 1 : _precision;
+
+    for (; count !== 0; count--) {
+      var item = currency(split / precision, _settings); // Add any left over pennies
+
+      pennies-- > 0 && (item = item[intValue >= 0 ? 'add' : 'subtract'](1 / precision));
+      distribution.push(item);
+    }
+
+    return distribution;
+  },
+
+  /**
+   * Returns the dollar value.
+   * @returns {number}
+   */
+  dollars: function dollars() {
+    return ~~this.value;
+  },
+
+  /**
+   * Returns the cent value.
+   * @returns {number}
+   */
+  cents: function cents() {
+    var intValue = this.intValue,
+        _precision = this.p;
+    return ~~(intValue % _precision);
+  },
+
+  /**
+   * Formats the value as a string according to the formatting settings.
+   * @param {boolean} useSymbol - format with currency symbol
+   * @returns {string}
+   */
+  format: function format(options) {
+    var _settings = this.s;
+
+    if (typeof options === 'function') {
+      return options(this, _settings);
+    }
+
+    return _settings.format(this, Object.assign({}, _settings, options));
+  },
+
+  /**
+   * Formats the value as a string according to the formatting settings.
+   * @returns {string}
+   */
+  toString: function toString() {
+    var intValue = this.intValue,
+        _precision = this.p,
+        _settings = this.s;
+    return rounding(intValue / _precision, _settings.increment).toFixed(_settings.precision);
+  },
+
+  /**
+   * Value for JSON serialization.
+   * @returns {float}
+   */
+  toJSON: function toJSON() {
+    return this.value;
+  }
+};
+
+export default currency;
--- a/node_modules/currency.js/dist/currency.js
+++ b/node_modules/currency.js/dist/currency.js
@@ -0,0 +1,256 @@
+/*!
+ * currency.js - v2.0.4
+ * http://scurker.github.io/currency.js
+ *
+ * Copyright (c) 2021 Jason Wilson
+ * Released under MIT license
+ */
+
+'use strict';
+
+var defaults = {
+  symbol: '$',
+  separator: ',',
+  decimal: '.',
+  errorOnInvalid: false,
+  precision: 2,
+  pattern: '!#',
+  negativePattern: '-!#',
+  format: format,
+  fromCents: false
+};
+
+var round = function round(v) {
+  return Math.round(v);
+};
+
+var pow = function pow(p) {
+  return Math.pow(10, p);
+};
+
+var rounding = function rounding(value, increment) {
+  return round(value / increment) * increment;
+};
+
+var groupRegex = /(\d)(?=(\d{3})+\b)/g;
+var vedicRegex = /(\d)(?=(\d\d)+\d\b)/g;
+/**
+ * Create a new instance of currency.js
+ * @param {number|string|currency} value
+ * @param {object} [opts]
+ */
+
+function currency(value, opts) {
+  var that = this;
+
+  if (!(that instanceof currency)) {
+    return new currency(value, opts);
+  }
+
+  var settings = Object.assign({}, defaults, opts),
+      precision = pow(settings.precision),
+      v = parse(value, settings);
+  that.intValue = v;
+  that.value = v / precision; // Set default incremental value
+
+  settings.increment = settings.increment || 1 / precision; // Support vedic numbering systems
+  // see: https://en.wikipedia.org/wiki/Indian_numbering_system
+
+  if (settings.useVedic) {
+    settings.groups = vedicRegex;
+  } else {
+    settings.groups = groupRegex;
+  } // Intended for internal usage only - subject to change
+
+
+  this.s = settings;
+  this.p = precision;
+}
+
+function parse(value, opts) {
+  var useRounding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var v = 0,
+      decimal = opts.decimal,
+      errorOnInvalid = opts.errorOnInvalid,
+      decimals = opts.precision,
+      fromCents = opts.fromCents,
+      precision = pow(decimals),
+      isNumber = typeof value === 'number',
+      isCurrency = value instanceof currency;
+
+  if (isCurrency && fromCents) {
+    return value.intValue;
+  }
+
+  if (isNumber || isCurrency) {
+    v = isCurrency ? value.value : value;
+  } else if (typeof value === 'string') {
+    var regex = new RegExp('[^-\\d' + decimal + ']', 'g'),
+        decimalString = new RegExp('\\' + decimal, 'g');
+    v = value.replace(/\((.*)\)/, '-$1') // allow negative e.g. (1.99)
+    .replace(regex, '') // replace any non numeric values
+    .replace(decimalString, '.'); // convert any decimal values
+
+    v = v || 0;
+  } else {
+    if (errorOnInvalid) {
+      throw Error('Invalid Input');
+    }
+
+    v = 0;
+  }
+
+  if (!fromCents) {
+    v *= precision; // scale number to integer value
+
+    v = v.toFixed(4); // Handle additional decimal for proper rounding.
+  }
+
+  return useRounding ? round(v) : v;
+}
+/**
+ * Formats a currency object
+ * @param currency
+ * @param {object} [opts]
+ */
+
+
+function format(currency, settings) {
+  var pattern = settings.pattern,
+      negativePattern = settings.negativePattern,
+      symbol = settings.symbol,
+      separator = settings.separator,
+      decimal = settings.decimal,
+      groups = settings.groups,
+      split = ('' + currency).replace(/^-/, '').split('.'),
+      dollars = split[0],
+      cents = split[1];
+  return (currency.value >= 0 ? pattern : negativePattern).replace('!', symbol).replace('#', dollars.replace(groups, '$1' + separator) + (cents ? decimal + cents : ''));
+}
+
+currency.prototype = {
+  /**
+   * Adds values together.
+   * @param {number} number
+   * @returns {currency}
+   */
+  add: function add(number) {
+    var intValue = this.intValue,
+        _settings = this.s,
+        _precision = this.p;
+    return currency((intValue += parse(number, _settings)) / (_settings.fromCents ? 1 : _precision), _settings);
+  },
+
+  /**
+   * Subtracts value.
+   * @param {number} number
+   * @returns {currency}
+   */
+  subtract: function subtract(number) {
+    var intValue = this.intValue,
+        _settings = this.s,
+        _precision = this.p;
+    return currency((intValue -= parse(number, _settings)) / (_settings.fromCents ? 1 : _precision), _settings);
+  },
+
+  /**
+   * Multiplies values.
+   * @param {number} number
+   * @returns {currency}
+   */
+  multiply: function multiply(number) {
+    var intValue = this.intValue,
+        _settings = this.s;
+    return currency((intValue *= number) / (_settings.fromCents ? 1 : pow(_settings.precision)), _settings);
+  },
+
+  /**
+   * Divides value.
+   * @param {number} number
+   * @returns {currency}
+   */
+  divide: function divide(number) {
+    var intValue = this.intValue,
+        _settings = this.s;
+    return currency(intValue /= parse(number, _settings, false), _settings);
+  },
+
+  /**
+   * Takes the currency amount and distributes the values evenly. Any extra pennies
+   * left over from the distribution will be stacked onto the first set of entries.
+   * @param {number} count
+   * @returns {array}
+   */
+  distribute: function distribute(count) {
+    var intValue = this.intValue,
+        _precision = this.p,
+        _settings = this.s,
+        distribution = [],
+        split = Math[intValue >= 0 ? 'floor' : 'ceil'](intValue / count),
+        pennies = Math.abs(intValue - split * count),
+        precision = _settings.fromCents ? 1 : _precision;
+
+    for (; count !== 0; count--) {
+      var item = currency(split / precision, _settings); // Add any left over pennies
+
+      pennies-- > 0 && (item = item[intValue >= 0 ? 'add' : 'subtract'](1 / precision));
+      distribution.push(item);
+    }
+
+    return distribution;
+  },
+
+  /**
+   * Returns the dollar value.
+   * @returns {number}
+   */
+  dollars: function dollars() {
+    return ~~this.value;
+  },
+
+  /**
+   * Returns the cent value.
+   * @returns {number}
+   */
+  cents: function cents() {
+    var intValue = this.intValue,
+        _precision = this.p;
+    return ~~(intValue % _precision);
+  },
+
+  /**
+   * Formats the value as a string according to the formatting settings.
+   * @param {boolean} useSymbol - format with currency symbol
+   * @returns {string}
+   */
+  format: function format(options) {
+    var _settings = this.s;
+
+    if (typeof options === 'function') {
+      return options(this, _settings);
+    }
+
+    return _settings.format(this, Object.assign({}, _settings, options));
+  },
+
+  /**
+   * Formats the value as a string according to the formatting settings.
+   * @returns {string}
+   */
+  toString: function toString() {
+    var intValue = this.intValue,
+        _precision = this.p,
+        _settings = this.s;
+    return rounding(intValue / _precision, _settings.increment).toFixed(_settings.precision);
+  },
+
+  /**
+   * Value for JSON serialization.
+   * @returns {float}
+   */
+  toJSON: function toJSON() {
+    return this.value;
+  }
+};
+
+module.exports = currency;
--- a/node_modules/currency.js/dist/currency.js.flow
+++ b/node_modules/currency.js/dist/currency.js.flow
@@ -0,0 +1,37 @@
+// @flow
+declare type $currency$any = number | string | currency;
+
+declare type formatFunction = (currency: currency, options: $currency$opts) => string;
+
+declare type $currency$opts = {
+  symbol?: string,
+  separator?: string,
+  decimal?: string,
+  errorOnInvalid?: boolean,
+  precision?: number,
+  increment?: number,
+  useVedic?: boolean,
+  pattern?: string,
+  negativePattern?: string,
+  format?: formatFunction,
+  fromCents?: boolean
+}
+
+declare class currency {
+  static (value: $currency$any, opts?: $currency$opts): currency,
+  constructor(value: $currency$any, opts?: $currency$opts): currency,
+  add(number: $currency$any): currency;
+  subtract(number: $currency$any): currency;
+  multiply(number: $currency$any): currency;
+  divide(number: $currency$any): currency;
+  distribute(count: number): Array<currency>;
+  dollars(): number;
+  cents(): number;
+  format(options?: $currency$opts | formatFunction): string;
+  toString(): string;
+  toJSON(): number;
+  +intValue: number;
+  +value: number;
+}
+
+declare module.exports: typeof currency;
--- a/node_modules/currency.js/dist/currency.min.js
+++ b/node_modules/currency.js/dist/currency.min.js
@@ -0,0 +1,12 @@
+/*
+ currency.js - v2.0.4
+ http://scurker.github.io/currency.js
+
+ Copyright (c) 2021 Jason Wilson
+ Released under MIT license
+*/
+(function(e,g){"object"===typeof exports&&"undefined"!==typeof module?module.exports=g():"function"===typeof define&&define.amd?define(g):(e=e||self,e.currency=g())})(this,function(){function e(b,a){if(!(this instanceof e))return new e(b,a);a=Object.assign({},m,a);var d=Math.pow(10,a.precision);this.intValue=b=g(b,a);this.value=b/d;a.increment=a.increment||1/d;a.groups=a.useVedic?n:p;this.s=a;this.p=d}function g(b,a){var d=2<arguments.length&&void 0!==arguments[2]?arguments[2]:!0;var c=a.decimal;
+var h=a.errorOnInvalid,k=a.fromCents,l=Math.pow(10,a.precision),f=b instanceof e;if(f&&k)return b.intValue;if("number"===typeof b||f)c=f?b.value:b;else if("string"===typeof b)h=new RegExp("[^-\\d"+c+"]","g"),c=new RegExp("\\"+c,"g"),c=(c=b.replace(/\((.*)\)/,"-$1").replace(h,"").replace(c,"."))||0;else{if(h)throw Error("Invalid Input");c=0}k||(c=(c*l).toFixed(4));return d?Math.round(c):c}var m={symbol:"$",separator:",",decimal:".",errorOnInvalid:!1,precision:2,pattern:"!#",negativePattern:"-!#",format:function(b,
+a){var d=a.pattern,c=a.negativePattern,h=a.symbol,k=a.separator,l=a.decimal;a=a.groups;var f=(""+b).replace(/^-/,"").split("."),q=f[0];f=f[1];return(0<=b.value?d:c).replace("!",h).replace("#",q.replace(a,"$1"+k)+(f?l+f:""))},fromCents:!1},p=/(\d)(?=(\d{3})+\b)/g,n=/(\d)(?=(\d\d)+\d\b)/g;e.prototype={add:function(b){var a=this.s,d=this.p;return e((this.intValue+g(b,a))/(a.fromCents?1:d),a)},subtract:function(b){var a=this.s,d=this.p;return e((this.intValue-g(b,a))/(a.fromCents?1:d),a)},multiply:function(b){var a=
+this.s;return e(this.intValue*b/(a.fromCents?1:Math.pow(10,a.precision)),a)},divide:function(b){var a=this.s;return e(this.intValue/g(b,a,!1),a)},distribute:function(b){var a=this.intValue,d=this.p,c=this.s,h=[],k=Math[0<=a?"floor":"ceil"](a/b),l=Math.abs(a-k*b);for(d=c.fromCents?1:d;0!==b;b--){var f=e(k/d,c);0<l--&&(f=f[0<=a?"add":"subtract"](1/d));h.push(f)}return h},dollars:function(){return~~this.value},cents:function(){return~~(this.intValue%this.p)},format:function(b){var a=this.s;return"function"===
+typeof b?b(this,a):a.format(this,Object.assign({},a,b))},toString:function(){var b=this.s,a=b.increment;return(Math.round(this.intValue/this.p/a)*a).toFixed(b.precision)},toJSON:function(){return this.value}};return e});
--- a/node_modules/currency.js/dist/currency.umd.js
+++ b/node_modules/currency.js/dist/currency.umd.js
@@ -0,0 +1,262 @@
+/*!
+ * currency.js - v2.0.4
+ * http://scurker.github.io/currency.js
+ *
+ * Copyright (c) 2021 Jason Wilson
+ * Released under MIT license
+ */
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = global || self, global.currency = factory());
+}(this, (function () { 'use strict';
+
+  var defaults = {
+    symbol: '$',
+    separator: ',',
+    decimal: '.',
+    errorOnInvalid: false,
+    precision: 2,
+    pattern: '!#',
+    negativePattern: '-!#',
+    format: format,
+    fromCents: false
+  };
+
+  var round = function round(v) {
+    return Math.round(v);
+  };
+
+  var pow = function pow(p) {
+    return Math.pow(10, p);
+  };
+
+  var rounding = function rounding(value, increment) {
+    return round(value / increment) * increment;
+  };
+
+  var groupRegex = /(\d)(?=(\d{3})+\b)/g;
+  var vedicRegex = /(\d)(?=(\d\d)+\d\b)/g;
+  /**
+   * Create a new instance of currency.js
+   * @param {number|string|currency} value
+   * @param {object} [opts]
+   */
+
+  function currency(value, opts) {
+    var that = this;
+
+    if (!(that instanceof currency)) {
+      return new currency(value, opts);
+    }
+
+    var settings = Object.assign({}, defaults, opts),
+        precision = pow(settings.precision),
+        v = parse(value, settings);
+    that.intValue = v;
+    that.value = v / precision; // Set default incremental value
+
+    settings.increment = settings.increment || 1 / precision; // Support vedic numbering systems
+    // see: https://en.wikipedia.org/wiki/Indian_numbering_system
+
+    if (settings.useVedic) {
+      settings.groups = vedicRegex;
+    } else {
+      settings.groups = groupRegex;
+    } // Intended for internal usage only - subject to change
+
+
+    this.s = settings;
+    this.p = precision;
+  }
+
+  function parse(value, opts) {
+    var useRounding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    var v = 0,
+        decimal = opts.decimal,
+        errorOnInvalid = opts.errorOnInvalid,
+        decimals = opts.precision,
+        fromCents = opts.fromCents,
+        precision = pow(decimals),
+        isNumber = typeof value === 'number',
+        isCurrency = value instanceof currency;
+
+    if (isCurrency && fromCents) {
+      return value.intValue;
+    }
+
+    if (isNumber || isCurrency) {
+      v = isCurrency ? value.value : value;
+    } else if (typeof value === 'string') {
+      var regex = new RegExp('[^-\\d' + decimal + ']', 'g'),
+          decimalString = new RegExp('\\' + decimal, 'g');
+      v = value.replace(/\((.*)\)/, '-$1') // allow negative e.g. (1.99)
+      .replace(regex, '') // replace any non numeric values
+      .replace(decimalString, '.'); // convert any decimal values
+
+      v = v || 0;
+    } else {
+      if (errorOnInvalid) {
+        throw Error('Invalid Input');
+      }
+
+      v = 0;
+    }
+
+    if (!fromCents) {
+      v *= precision; // scale number to integer value
+
+      v = v.toFixed(4); // Handle additional decimal for proper rounding.
+    }
+
+    return useRounding ? round(v) : v;
+  }
+  /**
+   * Formats a currency object
+   * @param currency
+   * @param {object} [opts]
+   */
+
+
+  function format(currency, settings) {
+    var pattern = settings.pattern,
+        negativePattern = settings.negativePattern,
+        symbol = settings.symbol,
+        separator = settings.separator,
+        decimal = settings.decimal,
+        groups = settings.groups,
+        split = ('' + currency).replace(/^-/, '').split('.'),
+        dollars = split[0],
+        cents = split[1];
+    return (currency.value >= 0 ? pattern : negativePattern).replace('!', symbol).replace('#', dollars.replace(groups, '$1' + separator) + (cents ? decimal + cents : ''));
+  }
+
+  currency.prototype = {
+    /**
+     * Adds values together.
+     * @param {number} number
+     * @returns {currency}
+     */
+    add: function add(number) {
+      var intValue = this.intValue,
+          _settings = this.s,
+          _precision = this.p;
+      return currency((intValue += parse(number, _settings)) / (_settings.fromCents ? 1 : _precision), _settings);
+    },
+
+    /**
+     * Subtracts value.
+     * @param {number} number
+     * @returns {currency}
+     */
+    subtract: function subtract(number) {
+      var intValue = this.intValue,
+          _settings = this.s,
+          _precision = this.p;
+      return currency((intValue -= parse(number, _settings)) / (_settings.fromCents ? 1 : _precision), _settings);
+    },
+
+    /**
+     * Multiplies values.
+     * @param {number} number
+     * @returns {currency}
+     */
+    multiply: function multiply(number) {
+      var intValue = this.intValue,
+          _settings = this.s;
+      return currency((intValue *= number) / (_settings.fromCents ? 1 : pow(_settings.precision)), _settings);
+    },
+
+    /**
+     * Divides value.
+     * @param {number} number
+     * @returns {currency}
+     */
+    divide: function divide(number) {
+      var intValue = this.intValue,
+          _settings = this.s;
+      return currency(intValue /= parse(number, _settings, false), _settings);
+    },
+
+    /**
+     * Takes the currency amount and distributes the values evenly. Any extra pennies
+     * left over from the distribution will be stacked onto the first set of entries.
+     * @param {number} count
+     * @returns {array}
+     */
+    distribute: function distribute(count) {
+      var intValue = this.intValue,
+          _precision = this.p,
+          _settings = this.s,
+          distribution = [],
+          split = Math[intValue >= 0 ? 'floor' : 'ceil'](intValue / count),
+          pennies = Math.abs(intValue - split * count),
+          precision = _settings.fromCents ? 1 : _precision;
+
+      for (; count !== 0; count--) {
+        var item = currency(split / precision, _settings); // Add any left over pennies
+
+        pennies-- > 0 && (item = item[intValue >= 0 ? 'add' : 'subtract'](1 / precision));
+        distribution.push(item);
+      }
+
+      return distribution;
+    },
+
+    /**
+     * Returns the dollar value.
+     * @returns {number}
+     */
+    dollars: function dollars() {
+      return ~~this.value;
+    },
+
+    /**
+     * Returns the cent value.
+     * @returns {number}
+     */
+    cents: function cents() {
+      var intValue = this.intValue,
+          _precision = this.p;
+      return ~~(intValue % _precision);
+    },
+
+    /**
+     * Formats the value as a string according to the formatting settings.
+     * @param {boolean} useSymbol - format with currency symbol
+     * @returns {string}
+     */
+    format: function format(options) {
+      var _settings = this.s;
+
+      if (typeof options === 'function') {
+        return options(this, _settings);
+      }
+
+      return _settings.format(this, Object.assign({}, _settings, options));
+    },
+
+    /**
+     * Formats the value as a string according to the formatting settings.
+     * @returns {string}
+     */
+    toString: function toString() {
+      var intValue = this.intValue,
+          _precision = this.p,
+          _settings = this.s;
+      return rounding(intValue / _precision, _settings.increment).toFixed(_settings.precision);
+    },
+
+    /**
+     * Value for JSON serialization.
+     * @returns {float}
+     */
+    toJSON: function toJSON() {
+      return this.value;
+    }
+  };
+
+  return currency;
+
+})));
--- a/node_modules/currency.js/license
+++ b/node_modules/currency.js/license
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jason Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/node_modules/currency.js/package.json
+++ b/node_modules/currency.js/package.json
@@ -0,0 +1,129 @@
+{
+  "_args": [
+    [
+      "currency.js@2.0.4",
+      "C:\\Users\\dredgy\\RiderProjects\\DredgePos\\DredgePos"
+    ]
+  ],
+  "_from": "currency.js@2.0.4",
+  "_id": "currency.js@2.0.4",
+  "_inBundle": false,
+  "_integrity": "sha512-6/OplJYgJ0RUlli74d93HJ/OsKVBi8lB1+Z6eJYS1YZzBuIp4qKKHpJ7ad+GvTlWmLR/hLJOWTykN5Nm8NJ7+w==",
+  "_location": "/currency.js",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "currency.js@2.0.4",
+    "name": "currency.js",
+    "escapedName": "currency.js",
+    "rawSpec": "2.0.4",
+    "saveSpec": null,
+    "fetchSpec": "2.0.4"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/currency.js/-/currency.js-2.0.4.tgz",
+  "_spec": "2.0.4",
+  "_where": "C:\\Users\\dredgy\\RiderProjects\\DredgePos\\DredgePos",
+  "author": {
+    "name": "Jason Wilson"
+  },
+  "browser": "dist/currency.min.js",
+  "bugs": {
+    "url": "https://github.com/scurker/currency.js/issues"
+  },
+  "description": "A small, lightweight javascript library for working with currency values.",
+  "devDependencies": {
+    "@babel/cli": "^7.10.4",
+    "@babel/core": "^7.10.4",
+    "@babel/node": "^7.10.4",
+    "@babel/preset-env": "^7.10.4",
+    "@babel/preset-flow": "^7.10.4",
+    "@babel/register": "^7.5.5",
+    "@scurker/eslint-config": "^1.1.5",
+    "ava": "^2.2.0",
+    "cheerio": "^1.0.0-rc",
+    "eslint": "^7.4.0",
+    "flow-bin": "^0.151.0",
+    "google-closure-compiler-js": "^20200719.0.0",
+    "gzip-size": "^6.0.0",
+    "handlebars": "^4.7.6",
+    "highlight.js": "^10.0.0",
+    "html-minifier": "^4.0.0",
+    "matchdep": "^2.0.0",
+    "metalsmith": "^2.3.0",
+    "metalsmith-ignore": "^1.0.0",
+    "metalsmith-markdown": "^1.3.0",
+    "minimatch": "^3.0.4",
+    "npm-run-all": "^4.1.5",
+    "nyc": "^15.1.0",
+    "pretty-bytes": "^5.3.0",
+    "rollup": "^2.21.0",
+    "rollup-plugin-babel": "^4.4.0",
+    "sinon": "^10.0.0",
+    "typescript": "^4.0.2"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "http://scurker.github.io/currency.js",
+  "js:next": "dist/currency.es.js",
+  "keywords": [
+    "currency",
+    "money",
+    "utilities",
+    "accounting",
+    "format",
+    "number",
+    "parse",
+    "precision",
+    "decimal"
+  ],
+  "license": "MIT",
+  "main": "dist/currency.js",
+  "module": "dist/currency.es.js",
+  "name": "currency.js",
+  "nyc": {
+    "include": [
+      "dist/**/*.js"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/scurker/currency.js.git"
+  },
+  "scripts": {
+    "build": "npm-run-all clean transpile copy-typescript-definition copy-flow-definition",
+    "build:docs": "npm-run-all clean:docs compile:docs minify:docs",
+    "clean": "rm -rf dist/*",
+    "clean:docs": "rm -rf docs/build",
+    "compile:docs": "npx babel-node --presets=@babel/preset-env ./docs/src/build-docs.js",
+    "copy-flow-definition": "cp -f src/currency.js.flow dist",
+    "copy-typescript-definition": "cp -f src/currency.d.ts dist",
+    "coverage": "BABEL_ENV=test nyc ava ./test/test.js",
+    "coverage:report": "nyc report --reporter=text-lcov > lcov.info",
+    "lint": "eslint .",
+    "minify:docs": "html-minifier --input-dir ./docs/build --output-dir ./docs/build --file-ext html --collapse-whitespace --decode-entities --minify-css --minify-js",
+    "prepare": "npm run build",
+    "pretest:flow": "npm run copy-flow-definition",
+    "pretest:js": "npm run transpile:es",
+    "pretest:typescript": "npm run copy-typescript-definition",
+    "test": "npm-run-all test:typescript test:flow test:js",
+    "test:flow": "flow",
+    "test:js": "BABEL_ENV=test ava ./test/test.js",
+    "test:typescript": "tsc -p ./test --noEmit",
+    "transpile": "npm-run-all transpile:*",
+    "transpile:es": "rollup -c ./config/rollup.config.js",
+    "transpile:umd": "rollup -c ./config/rollup.umd.js"
+  },
+  "typings": "./dist/currency.d.ts",
+  "version": "2.0.4"
+}
--- a/node_modules/currency.js/readme.md
+++ b/node_modules/currency.js/readme.md
@@ -0,0 +1,179 @@
+<div align="center" markdown="1">
+
+![currency.js logo](https://user-images.githubusercontent.com/1062039/31397824-9dfa15f0-adac-11e7-9869-fb20746e90c1.png)
+
+# currency.js
+
+[![Build Status](https://github.com/scurker/currency.js/actions/workflows/ci.yml/badge.svg)](https://github.com/scurker/currency.js/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/scurker/currency.js/badge.svg?branch=master&service=github)](https://coveralls.io/github/scurker/currency.js?branch=master)
+[![npm](https://img.shields.io/npm/v/currency.js.svg?style=flat)](https://www.npmjs.com/package/currency.js)
+[![gzip size](http://img.badgesize.io/https://unpkg.com/currency.js/dist/currency.min.js?compression=gzip)](https://unpkg.com/currency.js/dist/currency.min.js)
+
+</div>
+
+*currency.js* is a lightweight ~1kb javascript library for working with currency values. It was built to work around floating point issues in javascript. This [talk by Bartek Szopka](http://www.youtube.com/watch?v=MqHDDtVYJRI) explains in detail why javascript has floating point issues.
+
+currency.js works with values as integers behind the scenes, resolving some of the most basic precision problems.
+
+```javascript
+2.51 + .01;                   // 2.5199999999999996
+currency(2.51).add(.01);      // 2.52
+
+2.52 - .01;                   // 2.5100000000000002
+currency(2.52).subtract(.01); // 2.51
+```
+
+This should work for most *reasonable* values of currencies. As long as your currency values are less than 2<sup>53</sup> (in cents) or 90,071,992,547,409.91 you should be okay.
+
+### Features
+
+* *0 dependencies!*
+* Immutable
+* Flexible formatting options
+* Handles *any* type of currency input, strings, numbers, or another currency instance
+
+### Installation
+
+With [npm](https://www.npmjs.com/):
+
+```sh
+npm install --save currency.js
+```
+
+With [yarn](https://yarnpkg.com):
+
+```sh
+yarn add currency.js
+```
+
+Via cdn:
+
+```html
+<script src="https://unpkg.com/currency.js@~2.0.0/dist/currency.min.js"></script>
+```
+
+Need the latest cutting edge? All commits on master are tagged with `next` on npm:
+
+```sh
+npm install --save currency.js@next
+```
+
+### Usage
+
+Currency will accept numbers, strings, or the currency object itself as values.
+
+```javascript
+currency(123);      // 123.00
+currency(1.23);     // 1.23
+currency("1.23")    // 1.23
+currency("$12.30")  // 12.30
+
+var value = currency("123.45");
+currency(value);    // 123.45
+```
+
+Currency accepts decimal values (i.e. `1.23`) with a default precision of 2, but can accept a minor currency unit (e.g. cents in a dollar). This will respect the precision option when parsing.
+
+```javascript
+currency(123, { fromCents: true });               // 1.23
+currency('123', { fromCents: true });             // 1.23
+currency(123, { fromCents: true, precision: 0 }); // 123
+currency(123, { fromCents: true, precision: 3 }); // 0.123
+```
+
+There's various arithmetic methods that help take the guesswork out of trying to resolve floating point problems.
+
+```javascript
+currency(123.50).add(0.23);       // 123.73
+currency(5.00).subtract(0.50);    // 4.50
+currency(45.25).multiply(3);      // 135.75
+currency(1.12).distribute(5);     // [0.23, 0.23, 0.22, 0.22, 0.22]
+```
+
+There's even a built in formatter that will automatically place comma delimiters in the right place.
+
+```javascript
+currency("2,573,693.75").add("100,275.50").format();  // "$2,673,969.25"
+currency("1,237.72").subtract(300).format();          // "$937.72"
+```
+
+You can also change the format, localizing the decimal and/or delimiter to your locale.
+
+```javascript
+var euro = value => currency(value, { symbol: "€", separator: ".", decimal: "," });
+euro("2.573.693,75").add("100.275,50").format();  // "€2.673.969,25"
+euro("1.237,72").subtract(300).format();          // "€937,72"
+```
+
+### Options
+
+*currency.js* comes with its own set of default options conforming to USD. You can customize these according to your locale.
+
+`symbol` *default*: `$`<br/>
+Currency symbol included when calling `currency.format()`.
+
+`separator` *default*: `,`<br/>
+Separator dividing the number groups when calling `currency.format()`.
+
+`decimal` *default*: `.`<br/>
+Decimal used when calling `currency.format()`.
+
+`precision` *default*: `2`<br/>
+Number of decimal places to store as cents.
+
+`pattern` *default*: `!#`<br/>
+Allows you to customize the format pattern using `!` as replacement for the currency symbol and `#` as replacement for the currency amount.
+
+`negativePattern` *default*: `-!#`<br/>
+Allows you to customize the negative format pattern using `!` as replacement for the currency symbol and `#` as replacement for the currency amount.
+
+`format` *default* `null`
+Allows you to customize the format of the currency when calling `currency.format()`. `format` passes in the `currency` object as well as the `options` object to the function and expects a string to be returned. Use this when the provided formatting options do not meet your needs.
+
+`errorOnInvalid` *default*: `false`<br/>
+If an invalid value such as `null` or `undefined` is passed in, will throw an error.
+
+`increment` *default*: `null`<br/>
+When implementing a currency that implements rounding, setting the increment value will allow you to set the closest increment to round the display value to. `currency(1.48, { increment: .05 }); // => 1.50`
+
+`useVedic` *default*: `false`<br/>
+Formats number groupings using the Indian Numbering System, i.e. `10,00,000.00`
+
+`fromCents` *default*: `false`<br/>
+Parse the amount value as a minor currency unit (e.g. cents in a dollar) instead of dollars.
+
+> View more examples and full documentation at [https://currency.js.org](https://currency.js.org).
+
+### Internationalization Examples
+
+```js
+currency(1.23, { separator: " ", decimal: ",", symbol: "€" });
+```
+
+If you need to work with multiple currency values, the easiest way is to setup factory functions with your required currency settings.
+
+```js
+const USD = value => currency(value, { symbol: "$", precision: 2 });
+const JPY = value => currency(value, { symbol: "¥", precision: 0 });
+const GAS = value => currency(value, { precision: 3 });
+
+USD(1234.56).format(); // "$1,234.56"
+JPY(1234.56).format(); // "¥1,235"
+GAS(1234.56).format(); // "$1,234.560"
+```
+
+## Add-ons
+
+* [babel-plugin-transform-currency-operators](https://github.com/scurker/babel-plugin-transform-currency-operators): An experimental babel plugin for transforming currency operations `currency(1.23) + 4.56` to `currency(1.23).add(4.56)`.
+
+## Other Libraries
+
+Maybe currency.js isn't the right fit for your needs. Check out some of these other fine libraries:
+
+* [accounting.js](https://github.com/openexchangerates/accounting.js)
+* [dinero.js](https://github.com/sarahdayan/dinero.js)
+* [walletjs](https://github.com/dleitee/walletjs)
+
+## License
+
+[MIT](/license)