@contena/meteor-component-library 5.5.0

package/dist/esm/MtUnitField.js

@@ -0,0 +1,2308 @@
+import '../mt-unit-field.css';
+import { defineComponent, useSlots, computed, watch, openBlock, createElementBlock, createVNode, createSlots, withCtx, createBlock, createCommentVNode, unref, renderSlot } from "vue";
+import MtNumberField from "./MtNumberField.js";
+import MtFieldError from "./MtFieldError.js";
+import MtUnitSelect from "./MtUnitSelect.js";
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from "../_commonjsHelpers-7a77ea84.mjs";
+import { _ as _export_sfc } from "../_plugin-vue_export-helper-cc2b3d55.mjs";
+import "./MtTextField.js";
+import "../mt-base-field-3b5538c6.mjs";
+import "./MtInheritanceSwitch.js";
+import "../mt-icon.vue_vue_type_style_index_0_lang-c90dc25b.mjs";
+import "./MtTooltip.js";
+import "../floating-ui.vue-61aa2b7b.mjs";
+import "../floating-ui.dom-3a2ca2f5.mjs";
+import "../useIsInsideTooltip-0c3bd290.mjs";
+import "../index-431c2592.mjs";
+import "vue-i18n";
+import "./MtFieldCopyable.js";
+import "../tooltip.directive-f216b7fb.mjs";
+import "../id-1e5b8276.mjs";
+import "./MtHelpText.js";
+import "../useFutureFlags-af867fe7.mjs";
+import "./MtFieldHint.js";
+import "./MtText.js";
+import "./MtUnitSelectResult.js";
+import "../index-03602e2a.mjs";
+var objectTypes$3 = {
+  "boolean": false,
+  "function": true,
+  "object": true,
+  "number": false,
+  "string": false,
+  "undefined": false
+};
+var lodash__objecttypes = objectTypes$3;
+var objectTypes$2 = lodash__objecttypes;
+function isObject$4(value) {
+  return !!(value && objectTypes$2[typeof value]);
+}
+var lodash_isobject = isObject$4;
+var objectProto$1 = Object.prototype;
+var toString = objectProto$1.toString;
+var reNative$4 = RegExp(
+  "^" + String(toString).replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/toString| for [^\]]+/g, ".*?") + "$"
+);
+var lodash__renative = reNative$4;
+var objectTypes$1 = lodash__objecttypes;
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+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 result;
+};
+var lodash__shimkeys = shimKeys$1;
+var isObject$3 = lodash_isobject, reNative$3 = lodash__renative, shimKeys = lodash__shimkeys;
+var nativeKeys = reNative$3.test(nativeKeys = Object.keys) && nativeKeys;
+var keys$2 = !nativeKeys ? shimKeys : function(object) {
+  if (!isObject$3(object)) {
+    return [];
+  }
+  return nativeKeys(object);
+};
+var lodash_keys = keys$2;
+function noop$1() {
+}
+var lodash_noop = noop$1;
+var isObject$2 = lodash_isobject, reNative$2 = lodash__renative;
+var nativeCreate = reNative$2.test(nativeCreate = Object.create) && nativeCreate;
+function baseCreate$2(prototype, properties) {
+  return isObject$2(prototype) ? nativeCreate(prototype) : {};
+}
+if (!nativeCreate) {
+  baseCreate$2 = function() {
+    function Object2() {
+    }
+    return function(prototype) {
+      if (isObject$2(prototype)) {
+        Object2.prototype = prototype;
+        var result = new Object2();
+        Object2.prototype = null;
+      }
+      return result || commonjsGlobal.Object();
+    };
+  }();
+}
+var lodash__basecreate = baseCreate$2;
+var noop = lodash_noop, reNative$1 = lodash__renative;
+var descriptor = {
+  "configurable": false,
+  "enumerable": false,
+  "value": null,
+  "writable": false
+};
+var defineProperty = function() {
+  try {
+    var o = {}, func = reNative$1.test(func = Object.defineProperty) && func, result = func(o, o, o) && func;
+  } catch (e) {
+  }
+  return result;
+}();
+var setBindData$3 = !defineProperty ? noop : function(func, value) {
+  descriptor.value = value;
+  defineProperty(func, "__bindData__", descriptor);
+};
+var lodash__setbinddata = setBindData$3;
+var baseCreate$1 = lodash__basecreate, isObject$1 = lodash_isobject, setBindData$2 = lodash__setbinddata;
+var arrayRef$2 = [];
+var push$2 = arrayRef$2.push;
+function baseBind$1(bindData) {
+  var func = bindData[0], partialArgs = bindData[2], thisArg = bindData[4];
+  function bound() {
+    if (partialArgs) {
+      var args = partialArgs.slice();
+      push$2.apply(args, arguments);
+    }
+    if (this instanceof bound) {
+      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 lodash__basebind = baseBind$1;
+function slice$2(array, start, end) {
+  start || (start = 0);
+  if (typeof end == "undefined") {
+    end = array ? array.length : 0;
+  }
+  var index = -1, length2 = end - start || 0, result = Array(length2 < 0 ? 0 : length2);
+  while (++index < length2) {
+    result[index] = array[start + index];
+  }
+  return result;
+}
+var lodash__slice = slice$2;
+var baseCreate = lodash__basecreate, isObject = lodash_isobject, setBindData$1 = lodash__setbinddata, slice$1 = lodash__slice;
+var arrayRef$1 = [];
+var push$1 = arrayRef$1.push;
+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);
+    }
+    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 lodash__basecreatewrapper = baseCreateWrapper$1;
+function isFunction$1(value) {
+  return typeof value == "function";
+}
+var lodash_isfunction = isFunction$1;
+var baseBind = lodash__basebind, baseCreateWrapper = lodash__basecreatewrapper, isFunction = lodash_isfunction;
+var arrayRef = [];
+var push = arrayRef.push;
+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();
+    if (isBind && !(bindData[1] & 1)) {
+      bindData[4] = thisArg;
+    }
+    if (!isBind && bindData[1] & 1) {
+      bitmask |= 8;
+    }
+    if (isCurry && !(bindData[1] & 4)) {
+      bindData[5] = arity;
+    }
+    if (isPartial) {
+      push.apply(bindData[2] || (bindData[2] = []), partialArgs);
+    }
+    if (isPartialRight) {
+      push.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
+    }
+    bindData[1] |= bitmask;
+    return createWrapper$1.apply(null, bindData);
+  }
+  var creater = bitmask == 1 || bitmask === 17 ? baseBind : baseCreateWrapper;
+  return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
+}
+var lodash__createwrapper = createWrapper$1;
+var createWrapper = lodash__createwrapper, slice = lodash__slice;
+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;
+function identity$1(value) {
+  return value;
+}
+var lodash_identity = identity$1;
+var reNative = lodash__renative;
+var reThis$1 = /\bthis\b/;
+var support$1 = {};
+support$1.funcDecomp = !reNative.test(commonjsGlobal.WinRTError) && reThis$1.test(function() {
+  return this;
+});
+support$1.funcNames = typeof Function.name == "string";
+var lodash_support = support$1;
+var bind = lodash_bind, identity = lodash_identity, setBindData = lodash__setbinddata, support = lodash_support;
+var reFuncName = /^\s*function[ \n\r\t]+\w/;
+var reThis = /\bthis\b/;
+var fnToString = Function.prototype.toString;
+function baseCreateCallback$2(func, thisArg, argCount) {
+  if (typeof func != "function") {
+    return identity;
+  }
+  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) {
+        bindData = reThis.test(source);
+        setBindData(func, bindData);
+      }
+    }
+  }
+  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;
+var baseCreateCallback$1 = lodash__basecreatecallback, keys$1 = lodash_keys, objectTypes = lodash__objecttypes;
+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), length2 = ownProps ? ownProps.length : 0;
+  while (++ownIndex < length2) {
+    index = ownProps[ownIndex];
+    if (callback(iterable[index], index, collection) === false)
+      return result;
+  }
+  return result;
+};
+var lodash_forown = forOwn$1;
+var baseCreateCallback = lodash__basecreatecallback, forOwn = lodash_forown;
+function forEach(collection, callback, thisArg) {
+  var index = -1, length2 = collection ? collection.length : 0;
+  callback = callback && typeof thisArg == "undefined" ? callback : baseCreateCallback(callback, thisArg, 3);
+  if (typeof length2 == "number") {
+    while (++index < length2) {
+      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 / 1e3
+  },
+  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: 1e3
+  }
+};
+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 / 1e6
+  },
+  cm2: {
+    name: {
+      singular: "Centimeter",
+      plural: "Centimeters"
+    },
+    to_anchor: 1 / 1e4
+  },
+  m2: {
+    name: {
+      singular: "Square Meter",
+      plural: "Square Meters"
+    },
+    to_anchor: 1
+  },
+  ha: {
+    name: {
+      singular: "Hectare",
+      plural: "Hectares"
+    },
+    to_anchor: 1e4
+  },
+  km2: {
+    name: {
+      singular: "Square Kilometer",
+      plural: "Square Kilometers"
+    },
+    to_anchor: 1e6
+  }
+};
+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 / 1e6
+  },
+  mg: {
+    name: {
+      singular: "Milligram",
+      plural: "Milligrams"
+    },
+    to_anchor: 1 / 1e3
+  },
+  g: {
+    name: {
+      singular: "Gram",
+      plural: "Grams"
+    },
+    to_anchor: 1
+  },
+  kg: {
+    name: {
+      singular: "Kilogram",
+      plural: "Kilograms"
+    },
+    to_anchor: 1e3
+  },
+  mt: {
+    name: {
+      singular: "Metric Tonne",
+      plural: "Metric Tonnes"
+    },
+    to_anchor: 1e6
+  }
+};
+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: 2e3
+  }
+};
+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 / 1e6
+  },
+  cm3: {
+    name: {
+      singular: "Cubic Centimeter",
+      plural: "Cubic Centimeters"
+    },
+    to_anchor: 1 / 1e3
+  },
+  ml: {
+    name: {
+      singular: "Millilitre",
+      plural: "Millilitres"
+    },
+    to_anchor: 1 / 1e3
+  },
+  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: 1e3
+  },
+  m3: {
+    name: {
+      singular: "Cubic meter",
+      plural: "Cubic meters"
+    },
+    to_anchor: 1e3
+  },
+  km3: {
+    name: {
+      singular: "Cubic kilometer",
+      plural: "Cubic kilometers"
+    },
+    to_anchor: 1e12
+  },
+  krm: {
+    name: {
+      singular: "Matsked",
+      plural: "Matskedar"
+    },
+    to_anchor: 1 / 1e3
+  },
+  tsk: {
+    name: {
+      singular: "Tesked",
+      plural: "Teskedar"
+    },
+    to_anchor: 5 / 1e3
+  },
+  msk: {
+    name: {
+      singular: "Matsked",
+      plural: "Matskedar"
+    },
+    to_anchor: 15 / 1e3
+  },
+  kkp: {
+    name: {
+      singular: "Kaffekopp",
+      plural: "Kaffekoppar"
+    },
+    to_anchor: 150 / 1e3
+  },
+  glas: {
+    name: {
+      singular: "Glas",
+      plural: "Glas"
+    },
+    to_anchor: 200 / 1e3
+  },
+  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 / 1e9
+  },
+  mu: {
+    name: {
+      singular: "Microsecond",
+      plural: "Microseconds"
+    },
+    to_anchor: 1 / 1e6
+  },
+  ms: {
+    name: {
+      singular: "Millisecond",
+      plural: "Milliseconds"
+    },
+    to_anchor: 1 / 1e3
+  },
+  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,
+  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: 1e-3
+  },
+  ppt: {
+    name: {
+      singular: "Part-per Trillion",
+      plural: "Parts-per Trillion"
+    },
+    to_anchor: 1e-6
+  },
+  ppq: {
+    name: {
+      singular: "Part-per Quadrillion",
+      plural: "Parts-per Quadrillion"
+    },
+    to_anchor: 1e-9
+  }
+};
+var partsPer = {
+  metric: metric$5,
+  imperial: {},
+  _anchors: {
+    metric: {
+      unit: "ppm",
+      ratio: 1e-6
+    }
+  }
+};
+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 / 1e3
+  },
+  kPa: {
+    name: {
+      singular: "kilopascal",
+      plural: "kilopascals"
+    },
+    to_anchor: 1
+  },
+  MPa: {
+    name: {
+      singular: "megapascal",
+      plural: "megapascals"
+    },
+    to_anchor: 1e3
+  },
+  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 / 76e4
+  }
+};
+imperial$2 = {
+  psi: {
+    name: {
+      singular: "pound per square inch",
+      plural: "pounds per square inch"
+    },
+    to_anchor: 1 / 1e3
+  },
+  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: 14503768078e-14
+    },
+    imperial: {
+      unit: "psi",
+      ratio: 1 / 14503768078e-14
+    }
+  }
+};
+var current;
+current = {
+  A: {
+    name: {
+      singular: "Ampere",
+      plural: "Amperes"
+    },
+    to_anchor: 1
+  },
+  mA: {
+    name: {
+      singular: "Milliampere",
+      plural: "Milliamperes"
+    },
+    to_anchor: 1e-3
+  },
+  kA: {
+    name: {
+      singular: "Kiloampere",
+      plural: "Kiloamperes"
+    },
+    to_anchor: 1e3
+  }
+};
+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: 1e-3
+  },
+  kV: {
+    name: {
+      singular: "Kilovolt",
+      plural: "Kilovolts"
+    },
+    to_anchor: 1e3
+  }
+};
+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: 1e-3
+  },
+  kW: {
+    name: {
+      singular: "Kilowatt",
+      plural: "Kilowatts"
+    },
+    to_anchor: 1e3
+  },
+  MW: {
+    name: {
+      singular: "Megawatt",
+      plural: "Megawatts"
+    },
+    to_anchor: 1e6
+  },
+  GW: {
+    name: {
+      singular: "Gigawatt",
+      plural: "Gigawatts"
+    },
+    to_anchor: 1e9
+  }
+};
+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: 1e-3
+  },
+  kVAR: {
+    name: {
+      singular: "Kilovolt-Ampere Reactive",
+      plural: "Kilovolt-Amperes Reactive"
+    },
+    to_anchor: 1e3
+  },
+  MVAR: {
+    name: {
+      singular: "Megavolt-Ampere Reactive",
+      plural: "Megavolt-Amperes Reactive"
+    },
+    to_anchor: 1e6
+  },
+  GVAR: {
+    name: {
+      singular: "Gigavolt-Ampere Reactive",
+      plural: "Gigavolt-Amperes Reactive"
+    },
+    to_anchor: 1e9
+  }
+};
+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: 1e-3
+  },
+  kVA: {
+    name: {
+      singular: "Kilovolt-Ampere",
+      plural: "Kilovolt-Amperes"
+    },
+    to_anchor: 1e3
+  },
+  MVA: {
+    name: {
+      singular: "Megavolt-Ampere",
+      plural: "Megavolt-Amperes"
+    },
+    to_anchor: 1e6
+  },
+  GVA: {
+    name: {
+      singular: "Gigavolt-Ampere",
+      plural: "Gigavolt-Amperes"
+    },
+    to_anchor: 1e9
+  }
+};
+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: 36e5
+  },
+  MWh: {
+    name: {
+      singular: "Megawatt-hour",
+      plural: "Megawatt-hours"
+    },
+    to_anchor: 36e8
+  },
+  GWh: {
+    name: {
+      singular: "Gigawatt-hour",
+      plural: "Gigawatt-hours"
+    },
+    to_anchor: 36e11
+  },
+  J: {
+    name: {
+      singular: "Joule",
+      plural: "Joules"
+    },
+    to_anchor: 1
+  },
+  kJ: {
+    name: {
+      singular: "Kilojoule",
+      plural: "Kilojoules"
+    },
+    to_anchor: 1e3
+  }
+};
+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: 1e-3
+  },
+  kVARh: {
+    name: {
+      singular: "Kilovolt-Ampere Reactive Hour",
+      plural: "Kilovolt-Amperes Reactive Hour"
+    },
+    to_anchor: 1e3
+  },
+  MVARh: {
+    name: {
+      singular: "Megavolt-Ampere Reactive Hour",
+      plural: "Megavolt-Amperes Reactive Hour"
+    },
+    to_anchor: 1e6
+  },
+  GVARh: {
+    name: {
+      singular: "Gigavolt-Ampere Reactive Hour",
+      plural: "Gigavolt-Amperes Reactive Hour"
+    },
+    to_anchor: 1e9
+  }
+};
+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 / 1e6
+  },
+  "cm3/s": {
+    name: {
+      singular: "Cubic Centimeter per second",
+      plural: "Cubic Centimeters per second"
+    },
+    to_anchor: 1 / 1e3
+  },
+  "ml/s": {
+    name: {
+      singular: "Millilitre per second",
+      plural: "Millilitres per second"
+    },
+    to_anchor: 1 / 1e3
+  },
+  "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: 1e3
+  },
+  "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: 1e3
+  },
+  "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: 1e12
+  }
+};
+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,
+  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 / 1e3
+  },
+  Hz: {
+    name: {
+      singular: "hertz",
+      plural: "hertz"
+    },
+    to_anchor: 1
+  },
+  kHz: {
+    name: {
+      singular: "kilohertz",
+      plural: "kilohertz"
+    },
+    to_anchor: 1e3
+  },
+  MHz: {
+    name: {
+      singular: "megahertz",
+      plural: "megahertz"
+    },
+    to_anchor: 1e3 * 1e3
+  },
+  GHz: {
+    name: {
+      singular: "gigahertz",
+      plural: "gigahertz"
+    },
+    to_anchor: 1e3 * 1e3 * 1e3
+  },
+  THz: {
+    name: {
+      singular: "terahertz",
+      plural: "terahertz"
+    },
+    to_anchor: 1e3 * 1e3 * 1e3 * 1e3
+  },
+  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,
+  area,
+  mass,
+  volume,
+  each: each$1,
+  temperature,
+  time: time_1,
+  digital,
+  partsPer,
+  speed,
+  pace,
+  pressure,
+  current: current_1,
+  voltage: voltage_1,
+  power: power_1,
+  reactivePower: reactivePower_1,
+  apparentPower: apparentPower_1,
+  energy: energy_1,
+  reactiveEnergy: reactiveEnergy_1,
+  volumeFlowRate,
+  illuminance,
+  frequency: frequency_1,
+  angle: angle_1
+}, Converter;
+Converter = function(numerator, denominator) {
+  if (denominator)
+    this.val = numerator / denominator;
+  else
+    this.val = numerator;
+};
+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;
+};
+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);
+  }
+  if (this.origin.abbr === this.destination.abbr) {
+    return this.val;
+  }
+  if (this.destination.measure != this.origin.measure) {
+    throw new Error("Cannot convert incompatible measures of " + this.destination.measure + " and " + this.origin.measure);
+  }
+  result = this.val * this.origin.unit.to_anchor;
+  if (this.origin.unit.anchor_shift) {
+    result -= this.origin.unit.anchor_shift;
+  }
+  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;
+    }
+  }
+  if (this.destination.unit.anchor_shift) {
+    result += this.destination.unit.anchor_shift;
+  }
+  return result / this.destination.unit.to_anchor;
+};
+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;
+  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;
+};
+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,
+            measure,
+            system,
+            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
+  };
+};
+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;
+};
+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,
+          measure: testMeasure,
+          system,
+          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(", "));
+};
+Converter.prototype.possibilities = function(measure) {
+  var possibilities = [];
+  if (!this.origin && !measure) {
+    each(keys(measures), function(measure2) {
+      each(measures[measure2], 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;
+};
+Converter.prototype.measures = function() {
+  return keys(measures);
+};
+convert = function(value) {
+  return new Converter(value);
+};
+var lib = convert;
+const convert$1 = /* @__PURE__ */ getDefaultExportFromCjs(lib);
+const _hoisted_1 = { class: "mt-unit-field" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "mt-unit-field",
+  props: {
+    defaultUnit: { default: "mm" },
+    measurementType: { default: "length" },
+    modelValue: { default: void 0 },
+    placeholder: {},
+    numberType: {},
+    step: { default: 1 },
+    min: {},
+    max: {},
+    digits: {},
+    fillDigits: { type: Boolean },
+    allowEmpty: { type: Boolean },
+    numberAlignEnd: { type: Boolean },
+    label: {},
+    error: {},
+    disabled: { type: Boolean },
+    required: { type: Boolean },
+    name: {},
+    size: {},
+    helpText: {},
+    isInherited: { type: Boolean },
+    isInheritanceField: { type: Boolean },
+    disableInheritanceToggle: { type: Boolean },
+    copyable: { type: Boolean },
+    copyableTooltip: { type: Boolean },
+    zIndex: { default: null },
+    hint: { default: null }
+  },
+  emits: ["update:modelValue", "update:defaultUnit", "update:measurementType", "inheritance-restore", "inheritance-remove"],
+  setup(__props, { emit: __emit }) {
+    const slots = useSlots();
+    const props = __props;
+    const emit = __emit;
+    const availableUnits = computed(() => {
+      if (props.measurementType === "mass") {
+        return ["g", "kg", "oz", "lb"];
+      } else {
+        return ["mm", "cm", "m", "in", "ft", "yd"];
+      }
+    });
+    const onUnitChange = (value) => {
+      if (props.modelValue !== void 0) {
+        const convertedValue = convert$1(props.modelValue).from(props.defaultUnit).to(value);
+        const formattedValue = props.digits !== void 0 ? Number(convertedValue.toFixed(props.digits)) : convertedValue;
+        emit("update:modelValue", formattedValue);
+      }
+      emit("update:defaultUnit", value);
+    };
+    watch(
+      () => props.measurementType,
+      () => {
+        emit("update:defaultUnit", availableUnits.value[0]);
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(MtNumberField, {
+          "model-value": _ctx.modelValue,
+          hint: _ctx.hint,
+          placeholder: _ctx.placeholder,
+          "number-type": _ctx.numberType,
+          step: _ctx.step,
+          min: _ctx.min,
+          max: _ctx.max,
+          digits: _ctx.digits,
+          "fill-digits": _ctx.fillDigits,
+          "allow-empty": _ctx.allowEmpty,
+          "number-align-end": _ctx.numberAlignEnd,
+          disabled: _ctx.disabled,
+          required: _ctx.required,
+          "is-inherited": _ctx.isInherited,
+          "is-inheritance-field": _ctx.isInheritanceField,
+          "disable-inheritance-toggle": _ctx.disableInheritanceToggle,
+          copyable: _ctx.copyable,
+          "copyable-tooltip": _ctx.copyableTooltip,
+          "help-text": _ctx.helpText,
+          name: _ctx.name,
+          size: _ctx.size,
+          label: _ctx.label,
+          error: _ctx.error,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.$emit("update:modelValue", $event)),
+          onInheritanceRestore: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("inheritance-restore")),
+          onInheritanceRemove: _cache[2] || (_cache[2] = ($event) => _ctx.$emit("inheritance-remove"))
+        }, createSlots({
+          error: withCtx(() => [
+            _ctx.error ? (openBlock(), createBlock(MtFieldError, {
+              key: 0,
+              error: _ctx.error
+            }, null, 8, ["error"])) : createCommentVNode("", true)
+          ]),
+          "_unit-suffix": withCtx(() => [
+            createVNode(MtUnitSelect, {
+              "model-value": _ctx.defaultUnit,
+              units: availableUnits.value,
+              "z-index": _ctx.zIndex,
+              disabled: _ctx.disabled || _ctx.isInherited,
+              "onUpdate:modelValue": onUnitChange
+            }, null, 8, ["model-value", "units", "z-index", "disabled"])
+          ]),
+          _: 2
+        }, [
+          unref(slots).hint ? {
+            name: "hint",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "hint", {}, void 0, true)
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1032, ["model-value", "hint", "placeholder", "number-type", "step", "min", "max", "digits", "fill-digits", "allow-empty", "number-align-end", "disabled", "required", "is-inherited", "is-inheritance-field", "disable-inheritance-toggle", "copyable", "copyable-tooltip", "help-text", "name", "size", "label", "error"])
+      ]);
+    };
+  }
+});
+const mtUnitField_vue_vue_type_style_index_0_scoped_81f4502c_lang = "";
+const mtUnitField = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-81f4502c"]]);
+export {
+  mtUnitField as default
+};