@undp/carbon-library 1.0.63 → 1.0.64

package/dist/cjs/index.js

@@ -372,6 +372,14 @@ var sumArray = function (arrList) {
     }
     return arrList.reduce(function (a, b) { return Number(a) + Number(b); }, 0);
 };
+var getBase64 = function (file) {
+    return new Promise(function (resolve, reject) {
+        var reader = new FileReader();
+        reader.readAsDataURL(file);
+        reader.onload = function () { return resolve(reader.result); };
+        reader.onerror = function (error) { return reject(error); };
+    });
+};
 
 var Action;
 (function (Action) {
@@ -913,6 +921,68 @@ var mitigationTypeList = [
     { value: exports.MitigationTypes.TRANSPORT.valueOf(), label: "Transport" },
     { value: exports.MitigationTypes.WIND.valueOf(), label: "Wind" },
 ];
+var sectorMitigationTypesListMapped = {
+    Energy: [
+        {
+            value: exports.MitigationTypes.BIOMASS_ENERGY.valueOf(),
+            label: "Biomass energy",
+        },
+        {
+            value: exports.MitigationTypes.COAL_MINE.valueOf(),
+            label: "Coal bed/mine methane",
+        },
+        { value: exports.MitigationTypes.EE_HOUSEHOLDS.valueOf(), label: "EE households" },
+        { value: exports.MitigationTypes.EE_INDUSTRY.valueOf(), label: "EE industry" },
+        {
+            value: exports.MitigationTypes.EE_OWN_GENERATION.valueOf(),
+            label: "EE own generation",
+        },
+        { value: exports.MitigationTypes.EE_SERVICE.valueOf(), label: "EE service" },
+        {
+            value: exports.MitigationTypes.EE_SUPPLY_SIDE.valueOf(),
+            label: "EE supply side",
+        },
+        {
+            value: exports.MitigationTypes.ENERGY_DISTRIBUTION.valueOf(),
+            label: "Energy distribution",
+        },
+        {
+            value: exports.MitigationTypes.FOSSIL_FUEL.valueOf(),
+            label: "Fossil fuel switch",
+        },
+        { value: exports.MitigationTypes.GEOTHERMAL.valueOf(), label: "Geothermal" },
+        { value: exports.MitigationTypes.HYDRO.valueOf(), label: "Hydro" },
+        { value: exports.MitigationTypes.SOLAR.valueOf(), label: "Solar" },
+        { value: exports.MitigationTypes.WIND.valueOf(), label: "Wind" },
+    ],
+    Health: [],
+    Education: [],
+    Transport: [
+        { value: exports.MitigationTypes.TRANSPORT.valueOf(), label: "Transport" },
+    ],
+    Manufacturing: [
+        { value: exports.MitigationTypes.CEMENT.valueOf(), label: "Cement" },
+        { value: exports.MitigationTypes.CCS.valueOf(), label: "CCS" },
+        { value: exports.MitigationTypes.HFC_PFCS_SF6.valueOf(), label: "HFCs, PFCs, SF6" },
+    ],
+    Hospitality: [],
+    Forestry: [{ value: exports.MitigationTypes.FORESTRY.valueOf(), label: "Forestry" }],
+    Waste: [
+        { value: exports.MitigationTypes.LANDFILLS.valueOf(), label: "Landfills" },
+        { value: exports.MitigationTypes.FUGITIVE.valueOf(), label: "Fugitive" },
+        {
+            value: exports.MitigationTypes.METHANE_AVOIDANCE.valueOf(),
+            label: "Methane avoidance",
+        },
+    ],
+    Agriculture: [
+        { value: exports.MitigationTypes.AGRICULTURE.valueOf(), label: "Agriculture" },
+    ],
+    Other: [
+        { value: exports.MitigationTypes.MARINE.valueOf(), label: "Marine" },
+        { value: exports.MitigationTypes.N20.valueOf(), label: "N2O" },
+    ],
+};
 
 exports.ESGType = void 0;
 (function (ESGType) {
@@ -1014,161 +1084,3427 @@ exports.RetireType = void 0;
     RetireType["OTHER"] = "2";
 })(exports.RetireType || (exports.RetireType = {}));
 
-exports.ConfigurationSettingsType = void 0;
-(function (ConfigurationSettingsType) {
-    ConfigurationSettingsType[ConfigurationSettingsType["isTransferFrozen"] = 0] = "isTransferFrozen";
-})(exports.ConfigurationSettingsType || (exports.ConfigurationSettingsType = {}));
+exports.EnergyGenerationUnits = void 0;
+(function (EnergyGenerationUnits) {
+    EnergyGenerationUnits["Wh"] = "Wh/year/unit";
+    EnergyGenerationUnits["mWh"] = "mWh/year/unit";
+    EnergyGenerationUnits["kWh"] = "kWh/year/unit";
+    EnergyGenerationUnits["MWh"] = "MWh/year/unit";
+    EnergyGenerationUnits["GWh"] = "GWh/year/unit";
+    EnergyGenerationUnits["J"] = "J/year/unit";
+    EnergyGenerationUnits["KJ"] = "kJ/year/unit";
+})(exports.EnergyGenerationUnits || (exports.EnergyGenerationUnits = {}));
+var energyGenerationUnitList = [
+    { value: exports.EnergyGenerationUnits.Wh.valueOf(), label: "Wh" },
+    { value: exports.EnergyGenerationUnits.mWh.valueOf(), label: "mWh" },
+    { value: exports.EnergyGenerationUnits.kWh.valueOf(), label: "kWh" },
+    { value: exports.EnergyGenerationUnits.MWh.valueOf(), label: "MWh" },
+    { value: exports.EnergyGenerationUnits.GWh.valueOf(), label: "GWh" },
+    { value: exports.EnergyGenerationUnits.J.valueOf(), label: "J" },
+    { value: exports.EnergyGenerationUnits.KJ.valueOf(), label: "KJ" },
+];
 
-exports.MapTypes = void 0;
-(function (MapTypes) {
-    MapTypes["Mapbox"] = "Mapbox";
-    MapTypes["None"] = "None";
-})(exports.MapTypes || (exports.MapTypes = {}));
+exports.LandAreaUnits = void 0;
+(function (LandAreaUnits) {
+    LandAreaUnits["mm2"] = "mm2";
+    LandAreaUnits["cm2"] = "cm2";
+    LandAreaUnits["m2"] = "m2";
+    LandAreaUnits["ha"] = "ha";
+    LandAreaUnits["km2"] = "km2";
+    LandAreaUnits["in2"] = "in2";
+    LandAreaUnits["ft2"] = "ft2";
+    LandAreaUnits["ac"] = "ac";
+    LandAreaUnits["Mi2"] = "Mi2";
+})(exports.LandAreaUnits || (exports.LandAreaUnits = {}));
+var landAreaUnitList = [
+    { value: exports.LandAreaUnits.mm2.valueOf(), label: "mm2" },
+    { value: exports.LandAreaUnits.cm2.valueOf(), label: "cm2" },
+    { value: exports.LandAreaUnits.m2.valueOf(), label: "m2" },
+    { value: exports.LandAreaUnits.ha.valueOf(), label: "ha" },
+    { value: exports.LandAreaUnits.km2.valueOf(), label: "km2" },
+    { value: exports.LandAreaUnits.in2.valueOf(), label: "in2" },
+    { value: exports.LandAreaUnits.ft2.valueOf(), label: "ft2" },
+    { value: exports.LandAreaUnits.ac.valueOf(), label: "ac" },
+    { value: exports.LandAreaUnits.Mi2.valueOf(), label: "Mi2" },
+];
 
-var BaseEntity = /** @class */ (function () {
-    function BaseEntity() {
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var cjs = {};
+
+var calculator = {};
+
+var agricultureCal = {};
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+/** Used to determine if values are of the language type Object */
+var objectTypes$3 = {
+  'boolean': false,
+  'function': true,
+  'object': true,
+  'number': false,
+  'string': false,
+  'undefined': false
+};
+
+var lodash__objecttypes = objectTypes$3;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var objectTypes$2 = lodash__objecttypes;
+
+/**
+ * Checks if `value` is the language type of Object.
+ * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(1);
+ * // => false
+ */
+function isObject$4(value) {
+  // check if the value is the ECMAScript language type of Object
+  // http://es5.github.io/#x8
+  // and avoid a V8 bug
+  // http://code.google.com/p/v8/issues/detail?id=2291
+  return !!(value && objectTypes$2[typeof value]);
+}
+
+var lodash_isobject = isObject$4;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+/** Used for native method references */
+var objectProto$1 = Object.prototype;
+
+/** Used to resolve the internal [[Class]] of values */
+var toString = objectProto$1.toString;
+
+/** Used to detect if a method is native */
+var reNative$4 = RegExp('^' +
+  String(toString)
+    .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    .replace(/toString| for [^\]]+/g, '.*?') + '$'
+);
+
+var lodash__renative = reNative$4;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var objectTypes$1 = lodash__objecttypes;
+
+/** Used for native method references */
+var objectProto = Object.prototype;
+
+/** Native method shortcuts */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A fallback implementation of `Object.keys` which produces an array of the
+ * given object's own enumerable property names.
+ *
+ * @private
+ * @type Function
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names.
+ */
+var shimKeys$1 = function(object) {
+  var index, iterable = object, result = [];
+  if (!iterable) return result;
+  if (!(objectTypes$1[typeof object])) return result;
+    for (index in iterable) {
+      if (hasOwnProperty.call(iterable, index)) {
+        result.push(index);
+      }
     }
-    return BaseEntity;
+  return result
+};
+
+var lodash__shimkeys = shimKeys$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var isObject$3 = lodash_isobject,
+    reNative$3 = lodash__renative,
+    shimKeys = lodash__shimkeys;
+
+/* Native method shortcuts for methods with the same name as other `lodash` methods */
+var nativeKeys = reNative$3.test(nativeKeys = Object.keys) && nativeKeys;
+
+/**
+ * Creates an array composed of the own enumerable property names of an object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns an array of property names.
+ * @example
+ *
+ * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => ['one', 'two', 'three'] (property order is not guaranteed across environments)
+ */
+var keys$2 = !nativeKeys ? shimKeys : function(object) {
+  if (!isObject$3(object)) {
+    return [];
+  }
+  return nativeKeys(object);
+};
+
+var lodash_keys = keys$2;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+/**
+ * A no-operation function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.noop(object) === undefined;
+ * // => true
+ */
+function noop$1() {
+  // no operation performed
+}
+
+var lodash_noop = noop$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var isObject$2 = lodash_isobject,
+    reNative$2 = lodash__renative;
+
+/* Native method shortcuts for methods with the same name as other `lodash` methods */
+var nativeCreate = reNative$2.test(nativeCreate = Object.create) && nativeCreate;
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} prototype The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+function baseCreate$2(prototype, properties) {
+  return isObject$2(prototype) ? nativeCreate(prototype) : {};
+}
+// fallback for browsers without `Object.create`
+if (!nativeCreate) {
+  baseCreate$2 = (function() {
+    function Object() {}
+    return function(prototype) {
+      if (isObject$2(prototype)) {
+        Object.prototype = prototype;
+        var result = new Object;
+        Object.prototype = null;
+      }
+      return result || commonjsGlobal.Object();
+    };
+  }());
+}
+
+var lodash__basecreate = baseCreate$2;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var noop = lodash_noop,
+    reNative$1 = lodash__renative;
+
+/** Used as the property descriptor for `__bindData__` */
+var descriptor = {
+  'configurable': false,
+  'enumerable': false,
+  'value': null,
+  'writable': false
+};
+
+/** Used to set meta data on functions */
+var defineProperty = (function() {
+  // IE 8 only accepts DOM elements
+  try {
+    var o = {},
+        func = reNative$1.test(func = Object.defineProperty) && func,
+        result = func(o, o, o) && func;
+  } catch(e) { }
+  return result;
 }());
 
-var ProgrammeTransfer = /** @class */ (function () {
-    function ProgrammeTransfer() {
+/**
+ * Sets `this` binding data on a given function.
+ *
+ * @private
+ * @param {Function} func The function to set data on.
+ * @param {Array} value The data array to set.
+ */
+var setBindData$3 = !defineProperty ? noop : function(func, value) {
+  descriptor.value = value;
+  defineProperty(func, '__bindData__', descriptor);
+};
+
+var lodash__setbinddata = setBindData$3;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var baseCreate$1 = lodash__basecreate,
+    isObject$1 = lodash_isobject,
+    setBindData$2 = lodash__setbinddata;
+
+/**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+var arrayRef$2 = [];
+
+/** Native method shortcuts */
+var push$2 = arrayRef$2.push;
+
+/**
+ * The base implementation of `_.bind` that creates the bound function and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new bound function.
+ */
+function baseBind$1(bindData) {
+  var func = bindData[0],
+      partialArgs = bindData[2],
+      thisArg = bindData[4];
+
+  function bound() {
+    // `Function#bind` spec
+    // http://es5.github.io/#x15.3.4.5
+    if (partialArgs) {
+      var args = partialArgs.slice();
+      push$2.apply(args, arguments);
     }
-    return ProgrammeTransfer;
-}());
+    // mimic the constructor's `return` behavior
+    // http://es5.github.io/#x13.2.2
+    if (this instanceof bound) {
+      // ensure `new bound` is an instance of `func`
+      var thisBinding = baseCreate$1(func.prototype),
+          result = func.apply(thisBinding, args || arguments);
+      return isObject$1(result) ? result : thisBinding;
+    }
+    return func.apply(thisArg, args || arguments);
+  }
+  setBindData$2(bound, bindData);
+  return bound;
+}
 
-var User = /** @class */ (function () {
-    function User() {
+var lodash__basebind = baseBind$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+/**
+ * Slices the `collection` from the `start` index up to, but not including,
+ * the `end` index.
+ *
+ * Note: This function is used instead of `Array#slice` to support node lists
+ * in IE < 9 and to ensure dense arrays are returned.
+ *
+ * @private
+ * @param {Array|Object|string} collection The collection to slice.
+ * @param {number} start The start index.
+ * @param {number} end The end index.
+ * @returns {Array} Returns the new array.
+ */
+function slice$2(array, start, end) {
+  start || (start = 0);
+  if (typeof end == 'undefined') {
+    end = array ? array.length : 0;
+  }
+  var index = -1,
+      length = end - start || 0,
+      result = Array(length < 0 ? 0 : length);
+
+  while (++index < length) {
+    result[index] = array[start + index];
+  }
+  return result;
+}
+
+var lodash__slice = slice$2;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var baseCreate = lodash__basecreate,
+    isObject = lodash_isobject,
+    setBindData$1 = lodash__setbinddata,
+    slice$1 = lodash__slice;
+
+/**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+var arrayRef$1 = [];
+
+/** Native method shortcuts */
+var push$1 = arrayRef$1.push;
+
+/**
+ * The base implementation of `createWrapper` that creates the wrapper and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new function.
+ */
+function baseCreateWrapper$1(bindData) {
+  var func = bindData[0],
+      bitmask = bindData[1],
+      partialArgs = bindData[2],
+      partialRightArgs = bindData[3],
+      thisArg = bindData[4],
+      arity = bindData[5];
+
+  var isBind = bitmask & 1,
+      isBindKey = bitmask & 2,
+      isCurry = bitmask & 4,
+      isCurryBound = bitmask & 8,
+      key = func;
+
+  function bound() {
+    var thisBinding = isBind ? thisArg : this;
+    if (partialArgs) {
+      var args = partialArgs.slice();
+      push$1.apply(args, arguments);
     }
-    return User;
-}());
+    if (partialRightArgs || isCurry) {
+      args || (args = slice$1(arguments));
+      if (partialRightArgs) {
+        push$1.apply(args, partialRightArgs);
+      }
+      if (isCurry && args.length < arity) {
+        bitmask |= 16 & ~32;
+        return baseCreateWrapper$1([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]);
+      }
+    }
+    args || (args = arguments);
+    if (isBindKey) {
+      func = thisBinding[key];
+    }
+    if (this instanceof bound) {
+      thisBinding = baseCreate(func.prototype);
+      var result = func.apply(thisBinding, args);
+      return isObject(result) ? result : thisBinding;
+    }
+    return func.apply(thisBinding, args);
+  }
+  setBindData$1(bound, bindData);
+  return bound;
+}
 
-var ProgrammeEntity = /** @class */ (function () {
-    function ProgrammeEntity() {
+var lodash__basecreatewrapper = baseCreateWrapper$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+/**
+ * Checks if `value` is a function.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ */
+function isFunction$1(value) {
+  return typeof value == 'function';
+}
+
+var lodash_isfunction = isFunction$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var baseBind = lodash__basebind,
+    baseCreateWrapper = lodash__basecreatewrapper,
+    isFunction = lodash_isfunction;
+
+/**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+var arrayRef = [];
+
+/** Native method shortcuts */
+var push = arrayRef.push;
+
+/**
+ * Creates a function that, when called, either curries or invokes `func`
+ * with an optional `this` binding and partially applied arguments.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to reference.
+ * @param {number} bitmask The bitmask of method flags to compose.
+ *  The bitmask may be composed of the following flags:
+ *  1 - `_.bind`
+ *  2 - `_.bindKey`
+ *  4 - `_.curry`
+ *  8 - `_.curry` (bound)
+ *  16 - `_.partial`
+ *  32 - `_.partialRight`
+ * @param {Array} [partialArgs] An array of arguments to prepend to those
+ *  provided to the new function.
+ * @param {Array} [partialRightArgs] An array of arguments to append to those
+ *  provided to the new function.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new function.
+ */
+function createWrapper$1(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
+  var isBind = bitmask & 1,
+      isBindKey = bitmask & 2,
+      isCurry = bitmask & 4,
+      isPartial = bitmask & 16,
+      isPartialRight = bitmask & 32;
+
+  if (!isBindKey && !isFunction(func)) {
+    throw new TypeError;
+  }
+  if (isPartial && !partialArgs.length) {
+    bitmask &= ~16;
+    isPartial = partialArgs = false;
+  }
+  if (isPartialRight && !partialRightArgs.length) {
+    bitmask &= ~32;
+    isPartialRight = partialRightArgs = false;
+  }
+  var bindData = func && func.__bindData__;
+  if (bindData && bindData !== true) {
+    bindData = bindData.slice();
+
+    // set `thisBinding` is not previously bound
+    if (isBind && !(bindData[1] & 1)) {
+      bindData[4] = thisArg;
     }
-    return ProgrammeEntity;
-}());
+    // set if previously bound but not currently (subsequent curried functions)
+    if (!isBind && bindData[1] & 1) {
+      bitmask |= 8;
+    }
+    // set curried arity if not yet set
+    if (isCurry && !(bindData[1] & 4)) {
+      bindData[5] = arity;
+    }
+    // append partial left arguments
+    if (isPartial) {
+      push.apply(bindData[2] || (bindData[2] = []), partialArgs);
+    }
+    // append partial right arguments
+    if (isPartialRight) {
+      push.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
+    }
+    // merge flags
+    bindData[1] |= bitmask;
+    return createWrapper$1.apply(null, bindData);
+  }
+  // fast path for `_.bind`
+  var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper;
+  return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
+}
 
-var AddNewCompanyComponent = function (props) {
-    var _a;
-    var t = props.t, onNavigateToCompanyManagement = props.onNavigateToCompanyManagement, maximumImageSize = props.maximumImageSize, useConnection = props.useConnection, useUserContext = props.useUserContext, useLocation = props.useLocation, regionField = props.regionField;
-    var formOne = antd.Form.useForm()[0];
-    var formTwo = antd.Form.useForm()[0];
-    var _b = React.useState(), stepOneData = _b[0], setStepOneData = _b[1];
-    var _c = React.useState(false), loading = _c[0], setLoading = _c[1];
-    var contactNoInput = React.useState()[0];
-    var _d = React.useState(0), current = _d[0], setCurrent = _d[1];
-    var _e = React.useState(false), isUpdate = _e[0], setIsUpdate = _e[1];
-    var _f = useConnection(), put = _f.put, get = _f.get, post = _f.post;
-    var _g = useUserContext(), setUserInfo = _g.setUserInfo, userInfoState = _g.userInfoState;
-    var state = useLocation().state;
-    var _h = React.useState([]), fileList = _h[0], setFileList = _h[1];
-    var _j = React.useState([]), countries = _j[0], setCountries = _j[1];
-    var _k = React.useState(false), loadingList = _k[0], setLoadingList = _k[1];
-    var _l = React.useState([]), regionsList = _l[0], setRegionsList = _l[1];
-    var _m = React.useState((_a = state === null || state === void 0 ? void 0 : state.record) === null || _a === void 0 ? void 0 : _a.companyRole), companyRole = _m[0], setCompanyRole = _m[1];
-    var getCountryList = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var response, alpha2Names;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, get("national/organisation/countries")];
-                case 1:
-                    response = _a.sent();
-                    if (response.data) {
-                        alpha2Names = response.data.map(function (item) {
-                            return item.alpha2;
-                        });
-                        setCountries(alpha2Names);
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    var getRegionList = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var response, regionNames, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    setLoadingList(true);
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, 4, 5]);
-                    return [4 /*yield*/, post("national/organisation/regions", {
-                            page: 1,
-                            size: 100,
-                            filterAnd: [
-                                {
-                                    key: "lang",
-                                    operation: "=",
-                                    value: "en",
-                                },
-                            ],
-                        })];
-                case 2:
-                    response = _a.sent();
-                    if (response.data) {
-                        regionNames = response.data.map(function (item) { return item.regionName; });
-                        setRegionsList(__spreadArray([t("national")], regionNames, true));
-                    }
-                    return [3 /*break*/, 5];
-                case 3:
-                    error_1 = _a.sent();
-                    console.log("Error in getting regions list", error_1);
-                    return [3 /*break*/, 5];
-                case 4:
-                    setLoadingList(false);
-                    return [7 /*endfinally*/];
-                case 5: return [2 /*return*/];
-            }
-        });
-    }); };
-    React.useEffect(function () {
-        var _a, _b, _c;
-        setIsUpdate((state === null || state === void 0 ? void 0 : state.record) ? true : false);
-        getCountryList();
-        getRegionList();
-        if ((_a = state === null || state === void 0 ? void 0 : state.record) === null || _a === void 0 ? void 0 : _a.logo) {
-            setFileList([
-                {
-                    uid: "1",
-                    name: "".concat((_b = state === null || state === void 0 ? void 0 : state.record) === null || _b === void 0 ? void 0 : _b.name, ".png"),
-                    status: "done",
-                    url: (_c = state === null || state === void 0 ? void 0 : state.record) === null || _c === void 0 ? void 0 : _c.logo,
-                    type: "image/png",
-                },
-            ]);
-        }
-    }, []);
-    var normFile = function (e) {
-        if (Array.isArray(e)) {
-            return e;
-        }
-        return e === null || e === void 0 ? void 0 : e.fileList;
-    };
-    var nextOne = function (val) {
-        setCurrent(current + 1);
-        setStepOneData(val);
-    };
-    var prevOne = function () {
-        setCurrent(current - 1);
-    };
-    var onFinishStepOne = function (values) {
-        nextOne(values);
-    };
-    var onChangeRegion = function (values) {
-        if (values.includes(t("national"))) {
-            var buyerCountryValues = regionsList;
-            var newBuyerValues = buyerCountryValues === null || buyerCountryValues === void 0 ? void 0 : buyerCountryValues.filter(function (item) { return item !== t("national"); });
-            formOne.setFieldValue("regions", __spreadArray([], newBuyerValues, true));
-        }
-    };
-    var getBase64 = function (file) {
-        return new Promise(function (resolve, reject) {
-            var reader = new FileReader();
-            reader.readAsDataURL(file);
-            reader.onload = function () { return resolve(reader.result); };
-            reader.onerror = function (error) { return reject(error); };
-        });
+var lodash__createwrapper = createWrapper$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var createWrapper = lodash__createwrapper,
+    slice = lodash__slice;
+
+/**
+ * Creates a function that, when called, invokes `func` with the `this`
+ * binding of `thisArg` and prepends any additional `bind` arguments to those
+ * provided to the bound function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to bind.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {...*} [arg] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var func = function(greeting) {
+ *   return greeting + ' ' + this.name;
+ * };
+ *
+ * func = _.bind(func, { 'name': 'fred' }, 'hi');
+ * func();
+ * // => 'hi fred'
+ */
+function bind$1(func, thisArg) {
+  return arguments.length > 2
+    ? createWrapper(func, 17, slice(arguments, 2), null, thisArg)
+    : createWrapper(func, 1, null, null, thisArg);
+}
+
+var lodash_bind = bind$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+/**
+ * This method returns the first argument provided to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.identity(object) === object;
+ * // => true
+ */
+function identity$1(value) {
+  return value;
+}
+
+var lodash_identity = identity$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var reNative = lodash__renative;
+
+/** Used to detect functions containing a `this` reference */
+var reThis$1 = /\bthis\b/;
+
+/**
+ * An object used to flag environments features.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+var support$1 = {};
+
+/**
+ * Detect if functions can be decompiled by `Function#toString`
+ * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+support$1.funcDecomp = !reNative.test(commonjsGlobal.WinRTError) && reThis$1.test(function() { return this; });
+
+/**
+ * Detect if `Function#name` is supported (all but IE).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+support$1.funcNames = typeof Function.name == 'string';
+
+var lodash_support = support$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var bind = lodash_bind,
+    identity = lodash_identity,
+    setBindData = lodash__setbinddata,
+    support = lodash_support;
+
+/** Used to detected named functions */
+var reFuncName = /^\s*function[ \n\r\t]+\w/;
+
+/** Used to detect functions containing a `this` reference */
+var reThis = /\bthis\b/;
+
+/** Native method shortcuts */
+var fnToString = Function.prototype.toString;
+
+/**
+ * The base implementation of `_.createCallback` without support for creating
+ * "_.pluck" or "_.where" style callbacks.
+ *
+ * @private
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ */
+function baseCreateCallback$2(func, thisArg, argCount) {
+  if (typeof func != 'function') {
+    return identity;
+  }
+  // exit early for no `thisArg` or already bound by `Function#bind`
+  if (typeof thisArg == 'undefined' || !('prototype' in func)) {
+    return func;
+  }
+  var bindData = func.__bindData__;
+  if (typeof bindData == 'undefined') {
+    if (support.funcNames) {
+      bindData = !func.name;
+    }
+    bindData = bindData || !support.funcDecomp;
+    if (!bindData) {
+      var source = fnToString.call(func);
+      if (!support.funcNames) {
+        bindData = !reFuncName.test(source);
+      }
+      if (!bindData) {
+        // checks if `func` references the `this` keyword and stores the result
+        bindData = reThis.test(source);
+        setBindData(func, bindData);
+      }
+    }
+  }
+  // exit early if there are no `this` references or `func` is bound
+  if (bindData === false || (bindData !== true && bindData[1] & 1)) {
+    return func;
+  }
+  switch (argCount) {
+    case 1: return function(value) {
+      return func.call(thisArg, value);
+    };
+    case 2: return function(a, b) {
+      return func.call(thisArg, a, b);
+    };
+    case 3: return function(value, index, collection) {
+      return func.call(thisArg, value, index, collection);
+    };
+    case 4: return function(accumulator, value, index, collection) {
+      return func.call(thisArg, accumulator, value, index, collection);
+    };
+  }
+  return bind(func, thisArg);
+}
+
+var lodash__basecreatecallback = baseCreateCallback$2;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var baseCreateCallback$1 = lodash__basecreatecallback,
+    keys$1 = lodash_keys,
+    objectTypes = lodash__objecttypes;
+
+/**
+ * Iterates over own enumerable properties of an object, executing the callback
+ * for each property. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, key, object). Callbacks may exit iteration early by
+ * explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ *   console.log(key);
+ * });
+ * // => logs '0', '1', and 'length' (property order is not guaranteed across environments)
+ */
+var forOwn$1 = function(collection, callback, thisArg) {
+  var index, iterable = collection, result = iterable;
+  if (!iterable) return result;
+  if (!objectTypes[typeof iterable]) return result;
+  callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback$1(callback, thisArg, 3);
+    var ownIndex = -1,
+        ownProps = objectTypes[typeof iterable] && keys$1(iterable),
+        length = ownProps ? ownProps.length : 0;
+
+    while (++ownIndex < length) {
+      index = ownProps[ownIndex];
+      if (callback(iterable[index], index, collection) === false) return result;
+    }
+  return result
+};
+
+var lodash_forown = forOwn$1;
+
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+var baseCreateCallback = lodash__basecreatecallback,
+    forOwn = lodash_forown;
+
+/**
+ * Iterates over elements of a collection, executing the callback for each
+ * element. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection). Callbacks may exit iteration early by
+ * explicitly returning `false`.
+ *
+ * Note: As with other "Collections" methods, objects with a `length` property
+ * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
+ * may be used for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @alias each
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|string} Returns `collection`.
+ * @example
+ *
+ * _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(',');
+ * // => logs each number and returns '1,2,3'
+ *
+ * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+ * // => logs each number and returns the object (property order is not guaranteed across environments)
+ */
+function forEach(collection, callback, thisArg) {
+  var index = -1,
+      length = collection ? collection.length : 0;
+
+  callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+  if (typeof length == 'number') {
+    while (++index < length) {
+      if (callback(collection[index], index, collection) === false) {
+        break;
+      }
+    }
+  } else {
+    forOwn(collection, callback);
+  }
+  return collection;
+}
+
+var lodash_foreach = forEach;
+
+var metric$b,
+imperial$9;
+
+metric$b = {
+  mm: {
+    name: {
+      singular: 'Millimeter',
+      plural: 'Millimeters'
+    },
+    to_anchor: 1/1000
+  },
+  cm: {
+    name: {
+      singular: 'Centimeter',
+      plural: 'Centimeters'
+    },
+    to_anchor: 1/100
+  },
+  m: {
+    name: {
+      singular: 'Meter',
+      plural: 'Meters'
+    },
+    to_anchor: 1
+  },
+  km: {
+    name: {
+      singular: 'Kilometer',
+      plural: 'Kilometers'
+    },
+    to_anchor: 1000
+  }
+};
+
+imperial$9 = {
+  'in': {
+    name: {
+      singular: 'Inch',
+      plural: 'Inches'
+    },
+    to_anchor: 1/12
+  },
+  yd: {
+    name: {
+      singular: 'Yard',
+      plural: 'Yards'
+    },
+    to_anchor: 3
+  },
+  'ft-us': {
+    name: {
+      singular: 'US Survey Foot',
+      plural: 'US Survey Feet'
+    },
+    to_anchor: 1.000002
+  },
+  ft: {
+    name: {
+      singular: 'Foot',
+      plural: 'Feet'
+    },
+    to_anchor: 1
+  },
+  mi: {
+    name: {
+      singular: 'Mile',
+      plural: 'Miles'
+    },
+    to_anchor: 5280
+  }
+};
+
+var length = {
+  metric: metric$b,
+  imperial: imperial$9,
+  _anchors: {
+    metric: {
+      unit: 'm',
+      ratio: 3.28084
+    },
+    imperial: {
+      unit: 'ft',
+      ratio: 1/3.28084
+    }
+  }
+};
+
+var metric$a
+  , imperial$8;
+
+metric$a = {
+  mm2: {
+    name: {
+      singular: 'Square Millimeter'
+    , plural: 'Square Millimeters'
+    }
+  , to_anchor: 1/1000000
+  }
+, cm2: {
+    name: {
+      singular: 'Centimeter'
+    , plural: 'Centimeters'
+    }
+  , to_anchor: 1/10000
+  }
+, m2: {
+    name: {
+      singular: 'Square Meter'
+    , plural: 'Square Meters'
+    }
+  , to_anchor: 1
+  }
+, ha: {
+    name: {
+      singular: 'Hectare'
+    , plural: 'Hectares'
+    }
+  , to_anchor: 10000
+  }
+, km2: {
+    name: {
+      singular: 'Square Kilometer'
+    , plural: 'Square Kilometers'
+    }
+  , to_anchor: 1000000
+  }
+};
+
+imperial$8 = {
+  'in2': {
+    name: {
+      singular: 'Square Inch'
+    , plural: 'Square Inches'
+    }
+  , to_anchor: 1/144
+  }
+, yd2: {
+    name: {
+      singular: 'Square Yard'
+    , plural: 'Square Yards'  
+    }
+  , to_anchor: 9
+  }
+, ft2: {
+    name: {
+      singular: 'Square Foot'
+    , plural: 'Square Feet'
+    }
+  , to_anchor: 1
+  }
+, ac: {
+    name: {
+      singular: 'Acre'
+    , plural: 'Acres'
+    }
+  , to_anchor: 43560
+  }
+, mi2: {
+    name: {
+      singular: 'Square Mile'
+    , plural: 'Square Miles'
+    }
+  , to_anchor: 27878400
+  }
+};
+
+var area = {
+  metric: metric$a
+, imperial: imperial$8
+, _anchors: {
+    metric: {
+      unit: 'm2'
+    , ratio: 10.7639
+    }
+  , imperial: {
+      unit: 'ft2'
+    , ratio: 1/10.7639
+    }
+  }
+};
+
+var metric$9
+  , imperial$7;
+
+metric$9 = {
+  mcg: {
+    name: {
+      singular: 'Microgram'
+    , plural: 'Micrograms'
+    }
+  , to_anchor: 1/1000000
+  }
+, mg: {
+    name: {
+      singular: 'Milligram'
+    , plural: 'Milligrams'
+    }
+  , to_anchor: 1/1000
+  }
+, g: {
+    name: {
+      singular: 'Gram'
+    , plural: 'Grams'
+    }
+  , to_anchor: 1
+  }
+, kg: {
+    name: {
+      singular: 'Kilogram'
+    , plural: 'Kilograms'
+    }
+  , to_anchor: 1000
+}
+, mt: {
+    name: {
+      singular: 'Metric Tonne'
+    , plural: 'Metric Tonnes'
+    }
+  , to_anchor: 1000000
+  }
+};
+
+imperial$7 = {
+  oz: {
+    name: {
+      singular: 'Ounce'
+    , plural: 'Ounces'
+    }
+  , to_anchor: 1/16
+  }
+, lb: {
+    name: {
+      singular: 'Pound'
+    , plural: 'Pounds'
+    }
+  , to_anchor: 1
+}, t: {
+  name: {
+    singular: 'Ton',
+    plural: 'Tons',
+  },
+    to_anchor: 2000,
+  },
+};
+
+var mass = {
+  metric: metric$9
+, imperial: imperial$7
+, _anchors: {
+    metric: {
+      unit: 'g'
+    , ratio: 1/453.592
+    }
+  , imperial: {
+      unit: 'lb'
+    , ratio: 453.592
+    }
+  }
+};
+
+var metric$8
+  , imperial$6;
+
+metric$8 = {
+  mm3: {
+      name: {
+        singular: 'Cubic Millimeter'
+      , plural: 'Cubic Millimeters'
+      }
+    , to_anchor: 1/1000000
+  }
+, cm3: {
+    name: {
+      singular: 'Cubic Centimeter'
+    , plural: 'Cubic Centimeters'
+    }
+  , to_anchor: 1/1000
+  }
+, ml: {
+    name: {
+      singular: 'Millilitre'
+    , plural: 'Millilitres'
+    }
+  , to_anchor: 1/1000
+  }
+, cl: {
+    name: {
+      singular: 'Centilitre'
+    , plural: 'Centilitres'
+    }
+  , to_anchor: 1/100
+  }
+, dl: {
+    name: {
+      singular: 'Decilitre'
+    , plural: 'Decilitres'
+    }
+  , to_anchor: 1/10
+  }
+, l: {
+    name: {
+      singular: 'Litre'
+    , plural: 'Litres'
+    }
+  , to_anchor: 1
+  }
+, kl: {
+    name: {
+      singular: 'Kilolitre'
+    , plural: 'Kilolitres'
+    }
+  , to_anchor: 1000
+  }
+, m3: {
+    name: {
+      singular: 'Cubic meter'
+    , plural: 'Cubic meters'
+    }
+  , to_anchor: 1000
+  }
+, km3: {
+    name: {
+      singular: 'Cubic kilometer'
+    , plural: 'Cubic kilometers'
+    }
+  , to_anchor: 1000000000000
+  }
+
+// Swedish units
+, krm: {
+  name: {
+    singular: 'Matsked'
+    , plural: 'Matskedar'
+  }
+  , to_anchor: 1/1000
+}
+, tsk: {
+    name: {
+      singular: 'Tesked'
+    , plural: 'Teskedar'
+    }
+  , to_anchor: 5/1000
+  }
+, msk: {
+    name: {
+      singular: 'Matsked'
+      , plural: 'Matskedar'
+    }
+    , to_anchor: 15/1000
+  }
+, kkp: {
+    name: {
+      singular: 'Kaffekopp'
+      , plural: 'Kaffekoppar'
+    }
+    , to_anchor: 150/1000
+  }
+, glas: {
+    name: {
+      singular: 'Glas'
+      , plural: 'Glas'
+    }
+    , to_anchor: 200/1000
+  }
+, kanna: {
+    name: {
+      singular: 'Kanna'
+    , plural: 'Kannor'
+    }
+  , to_anchor: 2.617
+  }
+};
+
+imperial$6 = {
+  tsp: {
+    name: {
+      singular: 'Teaspoon'
+    , plural: 'Teaspoons'
+    }
+  , to_anchor: 1/6
+  }
+, Tbs: {
+    name: {
+      singular: 'Tablespoon'
+    , plural: 'Tablespoons'
+    }
+  , to_anchor: 1/2
+  }
+, in3: {
+    name: {
+      singular: 'Cubic inch'
+    , plural: 'Cubic inches'
+    }
+  , to_anchor: 0.55411
+  }
+, 'fl-oz': {
+    name: {
+      singular: 'Fluid Ounce'
+    , plural: 'Fluid Ounces'
+    }
+  , to_anchor: 1
+  }
+, cup: {
+    name: {
+      singular: 'Cup'
+    , plural: 'Cups'
+    }
+  , to_anchor: 8
+  }
+, pnt: {
+    name: {
+      singular: 'Pint'
+    , plural: 'Pints'
+    }
+  , to_anchor: 16
+  }
+, qt: {
+    name: {
+      singular: 'Quart'
+    , plural: 'Quarts'
+    }
+  , to_anchor: 32
+  }
+, gal: {
+    name: {
+      singular: 'Gallon'
+    , plural: 'Gallons'
+    }
+  , to_anchor: 128
+  }
+, ft3: {
+    name: {
+      singular: 'Cubic foot'
+    , plural: 'Cubic feet'
+    }
+  , to_anchor: 957.506
+  }
+, yd3: {
+    name: {
+      singular: 'Cubic yard'
+    , plural: 'Cubic yards'
+    }
+  , to_anchor: 25852.7
+  }
+};
+
+var volume = {
+  metric: metric$8
+, imperial: imperial$6
+, _anchors: {
+    metric: {
+      unit: 'l'
+    , ratio: 33.8140226
+    }
+  , imperial: {
+      unit: 'fl-oz'
+    , ratio: 1/33.8140226
+    }
+  }
+};
+
+var metric$7
+  ;
+
+metric$7 = {
+  ea: {
+    name: {
+      singular: 'Each'
+    , plural: 'Each'
+    }
+  , to_anchor: 1
+  },
+  dz: {
+    name: {
+      singular: 'Dozen'
+    , plural: 'Dozens'
+    }
+  , to_anchor: 12
+  }
+};
+
+var each$1 = {
+  metric: metric$7
+, imperial: {}
+, _anchors: {
+    metric: {
+      unit: 'ea'
+    , ratio: 1
+    }
+  }
+};
+
+var metric$6
+  , imperial$5;
+
+metric$6 = {
+  C: {
+    name: {
+      singular: 'degree Celsius'
+    , plural: 'degrees Celsius'
+    }
+  , to_anchor: 1
+  , anchor_shift: 0
+  },
+  K: {
+    name: {
+      singular: 'degree Kelvin'
+    , plural: 'degrees Kelvin'
+    }
+  , to_anchor: 1
+  , anchor_shift: 273.15
+  }
+};
+
+imperial$5 = {
+  F: {
+    name: {
+      singular: 'degree Fahrenheit'
+    , plural: 'degrees Fahrenheit'
+    }
+  , to_anchor: 1
+  },
+  R: {
+    name: {
+      singular: 'degree Rankine'
+    , plural: 'degrees Rankine'
+    }
+  , to_anchor: 1
+  , anchor_shift: 459.67
+  }
+};
+
+var temperature = {
+  metric: metric$6
+, imperial: imperial$5
+, _anchors: {
+    metric: {
+      unit: 'C'
+    , transform: function (C) { return C / (5/9) + 32 }
+    }
+  , imperial: {
+      unit: 'F'
+    , transform: function (F) { return (F - 32) * (5/9) }
+    }
+  }
+};
+
+var time;
+var daysInYear = 365.25;
+
+time = {
+  ns: {
+    name: {
+      singular: 'Nanosecond'
+    , plural: 'Nanoseconds'
+    }
+  , to_anchor: 1/1000000000
+  }
+, mu: {
+    name: {
+      singular: 'Microsecond'
+    , plural: 'Microseconds'
+    }
+  , to_anchor: 1/1000000
+  }
+, ms: {
+    name: {
+      singular: 'Millisecond'
+    , plural: 'Milliseconds'
+    }
+  , to_anchor: 1/1000
+  }
+, s: {
+    name: {
+      singular: 'Second'
+    , plural: 'Seconds'
+    }
+  , to_anchor: 1
+  }
+, min: {
+    name: {
+      singular: 'Minute'
+    , plural: 'Minutes'
+    }
+  , to_anchor: 60
+  }
+, h: {
+    name: {
+      singular: 'Hour'
+    , plural: 'Hours'
+    }
+  , to_anchor: 60 * 60 
+  }
+, d: {
+    name: {
+      singular: 'Day'
+    , plural: 'Days'
+    }
+  , to_anchor: 60 * 60 * 24
+  }
+, week: {
+    name: {
+      singular: 'Week'
+    , plural: 'Weeks'
+    }
+  , to_anchor: 60 * 60 * 24 * 7
+  }
+, month: {
+    name: {
+      singular: 'Month'
+    , plural: 'Months'
+    }
+  , to_anchor: 60 * 60 * 24 * daysInYear / 12
+  }
+, year: {
+    name: {
+      singular: 'Year'
+    , plural: 'Years'
+    }
+  , to_anchor: 60 * 60 * 24 * daysInYear
+  }
+};
+
+
+var time_1 = {
+  metric: time 
+, _anchors: {
+    metric: {
+      unit: 's'
+    , ratio: 1
+    }
+  }
+};
+
+var bits
+  , bytes;
+
+bits = {
+  b: {
+    name: {
+      singular: 'Bit'
+    , plural: 'Bits'
+    }
+  , to_anchor: 1
+  }
+, Kb: {
+    name: {
+      singular: 'Kilobit'
+    , plural: 'Kilobits'
+    }
+  , to_anchor: 1024
+  }
+, Mb: {
+    name: {
+      singular: 'Megabit'
+    , plural: 'Megabits'
+    }
+  , to_anchor: 1048576
+  }
+, Gb: {
+    name: {
+      singular: 'Gigabit'
+    , plural: 'Gigabits'
+    }
+  , to_anchor: 1073741824
+  }
+, Tb: {
+    name: {
+      singular: 'Terabit'
+    , plural: 'Terabits'
+    }
+  , to_anchor: 1099511627776
+  }
+};
+
+bytes = {
+  B: {
+    name: {
+      singular: 'Byte'
+    , plural: 'Bytes'
+    }
+  , to_anchor: 1
+  }
+, KB: {
+    name: {
+      singular: 'Kilobyte'
+    , plural: 'Kilobytes'
+    }
+  , to_anchor: 1024
+  }
+, MB: {
+    name: {
+      singular: 'Megabyte'
+    , plural: 'Megabytes'
+    }
+  , to_anchor: 1048576
+  }
+, GB: {
+    name: {
+      singular: 'Gigabyte'
+    , plural: 'Gigabytes'
+    }
+  , to_anchor: 1073741824
+  }
+, TB: {
+    name: {
+      singular: 'Terabyte'
+    , plural: 'Terabytes'
+    }
+  , to_anchor: 1099511627776
+  }
+};
+
+var digital = {
+  bits: bits
+, bytes: bytes
+, _anchors: {
+    bits: {
+      unit: 'b'
+    , ratio: 1/8
+    }
+  , bytes: {
+      unit: 'B'
+    , ratio: 8
+    }
+  }
+};
+
+var metric$5
+  ;
+
+metric$5 = {
+  ppm: {
+    name: {
+      singular: 'Part-per Million'
+      , plural: 'Parts-per Million'
+    }
+    , to_anchor: 1
+  }
+  , ppb: {
+    name: {
+      singular: 'Part-per Billion'
+      , plural: 'Parts-per Billion'
+    }
+    , to_anchor: .001
+  }
+  , ppt: {
+    name: {
+      singular: 'Part-per Trillion'
+      , plural: 'Parts-per Trillion'
+    }
+    , to_anchor: .000001
+  }
+  , ppq: {
+    name: {
+      singular: 'Part-per Quadrillion'
+      , plural: 'Parts-per Quadrillion'
+    }
+    , to_anchor: .000000001
+  }
+};
+
+var partsPer = {
+  metric: metric$5
+  , imperial: {}
+  , _anchors: {
+    metric: {
+      unit: 'ppm'
+      , ratio: .000001
+    }
+  }
+};
+
+var metric$4
+  , imperial$4;
+
+metric$4 = {
+  'm/s': {
+    name: {
+      singular: 'Metre per second'
+    , plural: 'Metres per second'
+    }
+  , to_anchor: 3.6
+  }
+, 'km/h': {
+    name: {
+      singular: 'Kilometre per hour'
+    , plural: 'Kilometres per hour'
+    }
+  , to_anchor: 1
+  }
+};
+
+  imperial$4 = {
+    'm/h': {
+      name: {
+        singular: 'Mile per hour'
+      , plural: 'Miles per hour'
+      }
+    , to_anchor: 1
+    }
+  , knot: {
+      name: {
+        singular: 'Knot'
+      , plural: 'Knots'
+      }
+    , to_anchor: 1.150779
+    }
+  , 'ft/s': {
+      name: {
+        singular: 'Foot per second'
+      , plural: 'Feet per second'
+      }
+    , to_anchor: 0.681818
+      }
+};
+
+var speed = {
+  metric: metric$4
+, imperial: imperial$4
+, _anchors: {
+    metric: {
+      unit: 'km/h'
+    , ratio: 1/1.609344
+    }
+  , imperial: {
+      unit: 'm/h'
+    , ratio: 1.609344
+    }
+  }
+};
+
+var metric$3
+  , imperial$3;
+
+metric$3 = {
+  'min/km': {
+    name: {
+      singular: 'Minute per kilometre'
+    , plural: 'Minutes per kilometre'
+    }
+  , to_anchor: 0.06
+  }
+  ,'s/m': {
+    name: {
+      singular: 'Second per metre'
+    , plural: 'Seconds per metre'
+    }
+  , to_anchor: 1
+  }
+};
+
+imperial$3 = {
+    'min/mi': {
+      name: {
+        singular: 'Minute per mile'
+      , plural: 'Minutes per mile'
+      }
+    , to_anchor: 0.0113636
+   }
+   , 's/ft': {
+      name: {
+        singular: 'Second per foot'
+      , plural: 'Seconds per foot'
+      }
+    , to_anchor: 1
+   }
+};
+
+var pace = {
+  metric: metric$3
+, imperial: imperial$3
+, _anchors: {
+    metric: {
+      unit: 's/m'
+    , ratio: 0.3048
+    }
+  , imperial: {
+      unit: 's/ft'
+    , ratio: 1/0.3048
+    }
+  }
+};
+
+var metric$2
+  , imperial$2;
+
+metric$2 = {
+  Pa: {
+    name: {
+      singular: 'pascal'
+    , plural: 'pascals'
+    }
+  , to_anchor: 1/1000
+  }
+, kPa: {
+    name: {
+      singular: 'kilopascal'
+    , plural: 'kilopascals'
+    }
+  , to_anchor: 1
+  }
+, MPa: {
+    name: {
+      singular: 'megapascal'
+    , plural: 'megapascals'
+    }
+  , to_anchor: 1000
+  }
+, hPa: {
+    name: {
+      singular: 'hectopascal'
+    , plural: 'hectopascals'
+    }
+  , to_anchor: 1/10
+  }
+, bar: {
+    name: {
+      singular: 'bar'
+    , plural: 'bar'
+    }
+  , to_anchor: 100
+  }
+, torr: {
+    name: {
+      singular: 'torr'
+    , plural: 'torr'
+    }
+  , to_anchor: 101325/760000
+  }
+};
+
+imperial$2 = {
+  psi: {
+    name: {
+      singular: 'pound per square inch'
+    , plural: 'pounds per square inch'
+    }
+  , to_anchor: 1/1000
+  }
+, ksi: {
+    name: {
+      singular: 'kilopound per square inch'
+    , plural: 'kilopound per square inch'
+    }
+  , to_anchor: 1
+  }
+};
+
+var pressure = {
+  metric: metric$2
+, imperial: imperial$2
+, _anchors: {
+    metric: {
+      unit: 'kPa'
+    , ratio: 0.00014503768078
+    }
+  , imperial: {
+      unit: 'psi'
+    , ratio: 1/0.00014503768078
+    }
+  }
+};
+
+var current;
+
+current = {
+  A: {
+    name: {
+      singular: 'Ampere'
+    , plural: 'Amperes'
+    }
+  , to_anchor: 1
+  }
+, mA: {
+    name: {
+      singular: 'Milliampere'
+      , plural: 'Milliamperes'
+    }
+    , to_anchor: .001
+  }
+, kA: {
+    name: {
+      singular: 'Kiloampere'
+    , plural: 'Kiloamperes'
+    }
+  , to_anchor: 1000
+  }
+};
+
+var current_1 = {
+  metric: current
+, _anchors: {
+    metric: {
+      unit: 'A'
+    , ratio: 1
+    }
+  }
+};
+
+var voltage;
+
+voltage = {
+  V: {
+    name: {
+      singular: 'Volt'
+    , plural: 'Volts'
+    }
+  , to_anchor: 1
+  }
+, mV: {
+    name: {
+      singular: 'Millivolt'
+      , plural: 'Millivolts'
+    }
+    , to_anchor: .001
+  }
+, kV: {
+    name: {
+      singular: 'Kilovolt'
+    , plural: 'Kilovolts'
+    }
+  , to_anchor: 1000
+  }
+};
+
+var voltage_1 = {
+  metric: voltage
+, _anchors: {
+    metric: {
+      unit: 'V'
+    , ratio: 1
+    }
+  }
+};
+
+var power;
+
+power = {
+  W: {
+    name: {
+      singular: 'Watt'
+    , plural: 'Watts'
+    }
+  , to_anchor: 1
+  }
+, mW: {
+    name: {
+      singular: 'Milliwatt'
+      , plural: 'Milliwatts'
+    }
+    , to_anchor: .001
+  }
+, kW: {
+    name: {
+      singular: 'Kilowatt'
+    , plural: 'Kilowatts'
+    }
+  , to_anchor: 1000
+  }
+, MW: {
+    name: {
+      singular: 'Megawatt'
+    , plural: 'Megawatts'
+    }
+  , to_anchor: 1000000
+  }
+, GW: {
+    name: {
+      singular: 'Gigawatt'
+    , plural: 'Gigawatts'
+    }
+  , to_anchor: 1000000000
+  }
+};
+
+var power_1 = {
+  metric: power
+, _anchors: {
+    metric: {
+      unit: 'W'
+    , ratio: 1
+    }
+  }
+};
+
+var reactivePower;
+
+reactivePower = {
+  VAR: {
+    name: {
+      singular: 'Volt-Ampere Reactive'
+    , plural: 'Volt-Amperes Reactive'
+    }
+  , to_anchor: 1
+  }
+, mVAR: {
+    name: {
+      singular: 'Millivolt-Ampere Reactive'
+      , plural: 'Millivolt-Amperes Reactive'
+    }
+    , to_anchor: .001
+  }
+, kVAR: {
+    name: {
+      singular: 'Kilovolt-Ampere Reactive'
+    , plural: 'Kilovolt-Amperes Reactive'
+    }
+  , to_anchor: 1000
+  }
+, MVAR: {
+    name: {
+      singular: 'Megavolt-Ampere Reactive'
+    , plural: 'Megavolt-Amperes Reactive'
+    }
+  , to_anchor: 1000000
+  }
+, GVAR: {
+    name: {
+      singular: 'Gigavolt-Ampere Reactive'
+    , plural: 'Gigavolt-Amperes Reactive'
+    }
+  , to_anchor: 1000000000
+  }
+};
+
+var reactivePower_1 = {
+  metric: reactivePower
+, _anchors: {
+    metric: {
+      unit: 'VAR'
+    , ratio: 1
+    }
+  }
+};
+
+var apparentPower;
+
+apparentPower = {
+  VA: {
+    name: {
+      singular: 'Volt-Ampere'
+    , plural: 'Volt-Amperes'
+    }
+  , to_anchor: 1
+  }
+, mVA: {
+    name: {
+      singular: 'Millivolt-Ampere'
+      , plural: 'Millivolt-Amperes'
+    }
+    , to_anchor: .001
+  }
+, kVA: {
+    name: {
+      singular: 'Kilovolt-Ampere'
+    , plural: 'Kilovolt-Amperes'
+    }
+  , to_anchor: 1000
+  }
+, MVA: {
+    name: {
+      singular: 'Megavolt-Ampere'
+    , plural: 'Megavolt-Amperes'
+    }
+  , to_anchor: 1000000
+  }
+, GVA: {
+    name: {
+      singular: 'Gigavolt-Ampere'
+    , plural: 'Gigavolt-Amperes'
+    }
+  , to_anchor: 1000000000
+  }
+};
+
+var apparentPower_1 = {
+  metric: apparentPower
+, _anchors: {
+    metric: {
+      unit: 'VA'
+    , ratio: 1
+    }
+  }
+};
+
+var energy;
+
+energy = {
+  Wh: {
+    name: {
+      singular: 'Watt-hour'
+    , plural: 'Watt-hours'
+    }
+  , to_anchor: 3600
+  }
+, mWh: {
+    name: {
+      singular: 'Milliwatt-hour'
+      , plural: 'Milliwatt-hours'
+    }
+    , to_anchor: 3.6
+  }
+, kWh: {
+    name: {
+      singular: 'Kilowatt-hour'
+    , plural: 'Kilowatt-hours'
+    }
+  , to_anchor: 3600000
+  }
+, MWh: {
+    name: {
+      singular: 'Megawatt-hour'
+    , plural: 'Megawatt-hours'
+    }
+  , to_anchor: 3600000000
+  }
+, GWh: {
+    name: {
+      singular: 'Gigawatt-hour'
+    , plural: 'Gigawatt-hours'
+    }
+  , to_anchor: 3600000000000
+  }
+, J: {
+    name: {
+      singular: 'Joule'
+    , plural: 'Joules'
+    }
+  , to_anchor: 1
+  }
+, kJ: {
+    name: {
+      singular: 'Kilojoule'
+    , plural: 'Kilojoules'
+    }
+  , to_anchor: 1000
+  }
+};
+
+var energy_1 = {
+  metric: energy
+, _anchors: {
+    metric: {
+      unit: 'J'
+    , ratio: 1
+    }
+  }
+};
+
+var reactiveEnergy;
+
+reactiveEnergy = {
+  VARh: {
+    name: {
+      singular: 'Volt-Ampere Reactive Hour'
+    , plural: 'Volt-Amperes Reactive Hour'
+    }
+  , to_anchor: 1
+  }
+, mVARh: {
+    name: {
+      singular: 'Millivolt-Ampere Reactive Hour'
+      , plural: 'Millivolt-Amperes Reactive Hour'
+    }
+    , to_anchor: .001
+  }
+, kVARh: {
+    name: {
+      singular: 'Kilovolt-Ampere Reactive Hour'
+    , plural: 'Kilovolt-Amperes Reactive Hour'
+    }
+  , to_anchor: 1000
+  }
+, MVARh: {
+    name: {
+      singular: 'Megavolt-Ampere Reactive Hour'
+    , plural: 'Megavolt-Amperes Reactive Hour'
+    }
+  , to_anchor: 1000000
+  }
+, GVARh: {
+    name: {
+      singular: 'Gigavolt-Ampere Reactive Hour'
+    , plural: 'Gigavolt-Amperes Reactive Hour'
+    }
+  , to_anchor: 1000000000
+  }
+};
+
+var reactiveEnergy_1 = {
+  metric: reactiveEnergy
+, _anchors: {
+    metric: {
+      unit: 'VARh'
+    , ratio: 1
+    }
+  }
+};
+
+var metric$1
+  , imperial$1;
+
+metric$1 = {
+  'mm3/s': {
+      name: {
+        singular: 'Cubic Millimeter per second'
+      , plural: 'Cubic Millimeters per second'
+      }
+    , to_anchor: 1/1000000
+  }
+, 'cm3/s': {
+    name: {
+      singular: 'Cubic Centimeter per second'
+    , plural: 'Cubic Centimeters per second'
+    }
+  , to_anchor: 1/1000
+  }
+, 'ml/s': {
+    name: {
+      singular: 'Millilitre per second'
+    , plural: 'Millilitres per second'
+    }
+  , to_anchor: 1/1000
+  }
+, 'cl/s': {
+    name: {
+      singular: 'Centilitre per second'
+    , plural: 'Centilitres per second'
+    }
+  , to_anchor: 1/100
+  }
+, 'dl/s': {
+    name: {
+      singular: 'Decilitre per second'
+    , plural: 'Decilitres per second'
+    }
+  , to_anchor: 1/10
+  }
+, 'l/s': {
+    name: {
+      singular: 'Litre per second'
+    , plural: 'Litres per second'
+    }
+  , to_anchor: 1
+  }
+, 'l/min': {
+    name: {
+      singular: 'Litre per minute'
+    , plural: 'Litres per minute'
+    }
+  , to_anchor: 1/60
+  }
+, 'l/h': {
+    name: {
+      singular: 'Litre per hour'
+    , plural: 'Litres per hour'
+    }
+  , to_anchor: 1/3600
+  }
+, 'kl/s': {
+    name: {
+      singular: 'Kilolitre per second'
+    , plural: 'Kilolitres per second'
+    }
+  , to_anchor: 1000
+  }
+, 'kl/min': {
+    name: {
+      singular: 'Kilolitre per minute'
+    , plural: 'Kilolitres per minute'
+    }
+  , to_anchor: 50/3
+  }
+, 'kl/h': {
+    name: {
+      singular: 'Kilolitre per hour'
+    , plural: 'Kilolitres per hour'
+    }
+  , to_anchor: 5/18
+  }
+, 'm3/s': {
+    name: {
+      singular: 'Cubic meter per second'
+    , plural: 'Cubic meters per second'
+    }
+  , to_anchor: 1000
+  }
+, 'm3/min': {
+    name: {
+      singular: 'Cubic meter per minute'
+    , plural: 'Cubic meters per minute'
+    }
+  , to_anchor: 50/3
+  }
+, 'm3/h': {
+    name: {
+      singular: 'Cubic meter per hour'
+    , plural: 'Cubic meters per hour'
+    }
+  , to_anchor: 5/18
+  }
+, 'km3/s': {
+    name: {
+      singular: 'Cubic kilometer per second'
+    , plural: 'Cubic kilometers per second'
+    }
+  , to_anchor: 1000000000000
+  }
+};
+
+imperial$1 = {
+  'tsp/s': {
+    name: {
+      singular: 'Teaspoon per second'
+    , plural: 'Teaspoons per second'
+    }
+  , to_anchor: 1/6
+  }
+, 'Tbs/s': {
+    name: {
+      singular: 'Tablespoon per second'
+    , plural: 'Tablespoons per second'
+    }
+  , to_anchor: 1/2
+  }
+, 'in3/s': {
+    name: {
+      singular: 'Cubic inch per second'
+    , plural: 'Cubic inches per second'
+    }
+  , to_anchor: 0.55411
+  }
+, 'in3/min': {
+    name: {
+      singular: 'Cubic inch per minute'
+    , plural: 'Cubic inches per minute'
+    }
+  , to_anchor: 0.55411/60
+  }
+, 'in3/h': {
+    name: {
+      singular: 'Cubic inch per hour'
+    , plural: 'Cubic inches per hour'
+    }
+  , to_anchor: 0.55411/3600
+  }
+, 'fl-oz/s': {
+    name: {
+      singular: 'Fluid Ounce per second'
+    , plural: 'Fluid Ounces per second'
+    }
+  , to_anchor: 1
+  }
+, 'fl-oz/min': {
+    name: {
+      singular: 'Fluid Ounce per minute'
+    , plural: 'Fluid Ounces per minute'
+    }
+  , to_anchor: 1/60
+  }
+, 'fl-oz/h': {
+    name: {
+      singular: 'Fluid Ounce per hour'
+    , plural: 'Fluid Ounces per hour'
+    }
+  , to_anchor: 1/3600
+  }
+, 'cup/s': {
+    name: {
+      singular: 'Cup per second'
+    , plural: 'Cups per second'
+    }
+  , to_anchor: 8
+  }
+, 'pnt/s': {
+    name: {
+      singular: 'Pint per second'
+    , plural: 'Pints per second'
+    }
+  , to_anchor: 16
+  }
+, 'pnt/min': {
+    name: {
+      singular: 'Pint per minute'
+    , plural: 'Pints per minute'
+    }
+  , to_anchor: 4/15
+  }
+, 'pnt/h': {
+    name: {
+      singular: 'Pint per hour'
+    , plural: 'Pints per hour'
+    }
+  , to_anchor: 1/225
+  }
+, 'qt/s': {
+    name: {
+      singular: 'Quart per second'
+    , plural: 'Quarts per second'
+    }
+  , to_anchor: 32
+  }
+, 'gal/s': {
+    name: {
+      singular: 'Gallon per second'
+    , plural: 'Gallons per second'
+    }
+  , to_anchor: 128
+  }
+, 'gal/min': {
+    name: {
+      singular: 'Gallon per minute'
+    , plural: 'Gallons per minute'
+    }
+  , to_anchor: 32/15
+  }
+, 'gal/h': {
+    name: {
+      singular: 'Gallon per hour'
+    , plural: 'Gallons per hour'
+    }
+  , to_anchor: 8/225
+  }
+, 'ft3/s': {
+    name: {
+      singular: 'Cubic foot per second'
+    , plural: 'Cubic feet per second'
+    }
+  , to_anchor: 957.506
+  }
+, 'ft3/min': {
+    name: {
+      singular: 'Cubic foot per minute'
+    , plural: 'Cubic feet per minute'
+    }
+  , to_anchor: 957.506/60
+  }
+, 'ft3/h': {
+    name: {
+      singular: 'Cubic foot per hour'
+    , plural: 'Cubic feet per hour'
+    }
+  , to_anchor: 957.506/3600
+  }
+, 'yd3/s': {
+    name: {
+      singular: 'Cubic yard per second'
+    , plural: 'Cubic yards per second'
+    }
+  , to_anchor: 25852.7
+  }
+, 'yd3/min': {
+    name: {
+      singular: 'Cubic yard per minute'
+    , plural: 'Cubic yards per minute'
+    }
+  , to_anchor: 25852.7/60
+  }
+, 'yd3/h': {
+    name: {
+      singular: 'Cubic yard per hour'
+    , plural: 'Cubic yards per hour'
+    }
+  , to_anchor: 25852.7/3600
+  }
+};
+
+var volumeFlowRate = {
+  metric: metric$1
+, imperial: imperial$1
+, _anchors: {
+    metric: {
+      unit: 'l/s'
+    , ratio: 33.8140227
+    }
+  , imperial: {
+      unit: 'fl-oz/s'
+    , ratio: 1/33.8140227
+    }
+  }
+};
+
+var metric,
+imperial;
+
+metric = {
+  'lx': {
+    name: {
+      singular: 'Lux',
+      plural: 'Lux'
+    },
+    to_anchor: 1
+  }
+};
+
+imperial = {
+  'ft-cd': {
+    name: {
+      singular: 'Foot-candle',
+      plural: 'Foot-candles'
+    },
+    to_anchor: 1
+  }
+};
+
+var illuminance = {
+  metric: metric,
+  imperial: imperial,
+  _anchors: {
+    metric: {
+      unit: 'lx',
+      ratio: 1/10.76391
+    },
+    imperial: {
+      unit: 'ft-cd',      
+	  ratio: 10.76391
+    }
+  }
+};
+
+var frequency;
+
+frequency = {
+  mHz: {
+    name: {
+      singular: 'millihertz'
+    , plural: 'millihertz'
+    }
+  , to_anchor: 1/1000
+  }
+, Hz: {
+    name: {
+      singular: 'hertz'
+    , plural: 'hertz'
+    }
+  , to_anchor: 1
+  }
+, kHz: {
+    name: {
+      singular: 'kilohertz'
+    , plural: 'kilohertz'
+    }
+  , to_anchor: 1000
+  }
+, MHz: {
+    name: {
+      singular: 'megahertz'
+    , plural: 'megahertz'
+    }
+  , to_anchor: 1000 * 1000
+  }
+, GHz: {
+    name: {
+      singular: 'gigahertz'
+    , plural: 'gigahertz'
+    }
+  , to_anchor: 1000 * 1000 * 1000
+  }
+, THz: {
+    name: {
+      singular: 'terahertz'
+    , plural: 'terahertz'
+    }
+  , to_anchor: 1000 * 1000 * 1000 * 1000
+  }
+, rpm: {
+    name: {
+      singular: 'rotation per minute'
+    , plural: 'rotations per minute'
+    }
+  , to_anchor: 1/60
+  }
+, "deg/s": {
+    name: {
+      singular: 'degree per second'
+    , plural: 'degrees per second'
+    }
+  , to_anchor: 1/360
+  }
+, "rad/s": {
+    name: {
+      singular: 'radian per second'
+    , plural: 'radians per second'
+    }
+  , to_anchor: 1/(Math.PI * 2)
+  }
+};
+
+
+var frequency_1 = {
+  metric: frequency
+, _anchors: {
+    frequency: {
+      unit: 'hz'
+    , ratio: 1
+    }
+  }
+};
+
+var angle;
+
+angle = {
+  rad: {
+    name: {
+      singular: 'radian'
+    , plural: 'radians'
+    }
+  , to_anchor: 180/Math.PI
+  }
+, deg: {
+    name: {
+      singular: 'degree'
+    , plural: 'degrees'
+    }
+  , to_anchor: 1
+  }
+, grad: {
+    name: {
+      singular: 'gradian'
+    , plural: 'gradians'
+    }
+  , to_anchor: 9/10
+  }
+, arcmin: {
+    name: {
+      singular: 'arcminute'
+    , plural: 'arcminutes'
+    }
+  , to_anchor: 1/60
+  }
+, arcsec: {
+    name: {
+      singular: 'arcsecond'
+    , plural: 'arcseconds'
+    }
+  , to_anchor: 1/3600
+  }
+};
+
+var angle_1 = {
+  metric: angle
+, _anchors: {
+    metric: {
+      unit: 'deg'
+    , ratio: 1
+    }
+  }
+};
+
+var convert
+  , keys = lodash_keys
+  , each = lodash_foreach
+  , measures = {
+      length: length
+    , area: area
+    , mass: mass
+    , volume: volume
+    , each: each$1
+    , temperature: temperature
+    , time: time_1
+    , digital: digital
+    , partsPer: partsPer
+    , speed: speed
+    , pace: pace
+    , pressure: pressure
+    , current: current_1
+    , voltage: voltage_1
+    , power: power_1
+    , reactivePower: reactivePower_1
+    , apparentPower: apparentPower_1
+    , energy: energy_1
+    , reactiveEnergy: reactiveEnergy_1
+    , volumeFlowRate: volumeFlowRate
+    , illuminance: illuminance
+    , frequency: frequency_1
+    , angle : angle_1
+    }
+  , Converter;
+
+Converter = function (numerator, denominator) {
+  if(denominator)
+    this.val = numerator / denominator;
+  else
+    this.val = numerator;
+};
+
+/**
+* Lets the converter know the source unit abbreviation
+*/
+Converter.prototype.from = function (from) {
+  if(this.destination)
+    throw new Error('.from must be called before .to');
+
+  this.origin = this.getUnit(from);
+
+  if(!this.origin) {
+    this.throwUnsupportedUnitError(from);
+  }
+
+  return this;
+};
+
+/**
+* Converts the unit and returns the value
+*/
+Converter.prototype.to = function (to) {
+  if(!this.origin)
+    throw new Error('.to must be called after .from');
+
+  this.destination = this.getUnit(to);
+
+  var result
+    , transform;
+
+  if(!this.destination) {
+    this.throwUnsupportedUnitError(to);
+  }
+
+  // Don't change the value if origin and destination are the same
+  if (this.origin.abbr === this.destination.abbr) {
+    return this.val;
+  }
+
+  // You can't go from liquid to mass, for example
+  if(this.destination.measure != this.origin.measure) {
+    throw new Error('Cannot convert incompatible measures of '
+      + this.destination.measure + ' and ' + this.origin.measure);
+  }
+
+  /**
+  * Convert from the source value to its anchor inside the system
+  */
+  result = this.val * this.origin.unit.to_anchor;
+
+  /**
+  * For some changes it's a simple shift (C to K)
+  * So we'll add it when convering into the unit (later)
+  * and subtract it when converting from the unit
+  */
+  if (this.origin.unit.anchor_shift) {
+    result -= this.origin.unit.anchor_shift;
+  }
+
+  /**
+  * Convert from one system to another through the anchor ratio. Some conversions
+  * aren't ratio based or require more than a simple shift. We can provide a custom
+  * transform here to provide the direct result
+  */
+  if(this.origin.system != this.destination.system) {
+    transform = measures[this.origin.measure]._anchors[this.origin.system].transform;
+    if (typeof transform === 'function') {
+      result = transform(result);
+    }
+    else {
+      result *= measures[this.origin.measure]._anchors[this.origin.system].ratio;
+    }
+  }
+
+  /**
+  * This shift has to be done after the system conversion business
+  */
+  if (this.destination.unit.anchor_shift) {
+    result += this.destination.unit.anchor_shift;
+  }
+
+  /**
+  * Convert to another unit inside the destination system
+  */
+  return result / this.destination.unit.to_anchor;
+};
+
+/**
+* Converts the unit to the best available unit.
+*/
+Converter.prototype.toBest = function(options) {
+  if(!this.origin)
+    throw new Error('.toBest must be called after .from');
+
+  var options = Object.assign({
+    exclude: [],
+    cutOffNumber: 1,
+  }, options);
+
+  var best;
+  /**
+    Looks through every possibility for the 'best' available unit.
+    i.e. Where the value has the fewest numbers before the decimal point,
+    but is still higher than 1.
+  */
+  each(this.possibilities(), function(possibility) {
+    var unit = this.describe(possibility);
+    var isIncluded = options.exclude.indexOf(possibility) === -1;
+
+    if (isIncluded && unit.system === this.origin.system) {
+      var result = this.to(possibility);
+      if (!best || (result >= options.cutOffNumber && result < best.val)) {
+        best = {
+          val: result,
+          unit: possibility,
+          singular: unit.singular,
+          plural: unit.plural
+        };
+      }
+    }
+  }.bind(this));
+
+  return best;
+};
+
+/**
+* Finds the unit
+*/
+Converter.prototype.getUnit = function (abbr) {
+  var found;
+
+  each(measures, function (systems, measure) {
+    each(systems, function (units, system) {
+      if(system == '_anchors')
+        return false;
+
+      each(units, function (unit, testAbbr) {
+        if(testAbbr == abbr) {
+          found = {
+            abbr: abbr
+          , measure: measure
+          , system: system
+          , unit: unit
+          };
+          return false;
+        }
+      });
+
+      if(found)
+        return false;
+    });
+
+    if(found)
+      return false;
+  });
+
+  return found;
+};
+
+var describe = function(resp) {
+  return {
+    abbr: resp.abbr
+  , measure: resp.measure
+  , system: resp.system
+  , singular: resp.unit.name.singular
+  , plural: resp.unit.name.plural
+  };
+};
+
+/**
+* An alias for getUnit
+*/
+Converter.prototype.describe = function (abbr) {
+  var resp = Converter.prototype.getUnit(abbr);
+  var desc = null;
+
+  try {
+    desc = describe(resp);
+  } catch(err) {
+    this.throwUnsupportedUnitError(abbr);
+  }
+
+  return desc;
+};
+
+/**
+* Detailed list of all supported units
+*/
+Converter.prototype.list = function (measure) {
+  var list = [];
+
+  each(measures, function (systems, testMeasure) {
+    if(measure && measure !== testMeasure)
+      return;
+
+    each(systems, function (units, system) {
+      if(system == '_anchors')
+        return false;
+
+      each(units, function (unit, abbr) {
+        list = list.concat(describe({
+          abbr: abbr,
+          measure: testMeasure
+        , system: system
+        , unit: unit
+        }));
+      });
+    });
+  });
+
+  return list;
+};
+
+Converter.prototype.throwUnsupportedUnitError = function (what) {
+  var validUnits = [];
+
+  each(measures, function (systems, measure) {
+    each(systems, function (units, system) {
+      if(system == '_anchors')
+        return false;
+
+      validUnits = validUnits.concat(keys(units));
+    });
+  });
+
+  throw new Error('Unsupported unit ' + what + ', use one of: ' + validUnits.join(', '));
+};
+
+/**
+* Returns the abbreviated measures that the value can be
+* converted to.
+*/
+Converter.prototype.possibilities = function (measure) {
+  var possibilities = [];
+  if(!this.origin && !measure) {
+	  each(keys(measures), function (measure){
+		  each(measures[measure], function (units, system) {
+		    if(system == '_anchors')
+		      return false;
+
+		    possibilities = possibilities.concat(keys(units));
+		  });
+	  });
+  } else {
+	  measure = measure || this.origin.measure;
+	  each(measures[measure], function (units, system) {
+	    if(system == '_anchors')
+	      return false;
+
+	    possibilities = possibilities.concat(keys(units));
+	  });
+  }
+
+  return possibilities;
+};
+
+/**
+* Returns the abbreviated measures that the value can be
+* converted to.
+*/
+Converter.prototype.measures = function () {
+  return keys(measures);
+};
+
+convert = function (value) {
+  return new Converter(value);
+};
+
+var lib = convert;
+
+var hasRequiredAgricultureCal;
+
+function requireAgricultureCal () {
+	if (hasRequiredAgricultureCal) return agricultureCal;
+	hasRequiredAgricultureCal = 1;
+	Object.defineProperty(agricultureCal, "__esModule", { value: true });
+	agricultureCal.AgricultureCal = void 0;
+	const calculator_1 = requireCalculator();
+	var convert = lib;
+	class AgricultureCal {
+	    static calculate(req) {
+	        const constants = req.agricultureConstants;
+	        const unitParts = constants.emissionFactorUnit.split('/');
+	        if (unitParts.length != 3) {
+	            throw Error("Invalid emission factor unit " + constants.emissionFactorUnit);
+	        }
+	        const landArea = convert(req.landArea).from(req.landAreaUnit).to(unitParts[1]);
+	        const duration = convert(req.duration).from(req.durationUnit).to(unitParts[2]);
+	        return Number((constants.emissionFactor * landArea * duration).toFixed(calculator_1.PRECISION));
+	    }
+	}
+	agricultureCal.AgricultureCal = AgricultureCal;
+	return agricultureCal;
+}
+
+var solarCal = {};
+
+var hasRequiredSolarCal;
+
+function requireSolarCal () {
+	if (hasRequiredSolarCal) return solarCal;
+	hasRequiredSolarCal = 1;
+	Object.defineProperty(solarCal, "__esModule", { value: true });
+	solarCal.SolarCal = void 0;
+	const calculator_1 = requireCalculator();
+	var convert = lib;
+	class SolarCal {
+	    static calculate(req) {
+	        const constants = req.solarConstants;
+	        const emissionUnitParts = constants.emissionFactorUnit.split('/');
+	        if (emissionUnitParts.length != 2) {
+	            throw Error("Invalid emission factor unit " + constants.emissionFactorUnit);
+	        }
+	        const measuredUnitParts = req.energyGenerationUnit.split('/');
+	        if (measuredUnitParts.length != 3) {
+	            throw Error("Invalid measured unit " + req.energyGenerationUnit);
+	        }
+	        let threshold = constants.buildingTypes[req.buildingType];
+	        if (!threshold) {
+	            throw Error("Invalid building type " + req.buildingType);
+	        }
+	        if (req.energyGenerationUnit != constants.thresholdUnit) {
+	            const thresholdUnitParts = constants.thresholdUnit.split('/');
+	            if (thresholdUnitParts.length != 2) {
+	                throw Error("Invalid threshold unit " + constants.thresholdUnit);
+	            }
+	            let factor = convert(1).from(thresholdUnitParts[0]).to(measuredUnitParts[0]);
+	            factor = factor / convert(1).from(thresholdUnitParts[1]).to(measuredUnitParts[1]);
+	            threshold = Number(threshold * factor);
+	        }
+	        const unitX = convert(1).from(measuredUnitParts[0]).to(emissionUnitParts[1]);
+	        const highFactor = Number(constants.highEmissionFactor * unitX);
+	        const lowFactor = Number(constants.lowEmissionFactor * unitX);
+	        let value;
+	        if (req.energyGeneration < threshold) {
+	            value = req.energyGeneration * highFactor;
+	        }
+	        else {
+	            value = threshold * highFactor + (req.energyGeneration - threshold) * lowFactor;
+	        }
+	        return Number(value.toFixed(calculator_1.PRECISION));
+	    }
+	}
+	solarCal.SolarCal = SolarCal;
+	return solarCal;
+}
+
+var agricultureCreationRequest = {};
+
+var agricultureConstants = {};
+
+Object.defineProperty(agricultureConstants, "__esModule", { value: true });
+agricultureConstants.AgricultureConstants = void 0;
+class AgricultureConstants {
+    constructor() {
+        this.emissionFactor = 0.046;
+        this.emissionFactorUnit = "tCO2e/ha/d";
+    }
+}
+agricultureConstants.AgricultureConstants = AgricultureConstants;
+
+Object.defineProperty(agricultureCreationRequest, "__esModule", { value: true });
+agricultureCreationRequest.AgricultureCreationRequest = void 0;
+const agricultureConstants_1 = agricultureConstants;
+class AgricultureCreationRequest {
+    constructor() {
+        this.agricultureConstants = new agricultureConstants_1.AgricultureConstants();
+    }
+}
+agricultureCreationRequest.AgricultureCreationRequest = AgricultureCreationRequest;
+
+var solarCreationRequest = {};
+
+var solarConstants = {};
+
+Object.defineProperty(solarConstants, "__esModule", { value: true });
+solarConstants.SolarConstants = void 0;
+class SolarConstants {
+    constructor() {
+        this.highEmissionFactor = 6.8;
+        this.lowEmissionFactor = 1.3;
+        this.emissionFactorUnit = "tCO2/MWh";
+        this.thresholdUnit = "kWh/year";
+        this.buildingTypes = {
+            Household: 55,
+            HealthCenter: 825,
+            Dispensary: 825,
+            School: 275,
+            PrimarySchool: 275,
+            SecondarySchool: 275,
+            PublicAdministration: 55,
+            TradingPlace: 825,
+            BusStop: 200,
+        };
+    }
+}
+solarConstants.SolarConstants = SolarConstants;
+
+Object.defineProperty(solarCreationRequest, "__esModule", { value: true });
+solarCreationRequest.SolarCreationRequest = void 0;
+const solarConstants_1 = solarConstants;
+class SolarCreationRequest {
+    constructor() {
+        this.solarConstants = new solarConstants_1.SolarConstants();
+    }
+}
+solarCreationRequest.SolarCreationRequest = SolarCreationRequest;
+
+var hasRequiredCalculator;
+
+function requireCalculator () {
+	if (hasRequiredCalculator) return calculator;
+	hasRequiredCalculator = 1;
+	Object.defineProperty(calculator, "__esModule", { value: true });
+	calculator.calculateCredit = calculator.PRECISION = void 0;
+	const agricultureCal_1 = requireAgricultureCal();
+	const solarCal_1 = requireSolarCal();
+	const agricultureCreationRequest_1 = agricultureCreationRequest;
+	const solarCreationRequest_1 = solarCreationRequest;
+	calculator.PRECISION = 2;
+	const calculateCredit = (request) => {
+	    if (request instanceof agricultureCreationRequest_1.AgricultureCreationRequest) {
+	        return agricultureCal_1.AgricultureCal.calculate(request);
+	    }
+	    else if (request instanceof solarCreationRequest_1.SolarCreationRequest) {
+	        return solarCal_1.SolarCal.calculate(request);
+	    }
+	    else {
+	        throw Error("Not implemented");
+	    }
+	};
+	calculator.calculateCredit = calculateCredit;
+	return calculator;
+}
+
+var building_type_enum = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.BuildingType = void 0;
+	(function (BuildingType) {
+	    BuildingType["Household"] = "Household";
+	    BuildingType["HealthCenter"] = "HealthCenter";
+	    BuildingType["Dispensary"] = "Dispensary";
+	    BuildingType["School"] = "School";
+	    BuildingType["PrimarySchool"] = "PrimarySchool";
+	    BuildingType["SecondarySchool"] = "SecondarySchool";
+	    BuildingType["PublicAdministration"] = "PublicAdministration";
+	    BuildingType["TradingPlace"] = "TradingPlace";
+	    BuildingType["BusStop"] = "BusStop";
+	})(exports.BuildingType || (exports.BuildingType = {})); 
+} (building_type_enum));
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.BuildingType = exports.SolarConstants = exports.AgricultureConstants = exports.AgricultureCreationRequest = exports.SolarCreationRequest = exports.calculateCredit = void 0;
+	const calculator_1 = requireCalculator();
+	Object.defineProperty(exports, "calculateCredit", { enumerable: true, get: function () { return calculator_1.calculateCredit; } });
+	const agricultureConstants_1 = agricultureConstants;
+	Object.defineProperty(exports, "AgricultureConstants", { enumerable: true, get: function () { return agricultureConstants_1.AgricultureConstants; } });
+	const building_type_enum_1 = building_type_enum;
+	Object.defineProperty(exports, "BuildingType", { enumerable: true, get: function () { return building_type_enum_1.BuildingType; } });
+	const solarConstants_1 = solarConstants;
+	Object.defineProperty(exports, "SolarConstants", { enumerable: true, get: function () { return solarConstants_1.SolarConstants; } });
+	const agricultureCreationRequest_1 = agricultureCreationRequest;
+	Object.defineProperty(exports, "AgricultureCreationRequest", { enumerable: true, get: function () { return agricultureCreationRequest_1.AgricultureCreationRequest; } });
+	const solarCreationRequest_1 = solarCreationRequest;
+	Object.defineProperty(exports, "SolarCreationRequest", { enumerable: true, get: function () { return solarCreationRequest_1.SolarCreationRequest; } }); 
+} (cjs));
+
+var consumerGroupList = [
+    { value: cjs.BuildingType.Household.valueOf(), label: "Household" },
+    { value: cjs.BuildingType.HealthCenter.valueOf(), label: "Health Center" },
+    { value: cjs.BuildingType.Dispensary.valueOf(), label: "Dispensary" },
+    { value: cjs.BuildingType.School.valueOf(), label: "School" },
+    { value: cjs.BuildingType.PrimarySchool.valueOf(), label: "Primary School" },
+    { value: cjs.BuildingType.SecondarySchool.valueOf(), label: "Secondary School" },
+    {
+        value: cjs.BuildingType.PublicAdministration.valueOf(),
+        label: "Public Administration",
+    },
+    { value: cjs.BuildingType.TradingPlace.valueOf(), label: "Trading Place" },
+    { value: cjs.BuildingType.BusStop.valueOf(), label: "Bus Stop" },
+];
+
+exports.Sector = void 0;
+(function (Sector) {
+    Sector["Energy"] = "Energy";
+    Sector["Health"] = "Health";
+    Sector["Education"] = "Education";
+    Sector["Transport"] = "Transport";
+    Sector["Manufacturing"] = "Manufacturing";
+    Sector["Hospitality"] = "Hospitality";
+    Sector["Forestry"] = "Forestry";
+    Sector["Waste"] = "Waste";
+    Sector["Agriculture"] = "Agriculture";
+    Sector["Other"] = "Other";
+})(exports.Sector || (exports.Sector = {}));
+
+exports.RadioButtonStatus = void 0;
+(function (RadioButtonStatus) {
+    RadioButtonStatus["YES"] = "YES";
+    RadioButtonStatus["NO"] = "NO";
+    RadioButtonStatus["NA"] = "N/A";
+})(exports.RadioButtonStatus || (exports.RadioButtonStatus = {}));
+exports.RadioButtonStatus2 = void 0;
+(function (RadioButtonStatus2) {
+    RadioButtonStatus2["YES"] = "YES";
+    RadioButtonStatus2["NO"] = "NO";
+    RadioButtonStatus2["MAYBE"] = "MAYBE";
+})(exports.RadioButtonStatus2 || (exports.RadioButtonStatus2 = {}));
+exports.Titles = void 0;
+(function (Titles) {
+    Titles["Mr"] = "Mr";
+    Titles["Mrs"] = "Mrs";
+})(exports.Titles || (exports.Titles = {}));
+var titleList = [
+    { value: exports.Titles.Mr, label: "Mr" },
+    { value: exports.Titles.Mrs, label: "Mrs" },
+];
+exports.FormElementType = void 0;
+(function (FormElementType) {
+    FormElementType[FormElementType["Radio"] = 0] = "Radio";
+    FormElementType[FormElementType["Label"] = 1] = "Label";
+    FormElementType[FormElementType["Input"] = 2] = "Input";
+})(exports.FormElementType || (exports.FormElementType = {}));
+
+exports.SdgGoals = void 0;
+(function (SdgGoals) {
+    SdgGoals["noPoverty"] = "No Poverty";
+    SdgGoals["zeroHunger"] = "Zero Hunger";
+    SdgGoals["gdHealth"] = "Good Health and Well-being";
+    SdgGoals["qualityEducation"] = "Quality Education";
+    SdgGoals["genderEq"] = "Gender Equality";
+    SdgGoals["cleanWatr"] = "Clean Water and Sanitation";
+    SdgGoals["affEnergy"] = "Affordable and Clean Energy";
+    SdgGoals["decentWork"] = "Decent Work and Economic Growth";
+    SdgGoals["industry"] = "Industry, Innovation and Infrastructure";
+    SdgGoals["reducedInEq"] = "Reduced Inequalities";
+    SdgGoals["sustainableCities"] = "Sustainable Cities and Communities";
+    SdgGoals["responsibleConsumption"] = "Responsible Consumption and Production";
+    SdgGoals["climateAction"] = "Climate Action";
+    SdgGoals["lifeBelowWater"] = "Life Below Water";
+    SdgGoals["lifeOnLand"] = "Life On Land";
+    SdgGoals["peace"] = "Peace, Justice and Strong Institutions";
+    SdgGoals["partnership"] = "Partnerships for the Goals";
+})(exports.SdgGoals || (exports.SdgGoals = {}));
+
+exports.ConfigurationSettingsType = void 0;
+(function (ConfigurationSettingsType) {
+    ConfigurationSettingsType[ConfigurationSettingsType["isTransferFrozen"] = 0] = "isTransferFrozen";
+})(exports.ConfigurationSettingsType || (exports.ConfigurationSettingsType = {}));
+
+exports.MapTypes = void 0;
+(function (MapTypes) {
+    MapTypes["Mapbox"] = "Mapbox";
+    MapTypes["None"] = "None";
+})(exports.MapTypes || (exports.MapTypes = {}));
+
+var BaseEntity = /** @class */ (function () {
+    function BaseEntity() {
+    }
+    return BaseEntity;
+}());
+
+var ProgrammeTransfer = /** @class */ (function () {
+    function ProgrammeTransfer() {
+    }
+    return ProgrammeTransfer;
+}());
+
+var User = /** @class */ (function () {
+    function User() {
+    }
+    return User;
+}());
+
+var ProgrammeEntity = /** @class */ (function () {
+    function ProgrammeEntity() {
+    }
+    return ProgrammeEntity;
+}());
+
+var AddNewCompanyComponent = function (props) {
+    var _a;
+    var t = props.t, onNavigateToCompanyManagement = props.onNavigateToCompanyManagement, maximumImageSize = props.maximumImageSize, useConnection = props.useConnection, useUserContext = props.useUserContext, useLocation = props.useLocation, regionField = props.regionField;
+    var formOne = antd.Form.useForm()[0];
+    var formTwo = antd.Form.useForm()[0];
+    var _b = React.useState(), stepOneData = _b[0], setStepOneData = _b[1];
+    var _c = React.useState(false), loading = _c[0], setLoading = _c[1];
+    var contactNoInput = React.useState()[0];
+    var _d = React.useState(0), current = _d[0], setCurrent = _d[1];
+    var _e = React.useState(false), isUpdate = _e[0], setIsUpdate = _e[1];
+    var _f = useConnection(), put = _f.put, get = _f.get, post = _f.post;
+    var _g = useUserContext(), setUserInfo = _g.setUserInfo, userInfoState = _g.userInfoState;
+    var state = useLocation().state;
+    var _h = React.useState([]), fileList = _h[0], setFileList = _h[1];
+    var _j = React.useState([]), countries = _j[0], setCountries = _j[1];
+    var _k = React.useState(false), loadingList = _k[0], setLoadingList = _k[1];
+    var _l = React.useState([]), regionsList = _l[0], setRegionsList = _l[1];
+    var _m = React.useState((_a = state === null || state === void 0 ? void 0 : state.record) === null || _a === void 0 ? void 0 : _a.companyRole), companyRole = _m[0], setCompanyRole = _m[1];
+    var getCountryList = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var response, alpha2Names;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, get("national/organisation/countries")];
+                case 1:
+                    response = _a.sent();
+                    if (response.data) {
+                        alpha2Names = response.data.map(function (item) {
+                            return item.alpha2;
+                        });
+                        setCountries(alpha2Names);
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var getRegionList = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var response, regionNames, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setLoadingList(true);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, 4, 5]);
+                    return [4 /*yield*/, post("national/organisation/regions", {
+                            page: 1,
+                            size: 100,
+                            filterAnd: [
+                                {
+                                    key: "lang",
+                                    operation: "=",
+                                    value: "en",
+                                },
+                            ],
+                        })];
+                case 2:
+                    response = _a.sent();
+                    if (response.data) {
+                        regionNames = response.data.map(function (item) { return item.regionName; });
+                        setRegionsList(__spreadArray([t("national")], regionNames, true));
+                    }
+                    return [3 /*break*/, 5];
+                case 3:
+                    error_1 = _a.sent();
+                    console.log("Error in getting regions list", error_1);
+                    return [3 /*break*/, 5];
+                case 4:
+                    setLoadingList(false);
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+    React.useEffect(function () {
+        var _a, _b, _c;
+        setIsUpdate((state === null || state === void 0 ? void 0 : state.record) ? true : false);
+        getCountryList();
+        getRegionList();
+        if ((_a = state === null || state === void 0 ? void 0 : state.record) === null || _a === void 0 ? void 0 : _a.logo) {
+            setFileList([
+                {
+                    uid: "1",
+                    name: "".concat((_b = state === null || state === void 0 ? void 0 : state.record) === null || _b === void 0 ? void 0 : _b.name, ".png"),
+                    status: "done",
+                    url: (_c = state === null || state === void 0 ? void 0 : state.record) === null || _c === void 0 ? void 0 : _c.logo,
+                    type: "image/png",
+                },
+            ]);
+        }
+    }, []);
+    var normFile = function (e) {
+        if (Array.isArray(e)) {
+            return e;
+        }
+        return e === null || e === void 0 ? void 0 : e.fileList;
+    };
+    var nextOne = function (val) {
+        setCurrent(current + 1);
+        setStepOneData(val);
+    };
+    var prevOne = function () {
+        setCurrent(current - 1);
+    };
+    var onFinishStepOne = function (values) {
+        nextOne(values);
+    };
+    var onChangeRegion = function (values) {
+        if (values.includes(t("national"))) {
+            var buyerCountryValues = regionsList;
+            var newBuyerValues = buyerCountryValues === null || buyerCountryValues === void 0 ? void 0 : buyerCountryValues.filter(function (item) { return item !== t("national"); });
+            formOne.setFieldValue("regions", __spreadArray([], newBuyerValues, true));
+        }
     };
     var onFinishStepTwo = function (values) { return __awaiter(void 0, void 0, void 0, function () {
         var requestData, logoBase64, logoUrls, response, error_2;
@@ -7347,6 +10683,9 @@ exports.addCommSep = addCommSep;
 exports.addCommSepRound = addCommSepRound;
 exports.addRoundNumber = addRoundNumber;
 exports.addSpaces = addSpaces;
+exports.consumerGroupList = consumerGroupList;
+exports.energyGenerationUnitList = energyGenerationUnitList;
+exports.getBase64 = getBase64;
 exports.getCompanyBgColor = getCompanyBgColor;
 exports.getCreditStageVal = getCreditStageVal;
 exports.getFinancialFields = getFinancialFields;
@@ -7362,7 +10701,10 @@ exports.getStageTransferEnumVal = getStageTransferEnumVal;
 exports.getStatusTagType = getStatusTagType;
 exports.getTransferStageTagType = getTransferStageTagType;
 exports.isBase64 = isBase64;
+exports.landAreaUnitList = landAreaUnitList;
 exports.mitigationTypeList = mitigationTypeList;
 exports.ndcActionTypeList = ndcActionTypeList;
+exports.sectorMitigationTypesListMapped = sectorMitigationTypesListMapped;
 exports.sumArray = sumArray;
+exports.titleList = titleList;
 //# sourceMappingURL=index.js.map