@mxtommy/kip 3.9.0-beta.3 → 3.9.0-beta.30

package/public/chunk-E24UNLSJ.js

@@ -0,0 +1,2228 @@
+import {
+  AppSettingsService,
+  DataService
+} from "./chunk-BIBIW64D.js";
+import {
+  Injectable,
+  __commonJS,
+  __toESM,
+  inject,
+  setClassMetadata,
+  ɵɵdefineInjectable
+} from "./chunk-SDOP6T56.js";
+
+// node_modules/js-quantities/build/quantities.js
+var require_quantities = __commonJS({
+  "node_modules/js-quantities/build/quantities.js"(exports, module) {
+    (function(global, factory) {
+      typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.Qty = factory());
+    })(exports, (function() {
+      "use strict";
+      function isString(value) {
+        return typeof value === "string" || value instanceof String;
+      }
+      var isFiniteImpl = Number.isFinite || window.isFinite;
+      function isNumber(value) {
+        return isFiniteImpl(value);
+      }
+      function identity(value) {
+        return value;
+      }
+      function uniq(strings) {
+        var seen = {};
+        return strings.filter(function(item) {
+          return seen.hasOwnProperty(item) ? false : seen[item] = true;
+        });
+      }
+      function compareArray(array1, array2) {
+        if (array2.length !== array1.length) {
+          return false;
+        }
+        for (var i2 = 0; i2 < array1.length; i2++) {
+          if (array2[i2].compareArray) {
+            if (!array2[i2].compareArray(array1[i2])) {
+              return false;
+            }
+          }
+          if (array2[i2] !== array1[i2]) {
+            return false;
+          }
+        }
+        return true;
+      }
+      function assign(target, properties) {
+        Object.keys(properties).forEach(function(key) {
+          target[key] = properties[key];
+        });
+      }
+      function mulSafe() {
+        var result = 1, decimals = 0;
+        for (var i2 = 0; i2 < arguments.length; i2++) {
+          var arg = arguments[i2];
+          decimals = decimals + getFractional(arg);
+          result *= arg;
+        }
+        return decimals !== 0 ? round(result, decimals) : result;
+      }
+      function divSafe(num, den) {
+        if (den === 0) {
+          throw new Error("Divide by zero");
+        }
+        var factor = Math.pow(10, getFractional(den));
+        var invDen = factor / (factor * den);
+        return mulSafe(num, invDen);
+      }
+      function round(val, decimals) {
+        return Math.round(val * Math.pow(10, decimals)) / Math.pow(10, decimals);
+      }
+      function getFractional(num) {
+        if (!isFinite(num)) {
+          return 0;
+        }
+        var count = 0;
+        while (num % 1 !== 0) {
+          num *= 10;
+          count++;
+        }
+        return count;
+      }
+      function QtyError() {
+        var err;
+        if (!this) {
+          err = Object.create(QtyError.prototype);
+          QtyError.apply(err, arguments);
+          return err;
+        }
+        err = Error.apply(this, arguments);
+        this.name = "QtyError";
+        this.message = err.message;
+        this.stack = err.stack;
+      }
+      QtyError.prototype = Object.create(Error.prototype, { constructor: { value: QtyError } });
+      function throwIncompatibleUnits(left, right) {
+        throw new QtyError("Incompatible units: " + left + " and " + right);
+      }
+      var UNITS = {
+        /* prefixes */
+        "<googol>": [["googol"], 1e100, "prefix"],
+        "<kibi>": [["Ki", "Kibi", "kibi"], Math.pow(2, 10), "prefix"],
+        "<mebi>": [["Mi", "Mebi", "mebi"], Math.pow(2, 20), "prefix"],
+        "<gibi>": [["Gi", "Gibi", "gibi"], Math.pow(2, 30), "prefix"],
+        "<tebi>": [["Ti", "Tebi", "tebi"], Math.pow(2, 40), "prefix"],
+        "<pebi>": [["Pi", "Pebi", "pebi"], Math.pow(2, 50), "prefix"],
+        "<exi>": [["Ei", "Exi", "exi"], Math.pow(2, 60), "prefix"],
+        "<zebi>": [["Zi", "Zebi", "zebi"], Math.pow(2, 70), "prefix"],
+        "<yebi>": [["Yi", "Yebi", "yebi"], Math.pow(2, 80), "prefix"],
+        "<yotta>": [["Y", "Yotta", "yotta"], 1e24, "prefix"],
+        "<zetta>": [["Z", "Zetta", "zetta"], 1e21, "prefix"],
+        "<exa>": [["E", "Exa", "exa"], 1e18, "prefix"],
+        "<peta>": [["P", "Peta", "peta"], 1e15, "prefix"],
+        "<tera>": [["T", "Tera", "tera"], 1e12, "prefix"],
+        "<giga>": [["G", "Giga", "giga"], 1e9, "prefix"],
+        "<mega>": [["M", "Mega", "mega"], 1e6, "prefix"],
+        "<kilo>": [["k", "kilo"], 1e3, "prefix"],
+        "<hecto>": [["h", "Hecto", "hecto"], 100, "prefix"],
+        "<deca>": [["da", "Deca", "deca", "deka"], 10, "prefix"],
+        "<deci>": [["d", "Deci", "deci"], 0.1, "prefix"],
+        "<centi>": [["c", "Centi", "centi"], 0.01, "prefix"],
+        "<milli>": [["m", "Milli", "milli"], 1e-3, "prefix"],
+        "<micro>": [
+          ["u", "\u03BC", "\xB5", "Micro", "mc", "micro"],
+          1e-6,
+          "prefix"
+        ],
+        "<nano>": [["n", "Nano", "nano"], 1e-9, "prefix"],
+        "<pico>": [["p", "Pico", "pico"], 1e-12, "prefix"],
+        "<femto>": [["f", "Femto", "femto"], 1e-15, "prefix"],
+        "<atto>": [["a", "Atto", "atto"], 1e-18, "prefix"],
+        "<zepto>": [["z", "Zepto", "zepto"], 1e-21, "prefix"],
+        "<yocto>": [["y", "Yocto", "yocto"], 1e-24, "prefix"],
+        "<1>": [["1", "<1>"], 1, ""],
+        /* length units */
+        "<meter>": [["m", "meter", "meters", "metre", "metres"], 1, "length", ["<meter>"]],
+        "<inch>": [["in", "inch", "inches", '"'], 0.0254, "length", ["<meter>"]],
+        "<foot>": [["ft", "foot", "feet", "'"], 0.3048, "length", ["<meter>"]],
+        "<yard>": [["yd", "yard", "yards"], 0.9144, "length", ["<meter>"]],
+        "<mile>": [["mi", "mile", "miles"], 1609.344, "length", ["<meter>"]],
+        "<naut-mile>": [["nmi", "naut-mile"], 1852, "length", ["<meter>"]],
+        "<league>": [["league", "leagues"], 4828, "length", ["<meter>"]],
+        "<furlong>": [["furlong", "furlongs"], 201.2, "length", ["<meter>"]],
+        "<rod>": [["rd", "rod", "rods"], 5.029, "length", ["<meter>"]],
+        "<mil>": [["mil", "mils"], 254e-7, "length", ["<meter>"]],
+        "<angstrom>": [["ang", "angstrom", "angstroms"], 1e-10, "length", ["<meter>"]],
+        "<fathom>": [["fathom", "fathoms"], 1.829, "length", ["<meter>"]],
+        "<pica>": [["pica", "picas"], 0.00423333333, "length", ["<meter>"]],
+        "<point>": [["pt", "point", "points"], 352777778e-12, "length", ["<meter>"]],
+        "<redshift>": [["z", "red-shift", "redshift"], 1302773e20, "length", ["<meter>"]],
+        "<AU>": [["AU", "astronomical-unit"], 1495979e5, "length", ["<meter>"]],
+        "<light-second>": [["ls", "light-second"], 299792500, "length", ["<meter>"]],
+        "<light-minute>": [["lmin", "light-minute"], 1798755e4, "length", ["<meter>"]],
+        "<light-year>": [["ly", "light-year"], 9460528e9, "length", ["<meter>"]],
+        "<parsec>": [["pc", "parsec", "parsecs"], 3085678e10, "length", ["<meter>"]],
+        "<datamile>": [["DM", "datamile"], 1828.8, "length", ["<meter>"]],
+        /* mass */
+        "<kilogram>": [["kg", "kilogram", "kilograms"], 1, "mass", ["<kilogram>"]],
+        "<AMU>": [["u", "AMU", "amu"], 1660538921e-36, "mass", ["<kilogram>"]],
+        "<dalton>": [["Da", "Dalton", "Daltons", "dalton", "daltons"], 1660538921e-36, "mass", ["<kilogram>"]],
+        "<slug>": [["slug", "slugs"], 14.5939029, "mass", ["<kilogram>"]],
+        "<short-ton>": [["tn", "ton", "short-ton"], 907.18474, "mass", ["<kilogram>"]],
+        "<metric-ton>": [["t", "tonne", "metric-ton"], 1e3, "mass", ["<kilogram>"]],
+        "<carat>": [["ct", "carat", "carats"], 2e-4, "mass", ["<kilogram>"]],
+        "<pound>": [["lbs", "lb", "pound", "pounds", "#"], 0.45359237, "mass", ["<kilogram>"]],
+        "<ounce>": [["oz", "ounce", "ounces"], 0.0283495231, "mass", ["<kilogram>"]],
+        "<gram>": [["g", "gram", "grams", "gramme", "grammes"], 1e-3, "mass", ["<kilogram>"]],
+        "<grain>": [["grain", "grains", "gr"], 6479891e-11, "mass", ["<kilogram>"]],
+        "<dram>": [["dram", "drams", "dr"], 0.0017718452, "mass", ["<kilogram>"]],
+        "<stone>": [["stone", "stones", "st"], 6.35029318, "mass", ["<kilogram>"]],
+        /* area */
+        "<hectare>": [["hectare"], 1e4, "area", ["<meter>", "<meter>"]],
+        "<acre>": [["acre", "acres"], 4046.85642, "area", ["<meter>", "<meter>"]],
+        "<sqft>": [["sqft"], 1, "area", ["<foot>", "<foot>"]],
+        /* volume */
+        "<liter>": [["l", "L", "liter", "liters", "litre", "litres"], 1e-3, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<gallon>": [["gal", "gallon", "gallons"], 0.0037854118, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<gallon-imp>": [["galimp", "gallon-imp", "gallons-imp"], 454609e-8, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<quart>": [["qt", "quart", "quarts"], 94635295e-11, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<pint>": [["pt", "pint", "pints"], 473176475e-12, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<pint-imp>": [["ptimp", "pint-imp", "pints-imp"], 56826125e-11, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<cup>": [["cu", "cup", "cups"], 236588238e-12, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<fluid-ounce>": [["floz", "fluid-ounce", "fluid-ounces"], 295735297e-13, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<fluid-ounce-imp>": [["flozimp", "floz-imp", "fluid-ounce-imp", "fluid-ounces-imp"], 284130625e-13, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<tablespoon>": [["tb", "tbsp", "tbs", "tablespoon", "tablespoons"], 147867648e-13, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<teaspoon>": [["tsp", "teaspoon", "teaspoons"], 492892161e-14, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<bushel>": [["bu", "bsh", "bushel", "bushels"], 0.035239072, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<oilbarrel>": [["bbl", "oilbarrel", "oilbarrels", "oil-barrel", "oil-barrels"], 0.158987294928, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<beerbarrel>": [["bl", "bl-us", "beerbarrel", "beerbarrels", "beer-barrel", "beer-barrels"], 0.1173477658, "volume", ["<meter>", "<meter>", "<meter>"]],
+        "<beerbarrel-imp>": [["blimp", "bl-imp", "beerbarrel-imp", "beerbarrels-imp", "beer-barrel-imp", "beer-barrels-imp"], 0.16365924, "volume", ["<meter>", "<meter>", "<meter>"]],
+        /* speed */
+        "<kph>": [["kph"], 0.277777778, "speed", ["<meter>"], ["<second>"]],
+        "<mph>": [["mph"], 0.44704, "speed", ["<meter>"], ["<second>"]],
+        "<knot>": [["kt", "kn", "kts", "knot", "knots"], 0.514444444, "speed", ["<meter>"], ["<second>"]],
+        "<fps>": [["fps"], 0.3048, "speed", ["<meter>"], ["<second>"]],
+        /* acceleration */
+        "<gee>": [["gee"], 9.80665, "acceleration", ["<meter>"], ["<second>", "<second>"]],
+        "<Gal>": [["Gal"], 0.01, "acceleration", ["<meter>"], ["<second>", "<second>"]],
+        /* temperature_difference */
+        "<kelvin>": [["degK", "kelvin"], 1, "temperature", ["<kelvin>"]],
+        "<celsius>": [["degC", "celsius", "celsius", "centigrade"], 1, "temperature", ["<kelvin>"]],
+        "<fahrenheit>": [["degF", "fahrenheit"], 5 / 9, "temperature", ["<kelvin>"]],
+        "<rankine>": [["degR", "rankine"], 5 / 9, "temperature", ["<kelvin>"]],
+        "<temp-K>": [["tempK", "temp-K"], 1, "temperature", ["<temp-K>"]],
+        "<temp-C>": [["tempC", "temp-C"], 1, "temperature", ["<temp-K>"]],
+        "<temp-F>": [["tempF", "temp-F"], 5 / 9, "temperature", ["<temp-K>"]],
+        "<temp-R>": [["tempR", "temp-R"], 5 / 9, "temperature", ["<temp-K>"]],
+        /* time */
+        "<second>": [["s", "sec", "secs", "second", "seconds"], 1, "time", ["<second>"]],
+        "<minute>": [["min", "mins", "minute", "minutes"], 60, "time", ["<second>"]],
+        "<hour>": [["h", "hr", "hrs", "hour", "hours"], 3600, "time", ["<second>"]],
+        "<day>": [["d", "day", "days"], 3600 * 24, "time", ["<second>"]],
+        "<week>": [["wk", "week", "weeks"], 7 * 3600 * 24, "time", ["<second>"]],
+        "<fortnight>": [["fortnight", "fortnights"], 1209600, "time", ["<second>"]],
+        "<year>": [["y", "yr", "year", "years", "annum"], 31556926, "time", ["<second>"]],
+        "<decade>": [["decade", "decades"], 315569260, "time", ["<second>"]],
+        "<century>": [["century", "centuries"], 3155692600, "time", ["<second>"]],
+        /* pressure */
+        "<pascal>": [["Pa", "pascal", "Pascal"], 1, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        "<bar>": [["bar", "bars"], 1e5, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        "<mmHg>": [["mmHg"], 133.322368, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        "<inHg>": [["inHg"], 3386.3881472, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        "<torr>": [["torr"], 133.322368, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        "<atm>": [["atm", "ATM", "atmosphere", "atmospheres"], 101325, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        "<psi>": [["psi"], 6894.76, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        "<cmh2o>": [["cmH2O", "cmh2o"], 98.0638, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        "<inh2o>": [["inH2O", "inh2o"], 249.082052, "pressure", ["<kilogram>"], ["<meter>", "<second>", "<second>"]],
+        /* viscosity */
+        "<poise>": [["P", "poise"], 0.1, "viscosity", ["<kilogram>"], ["<meter>", "<second>"]],
+        "<stokes>": [["St", "stokes"], 1e-4, "viscosity", ["<meter>", "<meter>"], ["<second>"]],
+        /* substance */
+        "<mole>": [["mol", "mole"], 1, "substance", ["<mole>"]],
+        /* molar_concentration */
+        "<molar>": [["M", "molar"], 1e3, "molar_concentration", ["<mole>"], ["<meter>", "<meter>", "<meter>"]],
+        "<wtpercent>": [["wt%", "wtpercent"], 10, "molar_concentration", ["<kilogram>"], ["<meter>", "<meter>", "<meter>"]],
+        /* activity */
+        "<katal>": [["kat", "katal", "Katal"], 1, "activity", ["<mole>"], ["<second>"]],
+        "<unit>": [["U", "enzUnit", "unit"], 16667e-19, "activity", ["<mole>"], ["<second>"]],
+        /* capacitance */
+        "<farad>": [["F", "farad", "Farad"], 1, "capacitance", ["<second>", "<second>", "<second>", "<second>", "<ampere>", "<ampere>"], ["<meter>", "<meter>", "<kilogram>"]],
+        /* charge */
+        "<coulomb>": [["C", "coulomb", "Coulomb"], 1, "charge", ["<ampere>", "<second>"]],
+        "<Ah>": [["Ah"], 3600, "charge", ["<ampere>", "<second>"]],
+        /* current */
+        "<ampere>": [["A", "Ampere", "ampere", "amp", "amps"], 1, "current", ["<ampere>"]],
+        /* conductance */
+        "<siemens>": [["S", "Siemens", "siemens"], 1, "conductance", ["<second>", "<second>", "<second>", "<ampere>", "<ampere>"], ["<kilogram>", "<meter>", "<meter>"]],
+        /* inductance */
+        "<henry>": [["H", "Henry", "henry"], 1, "inductance", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>", "<ampere>", "<ampere>"]],
+        /* potential */
+        "<volt>": [["V", "Volt", "volt", "volts"], 1, "potential", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>", "<second>", "<ampere>"]],
+        /* resistance */
+        "<ohm>": [
+          [
+            "Ohm",
+            "ohm",
+            "\u03A9",
+            "\u2126"
+            /*Ω as ohm sign*/
+          ],
+          1,
+          "resistance",
+          ["<meter>", "<meter>", "<kilogram>"],
+          ["<second>", "<second>", "<second>", "<ampere>", "<ampere>"]
+        ],
+        /* magnetism */
+        "<weber>": [["Wb", "weber", "webers"], 1, "magnetism", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>", "<ampere>"]],
+        "<tesla>": [["T", "tesla", "teslas"], 1, "magnetism", ["<kilogram>"], ["<second>", "<second>", "<ampere>"]],
+        "<gauss>": [["G", "gauss"], 1e-4, "magnetism", ["<kilogram>"], ["<second>", "<second>", "<ampere>"]],
+        "<maxwell>": [["Mx", "maxwell", "maxwells"], 1e-8, "magnetism", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>", "<ampere>"]],
+        "<oersted>": [["Oe", "oersted", "oersteds"], 250 / Math.PI, "magnetism", ["<ampere>"], ["<meter>"]],
+        /* energy */
+        "<joule>": [["J", "joule", "Joule", "joules", "Joules"], 1, "energy", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>"]],
+        "<erg>": [["erg", "ergs"], 1e-7, "energy", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>"]],
+        "<btu>": [["BTU", "btu", "BTUs"], 1055.056, "energy", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>"]],
+        "<calorie>": [["cal", "calorie", "calories"], 4.184, "energy", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>"]],
+        "<Calorie>": [["Cal", "Calorie", "Calories"], 4184, "energy", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>"]],
+        "<therm-US>": [["th", "therm", "therms", "Therm", "therm-US"], 105480400, "energy", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>"]],
+        "<Wh>": [["Wh"], 3600, "energy", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>"]],
+        "<electronvolt>": [["eV", "electronvolt", "electronvolts"], 1602176634e-28, "energy", ["<meter>", "<meter>", "<kilogram>"], ["<second>", "<second>"]],
+        /* force */
+        "<newton>": [["N", "Newton", "newton"], 1, "force", ["<kilogram>", "<meter>"], ["<second>", "<second>"]],
+        "<dyne>": [["dyn", "dyne"], 1e-5, "force", ["<kilogram>", "<meter>"], ["<second>", "<second>"]],
+        "<pound-force>": [["lbf", "pound-force"], 4.448222, "force", ["<kilogram>", "<meter>"], ["<second>", "<second>"]],
+        /* frequency */
+        "<hertz>": [["Hz", "hertz", "Hertz"], 1, "frequency", ["<1>"], ["<second>"]],
+        /* angle */
+        "<radian>": [["rad", "radian", "radians"], 1, "angle", ["<radian>"]],
+        "<degree>": [["deg", "degree", "degrees"], Math.PI / 180, "angle", ["<radian>"]],
+        "<arcminute>": [["arcmin", "arcminute", "arcminutes"], Math.PI / 10800, "angle", ["<radian>"]],
+        "<arcsecond>": [["arcsec", "arcsecond", "arcseconds"], Math.PI / 648e3, "angle", ["<radian>"]],
+        "<gradian>": [["gon", "grad", "gradian", "grads"], Math.PI / 200, "angle", ["<radian>"]],
+        "<steradian>": [["sr", "steradian", "steradians"], 1, "solid_angle", ["<steradian>"]],
+        /* rotation */
+        "<rotation>": [["rotation"], 2 * Math.PI, "angle", ["<radian>"]],
+        "<rpm>": [["rpm"], 2 * Math.PI / 60, "angular_velocity", ["<radian>"], ["<second>"]],
+        /* information */
+        "<byte>": [["B", "byte", "bytes"], 1, "information", ["<byte>"]],
+        "<bit>": [["b", "bit", "bits"], 0.125, "information", ["<byte>"]],
+        /* information rate */
+        "<Bps>": [["Bps"], 1, "information_rate", ["<byte>"], ["<second>"]],
+        "<bps>": [["bps"], 0.125, "information_rate", ["<byte>"], ["<second>"]],
+        /* currency */
+        "<dollar>": [["USD", "dollar"], 1, "currency", ["<dollar>"]],
+        "<cents>": [["cents"], 0.01, "currency", ["<dollar>"]],
+        /* luminosity */
+        "<candela>": [["cd", "candela"], 1, "luminosity", ["<candela>"]],
+        "<lumen>": [["lm", "lumen"], 1, "luminous_power", ["<candela>", "<steradian>"]],
+        "<lux>": [["lux"], 1, "illuminance", ["<candela>", "<steradian>"], ["<meter>", "<meter>"]],
+        /* power */
+        "<watt>": [["W", "watt", "watts"], 1, "power", ["<kilogram>", "<meter>", "<meter>"], ["<second>", "<second>", "<second>"]],
+        "<volt-ampere>": [["VA", "volt-ampere"], 1, "power", ["<kilogram>", "<meter>", "<meter>"], ["<second>", "<second>", "<second>"]],
+        "<volt-ampere-reactive>": [["var", "Var", "VAr", "VAR", "volt-ampere-reactive"], 1, "power", ["<kilogram>", "<meter>", "<meter>"], ["<second>", "<second>", "<second>"]],
+        "<horsepower>": [["hp", "horsepower"], 745.699872, "power", ["<kilogram>", "<meter>", "<meter>"], ["<second>", "<second>", "<second>"]],
+        /* radiation */
+        "<gray>": [["Gy", "gray", "grays"], 1, "radiation", ["<meter>", "<meter>"], ["<second>", "<second>"]],
+        "<roentgen>": [["R", "roentgen"], 933e-5, "radiation", ["<meter>", "<meter>"], ["<second>", "<second>"]],
+        "<sievert>": [["Sv", "sievert", "sieverts"], 1, "radiation", ["<meter>", "<meter>"], ["<second>", "<second>"]],
+        "<becquerel>": [["Bq", "becquerel", "becquerels"], 1, "radiation", ["<1>"], ["<second>"]],
+        "<curie>": [["Ci", "curie", "curies"], 37e9, "radiation", ["<1>"], ["<second>"]],
+        /* rate */
+        "<cpm>": [["cpm"], 1 / 60, "rate", ["<count>"], ["<second>"]],
+        "<dpm>": [["dpm"], 1 / 60, "rate", ["<count>"], ["<second>"]],
+        "<bpm>": [["bpm"], 1 / 60, "rate", ["<count>"], ["<second>"]],
+        /* resolution / typography */
+        "<dot>": [["dot", "dots"], 1, "resolution", ["<each>"]],
+        "<pixel>": [["pixel", "px"], 1, "resolution", ["<each>"]],
+        "<ppi>": [["ppi"], 1, "resolution", ["<pixel>"], ["<inch>"]],
+        "<dpi>": [["dpi"], 1, "typography", ["<dot>"], ["<inch>"]],
+        /* other */
+        "<cell>": [["cells", "cell"], 1, "counting", ["<each>"]],
+        "<each>": [["each"], 1, "counting", ["<each>"]],
+        "<count>": [["count"], 1, "counting", ["<each>"]],
+        "<base-pair>": [["bp", "base-pair"], 1, "counting", ["<each>"]],
+        "<nucleotide>": [["nt", "nucleotide"], 1, "counting", ["<each>"]],
+        "<molecule>": [["molecule", "molecules"], 1, "counting", ["<1>"]],
+        "<dozen>": [["doz", "dz", "dozen"], 12, "prefix_only", ["<each>"]],
+        "<percent>": [["%", "percent"], 0.01, "prefix_only", ["<1>"]],
+        "<ppm>": [["ppm"], 1e-6, "prefix_only", ["<1>"]],
+        "<ppb>": [["ppb"], 1e-9, "prefix_only", ["<1>"]],
+        "<ppt>": [["ppt"], 1e-12, "prefix_only", ["<1>"]],
+        "<ppq>": [["ppq"], 1e-15, "prefix_only", ["<1>"]],
+        "<gross>": [["gr", "gross"], 144, "prefix_only", ["<dozen>", "<dozen>"]],
+        "<decibel>": [["dB", "decibel", "decibels"], 1, "logarithmic", ["<decibel>"]]
+      };
+      var BASE_UNITS = ["<meter>", "<kilogram>", "<second>", "<mole>", "<ampere>", "<radian>", "<kelvin>", "<temp-K>", "<byte>", "<dollar>", "<candela>", "<each>", "<steradian>", "<decibel>"];
+      var UNITY = "<1>";
+      var UNITY_ARRAY = [UNITY];
+      function validateUnitDefinition(unitDef2, definition2) {
+        var scalar = definition2[1];
+        var numerator = definition2[3] || [];
+        var denominator = definition2[4] || [];
+        if (!isNumber(scalar)) {
+          throw new QtyError(unitDef2 + ": Invalid unit definition. 'scalar' must be a number");
+        }
+        numerator.forEach(function(unit) {
+          if (UNITS[unit] === void 0) {
+            throw new QtyError(unitDef2 + ": Invalid unit definition. Unit " + unit + " in 'numerator' is not recognized");
+          }
+        });
+        denominator.forEach(function(unit) {
+          if (UNITS[unit] === void 0) {
+            throw new QtyError(unitDef2 + ": Invalid unit definition. Unit " + unit + " in 'denominator' is not recognized");
+          }
+        });
+      }
+      var PREFIX_VALUES = {};
+      var PREFIX_MAP = {};
+      var UNIT_VALUES = {};
+      var UNIT_MAP = {};
+      var OUTPUT_MAP = {};
+      for (var unitDef in UNITS) {
+        if (UNITS.hasOwnProperty(unitDef)) {
+          var definition = UNITS[unitDef];
+          if (definition[2] === "prefix") {
+            PREFIX_VALUES[unitDef] = definition[1];
+            for (var i = 0; i < definition[0].length; i++) {
+              PREFIX_MAP[definition[0][i]] = unitDef;
+            }
+          } else {
+            validateUnitDefinition(unitDef, definition);
+            UNIT_VALUES[unitDef] = {
+              scalar: definition[1],
+              numerator: definition[3],
+              denominator: definition[4]
+            };
+            for (var j = 0; j < definition[0].length; j++) {
+              UNIT_MAP[definition[0][j]] = unitDef;
+            }
+          }
+          OUTPUT_MAP[unitDef] = definition[0][0];
+        }
+      }
+      function getUnits(kind) {
+        var i2;
+        var units = [];
+        var unitKeys = Object.keys(UNITS);
+        if (typeof kind === "undefined") {
+          for (i2 = 0; i2 < unitKeys.length; i2++) {
+            if (["", "prefix"].indexOf(UNITS[unitKeys[i2]][2]) === -1) {
+              units.push(unitKeys[i2].substr(1, unitKeys[i2].length - 2));
+            }
+          }
+        } else if (this.getKinds().indexOf(kind) === -1) {
+          throw new QtyError("Kind not recognized");
+        } else {
+          for (i2 = 0; i2 < unitKeys.length; i2++) {
+            if (UNITS[unitKeys[i2]][2] === kind) {
+              units.push(unitKeys[i2].substr(1, unitKeys[i2].length - 2));
+            }
+          }
+        }
+        return units.sort(function(a, b) {
+          if (a.toLowerCase() < b.toLowerCase()) {
+            return -1;
+          }
+          if (a.toLowerCase() > b.toLowerCase()) {
+            return 1;
+          }
+          return 0;
+        });
+      }
+      function getAliases(unitName) {
+        if (!UNIT_MAP[unitName]) {
+          throw new QtyError("Unit not recognized");
+        }
+        return UNITS[UNIT_MAP[unitName]][0];
+      }
+      var SIGNATURE_VECTOR = ["length", "time", "temperature", "mass", "current", "substance", "luminosity", "currency", "information", "angle"];
+      function unitSignature() {
+        if (this.signature) {
+          return this.signature;
+        }
+        var vector = unitSignatureVector.call(this);
+        for (var i2 = 0; i2 < vector.length; i2++) {
+          vector[i2] *= Math.pow(20, i2);
+        }
+        return vector.reduce(
+          function(previous, current) {
+            return previous + current;
+          },
+          0
+        );
+      }
+      function unitSignatureVector() {
+        if (!this.isBase()) {
+          return unitSignatureVector.call(this.toBase());
+        }
+        var vector = new Array(SIGNATURE_VECTOR.length);
+        for (var i2 = 0; i2 < vector.length; i2++) {
+          vector[i2] = 0;
+        }
+        var r, n;
+        for (var j2 = 0; j2 < this.numerator.length; j2++) {
+          if (r = UNITS[this.numerator[j2]]) {
+            n = SIGNATURE_VECTOR.indexOf(r[2]);
+            if (n >= 0) {
+              vector[n] = vector[n] + 1;
+            }
+          }
+        }
+        for (var k = 0; k < this.denominator.length; k++) {
+          if (r = UNITS[this.denominator[k]]) {
+            n = SIGNATURE_VECTOR.indexOf(r[2]);
+            if (n >= 0) {
+              vector[n] = vector[n] - 1;
+            }
+          }
+        }
+        return vector;
+      }
+      var SIGN = "[+-]";
+      var INTEGER = "\\d+";
+      var SIGNED_INTEGER = SIGN + "?" + INTEGER;
+      var FRACTION = "\\." + INTEGER;
+      var FLOAT = "(?:" + INTEGER + "(?:" + FRACTION + ")?)|(?:" + FRACTION + ")";
+      var EXPONENT = "[Ee]" + SIGNED_INTEGER;
+      var SCI_NUMBER = "(?:" + FLOAT + ")(?:" + EXPONENT + ")?";
+      var SIGNED_NUMBER = SIGN + "?\\s*" + SCI_NUMBER;
+      var QTY_STRING = "(" + SIGNED_NUMBER + ")?\\s*([^/]*)(?:/(.+))?";
+      var QTY_STRING_REGEX = new RegExp("^" + QTY_STRING + "$");
+      var POWER_OP = "\\^|\\*{2}";
+      var SAFE_POWER = "[01234]";
+      var TOP_REGEX = new RegExp("([^ \\*\\d]+?)(?:" + POWER_OP + ")?(-?" + SAFE_POWER + "(?![a-zA-Z]))");
+      var BOTTOM_REGEX = new RegExp("([^ \\*\\d]+?)(?:" + POWER_OP + ")?(" + SAFE_POWER + "(?![a-zA-Z]))");
+      function parse(val) {
+        if (!isString(val)) {
+          val = val.toString();
+        }
+        val = val.trim();
+        var result = QTY_STRING_REGEX.exec(val);
+        if (!result) {
+          throw new QtyError(val + ": Quantity not recognized");
+        }
+        var scalarMatch = result[1];
+        if (scalarMatch) {
+          scalarMatch = scalarMatch.replace(/\s/g, "");
+          this.scalar = parseFloat(scalarMatch);
+        } else {
+          this.scalar = 1;
+        }
+        var top = result[2];
+        var bottom = result[3];
+        var n, x, nx;
+        while (result = TOP_REGEX.exec(top)) {
+          n = parseFloat(result[2]);
+          if (isNaN(n)) {
+            throw new QtyError("Unit exponent is not a number");
+          }
+          if (n === 0 && !UNIT_TEST_REGEX.test(result[1])) {
+            throw new QtyError("Unit not recognized");
+          }
+          x = result[1] + " ";
+          nx = "";
+          for (var i2 = 0; i2 < Math.abs(n); i2++) {
+            nx += x;
+          }
+          if (n >= 0) {
+            top = top.replace(result[0], nx);
+          } else {
+            bottom = bottom ? bottom + nx : nx;
+            top = top.replace(result[0], "");
+          }
+        }
+        while (result = BOTTOM_REGEX.exec(bottom)) {
+          n = parseFloat(result[2]);
+          if (isNaN(n)) {
+            throw new QtyError("Unit exponent is not a number");
+          }
+          if (n === 0 && !UNIT_TEST_REGEX.test(result[1])) {
+            throw new QtyError("Unit not recognized");
+          }
+          x = result[1] + " ";
+          nx = "";
+          for (var j2 = 0; j2 < n; j2++) {
+            nx += x;
+          }
+          bottom = bottom.replace(result[0], nx);
+        }
+        if (top) {
+          this.numerator = parseUnits(top.trim());
+        }
+        if (bottom) {
+          this.denominator = parseUnits(bottom.trim());
+        }
+      }
+      var PREFIX_REGEX = Object.keys(PREFIX_MAP).sort(function(a, b) {
+        return b.length - a.length;
+      }).join("|");
+      var UNIT_REGEX = Object.keys(UNIT_MAP).sort(function(a, b) {
+        return b.length - a.length;
+      }).join("|");
+      var BOUNDARY_REGEX = "\\b|$";
+      var UNIT_MATCH = "(" + PREFIX_REGEX + ")??(" + UNIT_REGEX + ")(?:" + BOUNDARY_REGEX + ")";
+      var UNIT_TEST_REGEX = new RegExp("^\\s*(" + UNIT_MATCH + "[\\s\\*]*)+$");
+      var UNIT_MATCH_REGEX = new RegExp(UNIT_MATCH, "g");
+      var parsedUnitsCache = {};
+      function parseUnits(units) {
+        var cached = parsedUnitsCache[units];
+        if (cached) {
+          return cached;
+        }
+        var unitMatch, normalizedUnits = [];
+        if (!UNIT_TEST_REGEX.test(units)) {
+          throw new QtyError("Unit not recognized");
+        }
+        while (unitMatch = UNIT_MATCH_REGEX.exec(units)) {
+          normalizedUnits.push(unitMatch.slice(1));
+        }
+        normalizedUnits = normalizedUnits.map(function(item) {
+          return PREFIX_MAP[item[0]] ? [PREFIX_MAP[item[0]], UNIT_MAP[item[1]]] : [UNIT_MAP[item[1]]];
+        });
+        normalizedUnits = normalizedUnits.reduce(function(a, b) {
+          return a.concat(b);
+        }, []);
+        normalizedUnits = normalizedUnits.filter(function(item) {
+          return item;
+        });
+        parsedUnitsCache[units] = normalizedUnits;
+        return normalizedUnits;
+      }
+      function globalParse(value) {
+        if (!isString(value)) {
+          throw new QtyError("Argument should be a string");
+        }
+        try {
+          return this(value);
+        } catch (e) {
+          return null;
+        }
+      }
+      function isQty(value) {
+        return value instanceof Qty2;
+      }
+      function Qty2(initValue, initUnits) {
+        assertValidConstructorArgs.apply(null, arguments);
+        if (!isQty(this)) {
+          return new Qty2(initValue, initUnits);
+        }
+        this.scalar = null;
+        this.baseScalar = null;
+        this.signature = null;
+        this._conversionCache = {};
+        this.numerator = UNITY_ARRAY;
+        this.denominator = UNITY_ARRAY;
+        if (isDefinitionObject(initValue)) {
+          this.scalar = initValue.scalar;
+          this.numerator = initValue.numerator && initValue.numerator.length !== 0 ? initValue.numerator : UNITY_ARRAY;
+          this.denominator = initValue.denominator && initValue.denominator.length !== 0 ? initValue.denominator : UNITY_ARRAY;
+        } else if (initUnits) {
+          parse.call(this, initUnits);
+          this.scalar = initValue;
+        } else {
+          parse.call(this, initValue);
+        }
+        if (this.denominator.join("*").indexOf("temp") >= 0) {
+          throw new QtyError("Cannot divide with temperatures");
+        }
+        if (this.numerator.join("*").indexOf("temp") >= 0) {
+          if (this.numerator.length > 1) {
+            throw new QtyError("Cannot multiply by temperatures");
+          }
+          if (!compareArray(this.denominator, UNITY_ARRAY)) {
+            throw new QtyError("Cannot divide with temperatures");
+          }
+        }
+        this.initValue = initValue;
+        updateBaseScalar.call(this);
+        if (this.isTemperature() && this.baseScalar < 0) {
+          throw new QtyError("Temperatures must not be less than absolute zero");
+        }
+      }
+      Qty2.prototype = {
+        // Properly set up constructor
+        constructor: Qty2
+      };
+      function assertValidConstructorArgs(value, units) {
+        if (units) {
+          if (!(isNumber(value) && isString(units))) {
+            throw new QtyError("Only number accepted as initialization value when units are explicitly provided");
+          }
+        } else {
+          if (!(isString(value) || isNumber(value) || isQty(value) || isDefinitionObject(value))) {
+            throw new QtyError("Only string, number or quantity accepted as single initialization value");
+          }
+        }
+      }
+      function isDefinitionObject(value) {
+        return value && typeof value === "object" && value.hasOwnProperty("scalar");
+      }
+      function updateBaseScalar() {
+        if (this.baseScalar) {
+          return this.baseScalar;
+        }
+        if (this.isBase()) {
+          this.baseScalar = this.scalar;
+          this.signature = unitSignature.call(this);
+        } else {
+          var base = this.toBase();
+          this.baseScalar = base.scalar;
+          this.signature = base.signature;
+        }
+      }
+      var KINDS = {
+        "-312078": "elastance",
+        "-312058": "resistance",
+        "-312038": "inductance",
+        "-152058": "potential",
+        "-152040": "magnetism",
+        "-152038": "magnetism",
+        "-7997": "specific_volume",
+        "-79": "snap",
+        "-59": "jolt",
+        "-39": "acceleration",
+        "-38": "radiation",
+        "-20": "frequency",
+        "-19": "speed",
+        "-18": "viscosity",
+        "-17": "volumetric_flow",
+        "-1": "wavenumber",
+        "0": "unitless",
+        "1": "length",
+        "2": "area",
+        "3": "volume",
+        "20": "time",
+        "400": "temperature",
+        "7941": "yank",
+        "7942": "power",
+        "7959": "pressure",
+        "7961": "force",
+        "7962": "energy",
+        "7979": "viscosity",
+        "7981": "momentum",
+        "7982": "angular_momentum",
+        "7997": "density",
+        "7998": "area_density",
+        "8000": "mass",
+        "152020": "radiation_exposure",
+        "159999": "magnetism",
+        "160000": "current",
+        "160020": "charge",
+        "312058": "conductance",
+        "312078": "capacitance",
+        "3199980": "activity",
+        "3199997": "molar_concentration",
+        "3200000": "substance",
+        "63999998": "illuminance",
+        "64000000": "luminous_power",
+        "1280000000": "currency",
+        "25599999980": "information_rate",
+        "25600000000": "information",
+        "511999999980": "angular_velocity",
+        "512000000000": "angle"
+      };
+      function getKinds() {
+        return uniq(Object.keys(KINDS).map(function(knownSignature) {
+          return KINDS[knownSignature];
+        }));
+      }
+      Qty2.prototype.kind = function() {
+        return KINDS[this.signature.toString()];
+      };
+      assign(Qty2.prototype, {
+        isDegrees: function() {
+          return (this.signature === null || this.signature === 400) && this.numerator.length === 1 && compareArray(this.denominator, UNITY_ARRAY) && (this.numerator[0].match(/<temp-[CFRK]>/) || this.numerator[0].match(/<(kelvin|celsius|rankine|fahrenheit)>/));
+        },
+        isTemperature: function() {
+          return this.isDegrees() && this.numerator[0].match(/<temp-[CFRK]>/);
+        }
+      });
+      function subtractTemperatures(lhs, rhs) {
+        var lhsUnits = lhs.units();
+        var rhsConverted = rhs.to(lhsUnits);
+        var dstDegrees = Qty2(getDegreeUnits(lhsUnits));
+        return Qty2({ "scalar": lhs.scalar - rhsConverted.scalar, "numerator": dstDegrees.numerator, "denominator": dstDegrees.denominator });
+      }
+      function subtractTempDegrees(temp, deg) {
+        var tempDegrees = deg.to(getDegreeUnits(temp.units()));
+        return Qty2({ "scalar": temp.scalar - tempDegrees.scalar, "numerator": temp.numerator, "denominator": temp.denominator });
+      }
+      function addTempDegrees(temp, deg) {
+        var tempDegrees = deg.to(getDegreeUnits(temp.units()));
+        return Qty2({ "scalar": temp.scalar + tempDegrees.scalar, "numerator": temp.numerator, "denominator": temp.denominator });
+      }
+      function getDegreeUnits(units) {
+        if (units === "tempK") {
+          return "degK";
+        } else if (units === "tempC") {
+          return "degC";
+        } else if (units === "tempF") {
+          return "degF";
+        } else if (units === "tempR") {
+          return "degR";
+        } else {
+          throw new QtyError("Unknown type for temp conversion from: " + units);
+        }
+      }
+      function toDegrees(src, dst) {
+        var srcDegK = toDegK(src);
+        var dstUnits = dst.units();
+        var dstScalar;
+        if (dstUnits === "degK") {
+          dstScalar = srcDegK.scalar;
+        } else if (dstUnits === "degC") {
+          dstScalar = srcDegK.scalar;
+        } else if (dstUnits === "degF") {
+          dstScalar = srcDegK.scalar * 9 / 5;
+        } else if (dstUnits === "degR") {
+          dstScalar = srcDegK.scalar * 9 / 5;
+        } else {
+          throw new QtyError("Unknown type for degree conversion to: " + dstUnits);
+        }
+        return Qty2({ "scalar": dstScalar, "numerator": dst.numerator, "denominator": dst.denominator });
+      }
+      function toDegK(qty) {
+        var units = qty.units();
+        var q;
+        if (units.match(/(deg)[CFRK]/)) {
+          q = qty.baseScalar;
+        } else if (units === "tempK") {
+          q = qty.scalar;
+        } else if (units === "tempC") {
+          q = qty.scalar;
+        } else if (units === "tempF") {
+          q = qty.scalar * 5 / 9;
+        } else if (units === "tempR") {
+          q = qty.scalar * 5 / 9;
+        } else {
+          throw new QtyError("Unknown type for temp conversion from: " + units);
+        }
+        return Qty2({ "scalar": q, "numerator": ["<kelvin>"], "denominator": UNITY_ARRAY });
+      }
+      function toTemp(src, dst) {
+        var dstUnits = dst.units();
+        var dstScalar;
+        if (dstUnits === "tempK") {
+          dstScalar = src.baseScalar;
+        } else if (dstUnits === "tempC") {
+          dstScalar = src.baseScalar - 273.15;
+        } else if (dstUnits === "tempF") {
+          dstScalar = src.baseScalar * 9 / 5 - 459.67;
+        } else if (dstUnits === "tempR") {
+          dstScalar = src.baseScalar * 9 / 5;
+        } else {
+          throw new QtyError("Unknown type for temp conversion to: " + dstUnits);
+        }
+        return Qty2({ "scalar": dstScalar, "numerator": dst.numerator, "denominator": dst.denominator });
+      }
+      function toTempK(qty) {
+        var units = qty.units();
+        var q;
+        if (units.match(/(deg)[CFRK]/)) {
+          q = qty.baseScalar;
+        } else if (units === "tempK") {
+          q = qty.scalar;
+        } else if (units === "tempC") {
+          q = qty.scalar + 273.15;
+        } else if (units === "tempF") {
+          q = (qty.scalar + 459.67) * 5 / 9;
+        } else if (units === "tempR") {
+          q = qty.scalar * 5 / 9;
+        } else {
+          throw new QtyError("Unknown type for temp conversion from: " + units);
+        }
+        return Qty2({ "scalar": q, "numerator": ["<temp-K>"], "denominator": UNITY_ARRAY });
+      }
+      assign(Qty2.prototype, {
+        /**
+         * Converts to other compatible units.
+         * Instance's converted quantities are cached for faster subsequent calls.
+         *
+         * @param {(string|Qty)} other - Target units as string or retrieved from
+         *                               other Qty instance (scalar is ignored)
+         *
+         * @returns {Qty} New converted Qty instance with target units
+         *
+         * @throws {QtyError} if target units are incompatible
+         *
+         * @example
+         * var weight = Qty("25 kg");
+         * weight.to("lb"); // => Qty("55.11556554621939 lbs");
+         * weight.to(Qty("3 g")); // => Qty("25000 g"); // scalar of passed Qty is ignored
+         */
+        to: function(other) {
+          var cached, target;
+          if (other === void 0 || other === null) {
+            return this;
+          }
+          if (!isString(other)) {
+            return this.to(other.units());
+          }
+          cached = this._conversionCache[other];
+          if (cached) {
+            return cached;
+          }
+          target = Qty2(other);
+          if (target.units() === this.units()) {
+            return this;
+          }
+          if (!this.isCompatible(target)) {
+            if (this.isInverse(target)) {
+              target = this.inverse().to(other);
+            } else {
+              throwIncompatibleUnits(this.units(), target.units());
+            }
+          } else {
+            if (target.isTemperature()) {
+              target = toTemp(this, target);
+            } else if (target.isDegrees()) {
+              target = toDegrees(this, target);
+            } else {
+              var q = divSafe(this.baseScalar, target.baseScalar);
+              target = Qty2({ "scalar": q, "numerator": target.numerator, "denominator": target.denominator });
+            }
+          }
+          this._conversionCache[other] = target;
+          return target;
+        },
+        // convert to base SI units
+        // results of the conversion are cached so subsequent calls to this will be fast
+        toBase: function() {
+          if (this.isBase()) {
+            return this;
+          }
+          if (this.isTemperature()) {
+            return toTempK(this);
+          }
+          var cached = baseUnitCache[this.units()];
+          if (!cached) {
+            cached = toBaseUnits(this.numerator, this.denominator);
+            baseUnitCache[this.units()] = cached;
+          }
+          return cached.mul(this.scalar);
+        },
+        // Converts the unit back to a float if it is unitless.  Otherwise raises an exception
+        toFloat: function() {
+          if (this.isUnitless()) {
+            return this.scalar;
+          }
+          throw new QtyError("Can't convert to Float unless unitless.  Use Unit#scalar");
+        },
+        /**
+         * Returns the nearest multiple of quantity passed as
+         * precision
+         *
+         * @param {(Qty|string|number)} precQuantity - Quantity, string formated
+         *   quantity or number as expected precision
+         *
+         * @returns {Qty} Nearest multiple of precQuantity
+         *
+         * @example
+         * Qty('5.5 ft').toPrec('2 ft'); // returns 6 ft
+         * Qty('0.8 cu').toPrec('0.25 cu'); // returns 0.75 cu
+         * Qty('6.3782 m').toPrec('cm'); // returns 6.38 m
+         * Qty('1.146 MPa').toPrec('0.1 bar'); // returns 1.15 MPa
+         *
+         */
+        toPrec: function(precQuantity) {
+          if (isString(precQuantity)) {
+            precQuantity = Qty2(precQuantity);
+          }
+          if (isNumber(precQuantity)) {
+            precQuantity = Qty2(precQuantity + " " + this.units());
+          }
+          if (!this.isUnitless()) {
+            precQuantity = precQuantity.to(this.units());
+          } else if (!precQuantity.isUnitless()) {
+            throwIncompatibleUnits(this.units(), precQuantity.units());
+          }
+          if (precQuantity.scalar === 0) {
+            throw new QtyError("Divide by zero");
+          }
+          var precRoundedResult = mulSafe(
+            Math.round(this.scalar / precQuantity.scalar),
+            precQuantity.scalar
+          );
+          return Qty2(precRoundedResult + this.units());
+        }
+      });
+      function swiftConverter(srcUnits, dstUnits) {
+        var srcQty = Qty2(srcUnits);
+        var dstQty = Qty2(dstUnits);
+        if (srcQty.eq(dstQty)) {
+          return identity;
+        }
+        var convert;
+        if (!srcQty.isTemperature()) {
+          convert = function(value) {
+            return value * srcQty.baseScalar / dstQty.baseScalar;
+          };
+        } else {
+          convert = function(value) {
+            return srcQty.mul(value).to(dstQty).scalar;
+          };
+        }
+        return function converter(value) {
+          var i2, length, result;
+          if (!Array.isArray(value)) {
+            return convert(value);
+          } else {
+            length = value.length;
+            result = [];
+            for (i2 = 0; i2 < length; i2++) {
+              result.push(convert(value[i2]));
+            }
+            return result;
+          }
+        };
+      }
+      var baseUnitCache = {};
+      function toBaseUnits(numerator, denominator) {
+        var num = [];
+        var den = [];
+        var q = 1;
+        var unit;
+        for (var i2 = 0; i2 < numerator.length; i2++) {
+          unit = numerator[i2];
+          if (PREFIX_VALUES[unit]) {
+            q = mulSafe(q, PREFIX_VALUES[unit]);
+          } else {
+            if (UNIT_VALUES[unit]) {
+              q *= UNIT_VALUES[unit].scalar;
+              if (UNIT_VALUES[unit].numerator) {
+                num.push(UNIT_VALUES[unit].numerator);
+              }
+              if (UNIT_VALUES[unit].denominator) {
+                den.push(UNIT_VALUES[unit].denominator);
+              }
+            }
+          }
+        }
+        for (var j2 = 0; j2 < denominator.length; j2++) {
+          unit = denominator[j2];
+          if (PREFIX_VALUES[unit]) {
+            q /= PREFIX_VALUES[unit];
+          } else {
+            if (UNIT_VALUES[unit]) {
+              q /= UNIT_VALUES[unit].scalar;
+              if (UNIT_VALUES[unit].numerator) {
+                den.push(UNIT_VALUES[unit].numerator);
+              }
+              if (UNIT_VALUES[unit].denominator) {
+                num.push(UNIT_VALUES[unit].denominator);
+              }
+            }
+          }
+        }
+        num = num.reduce(function(a, b) {
+          return a.concat(b);
+        }, []);
+        den = den.reduce(function(a, b) {
+          return a.concat(b);
+        }, []);
+        return Qty2({ "scalar": q, "numerator": num, "denominator": den });
+      }
+      Qty2.parse = globalParse;
+      Qty2.getUnits = getUnits;
+      Qty2.getAliases = getAliases;
+      Qty2.mulSafe = mulSafe;
+      Qty2.divSafe = divSafe;
+      Qty2.getKinds = getKinds;
+      Qty2.swiftConverter = swiftConverter;
+      Qty2.Error = QtyError;
+      assign(Qty2.prototype, {
+        // Returns new instance with units of this
+        add: function(other) {
+          if (isString(other)) {
+            other = Qty2(other);
+          }
+          if (!this.isCompatible(other)) {
+            throwIncompatibleUnits(this.units(), other.units());
+          }
+          if (this.isTemperature() && other.isTemperature()) {
+            throw new QtyError("Cannot add two temperatures");
+          } else if (this.isTemperature()) {
+            return addTempDegrees(this, other);
+          } else if (other.isTemperature()) {
+            return addTempDegrees(other, this);
+          }
+          return Qty2({ "scalar": this.scalar + other.to(this).scalar, "numerator": this.numerator, "denominator": this.denominator });
+        },
+        sub: function(other) {
+          if (isString(other)) {
+            other = Qty2(other);
+          }
+          if (!this.isCompatible(other)) {
+            throwIncompatibleUnits(this.units(), other.units());
+          }
+          if (this.isTemperature() && other.isTemperature()) {
+            return subtractTemperatures(this, other);
+          } else if (this.isTemperature()) {
+            return subtractTempDegrees(this, other);
+          } else if (other.isTemperature()) {
+            throw new QtyError("Cannot subtract a temperature from a differential degree unit");
+          }
+          return Qty2({ "scalar": this.scalar - other.to(this).scalar, "numerator": this.numerator, "denominator": this.denominator });
+        },
+        mul: function(other) {
+          if (isNumber(other)) {
+            return Qty2({ "scalar": mulSafe(this.scalar, other), "numerator": this.numerator, "denominator": this.denominator });
+          } else if (isString(other)) {
+            other = Qty2(other);
+          }
+          if ((this.isTemperature() || other.isTemperature()) && !(this.isUnitless() || other.isUnitless())) {
+            throw new QtyError("Cannot multiply by temperatures");
+          }
+          var op1 = this;
+          var op2 = other;
+          if (op1.isCompatible(op2) && op1.signature !== 400) {
+            op2 = op2.to(op1);
+          }
+          var numdenscale = cleanTerms(op1.numerator, op1.denominator, op2.numerator, op2.denominator);
+          return Qty2({ "scalar": mulSafe(op1.scalar, op2.scalar, numdenscale[2]), "numerator": numdenscale[0], "denominator": numdenscale[1] });
+        },
+        div: function(other) {
+          if (isNumber(other)) {
+            if (other === 0) {
+              throw new QtyError("Divide by zero");
+            }
+            return Qty2({ "scalar": this.scalar / other, "numerator": this.numerator, "denominator": this.denominator });
+          } else if (isString(other)) {
+            other = Qty2(other);
+          }
+          if (other.scalar === 0) {
+            throw new QtyError("Divide by zero");
+          }
+          if (other.isTemperature()) {
+            throw new QtyError("Cannot divide with temperatures");
+          } else if (this.isTemperature() && !other.isUnitless()) {
+            throw new QtyError("Cannot divide with temperatures");
+          }
+          var op1 = this;
+          var op2 = other;
+          if (op1.isCompatible(op2) && op1.signature !== 400) {
+            op2 = op2.to(op1);
+          }
+          var numdenscale = cleanTerms(op1.numerator, op1.denominator, op2.denominator, op2.numerator);
+          return Qty2({ "scalar": mulSafe(op1.scalar, numdenscale[2]) / op2.scalar, "numerator": numdenscale[0], "denominator": numdenscale[1] });
+        },
+        // Returns a Qty that is the inverse of this Qty,
+        inverse: function() {
+          if (this.isTemperature()) {
+            throw new QtyError("Cannot divide with temperatures");
+          }
+          if (this.scalar === 0) {
+            throw new QtyError("Divide by zero");
+          }
+          return Qty2({ "scalar": 1 / this.scalar, "numerator": this.denominator, "denominator": this.numerator });
+        }
+      });
+      function cleanTerms(num1, den1, num2, den2) {
+        function notUnity(val) {
+          return val !== UNITY;
+        }
+        num1 = num1.filter(notUnity);
+        num2 = num2.filter(notUnity);
+        den1 = den1.filter(notUnity);
+        den2 = den2.filter(notUnity);
+        var combined = {};
+        function combineTerms(terms, direction) {
+          var k;
+          var prefix;
+          var prefixValue;
+          for (var i2 = 0; i2 < terms.length; i2++) {
+            if (PREFIX_VALUES[terms[i2]]) {
+              k = terms[i2 + 1];
+              prefix = terms[i2];
+              prefixValue = PREFIX_VALUES[prefix];
+              i2++;
+            } else {
+              k = terms[i2];
+              prefix = null;
+              prefixValue = 1;
+            }
+            if (k && k !== UNITY) {
+              if (combined[k]) {
+                combined[k][0] += direction;
+                var combinedPrefixValue = combined[k][2] ? PREFIX_VALUES[combined[k][2]] : 1;
+                combined[k][direction === 1 ? 3 : 4] *= divSafe(prefixValue, combinedPrefixValue);
+              } else {
+                combined[k] = [direction, k, prefix, 1, 1];
+              }
+            }
+          }
+        }
+        combineTerms(num1, 1);
+        combineTerms(den1, -1);
+        combineTerms(num2, 1);
+        combineTerms(den2, -1);
+        var num = [];
+        var den = [];
+        var scale = 1;
+        for (var prop in combined) {
+          if (combined.hasOwnProperty(prop)) {
+            var item = combined[prop];
+            var n;
+            if (item[0] > 0) {
+              for (n = 0; n < item[0]; n++) {
+                num.push(item[2] === null ? item[1] : [item[2], item[1]]);
+              }
+            } else if (item[0] < 0) {
+              for (n = 0; n < -item[0]; n++) {
+                den.push(item[2] === null ? item[1] : [item[2], item[1]]);
+              }
+            }
+            scale *= divSafe(item[3], item[4]);
+          }
+        }
+        if (num.length === 0) {
+          num = UNITY_ARRAY;
+        }
+        if (den.length === 0) {
+          den = UNITY_ARRAY;
+        }
+        num = num.reduce(function(a, b) {
+          return a.concat(b);
+        }, []);
+        den = den.reduce(function(a, b) {
+          return a.concat(b);
+        }, []);
+        return [num, den, scale];
+      }
+      assign(Qty2.prototype, {
+        eq: function(other) {
+          return this.compareTo(other) === 0;
+        },
+        lt: function(other) {
+          return this.compareTo(other) === -1;
+        },
+        lte: function(other) {
+          return this.eq(other) || this.lt(other);
+        },
+        gt: function(other) {
+          return this.compareTo(other) === 1;
+        },
+        gte: function(other) {
+          return this.eq(other) || this.gt(other);
+        },
+        // Compare two Qty objects. Throws an exception if they are not of compatible types.
+        // Comparisons are done based on the value of the quantity in base SI units.
+        //
+        // NOTE: We cannot compare inverses as that breaks the general compareTo contract:
+        //   if a.compareTo(b) < 0 then b.compareTo(a) > 0
+        //   if a.compareTo(b) == 0 then b.compareTo(a) == 0
+        //
+        //   Since "10S" == ".1ohm" (10 > .1) and "10ohm" == ".1S" (10 > .1)
+        //     Qty("10S").inverse().compareTo("10ohm") == -1
+        //     Qty("10ohm").inverse().compareTo("10S") == -1
+        //
+        //   If including inverses in the sort is needed, I suggest writing: Qty.sort(qtyArray,units)
+        compareTo: function(other) {
+          if (isString(other)) {
+            return this.compareTo(Qty2(other));
+          }
+          if (!this.isCompatible(other)) {
+            throwIncompatibleUnits(this.units(), other.units());
+          }
+          if (this.baseScalar < other.baseScalar) {
+            return -1;
+          } else if (this.baseScalar === other.baseScalar) {
+            return 0;
+          } else if (this.baseScalar > other.baseScalar) {
+            return 1;
+          }
+        },
+        // Return true if quantities and units match
+        // Unit("100 cm").same(Unit("100 cm"))  # => true
+        // Unit("100 cm").same(Unit("1 m"))     # => false
+        same: function(other) {
+          return this.scalar === other.scalar && this.units() === other.units();
+        }
+      });
+      assign(Qty2.prototype, {
+        // returns true if no associated units
+        // false, even if the units are "unitless" like 'radians, each, etc'
+        isUnitless: function() {
+          return [this.numerator, this.denominator].every(function(item) {
+            return compareArray(item, UNITY_ARRAY);
+          });
+        },
+        /*
+        check to see if units are compatible, but not the scalar part
+        this check is done by comparing signatures for performance reasons
+        if passed a string, it will create a unit object with the string and then do the comparison
+        this permits a syntax like:
+        unit =~ "mm"
+        if you want to do a regexp on the unit string do this ...
+        unit.units =~ /regexp/
+        */
+        isCompatible: function(other) {
+          if (isString(other)) {
+            return this.isCompatible(Qty2(other));
+          }
+          if (!isQty(other)) {
+            return false;
+          }
+          if (other.signature !== void 0) {
+            return this.signature === other.signature;
+          } else {
+            return false;
+          }
+        },
+        /*
+        check to see if units are inverse of each other, but not the scalar part
+        this check is done by comparing signatures for performance reasons
+        if passed a string, it will create a unit object with the string and then do the comparison
+        this permits a syntax like:
+        unit =~ "mm"
+        if you want to do a regexp on the unit string do this ...
+        unit.units =~ /regexp/
+        */
+        isInverse: function(other) {
+          return this.inverse().isCompatible(other);
+        },
+        // Returns 'true' if the Unit is represented in base units
+        isBase: function() {
+          if (this._isBase !== void 0) {
+            return this._isBase;
+          }
+          if (this.isDegrees() && this.numerator[0].match(/<(kelvin|temp-K)>/)) {
+            this._isBase = true;
+            return this._isBase;
+          }
+          this.numerator.concat(this.denominator).forEach(function(item) {
+            if (item !== UNITY && BASE_UNITS.indexOf(item) === -1) {
+              this._isBase = false;
+            }
+          }, this);
+          if (this._isBase === false) {
+            return this._isBase;
+          }
+          this._isBase = true;
+          return this._isBase;
+        }
+      });
+      function NestedMap() {
+      }
+      NestedMap.prototype.get = function(keys) {
+        if (arguments.length > 1) {
+          keys = Array.apply(null, arguments);
+        }
+        return keys.reduce(
+          function(map, key, index) {
+            if (map) {
+              var childMap = map[key];
+              if (index === keys.length - 1) {
+                return childMap ? childMap.data : void 0;
+              } else {
+                return childMap;
+              }
+            }
+          },
+          this
+        );
+      };
+      NestedMap.prototype.set = function(keys, value) {
+        if (arguments.length > 2) {
+          keys = Array.prototype.slice.call(arguments, 0, -1);
+          value = arguments[arguments.length - 1];
+        }
+        return keys.reduce(function(map, key, index) {
+          var childMap = map[key];
+          if (childMap === void 0) {
+            childMap = map[key] = {};
+          }
+          if (index === keys.length - 1) {
+            childMap.data = value;
+            return value;
+          } else {
+            return childMap;
+          }
+        }, this);
+      };
+      function defaultFormatter(scalar, units) {
+        return (scalar + " " + units).trim();
+      }
+      Qty2.formatter = defaultFormatter;
+      assign(Qty2.prototype, {
+        // returns the 'unit' part of the Unit object without the scalar
+        units: function() {
+          if (this._units !== void 0) {
+            return this._units;
+          }
+          var numIsUnity = compareArray(this.numerator, UNITY_ARRAY);
+          var denIsUnity = compareArray(this.denominator, UNITY_ARRAY);
+          if (numIsUnity && denIsUnity) {
+            this._units = "";
+            return this._units;
+          }
+          var numUnits = stringifyUnits(this.numerator);
+          var denUnits = stringifyUnits(this.denominator);
+          this._units = numUnits + (denIsUnity ? "" : "/" + denUnits);
+          return this._units;
+        },
+        /**
+         * Stringifies the quantity
+         * Deprecation notice: only units parameter is supported.
+         *
+         * @param {(number|string|Qty)} targetUnitsOrMaxDecimalsOrPrec -
+         *                              target units if string,
+         *                              max number of decimals if number,
+         *                              passed to #toPrec before converting if Qty
+         *
+         * @param {number=} maxDecimals - Maximum number of decimals of
+         *                                formatted output
+         *
+         * @returns {string} reparseable quantity as string
+         */
+        toString: function(targetUnitsOrMaxDecimalsOrPrec, maxDecimals) {
+          var targetUnits;
+          if (isNumber(targetUnitsOrMaxDecimalsOrPrec)) {
+            targetUnits = this.units();
+            maxDecimals = targetUnitsOrMaxDecimalsOrPrec;
+          } else if (isString(targetUnitsOrMaxDecimalsOrPrec)) {
+            targetUnits = targetUnitsOrMaxDecimalsOrPrec;
+          } else if (isQty(targetUnitsOrMaxDecimalsOrPrec)) {
+            return this.toPrec(targetUnitsOrMaxDecimalsOrPrec).toString(maxDecimals);
+          }
+          var out = this.to(targetUnits);
+          var outScalar = maxDecimals !== void 0 ? round(out.scalar, maxDecimals) : out.scalar;
+          out = (outScalar + " " + out.units()).trim();
+          return out;
+        },
+        /**
+         * Format the quantity according to optional passed target units
+         * and formatter
+         *
+         * @param {string} [targetUnits=current units] -
+         *                 optional units to convert to before formatting
+         *
+         * @param {function} [formatter=Qty.formatter] -
+         *                   delegates formatting to formatter callback.
+         *                   formatter is called back with two parameters (scalar, units)
+         *                   and should return formatted result.
+         *                   If unspecified, formatting is delegated to default formatter
+         *                   set to Qty.formatter
+         *
+         * @example
+         * var roundingAndLocalizingFormatter = function(scalar, units) {
+         *   // localize or limit scalar to n max decimals for instance
+         *   // return formatted result
+         * };
+         * var qty = Qty('1.1234 m');
+         * qty.format(); // same units, default formatter => "1.234 m"
+         * qty.format("cm"); // converted to "cm", default formatter => "123.45 cm"
+         * qty.format(roundingAndLocalizingFormatter); // same units, custom formatter => "1,2 m"
+         * qty.format("cm", roundingAndLocalizingFormatter); // convert to "cm", custom formatter => "123,4 cm"
+         *
+         * @returns {string} quantity as string
+         */
+        format: function(targetUnits, formatter) {
+          if (arguments.length === 1) {
+            if (typeof targetUnits === "function") {
+              formatter = targetUnits;
+              targetUnits = void 0;
+            }
+          }
+          formatter = formatter || Qty2.formatter;
+          var targetQty = this.to(targetUnits);
+          return formatter.call(this, targetQty.scalar, targetQty.units());
+        }
+      });
+      var stringifiedUnitsCache = new NestedMap();
+      function stringifyUnits(units) {
+        var stringified = stringifiedUnitsCache.get(units);
+        if (stringified) {
+          return stringified;
+        }
+        var isUnity = compareArray(units, UNITY_ARRAY);
+        if (isUnity) {
+          stringified = "1";
+        } else {
+          stringified = simplify(getOutputNames(units)).join("*");
+        }
+        stringifiedUnitsCache.set(units, stringified);
+        return stringified;
+      }
+      function getOutputNames(units) {
+        var unitNames = [], token, tokenNext;
+        for (var i2 = 0; i2 < units.length; i2++) {
+          token = units[i2];
+          tokenNext = units[i2 + 1];
+          if (PREFIX_VALUES[token]) {
+            unitNames.push(OUTPUT_MAP[token] + OUTPUT_MAP[tokenNext]);
+            i2++;
+          } else {
+            unitNames.push(OUTPUT_MAP[token]);
+          }
+        }
+        return unitNames;
+      }
+      function simplify(units) {
+        var unitCounts = units.reduce(function(acc, unit) {
+          var unitCounter = acc[unit];
+          if (!unitCounter) {
+            acc.push(unitCounter = acc[unit] = [unit, 0]);
+          }
+          unitCounter[1]++;
+          return acc;
+        }, []);
+        return unitCounts.map(function(unitCount) {
+          return unitCount[0] + (unitCount[1] > 1 ? unitCount[1] : "");
+        });
+      }
+      Qty2.version = "1.8.0";
+      return Qty2;
+    }));
+  }
+});
+
+// src/app/core/services/units.service.ts
+var import_js_quantities = __toESM(require_quantities());
+var UnitsService = class _UnitsService {
+  AppSettingsService = inject(AppSettingsService);
+  data = inject(DataService);
+  _defaultUnitsSub;
+  /**
+   * Definition of available Kip units to be used for conversion.
+   * Measure property has to match one Unit Conversion Function for proper operation.
+   * Description is human readable property.
+   */
+  _conversionList = [
+    { group: "Unitless", units: [
+      { measure: "unitless", description: "As-Is numeric value" },
+      { measure: " ", description: "No unit label - As-Is numeric value" }
+    ] },
+    { group: "Speed", units: [
+      { measure: "knots", description: "Knots - Nautical miles per hour" },
+      { measure: "kph", description: "kph - Kilometers per hour" },
+      { measure: "mph", description: "mph - Miles per hour" },
+      { measure: "m/s", description: "m/s - Meters per second (base)" }
+    ] },
+    { group: "Flow", units: [
+      { measure: "m3/s", description: "Cubic meters per second (base)" },
+      { measure: "l/min", description: "Liters per minute" },
+      { measure: "l/h", description: "Liters per hour" },
+      { measure: "g/min", description: "Gallons per minute" },
+      { measure: "g/h", description: "Gallons per hour" }
+    ] },
+    { group: "Fuel Distance", units: [
+      { measure: "m/m3", description: "Meters per cubic meter (base)" },
+      { measure: "nm/l", description: "Nautical Miles per liter" },
+      { measure: "nm/g", description: "Nautical Miles per gallon" },
+      { measure: "km/l", description: "Kilometers per liter" },
+      { measure: "mpg", description: "Miles per Gallon" }
+    ] },
+    { group: "Energy Distance", units: [
+      { measure: "m/J", description: "Meters per Joule (base)" },
+      { measure: "nm/J", description: "Nautical Miles per Joule" },
+      { measure: "km/J", description: "Kilometers per Joule" },
+      { measure: "nm/kWh", description: "Nautical Miles per Kilowatt-hour" },
+      { measure: "km/kWh", description: "Kilometers per Kilowatt-hour" }
+    ] },
+    { group: "Temperature", units: [
+      { measure: "K", description: "Kelvin (base)" },
+      { measure: "celsius", description: "Celsius" },
+      { measure: "fahrenheit", description: "Fahrenheit" }
+    ] },
+    { group: "Length", units: [
+      { measure: "m", description: "Meters (base)" },
+      { measure: "mm", description: "Millimeters" },
+      { measure: "fathom", description: "Fathoms" },
+      { measure: "nm", description: "Nautical Miles" },
+      { measure: "km", description: "Kilometers" },
+      { measure: "mi", description: "Miles" },
+      { measure: "feet", description: "Feet" },
+      { measure: "inch", description: "Inches" }
+    ] },
+    { group: "Volume", units: [
+      { measure: "liter", description: "Liters (base)" },
+      { measure: "m3", description: "Cubic Meters" },
+      { measure: "gallon", description: "Gallons" }
+    ] },
+    { group: "Current", units: [
+      { measure: "A", description: "Amperes (base)" },
+      { measure: "mA", description: "Milliamperes" }
+    ] },
+    { group: "Potential", units: [
+      { measure: "V", description: "Volts (base)" },
+      { measure: "mV", description: "Millivolts" }
+    ] },
+    { group: "Charge", units: [
+      { measure: "C", description: "Coulomb (base)" },
+      { measure: "Ah", description: "Ampere*Hours" }
+    ] },
+    { group: "Power", units: [
+      { measure: "W", description: "Watts (base)" },
+      { measure: "mW", description: "Milliwatts" }
+    ] },
+    { group: "Energy", units: [
+      { measure: "J", description: "Joules (base)" },
+      { measure: "kWh", description: "Kilowatt*Hours" }
+    ] },
+    { group: "Resistance", units: [
+      { measure: "ohm", description: "\u2126 (base)" },
+      { measure: "kiloohm", description: "k\u2126" }
+    ] },
+    { group: "Pressure", units: [
+      { measure: "Pa", description: "Pa (base)" },
+      { measure: "kPa", description: "kPa" },
+      { measure: "hPa", description: "hPa" },
+      { measure: "mbar", description: "mbar" },
+      { measure: "bar", description: "Bars" },
+      { measure: "psi", description: "psi" },
+      { measure: "mmHg", description: "mmHg" },
+      { measure: "inHg", description: "inHg" }
+    ] },
+    { group: "Density", units: [{ measure: "kg/m3", description: "Air density - kg/cubic meter (base)" }] },
+    { group: "Time", units: [
+      { measure: "s", description: "Seconds (base)" },
+      { measure: "Minutes", description: "Minutes" },
+      { measure: "Hours", description: "Hours" },
+      { measure: "Days", description: "Days" },
+      { measure: "D HH:MM:SS", description: "Day Hour:Minute:sec" }
+    ] },
+    { group: "Angular Velocity", units: [
+      { measure: "rad/s", description: "Radians per second (base)" },
+      { measure: "deg/s", description: "Degrees per second" },
+      { measure: "deg/min", description: "Degrees per minute" }
+    ] },
+    { group: "Angle", units: [
+      { measure: "rad", description: "Radians (base)" },
+      { measure: "deg", description: "Degrees" },
+      { measure: "grad", description: "Gradians" }
+    ] },
+    { group: "Frequency", units: [
+      { measure: "rpm", description: "RPM - Rotations per minute" },
+      { measure: "Hz", description: "Hz - Hertz (base)" },
+      { measure: "KHz", description: "KHz - Kilohertz" },
+      { measure: "MHz", description: "MHz - Megahertz" },
+      { measure: "GHz", description: "GHz - Gigahertz" }
+    ] },
+    { group: "Ratio", units: [
+      { measure: "percent", description: "As percentage value" },
+      { measure: "percentraw", description: "As ratio 0-1 with % sign" },
+      { measure: "ratio", description: "Ratio 0-1 (base)" }
+    ] },
+    { group: "Position", units: [
+      { measure: "pdeg", description: "Position Degrees" },
+      { measure: "latitudeMin", description: "Latitude in minutes" },
+      { measure: "latitudeSec", description: "Latitude in seconds" },
+      { measure: "longitudeMin", description: "Longitude in minutes" },
+      { measure: "longitudeSec", description: "Longitude in seconds" }
+    ] }
+  ];
+  skBaseUnits = [
+    {
+      unit: "s",
+      properties: {
+        display: "s",
+        quantity: "Time",
+        quantityDisplay: "t",
+        description: "Elapsed time (interval) in seconds"
+      }
+    },
+    {
+      unit: "Hz",
+      properties: {
+        display: "Hz",
+        quantity: "Frequency",
+        quantityDisplay: "f",
+        description: "Frequency in Hertz"
+      }
+    },
+    {
+      unit: "m3",
+      properties: {
+        display: "m\xB3",
+        quantity: "Volume",
+        quantityDisplay: "V",
+        description: "Volume in cubic meters"
+      }
+    },
+    {
+      unit: "m3/s",
+      properties: {
+        display: "m\xB3/s",
+        quantity: "Flow",
+        quantityDisplay: "Q",
+        description: "Liquid or gas flow in cubic meters per second"
+      }
+    },
+    {
+      unit: "kg/s",
+      properties: {
+        display: "kg/s",
+        quantity: "Mass flow rate",
+        quantityDisplay: "\u1E41",
+        description: "Liquid or gas flow in kilograms per second"
+      }
+    },
+    {
+      unit: "kg/m3",
+      properties: {
+        display: "kg/m\xB3",
+        quantity: "Density",
+        quantityDisplay: "\u03C1",
+        description: "Density in kg per cubic meter"
+      }
+    },
+    {
+      unit: "deg",
+      properties: {
+        display: "Position",
+        quantity: "Angle",
+        quantityDisplay: "\u2220",
+        description: "Latitude or longitude in decimal degrees"
+      }
+    },
+    {
+      unit: "rad",
+      properties: {
+        display: "\xB0",
+        quantity: "Angle",
+        quantityDisplay: "\u2220",
+        description: "Angular arc in radians"
+      }
+    },
+    {
+      unit: "rad/s",
+      properties: {
+        display: "\u33AD/s",
+        quantity: "Rotation",
+        quantityDisplay: "\u03C9",
+        description: "Angular rate in radians per second"
+      }
+    },
+    {
+      unit: "A",
+      properties: {
+        display: "A",
+        quantity: "Current",
+        quantityDisplay: "I",
+        description: "Electrical current in ampere"
+      }
+    },
+    {
+      unit: "C",
+      properties: {
+        display: "C",
+        quantity: "Charge",
+        quantityDisplay: "Q",
+        description: "Electrical charge in Coulomb"
+      }
+    },
+    {
+      unit: "V",
+      properties: {
+        display: "V",
+        quantity: "Voltage",
+        quantityDisplay: "V",
+        description: "Electrical potential in volt"
+      }
+    },
+    {
+      unit: "W",
+      properties: {
+        display: "W",
+        quantity: "Power",
+        quantityDisplay: "P",
+        description: "Power in watt"
+      }
+    },
+    {
+      unit: "Nm",
+      properties: {
+        display: "Nm",
+        quantity: "Torque",
+        quantityDisplay: "\u03C4",
+        description: "Torque in Newton meter"
+      }
+    },
+    {
+      unit: "J",
+      properties: {
+        display: "J",
+        quantity: "Energy",
+        quantityDisplay: "E",
+        description: "Electrical energy in joule"
+      }
+    },
+    {
+      unit: "ohm",
+      properties: {
+        display: "\u2126",
+        quantity: "Resistance",
+        quantityDisplay: "R",
+        description: "Electrical resistance in ohm"
+      }
+    },
+    {
+      unit: "m",
+      properties: {
+        display: "m",
+        quantity: "Distance",
+        quantityDisplay: "d",
+        description: "Distance in meters"
+      }
+    },
+    {
+      unit: "m/s",
+      properties: {
+        display: "m/s",
+        quantity: "Speed",
+        quantityDisplay: "v",
+        description: "Speed in meters per second"
+      }
+    },
+    {
+      unit: "m2",
+      properties: {
+        display: "\u33A1",
+        quantity: "Area",
+        quantityDisplay: "A",
+        description: "(Surface) area in square meters"
+      }
+    },
+    {
+      unit: "K",
+      properties: {
+        display: "K",
+        quantity: "Temperature",
+        quantityDisplay: "T",
+        description: "Temperature in kelvin"
+      }
+    },
+    {
+      unit: "Pa",
+      properties: {
+        display: "Pa",
+        quantity: "Pressure",
+        quantityDisplay: "P",
+        description: "Pressure in pascal"
+      }
+    },
+    {
+      unit: "kg",
+      properties: {
+        display: "kg",
+        quantity: "Mass",
+        quantityDisplay: "m",
+        description: "Mass in kilogram"
+      }
+    },
+    {
+      unit: "ratio",
+      properties: {
+        display: "",
+        quantity: "Ratio",
+        quantityDisplay: "\u03C6",
+        description: "Relative value compared to reference or normal value. 0 = 0%, 1 = 100%, 1e-3 = 1 ppt"
+      }
+    },
+    {
+      unit: "m/s2",
+      properties: {
+        display: "m/s\xB2",
+        quantity: "Acceleration",
+        quantityDisplay: "a",
+        description: "Acceleration in meters per second squared"
+      }
+    },
+    {
+      unit: "rad/s2",
+      properties: {
+        display: "rad/s\xB2",
+        quantity: "Angular acceleration",
+        quantityDisplay: "a",
+        description: "Angular acceleration in radians per second squared"
+      }
+    },
+    {
+      unit: "N",
+      properties: {
+        display: "N",
+        quantity: "Force",
+        quantityDisplay: "F",
+        description: "Force in newton"
+      }
+    },
+    {
+      unit: "T",
+      properties: {
+        display: "T",
+        quantity: "Magnetic field",
+        quantityDisplay: "B",
+        description: "Magnetic field strength in tesla"
+      }
+    },
+    {
+      unit: "Lux",
+      properties: {
+        display: "lx",
+        quantity: "Light Intensity",
+        quantityDisplay: "Ev",
+        description: "Light Intensity in lux"
+      }
+    },
+    {
+      unit: "Pa/s",
+      properties: {
+        display: "Pa/s",
+        quantity: "Pressure rate",
+        quantityDisplay: "R",
+        description: "Pressure change rate in pascal per second"
+      }
+    },
+    {
+      unit: "Pa.s",
+      properties: {
+        display: "Pa s",
+        quantity: "Viscosity",
+        quantityDisplay: "\u03BC",
+        description: "Viscosity in pascal seconds"
+      }
+    }
+  ];
+  _defaultUnits = null;
+  constructor() {
+    this._defaultUnitsSub = this.AppSettingsService.getDefaultUnitsAsO().subscribe((appSettings) => {
+      this._defaultUnits = appSettings;
+    });
+  }
+  unitConversionFunctions = {
+    "unitless": function(v) {
+      return v;
+    },
+    " ": function(v) {
+      return v;
+    },
+    //  speed
+    "knots": import_js_quantities.default.swiftConverter("m/s", "kn"),
+    "kph": import_js_quantities.default.swiftConverter("m/s", "kph"),
+    "m/s": function(v) {
+      return v;
+    },
+    "mph": import_js_quantities.default.swiftConverter("m/s", "mph"),
+    // volume
+    "liter": import_js_quantities.default.swiftConverter("m^3", "liter"),
+    "gallon": import_js_quantities.default.swiftConverter("m^3", "gallon"),
+    "m3": function(v) {
+      return v;
+    },
+    //  flow
+    "m3/s": function(v) {
+      return v;
+    },
+    "l/min": import_js_quantities.default.swiftConverter("m^3/s", "liter/minute"),
+    "l/h": import_js_quantities.default.swiftConverter("m^3/s", "liter/hour"),
+    "g/min": import_js_quantities.default.swiftConverter("m^3/s", "gallon/minute"),
+    "g/h": import_js_quantities.default.swiftConverter("m^3/s", "gallon/hour"),
+    //  fuel consumption
+    "m/m3": function(v) {
+      return v;
+    },
+    "nm/l": import_js_quantities.default.swiftConverter("m/m^3", "naut-mile/liter"),
+    "nm/g": import_js_quantities.default.swiftConverter("m/m^3", "naut-mile/gallon"),
+    "km/l": import_js_quantities.default.swiftConverter("m/m^3", "km/liter"),
+    "mpg": import_js_quantities.default.swiftConverter("m/m^3", "mile/gallon"),
+    //  energy consumption
+    "m/J": function(v) {
+      return v;
+    },
+    "nm/J": import_js_quantities.default.swiftConverter("m/J", "naut-mile/J"),
+    "km/J": import_js_quantities.default.swiftConverter("km/J", "km/J"),
+    "nm/kWh": import_js_quantities.default.swiftConverter("m/J", "naut-mile/kWh"),
+    "km/kWh": import_js_quantities.default.swiftConverter("m/J", "km/kWh"),
+    //  temp
+    "K": function(v) {
+      return v;
+    },
+    "celsius": import_js_quantities.default.swiftConverter("tempK", "tempC"),
+    "fahrenheit": import_js_quantities.default.swiftConverter("tempK", "tempF"),
+    //  length
+    "m": function(v) {
+      return v;
+    },
+    "mm": function(v) {
+      return v * 1e3;
+    },
+    "fathom": import_js_quantities.default.swiftConverter("m", "fathom"),
+    "feet": import_js_quantities.default.swiftConverter("m", "foot"),
+    "inch": import_js_quantities.default.swiftConverter("m", "in"),
+    "km": import_js_quantities.default.swiftConverter("m", "km"),
+    "nm": import_js_quantities.default.swiftConverter("m", "nmi"),
+    "mi": import_js_quantities.default.swiftConverter("m", "mi"),
+    //  Potential
+    "V": function(v) {
+      return v;
+    },
+    "mV": function(v) {
+      return v * 1e3;
+    },
+    //  Current
+    "A": function(v) {
+      return v;
+    },
+    "mA": function(v) {
+      return v * 1e3;
+    },
+    // charge
+    "C": function(v) {
+      return v;
+    },
+    "Ah": import_js_quantities.default.swiftConverter("C", "Ah"),
+    // Power
+    "W": function(v) {
+      return v;
+    },
+    "mW": function(v) {
+      return v * 1e3;
+    },
+    // Energy
+    "J": function(v) {
+      return v;
+    },
+    "kWh": import_js_quantities.default.swiftConverter("J", "kWh"),
+    // Resistance
+    "ohm": function(v) {
+      return v;
+    },
+    "kiloohm": function(v) {
+      return v / 1e3;
+    },
+    //  pressure
+    "Pa": function(v) {
+      return v;
+    },
+    "bar": import_js_quantities.default.swiftConverter("Pa", "bar"),
+    "psi": import_js_quantities.default.swiftConverter("Pa", "psi"),
+    "mmHg": import_js_quantities.default.swiftConverter("Pa", "mmHg"),
+    "inHg": import_js_quantities.default.swiftConverter("Pa", "inHg"),
+    "hPa": import_js_quantities.default.swiftConverter("Pa", "hPa"),
+    "kPa": import_js_quantities.default.swiftConverter("Pa", "kPa"),
+    "mbar": import_js_quantities.default.swiftConverter("Pa", "millibar"),
+    // Density - Description: Current outside air density
+    "kg/m3": function(v) {
+      return v;
+    },
+    //  Time
+    "s": function(v) {
+      return v;
+    },
+    "Minutes": import_js_quantities.default.swiftConverter("s", "minutes"),
+    "Hours": import_js_quantities.default.swiftConverter("s", "hours"),
+    "Days": import_js_quantities.default.swiftConverter("s", "days"),
+    "D HH:MM:SS": function(v) {
+      v = parseInt(v, 10);
+      const isNegative = v < 0;
+      v = Math.abs(v);
+      const days = Math.floor(v / 86400);
+      const h = Math.floor(v % 86400 / 3600);
+      const m = Math.floor(v % 3600 / 60);
+      const s = Math.floor(v % 60);
+      let result = isNegative ? "-" : "";
+      if (days > 0) {
+        result += days + "d " + h.toString() + ":" + m.toString().padStart(2, "0") + ":" + s.toString().padStart(2, "0");
+      } else {
+        result += h.toString() + ":" + m.toString().padStart(2, "0") + ":" + s.toString().padStart(2, "0");
+      }
+      return result;
+    },
+    //  angularVelocity
+    "rad/s": function(v) {
+      return v;
+    },
+    "deg/s": import_js_quantities.default.swiftConverter("rad/s", "deg/s"),
+    "deg/min": import_js_quantities.default.swiftConverter("rad/s", "deg/min"),
+    //  frequency
+    "rpm": function(v) {
+      return v * 60;
+    },
+    "Hz": function(v) {
+      return v;
+    },
+    "KHz": function(v) {
+      return v / 1e3;
+    },
+    "MHz": function(v) {
+      return v / 1e6;
+    },
+    "GHz": function(v) {
+      return v / 1e9;
+    },
+    //  angle
+    "rad": function(v) {
+      return v;
+    },
+    "deg": import_js_quantities.default.swiftConverter("rad", "deg"),
+    "grad": import_js_quantities.default.swiftConverter("rad", "grad"),
+    //   ratio
+    "percent": function(v) {
+      return v * 100;
+    },
+    "percentraw": function(v) {
+      return v;
+    },
+    "ratio": function(v) {
+      return v;
+    },
+    // Position Degrees lat/lon
+    "pdeg": function(v) {
+      return v;
+    },
+    // Signal K uses degrees for lat/lon
+    "latitudeMin": function(v) {
+      let degree = Math.trunc(v);
+      let s = "N";
+      if (v < 0) {
+        s = "S";
+        degree = degree * -1;
+      }
+      let r = v % 1 * 60;
+      if (s == "S") {
+        r = r * -1;
+      }
+      return degree + "\xB0 " + r.toFixed(2).padStart(5, "0") + "' " + s;
+    },
+    "latitudeSec": function(v) {
+      let degree = Math.trunc(v);
+      let s = "N";
+      if (v < 0) {
+        s = "S";
+        degree = degree * -1;
+      }
+      let r = v % 1 * 60;
+      if (s == "S") {
+        r = r * -1;
+      }
+      const minutes = Math.trunc(r);
+      const seconds = r % 1 * 60;
+      return degree + "\xB0 " + minutes + "' " + seconds.toFixed(2).padStart(5, "0") + '" ' + s;
+    },
+    "longitudeMin": function(v) {
+      let degree = Math.trunc(v);
+      let s = "E";
+      if (v < 0) {
+        s = "W";
+        degree = degree * -1;
+      }
+      let r = v % 1 * 60;
+      if (s == "W") {
+        r = r * -1;
+      }
+      return degree + "\xB0 " + r.toFixed(2).padStart(5, "0") + "' " + s;
+    },
+    "longitudeSec": function(v) {
+      let degree = Math.trunc(v);
+      let s = "E";
+      if (v < 0) {
+        s = "W";
+        degree = degree * -1;
+      }
+      let r = v % 1 * 60;
+      if (s == "W") {
+        r = r * -1;
+      }
+      const minutes = Math.trunc(r);
+      const seconds = r % 1 * 60;
+      return degree + "\xB0 " + minutes + "' " + seconds.toFixed(2).padStart(5, "0") + '" ' + s;
+    }
+  };
+  /**
+   * Converts any number to the specified unit. The function does not validate if
+   * source and destination units are compatible, ie. kph to degrees will be converted
+   * but will return meaningless results.
+   *
+   * If the unit is not know, or or the value is null, Null will be returned.
+   *
+   * @param {string} unit The conversion type unit
+   * @param {number} value The source value
+   * @return {*}  {number} The result of the conversion
+   * @memberof UnitsService
+   */
+  convertToUnit(unit, value) {
+    if (!(unit in this.unitConversionFunctions)) {
+      return null;
+    }
+    if (value === null) {
+      return null;
+    }
+    const num = +value;
+    return this.unitConversionFunctions[unit](num);
+  }
+  /**
+   * Returns the list KIP base unit conversion settings applied before presentation.
+   * See KIP's Units Settings configuration.
+   *
+   * Ex: If a Signal K path's meta Units is set to 'm/s', could KIP automatically
+   * convert to say, 'knots' before presentation. Received Signal K data is always
+   * kept in native format.
+   *
+   * @return {*}  {IUnitDefaults}
+   * @memberof UnitsService
+   */
+  getDefaults() {
+    return this._defaultUnits;
+  }
+  /**
+   * Return the list of possible conversions matrix by unit groups. Useful
+   * to present possible conversion or select a conversation units that are
+   * related.
+   *
+   * @return {*}  {IUnitGroup[]} an array of units by groups
+   * @memberof UnitsService
+   */
+  getConversions() {
+    return this._conversionList;
+  }
+  /**
+   * Obtain a list of possible Kip value type conversions for a given path. ie,.: Speed conversion group
+   * (kph, Knots, etc.). The conversion list will be trimmed to only the conversions for the group in question.
+   * If a base value type (provided by server) for a path cannot be found,
+   * the full list is returned and with 'unitless' as the base. Same goes if the value type exists,
+   * but Kip does not handle it...yet.
+   *
+   * @param path The Signal K path of the value
+   * @return conversions Full list array or subset of list array
+   */
+  getConversionsForPath(path) {
+    const pathUnitType = this.data.getPathUnitType(path);
+    const UNITLESS = "unitless";
+    let defaultUnit = "unitless";
+    if (pathUnitType === null || pathUnitType === "RFC 3339 (UTC)") {
+      return { base: UNITLESS, conversions: this._conversionList };
+    } else {
+      const groupList = this._conversionList.filter((unitGroup) => {
+        if (unitGroup.group == "Position" && (path.includes("position.latitude") || path.includes("position.longitude"))) {
+          return true;
+        }
+        const unitExists = unitGroup.units.find((unit) => unit.measure == pathUnitType);
+        if (unitExists) {
+          defaultUnit = this._defaultUnits[unitGroup.group];
+          return true;
+        }
+        return false;
+      });
+      if (groupList.length > 0) {
+        return { base: defaultUnit, conversions: groupList };
+      }
+      console.log("[Units Service] Unit type: " + pathUnitType + ", found for path: " + path + "\nbut Kip does not support it.");
+      return { base: UNITLESS, conversions: this._conversionList };
+    }
+  }
+  ngOnDestroy() {
+    this._defaultUnitsSub?.unsubscribe();
+  }
+  static \u0275fac = function UnitsService_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _UnitsService)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _UnitsService, factory: _UnitsService.\u0275fac });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UnitsService, [{
+    type: Injectable
+  }], () => [], null);
+})();
+
+export {
+  UnitsService
+};
+//# sourceMappingURL=chunk-E24UNLSJ.js.map