@vidispine/vdt-js 22.3.0-pre.5 → 22.3.0

package/dist/index.js

@@ -259,7 +259,7 @@ var roles = /*#__PURE__*/Object.freeze({
   VXA_READ: VXA_READ
 });
 
-var _excluded$4 = ["value"],
+var _excluded$8 = ["value"],
     _excluded2$2 = ["start", "end"];
 
 function ownKeys$7(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
@@ -271,7 +271,7 @@ var GROUP_PROPERTY_KEYS = [].concat(COMBINED_PROPERTY_KEYS, ['cycle']);
 var FIELD_PROPERTY_KEYS = [].concat(COMBINED_PROPERTY_KEYS, ['value', 'reference', 'type', 'track']);
 var FIELD_VALUE_PROPERTY_KEYS = [].concat(COMBINED_PROPERTY_KEYS, ['value', 'lang']);
 
-var isObject = function isObject(o) {
+var isObject$1 = function isObject(o) {
   return Object.prototype.toString.call(o) === '[object Object]';
 };
 
@@ -287,7 +287,7 @@ var isField = function isField(value) {
   };
 
   var isFieldObject = function isFieldObject(v) {
-    return isObject(v) && (v.value === null || isObject(v.value) || isFieldType(v.value));
+    return isObject$1(v) && (v.value === null || isObject$1(v.value) || isFieldType(v.value));
   };
 
   if (value === null) {
@@ -303,7 +303,7 @@ var isField = function isField(value) {
 
 var isGroup = function isGroup(value) {
   var isGroupObject = function isGroupObject(v) {
-    return isObject(v) && v.value === undefined && Object.entries(value);
+    return isObject$1(v) && v.value === undefined && Object.entries(value);
   };
 
   if (Array.isArray(value)) {
@@ -355,7 +355,7 @@ var parseValueObject = function parseValueObject(valueObject) {
 var parseFieldValue = function parseFieldValue(value) {
   if ([undefined, null].includes(value)) return undefined;
   if (Array.isArray(value)) return value.map(parseFieldValue);
-  if (isObject(value)) return parseValueObject(value);
+  if (isObject$1(value)) return parseValueObject(value);
   return parseValue(value);
 };
 
@@ -365,7 +365,7 @@ var parseFieldObject = function parseFieldObject(fieldObject) {
 
   if (parsedFieldValue === undefined) {
     fieldObject.value;
-        var fieldObjectWithoutValue = _objectWithoutProperties__default["default"](fieldObject, _excluded$4);
+        var fieldObjectWithoutValue = _objectWithoutProperties__default["default"](fieldObject, _excluded$8);
 
     return fieldObjectWithoutValue;
   }
@@ -376,7 +376,7 @@ var parseFieldObject = function parseFieldObject(fieldObject) {
 };
 
 var parseField$1 = function parseField(field) {
-  if (isObject(field)) {
+  if (isObject$1(field)) {
     return parseFieldObject(field);
   }
 
@@ -451,10 +451,10 @@ var parseTimespan$1 = function parseTimespan() {
   });
 };
 /**
- * Create a MetadataType object from a metadata object
+ * Create a VidiCore MetadataType from a simplified object structure
  *
- * @param {Object} metadata - object with metadata to create MetadataType object of
- * @returns {Object} MetadataType
+ * @param {object} metadata - object to create MetadataType from
+ * @returns {object} a MetadataType object
  */
 
 
@@ -490,7 +490,7 @@ var sortTimespanList = function sortTimespanList(timespan1, timespan2) {
   return 0;
 };
 
-var _excluded$3 = ["value"],
+var _excluded$7 = ["value"],
     _excluded2$1 = ["field", "group"],
     _excluded3 = ["field", "group"];
 
@@ -535,7 +535,7 @@ var parseField = function parseField() {
 
   var _field$value = field.value,
       value = _field$value === void 0 ? [] : _field$value,
-      attributes = _objectWithoutProperties__default["default"](field, _excluded$3);
+      attributes = _objectWithoutProperties__default["default"](field, _excluded$7);
 
   var parsedValueList = parseValueList(value, options);
   if (includeAttributes || includeFieldAttributes) return _objectSpread$6(_objectSpread$6({}, attributes), {}, {
@@ -684,21 +684,21 @@ var parseGroupList = function parseGroupList() {
 /**
  * Parses timespan according to specified options.
  * The attributes can be targeted for each sub-type.
- * @param {Object} timespan={} - The timespan response from the API.
- * @param {Object} options={} - Options which change how the metadataType is parsed.
- * @param {string} options.joinValue=undefined - String to join the values, eg ','.
- * @param {boolean} options.includeAttributes=false - Include attributes on all objects.
- * @param {boolean} options.includeTimespanAttributes=false - Include attributes on timespans.
- * @param {boolean} options.includeGroupAttributes=false - Include attributes on groups.
- * @param {boolean} options.includeFieldAttributes=false - Include attributes on fields.
- * @param {boolean} options.includeValueAttributes=false - Include attributes on values.
- * @param {boolean} options.flat=false - Flatten to key/value (Note: keys may be overwritten).
- * @param {boolean} options.flatTimespan=false - Flatten timespan.
- * @param {boolean} options.flatGroup=false - Flatten group.
- * @param {boolean} options.groupAsList=false - Return groups as list.
- * @param {boolean} options.fieldAsList=false - Return fields as list.
- * @param {boolean} options.arrayOnSingle=true - Return fields as array even if single field.
- * @param {boolean} options.arrayOnSingleValue=true - Return fields as array even if single field value.
+ * @param {Object} [timespan={}] - A timespan from VidiCore.
+ * @param {Object} [options={}] - Options which change how the metadataType is parsed.
+ * @param {string} [options.joinValue=undefined] - String to join the values, eg ','.
+ * @param {boolean} [options.includeAttributes=false] - Include attributes on all objects.
+ * @param {boolean} [options.includeTimespanAttributes=false] - Include attributes on timespans.
+ * @param {boolean} [options.includeGroupAttributes=false] - Include attributes on groups.
+ * @param {boolean} [options.includeFieldAttributes=false] - Include attributes on fields.
+ * @param {boolean} [options.includeValueAttributes=false] - Include attributes on values.
+ * @param {boolean} [options.flat=false] - Flatten to key/value (Note: keys may be overwritten).
+ * @param {boolean} [options.flatTimespan=false] - Flatten timespan.
+ * @param {boolean} [options.flatGroup=false] - Flatten group.
+ * @param {boolean} [options.groupAsList=false] - Return groups as list.
+ * @param {boolean} [options.fieldAsList=false] - Return fields as list.
+ * @param {boolean} [options.arrayOnSingle=true] - Return fields as array even if single field.
+ * @param {boolean} [options.arrayOnSingleValue=true] - Return fields as array even if single field value.
  * @returns {Object} Metadata object parsed according to options.
  */
 
@@ -763,7 +763,8 @@ function _objectSpread$5(target) { for (var i = 1; i < arguments.length; i++) {
 /**
  * Parses timespanList according to specified options.
  * The attributes can be targeted for each sub-type.
- * @param {Object[]} timespanList - The timespanList response from the API.
+ *
+ * @param {Object[]} timespanList - A timespanList from VidiCore.
  * @param {Object} options - Options which change how the metadataType is parsed.
  * @param {string} options.joinValue - String to join the values, eg ','.
  * @param {boolean} options.includeAttributes - Include attributes on all objects.
@@ -779,8 +780,8 @@ function _objectSpread$5(target) { for (var i = 1; i < arguments.length; i++) {
  * @param {boolean} options.timespanAsList - Return timespans as list.
  * @param {boolean} options.groupAsList - Return groups as list.
  * @param {boolean} options.fieldAsList - Return fields as list.
- * @param {boolean} options.arrayOnSingle=true - Return fields as array even if single field.
- * @param {boolean} options.arrayOnSingleValue=true - Return fields as array even if single field value.
+ * @param {boolean} [options.arrayOnSingle=true] - Return fields as array even if single field.
+ * @param {boolean} [options.arrayOnSingleValue=true] - Return fields as array even if single field value.
  * @returns {Object} Metadata object parsed according to options.
  */
 
@@ -823,11 +824,11 @@ var parseTimespanList = function parseTimespanList() {
   return output;
 };
 
-var _excluded$2 = ["timespan"];
+var _excluded$6 = ["timespan"];
 /**
  * Parses MetadataType according to specified options.
  * The attributes can be targeted for each sub-type.
- * @param {Object} metadataType - The MetadataType response from the API.
+ * @param {Object} metadataType - A MetadataType from VidiCore.
  * @param {Object} options - Options which change how the metadataType is parsed.
  * @param {string} options.joinValue - String to join the values, eg ','.
  * @param {boolean} options.includeAttributes - Include attributes on all objects.
@@ -843,8 +844,8 @@ var _excluded$2 = ["timespan"];
  * @param {boolean} options.timespanAsList - Return timespans as list.
  * @param {boolean} options.groupAsList - Return groups as list.
  * @param {boolean} options.fieldAsList - Return fields as list.
- * @param {boolean} options.arrayOnSingle=true - Return fields as array even if single field.
- * @param {boolean} options.arrayOnSingleValue=true - Return fields as array even if single field value.
+ * @param {boolean} [options.arrayOnSingle=true] - Return fields as array even if single field.
+ * @param {boolean} [options.arrayOnSingleValue=true] - Return fields as array even if single field value.
  * @returns {Object} Metadata object parsed according to options.
  */
 
@@ -860,7 +861,7 @@ var parseMetadataType = function parseMetadataType() {
   var _ref2 = metadataType || {},
       _ref2$timespan = _ref2.timespan,
       timespanList = _ref2$timespan === void 0 ? [] : _ref2$timespan,
-      attributes = _objectWithoutProperties__default["default"](_ref2, _excluded$2);
+      attributes = _objectWithoutProperties__default["default"](_ref2, _excluded$6);
 
   if (sortTimespan) timespanList.sort(sortTimespanList);
   var timespan = parseTimespanList(timespanList, options);
@@ -885,12 +886,12 @@ function ownKeys$4(object, enumerableOnly) { var keys = Object.keys(object); if
 function _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$4(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$4(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 /**
- * Parses highlight timespan responses from the api into key/value object.
+ * Parses highlight timespan in VidiCore into key/value object.
  * The attributes can be targeted for each sub-type.
- * @param {Object[]} highlightTimespan - A timespan object from the api response.
+ * @param {Object[]} highlightTimespan - A VidiCore timespan object.
  * @param {Object} options - Options which change how the timespans are parsed.
- * @param {boolean} options.arrayOnSingle=true - Return an array if there is a single value.
- * @param {boolean} options.timespanAsList=false - Return timespans as list.
+ * @param {boolean} [options.arrayOnSingle=true] - Return an array if there is a single value.
+ * @param {boolean} [options.timespanAsList=false] - Return timespans as list.
  * @param {string} options.joinValue - String to join the values, eg ','.
  */
 var parseHighlightTimespan = function parseHighlightTimespan() {
@@ -933,38 +934,38 @@ function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if
 
 function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$3(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 /**
- * Parses highlight timespans responses from the api into key/value object.
+ * Parses highlight timespans from VidiCore into key/value object.
  * The attributes can be targeted for each sub-type.
- * @param {Object} highlightTimespanList - A list of timespans from the api response.
+ * @param {Object} highlightTimespanList - A list of timespans from VidiCore.
  * @param {Object} options - Options which change how the timespans are parsed.
- * @param {boolean} options.arrayOnSingle=true - Return an array if there is a single value.
+ * @param {boolean} [options.arrayOnSingle=true] - Return an array if there is a single value.
  * @param {string} options.joinValue - String to join the values, eg ','.
- * @param {boolean} options.timespanAsList=false - Return timespans as list.
- * @param {boolean} options.flat=false - Flatten to field-name/field-value (Note: field-values may be overwritten).
- * @param {boolean} options.flatTimespan=false - Flatten timespan to object with start/end as key.
- * @param {string} options.joinTimespan=_ - Character to join the start/end timecodes.
+ * @param {boolean} [options.timespanAsList=false] - Return timespans as list.
+ * @param {boolean} [options.flat=false] - Flatten to field-name/field-value (Note: field-values may be overwritten).
+ * @param {boolean} [options.flatTimespan=false] - Flatten timespan to object with start/end as key.
+ * @param {string} [options.joinTimespan=_] - Character to join the start/end timecodes.
  */
 
 var parseHighlightTimespanList = function parseHighlightTimespanList() {
   var highlightTimespanList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var flat = opts.flat,
-      timespanAsList = opts.timespanAsList,
-      _opts$joinTimespan = opts.joinTimespan,
-      joinTimespan = _opts$joinTimespan === void 0 ? '_' : _opts$joinTimespan,
-      flatTimespan = opts.flatTimespan;
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var flat = options.flat,
+      timespanAsList = options.timespanAsList,
+      _options$joinTimespan = options.joinTimespan,
+      joinTimespan = _options$joinTimespan === void 0 ? '_' : _options$joinTimespan,
+      flatTimespan = options.flatTimespan;
   if (timespanAsList === true) return highlightTimespanList.map(function (timespan) {
-    return parseHighlightTimespan(timespan, opts);
+    return parseHighlightTimespan(timespan, options);
   });
   if (flat === true || flatTimespan === true) return highlightTimespanList.reduce(function (a, timespan) {
-    return _objectSpread$3(_objectSpread$3({}, a), parseHighlightTimespan(timespan, opts));
+    return _objectSpread$3(_objectSpread$3({}, a), parseHighlightTimespan(timespan, options));
   }, {});
   return highlightTimespanList.reduce(function (a, timespan) {
-    return _objectSpread$3(_objectSpread$3({}, a), {}, _defineProperty__default["default"]({}, [timespan.start, timespan.end].join(joinTimespan), parseHighlightTimespan(timespan, opts)));
+    return _objectSpread$3(_objectSpread$3({}, a), {}, _defineProperty__default["default"]({}, [timespan.start, timespan.end].join(joinTimespan), parseHighlightTimespan(timespan, options)));
   }, {});
 };
 
-var CONSTANT_TIMEBASES = {
+var MAP_CONSTANT_TO_DEN_NUM = {
   PAL: {
     denominator: 25,
     numerator: 1
@@ -984,59 +985,61 @@ var CONSTANT_TIMEBASES = {
   59.94: {
     denominator: 60000,
     numerator: 1001
-  }
-};
-var FRAME_SEPARATORS = {
-  ':': {
-    dropFrame: false,
-    field: 2
-  },
-  ';': {
-    dropFrame: true,
-    field: 2
   },
-  '.': {
-    dropFrame: false,
-    field: 1
+  23.976: {
+    denominator: 48000,
+    numerator: 2002
   },
-  ',': {
-    dropFrame: true,
-    field: 1
+  23.98: {
+    denominator: 48000,
+    numerator: 2002
   }
 };
+var TIME_BASE_CONSTANTS = Object.keys(MAP_CONSTANT_TO_DEN_NUM);
+
+/**
+ * TimeBase class representing the TimeBaseType in VidiCore
+ *
+ * For more info, see the [Time bases section in VidiCore API Docs](https://apidoc.vidispine.com/latest/time.html#time-bases)
+ */
 
 var TimeBase = /*#__PURE__*/function () {
-  function TimeBase() {
-    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+  /**
+   * Constructor for TimeBase
+   *
+   * @param {object} [timeCodeType={}] A time base type object
+   * @param {number} [timeCodeType.numerator=1] The numerator for the TimeBase
+   * @param {number} [timeCodeType.denominator=1] The denominator for the TimeBase
+   */
+  function TimeBase(timeCodeType) {
+    _classCallCheck__default["default"](this, TimeBase);
+
+    var _ref = timeCodeType || {},
         _ref$numerator = _ref.numerator,
         numerator = _ref$numerator === void 0 ? 1 : _ref$numerator,
         _ref$denominator = _ref.denominator,
         denominator = _ref$denominator === void 0 ? 1 : _ref$denominator;
 
-    _classCallCheck__default["default"](this, TimeBase);
-
     this.numerator = Number(numerator);
     this.denominator = Number(denominator);
   }
+  /**
+   * Get TimeBase in a constant representation (e.g. "PAL") if possible, otherwise undefined
+   * @returns {string} Constant representation of the TimeBase
+   */
+
 
   _createClass__default["default"](TimeBase, [{
-    key: "toJSON",
-    value: function toJSON() {
-      return {
-        denominator: this.denominator,
-        numerator: this.numerator
-      };
-    }
-  }, {
     key: "toConstant",
     value: function toConstant() {
       var _this = this;
 
-      var constant;
-      Object.entries(CONSTANT_TIMEBASES).find(function (thisTimeBase) {
-        var _thisTimeBase = _slicedToArray__default["default"](thisTimeBase, 2),
-            thisTimeBaseText = _thisTimeBase[0],
-            thisTimeBaseType = _thisTimeBase[1];
+      var constant; // If multiple equal den/num, it selects first in MAP_CONSTANT_TO_DEN_NUM
+
+      Object.entries(MAP_CONSTANT_TO_DEN_NUM).find(function (timeBaseConstant) {
+        var _timeBaseConstant = _slicedToArray__default["default"](timeBaseConstant, 2),
+            thisTimeBaseText = _timeBaseConstant[0],
+            thisTimeBaseType = _timeBaseConstant[1];
 
         var numerator = thisTimeBaseType.numerator,
             denominator = thisTimeBaseType.denominator;
@@ -1050,18 +1053,36 @@ var TimeBase = /*#__PURE__*/function () {
       });
       return constant;
     }
+    /**
+     * Get TimeBase as a VidiCore TimeBaseType string
+     *
+     * Default format: denominator(:numerator if > 1)
+     * `constant` has precedence over `fraction` if both are true (e.g. NTSC > 30000:1001)
+     *
+     * @param {object} [options={}] For how to display it as text
+     * @param {boolean} [options.constant=false] Show time base as constant (e.g. PAL)
+     * @param {boolean} [options.fraction=false] Show time base as fraction (25:1) even when numerator is 1
+     * @returns {string} Text representation of the TimeBase
+     */
+
   }, {
     key: "toText",
     value: function toText() {
-      var useConstant = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      var _ref2 = options || {},
+          _ref2$constant = _ref2.constant,
+          constant = _ref2$constant === void 0 ? false : _ref2$constant,
+          _ref2$fraction = _ref2.fraction,
+          fraction = _ref2$fraction === void 0 ? false : _ref2$fraction;
 
-      if (useConstant) {
+      if (constant) {
         var _timeBaseText = this.toConstant();
 
         if (_timeBaseText) return _timeBaseText;
       }
 
-      if (this.numerator > 1) {
+      if (fraction || this.numerator > 1) {
         var _timeBaseText2 = [this.denominator, this.numerator].join(':');
 
         return _timeBaseText2;
@@ -1070,13 +1091,40 @@ var TimeBase = /*#__PURE__*/function () {
       var timeBaseText = String(this.denominator);
       return timeBaseText;
     }
+    /**
+     * Output TimeBase as frame rate (by default max 16 decimal places)
+     *
+     *
+     * For `options.fixed`:
+     * - `true` gives two decimal places
+     * - `false` gives max amount of decimal places
+     * - `number` gives that amount of decimal places
+     *
+     * Default format: rate with two decimals if needed (i.e. decimals are > 0)
+     * Option precedence (when all true): `constant` > `rounded` > `fixed`
+     *
+     * @param {object} [options={}] For how to display it as rate
+     * @param {boolean|number} [options.fixed=true] Amount of decimal places (true gives 2 decimal places)
+     * @param {boolean} [options.constant=false] Use constant representation (if applicable)
+     * @param {boolean} [options.rounded=false] Rounded to nearest integer
+     *
+     * @returns {number} Rate of the TimeBase
+     */
+
   }, {
     key: "toRate",
     value: function toRate() {
-      var useConstant = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var round = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      var _ref3 = options || {},
+          _ref3$constant = _ref3.constant,
+          constant = _ref3$constant === void 0 ? false : _ref3$constant,
+          _ref3$rounded = _ref3.rounded,
+          rounded = _ref3$rounded === void 0 ? false : _ref3$rounded,
+          _ref3$fixed = _ref3.fixed,
+          fixed = _ref3$fixed === void 0 ? true : _ref3$fixed;
 
-      if (useConstant) {
+      if (constant) {
         var _rate = this.toConstant();
 
         if (_rate) return _rate;
@@ -1088,56 +1136,110 @@ var TimeBase = /*#__PURE__*/function () {
         return rate;
       }
 
-      return round ? rate.toFixed(2) : rate;
+      if (rounded) {
+        return Math.round(rate);
+      }
+
+      if (fixed === true || typeof fixed === 'number') {
+        return Number(rate.toFixed(fixed === true ? 2 : fixed));
+      }
+
+      return rate;
+    }
+    /**
+     * Get TimeBase in a object representation
+     *
+     * @returns {object} TimeBase as `{denominator, numerator}` object
+     */
+
+  }, {
+    key: "toObject",
+    value: function toObject() {
+      return {
+        denominator: this.denominator,
+        numerator: this.numerator
+      };
+    }
+    /**
+     * @deprecated Use {@link TimeBase#toObject|toObject} instead
+     *
+     * @returns {object} TimeBase as `{denominator, numerator}` object
+     */
+
+  }, {
+    key: "toJson",
+    value: function toJson() {
+      // eslint-disable-next-line no-console
+      console.warn('Deprecated - use toObject instead');
+      return this.toObject();
     }
   }]);
 
   return TimeBase;
 }();
 
-var formatTimeBaseType = function formatTimeBaseType(timeBase) {
-  return new TimeBase(timeBase);
-};
+/**
+ * Format a string representation of a time base to a TimeBase Instance
+ *
+ * @param {string} timeBaseText The string to format to a TimeBase instance
+ * @returns {TimeBase} A TimeBase Instance
+ */
 
 var formatTimeBaseText = function formatTimeBaseText(timeBaseText) {
   if (timeBaseText === undefined) {
-    return formatTimeBaseType();
+    return new TimeBase();
   }
 
   if (typeof timeBaseText === 'number') {
-    return formatTimeBaseType({
+    return new TimeBase({
       denominator: timeBaseText
     });
   }
 
-  if (timeBaseText.includes(':')) {
+  if (typeof timeBaseText === 'string' && timeBaseText.includes(':')) {
     var _timeBaseText$split = timeBaseText.split(':'),
         _timeBaseText$split2 = _slicedToArray__default["default"](_timeBaseText$split, 2),
-        _denominator = _timeBaseText$split2[0],
+        denominator = _timeBaseText$split2[0],
         numerator = _timeBaseText$split2[1];
 
-    return formatTimeBaseType({
-      denominator: _denominator,
+    return new TimeBase({
+      denominator: denominator,
       numerator: numerator
     });
   }
 
-  if (Object.keys(CONSTANT_TIMEBASES).includes(timeBaseText)) {
-    return formatTimeBaseType(CONSTANT_TIMEBASES[timeBaseText]);
+  if (TIME_BASE_CONSTANTS.includes(timeBaseText)) {
+    return new TimeBase(MAP_CONSTANT_TO_DEN_NUM[timeBaseText]);
   }
 
-  var denominator = Number(timeBaseText);
-
-  if (Number.isNaN(denominator)) {
-    throw new Error("timeBaseText must be a number or ".concat(Object.keys(CONSTANT_TIMEBASES).join(','), " - is ").concat(timeBaseText));
+  if (!['string', 'number'].includes(_typeof__default["default"](timeBaseText)) || Number.isNaN(Number(timeBaseText))) {
+    throw new Error("timeBaseText must be a number or ".concat(TIME_BASE_CONSTANTS.join(','), " - is ").concat(JSON.stringify(timeBaseText)));
   }
 
-  return formatTimeBaseType({
-    denominator: denominator
+  return new TimeBase({
+    denominator: Number(timeBaseText)
   });
 };
 
-var formatTimeBase = function formatTimeBase(timeBase) {
+/**
+ * Create a TimeBase instance of an object
+ *
+ * @param {object} timeBase A TimeBase object ({ numerator, denominator })
+ * @returns {TimeBase} A TimeBase instance
+ */
+
+var formatTimeBaseType = function formatTimeBaseType(timeBase) {
+  return new TimeBase(timeBase);
+};
+
+/**
+ * Create a TimeBase Instance from a string or object representation of a time base
+ *
+ * @param {string|object} timeBase Expressed as "denominator:numerator" or { numerator, denominator }
+ * @returns {TimeBase} A TimeBase instance
+ */
+
+var createTimeBase = function createTimeBase(timeBase) {
   if (_typeof__default["default"](timeBase) === 'object') {
     return formatTimeBaseType(timeBase);
   }
@@ -1145,47 +1247,86 @@ var formatTimeBase = function formatTimeBase(timeBase) {
   return formatTimeBaseText(timeBase);
 };
 
-var getDropFrames$1 = function getDropFrames(roundedFrameRate) {
-  return roundedFrameRate === 60 ? 4 : 2;
+/**
+ * @private
+ *
+ * Drops 4 frames (0-3) for 59.97 and 2 frames (0-1) for 29.97/NTSC
+ *
+ * @param {TimeBase} timeBase to check
+ * @returns {number} amount of frame drops for specified timeBase
+ */
+var getAmountOfFrameDrops = function getAmountOfFrameDrops(timeBase) {
+  var timeBaseConstant = timeBase.toRate({
+    constant: true
+  });
+  return timeBaseConstant === '59.94' && 4 || ['NTSC', '29.97'].includes(timeBaseConstant) && 2 || 0;
 };
 
-var getRoundedFrameRate$1 = function getRoundedFrameRate(timeBase) {
-  return Math.round(timeBase.denominator / timeBase.numerator);
+/**
+ * @private
+ *
+ * Check if TimeBase drops frames
+ *
+ * @param {object} timeBase TimeBase Instance to check
+ * @returns {boolean} true if time base drops frames, false otherwise
+ */
+
+var isDropFrameTimeBase = function isDropFrameTimeBase(timeBase) {
+  return getAmountOfFrameDrops(timeBase) > 0;
 };
 
-function countDroppedFrames(frames, roundedFrameRate) {
-  var dropFrames = getDropFrames$1(roundedFrameRate);
-  var oneMinuteUndroppedFrames = 60 * roundedFrameRate;
-  var oneMinuteDroppedFrames = 60 * roundedFrameRate - dropFrames;
-  var tenMinuteFrames = 10 * (oneMinuteUndroppedFrames - dropFrames) + dropFrames;
-  var tenMinuteChunks = Math.floor(frames / tenMinuteFrames);
-  var minuteRemainder = Math.max(0, frames % tenMinuteFrames - oneMinuteUndroppedFrames);
-  var oneMinuteChunks = Math.floor(minuteRemainder / oneMinuteDroppedFrames);
-  var frameRemainder = minuteRemainder % oneMinuteDroppedFrames;
-  var frameChunks = frameRemainder > 0 ? dropFrames : 0;
-  return tenMinuteChunks * 9 * dropFrames + oneMinuteChunks * dropFrames + frameChunks;
-}
+var _excluded$5 = ["hours"];
 
-var isDropFrameTimeBase = function isDropFrameTimeBase(_ref) {
-  var numerator = _ref.numerator,
-      denominator = _ref.denominator;
-  return numerator === 1001 && (denominator === 60000 || denominator === 30000);
+var getDroppedFramesFromSamples = function getDroppedFramesFromSamples(_ref) {
+  var samples = _ref.samples,
+      timeBase = _ref.timeBase;
+  var amountOfFrameDrops = getAmountOfFrameDrops(timeBase);
+  if (amountOfFrameDrops === 0) return 0;
+  var roundedFrameRate = timeBase.toRate({
+    rounded: true
+  });
+  var oneMinuteNotDroppedFrames = 60 * roundedFrameRate;
+  var amountOfFramesToDropPerMinute = 60 * roundedFrameRate - amountOfFrameDrops;
+  var tenMinuteFrames = 10 * (oneMinuteNotDroppedFrames - amountOfFrameDrops) + amountOfFrameDrops;
+  var amountOfTenMinuteChunks = Math.floor((samples + 1) / tenMinuteFrames);
+  var minuteRemainder = Math.max(0, (samples + 1) % tenMinuteFrames - oneMinuteNotDroppedFrames);
+  var amountOfOneMinuteReminderChunks = Math.floor(minuteRemainder / amountOfFramesToDropPerMinute);
+  var frameRemainder = minuteRemainder % amountOfFramesToDropPerMinute;
+  var amountOfFrameRemainderChunks = frameRemainder > 0 ? amountOfFrameDrops : 0;
+  return amountOfTenMinuteChunks * 9 * amountOfFrameDrops + amountOfOneMinuteReminderChunks * amountOfFrameDrops + amountOfFrameRemainderChunks;
 };
+/**
+ * TimeCode class representing the TimeCodeType in VidiCore
+ *
+ * For more info, see the [Time Codes section of VidiCore API Docs](https://apidoc.vidispine.com/latest/time.html#time-codes)
+ */
+
 
 var TimeCode = /*#__PURE__*/function () {
+  /**
+   * Constructor for TimeCode
+   *
+   * @param {object} [timeCodeType={}] Object to create TimeCode of
+   * @param {number} [timeCodeType.samples=0] Amount of samples for the time code
+   * @param {object|string|number} [timeCodeType.timeBase={numerator: 1, denominator: 1}] The time base it should have
+   * @param {object} [options={}] Options for the timeCode
+   * @param {boolean} options.dropFrame If time code should be dropFrame or not (by default checks timeBase)
+   * @param {string} options.frameSeparator Separator to use for frame smpte output (default ":" for non-drop-frame and ";" for dropFrame)
+   */
   function TimeCode() {
-    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        _ref2$samples = _ref2.samples,
-        samples = _ref2$samples === void 0 ? 0 : _ref2$samples,
-        timeBase = _ref2.timeBase;
+    var _options$dropFrame, _options$frameSeparat;
 
-    var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        dropFrame = _ref3.dropFrame,
-        _ref3$field = _ref3.field,
-        field = _ref3$field === void 0 ? 2 : _ref3$field;
+    var timeCodeType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
     _classCallCheck__default["default"](this, TimeCode);
 
+    var _ref2 = timeCodeType || {},
+        _ref2$samples = _ref2.samples,
+        samples = _ref2$samples === void 0 ? 0 : _ref2$samples,
+        _ref2$timeBase = _ref2.timeBase,
+        timeBase = _ref2$timeBase === void 0 ? new TimeBase() : _ref2$timeBase;
+
     if (typeof samples === 'number') {
       this.samples = samples;
     } else if (typeof samples === 'string') {
@@ -1200,21 +1341,39 @@ var TimeCode = /*#__PURE__*/function () {
       throw new Error("samples is not number/string/-Inf/+Inf is: ".concat(samples));
     }
 
-    this.timeBase = new TimeBase(timeBase);
-    this.dropFrame = dropFrame === undefined ? isDropFrameTimeBase(this.timeBase) : dropFrame;
-    this.field = field;
+    this.timeBase = createTimeBase(timeBase);
+    this.dropFrame = (_options$dropFrame = options === null || options === void 0 ? void 0 : options.dropFrame) !== null && _options$dropFrame !== void 0 ? _options$dropFrame : isDropFrameTimeBase(this.timeBase);
+    this.frameSeparator = (_options$frameSeparat = options === null || options === void 0 ? void 0 : options.frameSeparator) !== null && _options$frameSeparat !== void 0 ? _options$frameSeparat : this.dropFrame ? ';' : ':';
   }
+  /**
+   * Return this TimeCode added with the supplied timeCodeType
+   * If time bases differ, it will retain the time base of this TimeCode instance
+   * If supplied time code has a more granular time base - it will round down exceeding samples (hasn't reached that sample yet)
+   *
+   * Note: This might make you "lose" frames depending on granularity of time bases, e.g.
+   * "51@50".add("25@25") => "101@50"
+   * while "25@25".add("51@50") => "50@25" (not "101@50")
+   *
+   * @param {TimeCode} timeCodeType A TimeCode instance you want to add with
+   * @returns A new TimeCode instance with the addition applied
+   */
+
 
   _createClass__default["default"](TimeCode, [{
     key: "add",
-    value: function add(val) {
-      var _val$timeBase = val.timeBase,
-          numerator = _val$timeBase.numerator,
-          denominator = _val$timeBase.denominator;
-      var conformedTimeCode = val;
+    value: function add(timeCodeType) {
+      if (!(timeCodeType !== null && timeCodeType !== void 0 && timeCodeType.timeBase) || (timeCodeType === null || timeCodeType === void 0 ? void 0 : timeCodeType.samples) === undefined) {
+        throw Error('Invalid timeCodeType, cannot be added');
+      }
+
+      var _timeCodeType$timeBas = timeCodeType.timeBase;
+      _timeCodeType$timeBas = _timeCodeType$timeBas === void 0 ? {} : _timeCodeType$timeBas;
+      var numerator = _timeCodeType$timeBas.numerator,
+          denominator = _timeCodeType$timeBas.denominator;
+      var conformedTimeCode = timeCodeType;
 
       if (numerator !== this.timeBase.numerator || denominator !== this.timeBase.denominator) {
-        conformedTimeCode = val.conformTimeBase(this.timeBase);
+        conformedTimeCode = timeCodeType.conformTimeBase(this.timeBase);
       }
 
       var _conformedTimeCode = conformedTimeCode,
@@ -1224,16 +1383,34 @@ var TimeCode = /*#__PURE__*/function () {
         timeBase: this.timeBase
       });
     }
+    /**
+     * Return this TimeCode subtracted with the supplied timeCodeType
+     * If time bases differ, it will retain the time base of the instance time code
+     * If supplied time code has a more granular time base - it will round down exceeding samples (hasn't reached that sample yet)
+     *
+     * Note: This might make you "lose" frames depending on granularity of time bases, e.g.
+     * "101@50".subtract("25@25") => "51@50"
+     * while "50@25".subtract("51@50") => "25@25" (not "49@50")
+     *
+     * @param {TimeCode} timeCodeType A TimeCode instance you want to subtract with
+     * @returns A new TimeCode instance with the subtraction applied
+     */
+
   }, {
     key: "subtract",
-    value: function subtract(val) {
-      var _val$timeBase2 = val.timeBase,
-          numerator = _val$timeBase2.numerator,
-          denominator = _val$timeBase2.denominator;
-      var conformedTimeCode = val;
+    value: function subtract(timeCodeType) {
+      if (!(timeCodeType !== null && timeCodeType !== void 0 && timeCodeType.timeBase) || (timeCodeType === null || timeCodeType === void 0 ? void 0 : timeCodeType.samples) === undefined) {
+        throw Error('Invalid timeCodeType, cannot be subtracted');
+      }
+
+      var _timeCodeType$timeBas2 = timeCodeType.timeBase;
+      _timeCodeType$timeBas2 = _timeCodeType$timeBas2 === void 0 ? {} : _timeCodeType$timeBas2;
+      var numerator = _timeCodeType$timeBas2.numerator,
+          denominator = _timeCodeType$timeBas2.denominator;
+      var conformedTimeCode = timeCodeType;
 
       if (numerator !== this.timeBase.numerator || denominator !== this.timeBase.denominator) {
-        conformedTimeCode = val.conformTimeBase(this.timeBase);
+        conformedTimeCode = timeCodeType.conformTimeBase(this.timeBase);
       }
 
       var _conformedTimeCode2 = conformedTimeCode,
@@ -1243,361 +1420,765 @@ var TimeCode = /*#__PURE__*/function () {
         timeBase: this.timeBase
       });
     }
+    /**
+     * Creates a new TimeCode instance with specified timeBase and samples adjusted to that.
+     *
+     * If it conforms to a less granular time base - it will floor samples (hasn't reached that sample yet)
+     * - e.g. "51@50".conformTo("PAL") => "25@PAL" (not "26@PAL")
+     *
+     * @param {string|object} conformTo The TimeBase it should conform the TimeCode to
+     * @returns A new TimeCode instance with the conformTo timeBase applied
+     */
+
   }, {
     key: "conformTimeBase",
     value: function conformTimeBase(conformTo) {
-      var timeBase = conformTo;
+      var conformToTimeBase = conformTo;
 
-      if (conformTo instanceof TimeCode === false) {
-        timeBase = new TimeBase(conformTo);
+      if (!(conformTo instanceof TimeBase)) {
+        conformToTimeBase = createTimeBase(conformTo);
       }
 
-      var samples = Math.round(this.samples / (this.timeBase.toRate(false, false) / timeBase.toRate(false, false)));
+      var samples = Math.floor(this.samples / (this.timeBase.toRate({
+        fixed: false
+      }) / conformToTimeBase.toRate({
+        fixed: false
+      })));
       var timeCode = {
         samples: samples,
-        timeBase: timeBase
+        timeBase: conformToTimeBase
       };
       return new TimeCode(timeCode);
     }
-  }, {
-    key: "toJSON",
-    value: function toJSON() {
-      return {
-        samples: this.samples,
-        timeBase: this.timeBase
-      };
-    }
+    /**
+     * Get TimeCode as a text representation
+     *
+     * Default format: samples@denominator(:numerator if > 1)
+     * `constant` has precedence over `fraction` if both are true
+     *
+     * @param {object} [options={}] TimeBase toText options
+     * @param {boolean} [options.includeTimeBaseForSeconds=false] include time base even if seconds
+     * @param {boolean} [options.constant=false] show as constant (e.g. @PAL)
+     * @param {boolean} [options.fraction=false] show as fraction (@25:1)
+     * @returns Text representation of TimeCode
+     */
+
   }, {
     key: "toText",
     value: function toText() {
-      var timeCodeText = String(this.samples);
-      var timeBaseText = this.timeBase.toText();
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var timeCodeText = "".concat(this.samples);
+      var timeBaseText = this.timeBase.toText(options);
 
-      if (timeBaseText !== '1') {
+      if (options !== null && options !== void 0 && options.includeTimeBaseForSeconds || !['1', '1:1'].includes(timeBaseText)) {
         timeCodeText = [this.samples, timeBaseText].join('@');
       }
 
       return timeCodeText;
     }
+    /**
+     *  Get TimeCode in a units object representation
+     *
+     * @returns {object} in the format { hours, minutes, seconds, frames }
+     */
+
   }, {
-    key: "toSeconds",
-    value: function toSeconds() {
-      var _this$timeBase = this.timeBase,
-          numerator = _this$timeBase.numerator,
-          denominator = _this$timeBase.denominator;
-      return this.samples * (numerator / denominator);
+    key: "toUnits",
+    value: function toUnits() {
+      var totalSamples = this.samples + (this.dropFrame ? getDroppedFramesFromSamples(this) : 0);
+      var roundedFrameRate = this.timeBase.toRate({
+        rounded: true
+      }); // Calculated without drop-frame but with 2 decimal places
+
+      if (['23.976', '23.98'].includes(this.timeBase.toConstant())) {
+        roundedFrameRate = this.timeBase.toRate({
+          fixed: true
+        });
+      }
+
+      var hours = Math.floor(totalSamples / (3600 * roundedFrameRate));
+      var minutes = Math.floor(totalSamples / (60 * roundedFrameRate)) % 60;
+      var seconds = Math.floor(totalSamples / roundedFrameRate) % 60;
+      var frames = Math.floor(totalSamples % roundedFrameRate);
+      return {
+        hours: hours,
+        minutes: minutes,
+        seconds: seconds,
+        frames: frames
+      };
     }
+    /**
+     * Get TimeCode in a time object representation
+     * "milliseconds" is rounded down, if you want another representation use "partialSeconds"
+     *
+     * @returns {object} in the format { hours, minutes, seconds, milliseconds, partialSeconds }
+     */
+
   }, {
     key: "toTime",
     value: function toTime() {
-      var roundedFrameRate = getRoundedFrameRate$1(this.timeBase);
-      var totalSamples = this.samples + (this.dropFrame ? countDroppedFrames(this.samples + 1, roundedFrameRate) : 0);
-      var hours = Math.floor(totalSamples / (3600 * roundedFrameRate));
-      var minutes = Math.floor(totalSamples / (60 * roundedFrameRate)) % 60;
-      var seconds = Math.floor(totalSamples / roundedFrameRate) % 60;
-      var frames = totalSamples % roundedFrameRate;
-      var partialSeconds = frames / roundedFrameRate;
+      var totalSamples = this.samples + getDroppedFramesFromSamples(this);
+
+      var _this$toUnits = this.toUnits(),
+          hours = _this$toUnits.hours,
+          minutes = _this$toUnits.minutes,
+          seconds = _this$toUnits.seconds;
+
+      var roundedFrameRate = this.timeBase.toRate({
+        rounded: true
+      });
+      var framesPrecise = totalSamples % roundedFrameRate;
+      var milliseconds = Math.floor(1000 * framesPrecise / roundedFrameRate);
+      var partialSeconds = framesPrecise / roundedFrameRate;
       return {
         hours: hours,
         minutes: minutes,
         seconds: seconds,
-        frames: frames,
+        milliseconds: milliseconds,
         partialSeconds: partialSeconds
       };
     }
+    /**
+     * Get TimeCode in a seconds representation
+     *
+     * @returns {number} the seconds
+     */
+
+  }, {
+    key: "toSeconds",
+    value: function toSeconds() {
+      var _this$timeBase = this.timeBase,
+          numerator = _this$timeBase.numerator,
+          denominator = _this$timeBase.denominator;
+      return Math.round(1000 * +(this.samples * numerator / denominator)) / 1000;
+    }
+    /**
+     * Get TimeCode in a duration representation
+     * The time unit char keys for the format string are:
+     * - "h" for hour
+     * - "m" for minute
+     * - "s" for seconds
+     * - "S" for milliseconds
+     * Any other char will be kept in the duration output string.
+     *
+     * Add consecutive chars for zero padding.
+     *
+     * By default it:
+     * - uses colon delimiter (e.g. for format "hhmmss")
+     * - shows "m:ss" or "h:mm:ss" if format is undefined
+     *
+     * @param {object} [options={}]
+     * @param {string} options.format specify format of duration string, e.g. hh:mm:ss.S for 01:23:04.5
+     * @returns {string} Duration representation of the TimeCode
+     */
+
   }, {
     key: "toDuration",
     value: function toDuration() {
-      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          format = _ref4.format;
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var format = options.format;
 
       var _this$toTime = this.toTime(),
           hours = _this$toTime.hours,
-          minutes = _this$toTime.minutes,
-          seconds = _this$toTime.seconds;
+          rest = _objectWithoutProperties__default["default"](_this$toTime, _excluded$5);
 
-      if (typeof format === 'string') {
-        if (format.toLowerCase() === 'hhmmss') {
-          return [hours.toFixed().padStart(2, '0'), minutes.toFixed().padStart(2, '0'), seconds.toFixed().padStart(2, '0')].join(':');
-        }
+      var minutes = rest.minutes,
+          seconds = rest.seconds,
+          milliseconds = rest.milliseconds;
+
+      if (!!format && typeof format !== 'string') {
+        throw Error('format has to be a string');
       }
 
-      if (hours) {
-        return [hours.toFixed(), minutes.toFixed().padStart(2, '0'), seconds.toFixed().padStart(2, '0')].join(':');
+      var isBefore = function isBefore(unit, units) {
+        return !format.includes(unit) || !units.some(function (u) {
+          return format.includes(u) && format.lastIndexOf(unit) > format.indexOf(u);
+        });
+      };
+
+      if (!!format && !(isBefore('h', ['m', 's', 'S']) && isBefore('m', ['s', 'S']) && isBefore('s', ['S']))) {
+        throw Error('format order is unsupported (has to be h, m, s then S)');
       }
 
-      if (minutes >= 10) {
-        return [minutes.toFixed().padStart(2, '0'), seconds.toFixed().padStart(2, '0')].join(':');
+      if (!format) {
+        return "".concat(hours > 0 ? "".concat(hours, ":").concat("".concat(minutes).padStart(2, '0')) : minutes, ":").concat("".concat(seconds).padStart(2, '0'));
       }
 
-      return [minutes.toFixed(), seconds.toFixed().padStart(2, '0')].join(':');
+      var countConsecutiveChars = function countConsecutiveChars(i, arr) {
+        var j = i;
+
+        while (arr[j] === arr[j + 1]) {
+          j += 1;
+        }
+
+        return j - i + 1;
+      };
+
+      var timeUnitKeys = ['h', 'm', 's', 'S'];
+      var output = [];
+
+      _toConsumableArray__default["default"](format).forEach(function (c, i, arr) {
+        switch (c) {
+          case 'h':
+            {
+              if (arr[i - 1] === 'h') {
+                break;
+              }
+
+              var amount = countConsecutiveChars(i, arr);
+              output.push("".concat(hours).padStart(amount, '0'));
+
+              if (timeUnitKeys.includes(arr[i + amount])) {
+                output.push(':');
+              }
+
+              break;
+            }
+
+          case 'm':
+            {
+              if (arr[i - 1] === 'm') {
+                break;
+              }
+
+              var _amount = countConsecutiveChars(i, arr);
+
+              if (!format.includes('h')) {
+                minutes *= hours * 60;
+              }
+
+              output.push("".concat(minutes).padStart(_amount, '0'));
+
+              if (timeUnitKeys.includes(arr[i + _amount])) {
+                output.push(':');
+              }
+
+              break;
+            }
+
+          case 's':
+            {
+              if (arr[i - 1] === 's') {
+                break;
+              }
+
+              var _amount2 = countConsecutiveChars(i, arr);
+
+              if (!format.includes('m')) {
+                seconds *= minutes * 60;
+              }
+
+              output.push("".concat(seconds).padStart(_amount2, '0'));
+
+              if (timeUnitKeys.includes(arr[i + _amount2])) {
+                output.push('.');
+              }
+
+              break;
+            }
+
+          case 'S':
+            {
+              if (arr[i - 1] === 'S') {
+                break;
+              }
+
+              var _amount3 = countConsecutiveChars(i, arr);
+
+              if (!format.includes('s')) {
+                milliseconds *= seconds * 1000;
+              }
+
+              output.push("".concat(Math.round(milliseconds / Math.pow(10, 3 - _amount3))).padStart(_amount3, '0'));
+              break;
+            }
+
+          default:
+            output.push(c);
+        }
+      });
+
+      return output.join('');
     }
+    /**
+     * Get TimeCode in a smpte representation
+     *
+     * @returns {string} Smpte representation of the TimeCode
+     */
+
   }, {
     key: "toSmpte",
     value: function toSmpte() {
-      var _this = this;
-
       if (this.samples === -Infinity) return '00:00:00:00';
 
-      var _this$toTime2 = this.toTime(),
-          hours = _this$toTime2.hours,
-          minutes = _this$toTime2.minutes,
-          seconds = _this$toTime2.seconds,
-          frames = _this$toTime2.frames;
+      var _this$toUnits2 = this.toUnits(),
+          hours = _this$toUnits2.hours,
+          minutes = _this$toUnits2.minutes,
+          seconds = _this$toUnits2.seconds,
+          frames = _this$toUnits2.frames;
 
       var hhmmss = [hours.toFixed().padStart(2, '0'), minutes.toFixed().padStart(2, '0'), seconds.toFixed().padStart(2, '0')].join(':');
+      return [hhmmss, "".concat(frames).padStart(2, '0')].join(this.frameSeparator);
+    }
+    /**
+     * Get TimeCode as a VidiCore TimeCodeType object
+     *
+     * @returns {object} TimeCode as `{ samples, timeBase }`
+     */
 
-      var _Object$entries$find = Object.entries(FRAME_SEPARATORS).find(function (thisSeparator) {
-        var _thisSeparator = _slicedToArray__default["default"](thisSeparator, 2),
-            _thisSeparator$ = _thisSeparator[1],
-            dropFrame = _thisSeparator$.dropFrame,
-            field = _thisSeparator$.field;
-
-        return dropFrame === _this.dropFrame && field === _this.field;
-      }),
-          _Object$entries$find2 = _slicedToArray__default["default"](_Object$entries$find, 1),
-          _Object$entries$find3 = _Object$entries$find2[0],
-          frameSeparator = _Object$entries$find3 === void 0 ? ':' : _Object$entries$find3;
-
-      return [hhmmss, frames.toFixed().padStart(2, '0')].join(frameSeparator);
+  }, {
+    key: "toObject",
+    value: function toObject() {
+      return {
+        samples: this.samples,
+        timeBase: this.timeBase.toObject()
+      };
     }
+    /**
+     * @deprecated Use {@link TimeCode#toObject|toObject} instead
+     *
+     * @returns {object} TimeCode as `{ samples, timeBase }`
+     */
+
   }, {
-    key: "toFraction",
-    value: function toFraction() {
-      return "".concat(this.samples, "@").concat(this.timeBase.denominator, ":").concat(this.timeBase.numerator);
+    key: "toJson",
+    value: function toJson() {
+      // eslint-disable-next-line no-console
+      console.warn('Deprecated - use toObject instead');
+      return this.toObject();
     }
   }]);
 
   return TimeCode;
 }();
 
-var formatTimeCodeType = function formatTimeCodeType(timeCode, options) {
-  return new TimeCode(timeCode, options);
-};
-
-var formatTimeCodeText = function formatTimeCodeText(timeCodeText, options) {
-  if (timeCodeText === undefined) {
-    var _timeCode = {
-      samples: 0
-    };
-    return formatTimeCodeType(_timeCode, options);
-  }
+/* eslint-disable no-self-assign */
 
-  if (typeof timeCodeText === 'number') {
-    var _timeCode2 = {
-      samples: timeCodeText
-    };
-    return formatTimeCodeType(_timeCode2, options);
+/**
+ * @private
+ *
+ * Using Euclid's algorithm
+ *
+ * @param {number} num1 a number
+ * @param {number} num2 another number
+ * @returns {number} the greatest common divisor as a number
+ */
+var getGreatestCommonDivisor = function getGreatestCommonDivisor(num1, num2) {
+  var a = Math.abs(num1);
+  var b = Math.abs(num2);
+
+  while (a && b && a !== b) {
+    if (a > b) {
+      var _ref = [a - b, b];
+      a = _ref[0];
+      b = _ref[1];
+    } else {
+      var _ref2 = [a, b - a];
+      a = _ref2[0];
+      b = _ref2[1];
+    }
   }
 
-  if (timeCodeText.includes('@')) {
-    var _timeCodeText$split = timeCodeText.split('@'),
-        _timeCodeText$split2 = _slicedToArray__default["default"](_timeCodeText$split, 2),
-        samplesString = _timeCodeText$split2[0],
-        timeBaseText = _timeCodeText$split2[1];
-
-    var _samples = Number(samplesString);
-
-    var timeBase = formatTimeBaseText(timeBaseText);
-    var _timeCode3 = {
-      samples: _samples,
-      timeBase: timeBase
-    };
-    return formatTimeCodeType(_timeCode3, options);
-  }
+  return a || b;
+};
 
-  if (timeCodeText === '-INF') {
-    var _samples2 = -Infinity;
+var _excluded$4 = ["timeBase", "useGCD"];
+/**
+ * Format seconds to TimeCode object
+ * Input time base is always 1:1 since it expects seconds as input
+ *
+ * Note: Max 15 digits accuracy (double precision float64), e.g.
+ * - 10^6 seconds can have 10^9 decimals (nanosecond) precision
+ * - 10^9 seconds can have 10^6 decimals (microsecond) precision
+ * - 10^12 seconds can have 10^3 decimals (millisecond) precision
+ *
+ * @param {string|number} seconds With or without decimals ("." and "," are both interpreted as decimal)
+ * @param {object} [options={}] Options for how to format the seconds to a TimeCode
+ * @param {object|string} options.timeBase What TimeBase the resulting TimeCode should have (if unset and useGCD=false, denominator will be 10^<amount-of-decimals>)
+ * @param {boolean} [options.useGCD=false] Samples and denominator are divided with GCD (ignored if timeBase is set) (e.g. 1.04 => 104@100 => 26@25)
+ * @returns {TimeCode} A TimeCode instance
+ */
 
-    var _timeCode4 = {
-      samples: _samples2
-    };
-    return formatTimeCodeType(_timeCode4, options);
-  }
+var formatTimeCodeSeconds = function formatTimeCodeSeconds(seconds) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-  if (timeCodeText === '+INF') {
-    var _samples3 = Infinity;
-    var _timeCode5 = {
-      samples: _samples3
-    };
-    return formatTimeCodeType(_timeCode5, options);
-  }
+  var timeBase = options.timeBase,
+      _options$useGCD = options.useGCD,
+      useGCD = _options$useGCD === void 0 ? false : _options$useGCD,
+      timeCodeOptions = _objectWithoutProperties__default["default"](options, _excluded$4);
 
-  var samples = Number(timeCodeText);
+  var secondsWithDot = "".concat(seconds).replace(/,/g, '.');
+  var amountOfDigits = secondsWithDot.replace('.', '').length;
 
-  if (Number.isNaN(samples)) {
-    throw new Error("timeBaseText must be a number or sample@timeBase - is ".concat(timeCodeText));
+  if (amountOfDigits > 16) {
+    throw new Error("Amount of second digits cannot be more than 16, is ".concat(amountOfDigits));
   }
 
-  var timeCode = {
-    samples: samples
-  };
-  return formatTimeCodeType(timeCode, options);
-};
-
-var formatSeconds = function formatSeconds(seconds, timeBase, options) {
-  if (Number.isNaN(Number(seconds))) {
+  if (Number.isNaN(+secondsWithDot)) {
     throw new Error("seconds must be digits, is ".concat(seconds));
   }
 
-  var _ref = timeBase || {},
-      _ref$denominator = _ref.denominator,
-      denominator = _ref$denominator === void 0 ? 1 : _ref$denominator,
-      _ref$numerator = _ref.numerator,
-      numerator = _ref$numerator === void 0 ? 1 : _ref$numerator;
+  var denominator = 1;
+  var samples;
 
-  var samples = seconds * (denominator / numerator);
-  var timeCode = {
-    samples: samples,
-    timeBase: timeBase || {}
-  };
-  return new TimeCode(timeCode, options);
-};
-
-var formatSecondsPrecise = function formatSecondsPrecise(seconds, timeBase, options) {
-  if (Number.isNaN(Number(seconds))) {
-    throw new Error("seconds must be digits, is ".concat(seconds));
-  }
-
-  var _ref = timeBase || {},
-      _ref$numerator = _ref.numerator,
-      numerator = _ref$numerator === void 0 ? 1 : _ref$numerator;
+  if (Number.isInteger(+secondsWithDot)) {
+    samples = +secondsWithDot * denominator;
+  } else {
+    var _ms$length;
 
-  var _ref2 = timeBase || {},
-      _ref2$denominator = _ref2.denominator,
-      denominator = _ref2$denominator === void 0 ? 1 : _ref2$denominator;
+    var _secondsWithDot$split = secondsWithDot.split('.'),
+        _secondsWithDot$split2 = _slicedToArray__default["default"](_secondsWithDot$split, 2),
+        ms = _secondsWithDot$split2[1];
 
-  if (!Number.isInteger(seconds)) {
-    var decimalPlaces = String(seconds).split('.')[1].length;
+    var decimalPlaces = Math.min((_ms$length = ms === null || ms === void 0 ? void 0 : ms.length) !== null && _ms$length !== void 0 ? _ms$length : 0, 16);
     denominator *= Math.pow(10, decimalPlaces);
+    samples = Math.round(secondsWithDot * denominator);
   }
 
-  var samples = (seconds * (denominator / numerator)).toFixed();
-  var timeCode = {
+  if (!timeBase && useGCD) {
+    var gcd = getGreatestCommonDivisor(denominator, samples);
+    samples /= gcd;
+    denominator /= gcd;
+  }
+
+  var timeCode = new TimeCode({
     samples: samples,
     timeBase: {
       denominator: denominator,
-      numerator: numerator
+      numerator: 1
     }
-  };
-  return new TimeCode(timeCode, options);
+  }, timeCodeOptions);
+  return timeBase ? timeCode.conformTimeBase(createTimeBase(timeBase === true ? 1 : timeBase)) : timeCode;
 };
 
+var _excluded$3 = ["exceedingMode", "timeBase"];
+
 function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$2(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-var getDropFrames = function getDropFrames(roundedFrameRate) {
-  return roundedFrameRate === 60 ? 4 : 2;
+var MAP_SEPARATOR_TO_OPTIONS = {
+  ':': {
+    dropFrame: false,
+    frameSeparator: ':'
+  },
+  '.': {
+    dropFrame: false,
+    frameSeparator: '.'
+  },
+  ';': {
+    dropFrame: true,
+    frameSeparator: ';'
+  },
+  ',': {
+    dropFrame: true,
+    frameSeparator: ','
+  }
 };
+var getDroppedFramesFromSmpte = function getDroppedFramesFromSmpte(_ref, samples, timeBase) {
+  var _ref2 = _slicedToArray__default["default"](_ref, 4),
+      hh = _ref2[0],
+      mm = _ref2[1],
+      ss = _ref2[2],
+      ff = _ref2[3];
+
+  var roundedFrameRate = timeBase.toRate({
+    rounded: true
+  });
+  var dropFrames = getAmountOfFrameDrops(timeBase);
+
+  if (samples === 0 || dropFrames === 0) {
+    return 0;
+  }
 
-var getRoundedFrameRate = function getRoundedFrameRate(timeBase) {
-  return Math.round(timeBase.denominator / timeBase.numerator);
+  var shouldDropMinute = mm % 10 !== 0;
+  var shouldDropSecond = shouldDropMinute && ss === 0;
+  var hourFrames = hh * (3600 * roundedFrameRate - 54 * dropFrames);
+  var minuteFrames = mm * 60 * roundedFrameRate - (mm - Math.ceil(mm / 10)) * dropFrames;
+  var secondFrames = ss * roundedFrameRate - (shouldDropMinute && ss > 1 ? dropFrames : 0);
+
+  if (shouldDropSecond && ff < dropFrames) {
+    throw new Error("Frame does not exist for ".concat(timeBase.toRate({
+      constant: true
+    }), " drop-frame"));
+  }
+
+  var frameFrames = shouldDropSecond ? ff - dropFrames : ff;
+  var samplesWithoutDroppedFrames = hourFrames + minuteFrames + secondFrames + frameFrames;
+  return samples - samplesWithoutDroppedFrames;
 };
 
-var splitSmpte = function splitSmpte(smpteText) {
-  var hasDropFrameSeparator = smpteText.match(/[^0-9:\-_]/);
-  var hhmmssff;
-  var frameOptions = {};
+var splitSmpte = function splitSmpte(smpte) {
+  var _ref3 = (smpte === null || smpte === void 0 ? void 0 : smpte.match(/[^0-9:\-_]/)) || [],
+      _ref4 = _slicedToArray__default["default"](_ref3, 1),
+      nonColonFrameSeparator = _ref4[0];
 
-  if (hasDropFrameSeparator) {
-    var _hasDropFrameSeparato = _slicedToArray__default["default"](hasDropFrameSeparator, 1),
-        frameSeparator = _hasDropFrameSeparato[0];
+  var smpteValues = [];
+  var options = {
+    frameSeparator: ':',
+    dropFrame: false
+  };
 
-    var _smpteText$split = smpteText.split(frameSeparator),
-        _smpteText$split2 = _slicedToArray__default["default"](_smpteText$split, 2),
-        hhmmss = _smpteText$split2[0],
-        splitFrames = _smpteText$split2[1];
+  if (nonColonFrameSeparator) {
+    var _smpte$split = smpte.split(nonColonFrameSeparator),
+        _smpte$split2 = _slicedToArray__default["default"](_smpte$split, 2),
+        hhmmss = _smpte$split2[0],
+        ff = _smpte$split2[1];
 
-    hhmmssff = [].concat(_toConsumableArray__default["default"](hhmmss.split(':')), [splitFrames]);
-    frameOptions = FRAME_SEPARATORS[frameSeparator] || {};
+    smpteValues = [].concat(_toConsumableArray__default["default"](hhmmss.split(':')), [ff]);
+    options = MAP_SEPARATOR_TO_OPTIONS[nonColonFrameSeparator] || {};
   } else {
-    hhmmssff = smpteText.split(':');
+    smpteValues = smpte.split(':');
   }
 
-  hhmmssff = hhmmssff.map(Number);
+  smpteValues = smpteValues.map(Number);
 
-  if (hhmmssff.length > 4 || hhmmssff.some(function (n) {
+  if (smpteValues.length !== 4) {
+    throw new Error('Invalid format, must be "##:##:##:##');
+  }
+
+  if (smpteValues.some(function (n) {
     return Number.isNaN(n);
   })) {
-    throw new Error('Invalid SMPTE timecode');
+    throw new Error('Invalid format, values must be numbers');
   }
 
-  return [hhmmssff, frameOptions];
+  return [smpteValues, options];
 };
 
-var countSamples = function countSamples(hh, mm, ss, ff, _ref) {
-  var dropFrame = _ref.dropFrame,
-      roundedFrameRate = _ref.roundedFrameRate;
+var getSamplesFromSmpte = function getSamplesFromSmpte(smpteValues, timeBase, dropFrame) {
+  var _smpteValues = _slicedToArray__default["default"](smpteValues, 4),
+      hh = _smpteValues[0],
+      mm = _smpteValues[1],
+      ss = _smpteValues[2],
+      ff = _smpteValues[3];
+
+  var roundedFrameRate = timeBase.toRate({
+    rounded: true
+  });
+  var samples = hh * 3600 * roundedFrameRate + mm * 60 * roundedFrameRate + ss * roundedFrameRate + ff;
+  return samples - (dropFrame ? getDroppedFramesFromSmpte(smpteValues, samples, timeBase) : 0);
+}; // Better naming than "useValueExcess" and "useValueTruncate" must exist
+
+
+var EXCEEDING_OPTIONS = ['error', 'add', 'ignore'];
+/**
+ * Format smpte text to a TimeCode Instance
+ *
+ * exceedingMode:
+ * - "overflow" exceeding values will be kept (e.g. PAL and 00:00:00:25 => 00:00:01:00)
+ * - "truncate" exceeding values will be truncated (e.g. PAL and 00:00:00:25 => 00:00:00:24)
+ * - "error" exceeding values will throw error (e.g. PAL and 00:00:00:25 => Error)
+ *
+ * @param {string} smpte String representation of smpte
+ * @param {object} [options={}] What options to use for creating the time code from smpte (all not specified below are passed to the TimeCode constructor)
+ * @param {object|string|number} options.timeBase TimeBase of smpte (and consequently TimeBase of output TimeCode)
+ * @param {string} [options.exceedingMode=error] How to handle exceeding values (`overflow|truncate|error`)
+ * @param {boolean} options.dropFrame If it should parse and create time code using dropFrame
+ * @param {string} options.frameSeparator What frame separator the TimeCode should store (defaults to what the smpte has)
+ * @returns {TimeCode} A TimeCode instance
+ */
+
+var formatTimeCodeSmpte = function formatTimeCodeSmpte(smpte) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-  if (!dropFrame) {
-    return hh * 3600 * roundedFrameRate + mm * 60 * roundedFrameRate + ss * roundedFrameRate + ff;
+  var _options$exceedingMod = options.exceedingMode,
+      exceedingMode = _options$exceedingMod === void 0 ? 'error' : _options$exceedingMod,
+      timeBase = options.timeBase,
+      timeCodeOptions = _objectWithoutProperties__default["default"](options, _excluded$3);
+
+  if ([null, undefined].includes(smpte)) {
+    throw new Error("smpte cannot be undefined or null");
   }
 
-  if (![30, 60].includes(roundedFrameRate)) {
-    throw new Error('Cannot use dropframe with non NTSC timebase');
+  if (typeof smpte !== 'string') {
+    throw new Error("smpte must be a string, is ".concat(JSON.stringify(smpte)));
   }
 
-  var dropFrames = getDropFrames(roundedFrameRate);
-  var shouldDropMinute = mm % 10 !== 0;
-  var shouldDropSecond = shouldDropMinute && ss === 0;
-  var hourFrames = hh * (3600 * roundedFrameRate - 54 * dropFrames);
-  var minuteFrames = mm * 60 * roundedFrameRate - (mm - Math.ceil(mm / 10)) * dropFrames;
-  var secondFrames = ss * roundedFrameRate - (shouldDropMinute && ss > 1 ? dropFrames : 0);
+  var _splitSmpte = splitSmpte(smpte),
+      _splitSmpte2 = _slicedToArray__default["default"](_splitSmpte, 2),
+      smpteValues = _splitSmpte2[0],
+      timeCodeOptionsFromSmpte = _splitSmpte2[1];
 
-  if (shouldDropSecond && ff < dropFrames) {
-    throw new Error('Invalid ff');
+  var timeBaseInstance = createTimeBase(timeBase);
+
+  var mergedOptions = _objectSpread$2(_objectSpread$2({}, timeCodeOptionsFromSmpte), {}, {
+    dropFrame: isDropFrameTimeBase(timeBaseInstance)
+  }, timeCodeOptions);
+
+  var roundedFrameRate = timeBaseInstance.toRate({
+    rounded: true
+  });
+  var maxFrame = Math.max(0, roundedFrameRate - 1);
+
+  if (smpteValues.some(function (v) {
+    return v < 0;
+  })) {
+    throw new Error('Negative values are not supported');
   }
 
-  var frameFrames = shouldDropSecond ? ff - dropFrames : ff;
-  return hourFrames + minuteFrames + secondFrames + frameFrames;
+  var samples;
+
+  switch (exceedingMode) {
+    case 'error':
+      {
+        var _smpteValues2 = _slicedToArray__default["default"](smpteValues, 4),
+            hours = _smpteValues2[0],
+            minutes = _smpteValues2[1],
+            seconds = _smpteValues2[2],
+            frames = _smpteValues2[3];
+
+        if (hours >= 100) {
+          throw Error('Minutes has to be less than 60');
+        }
+
+        if (minutes >= 60) {
+          throw Error('Minutes has to be less than 60');
+        }
+
+        if (seconds >= 60) {
+          throw Error('Seconds has to be less than 60');
+        }
+
+        if (frames > maxFrame) {
+          throw Error("Frames has to be less or equal to ".concat(maxFrame));
+        }
+
+        samples = getSamplesFromSmpte(smpteValues, timeBaseInstance, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.dropFrame);
+        break;
+      }
+
+    case 'ignore':
+      {
+        var _smpteValues3 = _slicedToArray__default["default"](smpteValues, 4),
+            _hours = _smpteValues3[0],
+            _minutes = _smpteValues3[1],
+            _seconds = _smpteValues3[2],
+            _frames = _smpteValues3[3];
+
+        var truncatedSmpteValues = [Math.min(100, _hours), Math.min(59, _minutes), Math.min(59, _seconds), Math.min(maxFrame, _frames)];
+        samples = getSamplesFromSmpte(truncatedSmpteValues, timeBaseInstance, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.dropFrame);
+        break;
+      }
+
+    case 'add':
+      {
+        samples = getSamplesFromSmpte(smpteValues, timeBaseInstance, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.dropFrame);
+        break;
+      }
+
+    default:
+      {
+        throw new Error("Invalid exceedingMode, options are ".concat(JSON.stringify(EXCEEDING_OPTIONS)));
+      }
+  }
+
+  return new TimeCode({
+    samples: samples,
+    timeBase: timeBaseInstance
+  }, mergedOptions);
 };
 
-var formatSmpte = function formatSmpte(smpteText, timeBaseText) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+var _excluded$2 = ["timeBase"];
+/**
+ * Format text to a TimeCode instance
+ *
+ * @param {string} timeCodeText A time code text (e.g. "25@PAL")
+ * @param {object} [options={}] Options for how to format
+ * @param {object|string} options.timeBase The time base the returned TimeCode should have
+ * @returns {TimeCode} A TimeCode instance
+ */
 
-  if (smpteText === undefined) {
-    var _timeBase = formatTimeBase(timeBaseText);
+var formatTimeCodeText = function formatTimeCodeText(timeCodeText, options) {
+  var _timeCodeObject;
+
+  var _ref = options || {},
+      timeBase = _ref.timeBase,
+      timeCodeOptions = _objectWithoutProperties__default["default"](_ref, _excluded$2);
 
-    var _timeCode = {
-      samples: 0,
-      timeBase: _timeBase
+  var timeCodeObject;
+
+  if (timeCodeText === undefined) {
+    timeCodeObject = {
+      samples: 0
+    };
+  } else if (typeof timeCodeText === 'number') {
+    timeCodeObject = {
+      samples: timeCodeText
+    };
+  } else if (timeCodeText.includes('@')) {
+    var _timeCodeText$split = timeCodeText.split('@'),
+        _timeCodeText$split2 = _slicedToArray__default["default"](_timeCodeText$split, 2),
+        samplesString = _timeCodeText$split2[0],
+        timeBaseText = _timeCodeText$split2[1];
+
+    var samples = Number(samplesString);
+    timeCodeObject = {
+      samples: samples,
+      timeBase: formatTimeBaseText(timeBaseText)
+    };
+  } else if (timeCodeText === '-INF') {
+    timeCodeObject = {
+      samples: -Infinity
+    };
+  } else if (timeCodeText === '+INF') {
+    timeCodeObject = {
+      samples: Infinity
+    };
+  } else {
+    timeCodeObject = {
+      samples: Number(timeCodeText)
     };
-    return formatTimeCodeType(_timeCode);
   }
 
-  if (typeof smpteText !== 'string') {
-    throw new Error("smpteText must be a string, is ".concat(smpteText));
+  if (Number.isNaN((_timeCodeObject = timeCodeObject) === null || _timeCodeObject === void 0 ? void 0 : _timeCodeObject.samples) || timeCodeObject.timeBase && !(timeCodeObject.timeBase instanceof TimeBase)) {
+    throw new Error("timeCodeText must be a number or sample@timeBase - is ".concat(timeCodeText));
   }
 
-  var _splitSmpte = splitSmpte(smpteText),
-      _splitSmpte2 = _slicedToArray__default["default"](_splitSmpte, 2),
-      _splitSmpte2$ = _slicedToArray__default["default"](_splitSmpte2[0], 4),
-      hh = _splitSmpte2$[0],
-      mm = _splitSmpte2$[1],
-      ss = _splitSmpte2$[2],
-      _splitSmpte2$$ = _splitSmpte2$[3],
-      ff = _splitSmpte2$$ === void 0 ? 0 : _splitSmpte2$$,
-      frameOptions = _splitSmpte2[1];
-
-  var _frameOptions$dropFra = frameOptions.dropFrame,
-      dropFrame = _frameOptions$dropFra === void 0 ? false : _frameOptions$dropFra;
-  var timeBase = formatTimeBase(timeBaseText);
-  var roundedFrameRate = getRoundedFrameRate(timeBase);
-
-  if (mm >= 60 || mm < 0 || ss >= 60 || ss < 0 || ff >= roundedFrameRate || ff < 0) {
-    throw new Error('Invalid mm, ss or ff');
-  }
-
-  var samples = countSamples(hh, mm, ss, ff, {
-    dropFrame: dropFrame,
-    roundedFrameRate: roundedFrameRate
-  });
-  var timeCode = {
-    samples: samples,
-    timeBase: timeBase
-  };
-  return formatTimeCodeType(timeCode, _objectSpread$2(_objectSpread$2({}, frameOptions), options));
+  var timeCode = new TimeCode(timeCodeObject, timeCodeOptions);
+  return timeBase ? timeCode.conformTimeBase(createTimeBase(timeBase)) : timeCode;
+};
+
+/**
+ * Format an object to a TimeCode instance
+ *
+ * @param {object} timeCode To create TimeCode instance of
+ * @param {object} options For the TimeCode constructor
+ * @returns {TimeCode} A TimeCode instance
+ */
+
+var formatTimeCodeType = function formatTimeCodeType(timeCode, options) {
+  return new TimeCode(timeCode, options);
+};
+
+var isObject = function isObject(o) {
+  return Object.prototype.toString.call(o) === '[object Object]';
+};
+
+var isString = function isString(s) {
+  return typeof s === 'string';
+};
+
+var hasSmpteFormat = function hasSmpteFormat(s) {
+  return isString(s) && !!s.match(/^(\d\d+):(\d\d+):(\d\d+)(:|;|\.|,)(\d\d+)$/);
+};
+
+var isNumber = function isNumber(s) {
+  return !Number.isNaN(Number(s));
+};
+/**
+ * Create a TimeCode instance from smpte, seconds/samples, timeCode object or string
+ *
+ * @param {object|string|number} timeCode Smpte, seconds/samples, timeCode object or string
+ * @param {object} [options={}] For the format functions
+ * @returns {TimeCode} A TimeCode instance
+ */
+
+
+var createTimeCode = function createTimeCode(timeCode, options) {
+  if (isObject(timeCode)) return formatTimeCodeType(timeCode, options);
+  if (hasSmpteFormat(timeCode)) return formatTimeCodeSmpte(timeCode, options);
+  if (isNumber(timeCode)) return formatTimeCodeSeconds(timeCode, options);
+  return formatTimeCodeText(timeCode, options);
 };
 
 function timeToCueTime(_ref) {
@@ -1617,10 +2198,10 @@ function timeToCueTime(_ref) {
 }
 /**
  * Convert subtitle groups to WebVtt subtitle format
- * @param {Object} input={}
+ * @param {Object} [input={}]
  * @param {Object} input.metadataType - MetadataType response from API.
- * @param {string} input.subtitleGroup=stl_subtitle - Name of group containing subtitle field/text.
- * @param {string} input.subtitleField=stl_text - Name of field (text) to use for the subtitles.
+ * @param {string} [input.subtitleGroup=stl_subtitle] - Name of group containing subtitle field/text.
+ * @param {string} [input.subtitleField=stl_text] - Name of field (text) to use for the subtitles.
  * @returns {string} WebVtt subtitles
  */
 
@@ -1815,12 +2396,13 @@ var parseContainerComponent = function parseContainerComponent(containerComponen
   }
 
   if (durationTimeCode !== undefined && durationTimeCode.samples !== 0) {
-    parsedContainerComponent.durationTimeCode = formatTimeCodeType(durationTimeCode);
-    parsedContainerComponent.duration = parsedContainerComponent.durationTimeCode.toDuration();
+    var timeCode = formatTimeCodeType(durationTimeCode);
+    parsedContainerComponent.durationTimeCode = timeCode.toObject();
+    parsedContainerComponent.duration = timeCode.toDuration();
   }
 
   if (startTimestamp) {
-    parsedContainerComponent.startTimestamp = formatTimeCodeType(startTimestamp);
+    parsedContainerComponent.startTimestamp = formatTimeCodeType(startTimestamp).toObject();
   }
 
   if (startTimecode !== undefined && timeCodeTimeBase) {
@@ -1892,8 +2474,10 @@ var parseVideoComponent = function parseVideoComponent(videoComponent) {
       samples: samples,
       timeBase: timeBase
     });
-    frameRate = timeCode.timeBase.toRate(true);
-    smpte = timeCode.toSmpte(true);
+    frameRate = timeCode.timeBase.toRate({
+      constant: true
+    });
+    smpte = timeCode.toSmpte();
   }
 
   var height = resolution.height,
@@ -2274,7 +2858,9 @@ var parseMediaConvertPreset = function parseMediaConvertPreset(transcodePresetTy
         numerator: numerator
       });
       output.timeBase = timeBase;
-      output.frameRate = timeBase.toRate(true);
+      output.frameRate = timeBase.toRate({
+        constant: true
+      });
     }
   }
 
@@ -2319,7 +2905,9 @@ var parseTranscodePreset = function parseTranscodePreset(transcodePresetType) {
     if (video.framerate) {
       var timeBase = formatTimeBaseType(video.framerate);
       output.timeBase = timeBase;
-      output.frameRate = timeBase.toRate(true);
+      output.frameRate = timeBase.toRate({
+        constant: true
+      });
     }
 
     if (video.scaling) {
@@ -2372,14 +2960,14 @@ exports.TimeBase = TimeBase;
 exports.TimeCode = TimeCode;
 exports.createFacetType = createFacetType;
 exports.createMetadataType = createMetadataType;
+exports.createTimeBase = createTimeBase;
+exports.createTimeCode = createTimeCode;
 exports.filterShapeSource = filterShapeSource;
 exports.findNearestThumbnail = findNearestThumbnail;
-exports.formatSeconds = formatSeconds;
-exports.formatSecondsPrecise = formatSecondsPrecise;
-exports.formatSmpte = formatSmpte;
-exports.formatTimeBase = formatTimeBase;
 exports.formatTimeBaseText = formatTimeBaseText;
 exports.formatTimeBaseType = formatTimeBaseType;
+exports.formatTimeCodeSeconds = formatTimeCodeSeconds;
+exports.formatTimeCodeSmpte = formatTimeCodeSmpte;
 exports.formatTimeCodeText = formatTimeCodeText;
 exports.formatTimeCodeType = formatTimeCodeType;
 exports.getDocumentType = getDocumentType;