@nmshd/runtime 2.5.5 → 2.6.0

package/lib-web/nmshd.runtime.js

@@ -548,11 +548,11 @@ const content_1 = __webpack_require__(/*! @nmshd/content */ "@nmshd/content");
 const crypto_1 = __webpack_require__(/*! @nmshd/crypto */ "@nmshd/crypto");
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
 exports.buildInformation = {
-    version: "2.5.5",
-    build: "160",
-    date: "2023-08-02T15:11:53+00:00",
-    commit: "abc570f47c30c4f6bba2e25c7e8ce8cd1fe3e34e",
-    dependencies: {"@js-soft/docdb-querytranslator":"1.1.0","@js-soft/logging-abstractions":"1.0.0","@js-soft/ts-serval":"2.0.9","@js-soft/ts-utils":"^2.3.1","@nmshd/consumption":"3.2.2","@nmshd/content":"2.3.6","@nmshd/crypto":"2.0.4","@nmshd/transport":"2.0.5","ajv":"^8.12.0","ajv-errors":"^3.0.0","ajv-formats":"^2.1.1","json-stringify-safe":"^5.0.1","lodash":"^4.17.21","luxon":"^3.3.0","qrcode":"1.5.3","reflect-metadata":"0.1.13","ts-simple-nameof":"1.3.1","typescript-ioc":"3.2.2"},
+    version: "2.6.0",
+    build: "161",
+    date: "2023-08-14T11:46:35+00:00",
+    commit: "3bc0a7d1b8c05d5706f9b4cac0b63d689287a732",
+    dependencies: {"@js-soft/docdb-querytranslator":"1.1.0","@js-soft/logging-abstractions":"1.0.0","@js-soft/ts-serval":"2.0.9","@js-soft/ts-utils":"^2.3.1","@nmshd/consumption":"3.2.2","@nmshd/content":"2.3.6","@nmshd/crypto":"2.0.4","@nmshd/transport":"2.0.5","ajv":"^8.12.0","ajv-errors":"^3.0.0","ajv-formats":"^2.1.1","json-stringify-safe":"^5.0.1","lodash":"^4.17.21","luxon":"^3.4.0","qrcode":"1.5.3","reflect-metadata":"0.1.13","ts-simple-nameof":"1.3.1","typescript-ioc":"3.2.2"},
     libraries: {
         serval: ts_serval_1.buildInformation,
         consumption: consumption_1.buildInformation,
@@ -32824,7 +32824,7 @@ let GetDeviceInfoUseCase = exports.GetDeviceInfoUseCase = class GetDeviceInfoUse
     }
     executeInternal() {
         const device = this.deviceController.device;
-        return ts_utils_1.Result.ok(DeviceMapper_1.DeviceMapper.toDeviceDTO(device));
+        return ts_utils_1.Result.ok(DeviceMapper_1.DeviceMapper.toDeviceDTO(device, true));
     }
 };
 exports.GetDeviceInfoUseCase = GetDeviceInfoUseCase = __decorate([
@@ -33578,7 +33578,7 @@ let CreateDeviceUseCase = exports.CreateDeviceUseCase = class CreateDeviceUseCas
     async executeInternal(request) {
         const device = await this.devicesController.sendDevice(request);
         await this.accountController.syncDatawallet();
-        return ts_utils_1.Result.ok(DeviceMapper_1.DeviceMapper.toDeviceDTO(device));
+        return ts_utils_1.Result.ok(DeviceMapper_1.DeviceMapper.toDeviceDTO(device, false));
     }
 };
 exports.CreateDeviceUseCase = CreateDeviceUseCase = __decorate([
@@ -33735,7 +33735,7 @@ exports.DeviceMapper = void 0;
 const crypto_1 = __webpack_require__(/*! @nmshd/crypto */ "@nmshd/crypto");
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
 class DeviceMapper {
-    static toDeviceDTO(device) {
+    static toDeviceDTO(device, isCurrentDevice) {
         return {
             id: device.id.toString(),
             createdAt: device.createdAt.toString(),
@@ -33747,7 +33747,8 @@ class DeviceMapper {
             description: device.description,
             lastLoginAt: device.lastLoginAt?.toString(),
             operatingSystem: device.operatingSystem,
-            publicKey: device.publicKey?.toBase64(false)
+            publicKey: device.publicKey?.toBase64(false),
+            isCurrentDevice: isCurrentDevice
         };
     }
     static toDeviceOnboardingInfoDTO(deviceSharedSecret) {
@@ -33834,22 +33835,27 @@ Validator = __decorate([
     __metadata("design:paramtypes", [common_1.SchemaRepository])
 ], Validator);
 let GetDeviceUseCase = exports.GetDeviceUseCase = class GetDeviceUseCase extends common_1.UseCase {
-    constructor(devicesController, validator) {
+    constructor(devicesController, deviceController, validator) {
         super(validator);
         this.devicesController = devicesController;
+        this.deviceController = deviceController;
     }
     async executeInternal(request) {
         const device = await this.devicesController.get(transport_1.CoreId.from(request.id));
         if (!device) {
             return ts_utils_1.Result.fail(common_1.RuntimeErrors.general.recordNotFound(transport_1.Device));
         }
-        return ts_utils_1.Result.ok(DeviceMapper_1.DeviceMapper.toDeviceDTO(device));
+        const currentDevice = this.deviceController.device;
+        const isCurrentDevice = device.id.equals(currentDevice.id);
+        return ts_utils_1.Result.ok(DeviceMapper_1.DeviceMapper.toDeviceDTO(device, isCurrentDevice));
     }
 };
 exports.GetDeviceUseCase = GetDeviceUseCase = __decorate([
     __param(0, typescript_ioc_1.Inject),
     __param(1, typescript_ioc_1.Inject),
+    __param(2, typescript_ioc_1.Inject),
     __metadata("design:paramtypes", [transport_1.DevicesController,
+        transport_1.DeviceController,
         Validator])
 ], GetDeviceUseCase);
 //# sourceMappingURL=GetDevice.js.map
@@ -33940,19 +33946,23 @@ const typescript_ioc_1 = __webpack_require__(/*! typescript-ioc */ "./node_modul
 const common_1 = __webpack_require__(/*! ../../common */ "./dist/useCases/common/index.js");
 const DeviceMapper_1 = __webpack_require__(/*! ./DeviceMapper */ "./dist/useCases/transport/devices/DeviceMapper.js");
 let GetDevicesUseCase = exports.GetDevicesUseCase = class GetDevicesUseCase extends common_1.UseCase {
-    constructor(devicesController) {
+    constructor(devicesController, deviceController) {
         super();
         this.devicesController = devicesController;
+        this.deviceController = deviceController;
     }
     async executeInternal() {
         const devices = await this.devicesController.list();
-        const deviceDTOs = devices.map((device) => DeviceMapper_1.DeviceMapper.toDeviceDTO(device));
+        const currentDevice = this.deviceController.device;
+        const deviceDTOs = devices.map((device) => DeviceMapper_1.DeviceMapper.toDeviceDTO(device, device.id.equals(currentDevice.id)));
         return ts_utils_1.Result.ok(deviceDTOs);
     }
 };
 exports.GetDevicesUseCase = GetDevicesUseCase = __decorate([
     __param(0, typescript_ioc_1.Inject),
-    __metadata("design:paramtypes", [transport_1.DevicesController])
+    __param(1, typescript_ioc_1.Inject),
+    __metadata("design:paramtypes", [transport_1.DevicesController,
+        transport_1.DeviceController])
 ], GetDevicesUseCase);
 //# sourceMappingURL=GetDevices.js.map
 
@@ -33995,31 +34005,36 @@ Validator = __decorate([
     __metadata("design:paramtypes", [common_1.SchemaRepository])
 ], Validator);
 let UpdateDeviceUseCase = exports.UpdateDeviceUseCase = class UpdateDeviceUseCase extends common_1.UseCase {
-    constructor(devicesController, accountController, validator) {
+    constructor(devicesController, accountController, deviceController, validator) {
         super(validator);
         this.devicesController = devicesController;
         this.accountController = accountController;
+        this.deviceController = deviceController;
     }
     async executeInternal(request) {
         const device = await this.devicesController.get(transport_1.CoreId.from(request.id));
         if (!device) {
             return ts_utils_1.Result.fail(common_1.RuntimeErrors.general.recordNotFound(transport_1.Device));
         }
-        if (request.name) {
+        if (typeof request.name !== "undefined") {
             device.name = request.name;
         }
         device.description = request.description;
         await this.devicesController.update(device);
         await this.accountController.syncDatawallet();
-        return ts_utils_1.Result.ok(DeviceMapper_1.DeviceMapper.toDeviceDTO(device));
+        const currentDevice = this.deviceController.device;
+        const isCurrentDevice = device.id.equals(currentDevice.id);
+        return ts_utils_1.Result.ok(DeviceMapper_1.DeviceMapper.toDeviceDTO(device, isCurrentDevice));
     }
 };
 exports.UpdateDeviceUseCase = UpdateDeviceUseCase = __decorate([
     __param(0, typescript_ioc_1.Inject),
     __param(1, typescript_ioc_1.Inject),
     __param(2, typescript_ioc_1.Inject),
+    __param(3, typescript_ioc_1.Inject),
     __metadata("design:paramtypes", [transport_1.DevicesController,
         transport_1.AccountController,
+        transport_1.DeviceController,
         Validator])
 ], UpdateDeviceUseCase);
 //# sourceMappingURL=UpdateDevice.js.map
@@ -67946,7 +67961,7 @@ function intlConfigString(localeStr, numberingSystem, outputCalendar) {
 function mapMonths(f) {
   const ms = [];
   for (let i = 1; i <= 12; i++) {
-    const dt = DateTime.utc(2016, i, 1);
+    const dt = DateTime.utc(2009, i, 1);
     ms.push(f(dt));
   }
   return ms;
@@ -67959,8 +67974,8 @@ function mapWeekdays(f) {
   }
   return ms;
 }
-function listStuff(loc, length, defaultOK, englishFn, intlFn) {
-  const mode = loc.listingMode(defaultOK);
+function listStuff(loc, length, englishFn, intlFn) {
+  const mode = loc.listingMode();
   if (mode === "error") {
     return null;
   } else if (mode === "en") {
@@ -68206,8 +68221,8 @@ class Locale {
       defaultToEN: false
     });
   }
-  months(length, format = false, defaultOK = true) {
-    return listStuff(this, length, defaultOK, months, () => {
+  months(length, format = false) {
+    return listStuff(this, length, months, () => {
       const intl = format ? {
           month: length,
           day: "numeric"
@@ -68221,8 +68236,8 @@ class Locale {
       return this.monthsCache[formatStr][length];
     });
   }
-  weekdays(length, format = false, defaultOK = true) {
-    return listStuff(this, length, defaultOK, weekdays, () => {
+  weekdays(length, format = false) {
+    return listStuff(this, length, weekdays, () => {
       const intl = format ? {
           weekday: length,
           year: "numeric",
@@ -68238,8 +68253,8 @@ class Locale {
       return this.weekdaysCache[formatStr][length];
     });
   }
-  meridiems(defaultOK = true) {
-    return listStuff(this, undefined, defaultOK, () => meridiems, () => {
+  meridiems() {
+    return listStuff(this, undefined, () => meridiems, () => {
       // In theory there could be aribitrary day periods. We're gonna assume there are exactly two
       // for AM and PM. This is probably wrong, but it's makes parsing way easier.
       if (!this.meridiemCache) {
@@ -68252,8 +68267,8 @@ class Locale {
       return this.meridiemCache;
     });
   }
-  eras(length, defaultOK = true) {
-    return listStuff(this, length, defaultOK, eras, () => {
+  eras(length) {
+    return listStuff(this, length, eras, () => {
       const intl = {
         era: length
       };
@@ -68457,7 +68472,7 @@ function normalizeZone(input, defaultZone) {
     if (lowered === "default") return defaultZone;else if (lowered === "local" || lowered === "system") return SystemZone.instance;else if (lowered === "utc" || lowered === "gmt") return FixedOffsetZone.utcInstance;else return FixedOffsetZone.parseSpecifier(lowered) || IANAZone.create(input);
   } else if (isNumber(input)) {
     return FixedOffsetZone.instance(input);
-  } else if (typeof input === "object" && input.offset && typeof input.offset === "number") {
+  } else if (typeof input === "object" && "offset" in input && typeof input.offset === "function") {
     // This is dumb, but the instanceof check above doesn't seem to really work
     // so we're duck checking it
     return input;
@@ -68574,10 +68589,10 @@ class Settings {
   /**
    * Set the cutoff year after which a string encoding a year as two digits is interpreted to occur in the current century.
    * @type {number}
-   * @example Settings.twoDigitCutoffYear = 0 // cut-off year is 0, so all 'yy' are interpretted as current century
+   * @example Settings.twoDigitCutoffYear = 0 // cut-off year is 0, so all 'yy' are interpreted as current century
    * @example Settings.twoDigitCutoffYear = 50 // '49' -> 1949; '50' -> 2050
-   * @example Settings.twoDigitCutoffYear = 1950 // interpretted as 50
-   * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpretted as 50
+   * @example Settings.twoDigitCutoffYear = 1950 // interpreted as 50
+   * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpreted as 50
    */
   static set twoDigitCutoffYear(cutoffYear) {
     twoDigitCutoffYear = cutoffYear % 100;
@@ -68744,7 +68759,7 @@ function daysInMonth(year, month) {
   }
 }
 
-// covert a calendar object to a local timestamp (epoch, but with the offset baked in)
+// convert a calendar object to a local timestamp (epoch, but with the offset baked in)
 function objToLocalTS(obj) {
   let d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond);
 
@@ -69046,33 +69061,24 @@ class Formatter {
     });
     return df.format();
   }
-  formatDateTime(dt, opts = {}) {
-    const df = this.loc.dtFormatter(dt, {
+  dtFormatter(dt, opts = {}) {
+    return this.loc.dtFormatter(dt, {
       ...this.opts,
       ...opts
     });
-    return df.format();
   }
-  formatDateTimeParts(dt, opts = {}) {
-    const df = this.loc.dtFormatter(dt, {
-      ...this.opts,
-      ...opts
-    });
-    return df.formatToParts();
+  formatDateTime(dt, opts) {
+    return this.dtFormatter(dt, opts).format();
   }
-  formatInterval(interval, opts = {}) {
-    const df = this.loc.dtFormatter(interval.start, {
-      ...this.opts,
-      ...opts
-    });
+  formatDateTimeParts(dt, opts) {
+    return this.dtFormatter(dt, opts).formatToParts();
+  }
+  formatInterval(interval, opts) {
+    const df = this.dtFormatter(interval.start, opts);
     return df.dtf.formatRange(interval.start.toJSDate(), interval.end.toJSDate());
   }
-  resolvedOptions(dt, opts = {}) {
-    const df = this.loc.dtFormatter(dt, {
-      ...this.opts,
-      ...opts
-    });
-    return df.resolvedOptions();
+  resolvedOptions(dt, opts) {
+    return this.dtFormatter(dt, opts).resolvedOptions();
   }
   num(n, p = 0) {
     // we get some perf out of doing this here, annoyingly
@@ -69126,7 +69132,7 @@ class Formatter {
         era: length
       }, "era"),
       tokenToString = token => {
-        // Where possible: http://cldr.unicode.org/translation/date-time-1/date-time#TOC-Standalone-vs.-Format-Styles
+        // Where possible: https://cldr.unicode.org/translation/date-time/date-time-symbols
         switch (token) {
           // ms
           case "S":
@@ -69715,19 +69721,19 @@ function clone$1(dur, alts, clear = false) {
   };
   return new Duration(conf);
 }
-function antiTrunc(n) {
-  return n < 0 ? Math.floor(n) : Math.ceil(n);
+
+// this is needed since in some test cases it would return 0.9999999999999999 instead of 1
+function removePrecisionIssue(a) {
+  return Math.trunc(a * 1e3) / 1e3;
 }
 
 // NB: mutates parameters
 function convert(matrix, fromMap, fromUnit, toMap, toUnit) {
   const conv = matrix[toUnit][fromUnit],
     raw = fromMap[fromUnit] / conv,
-    sameSign = Math.sign(raw) === Math.sign(toMap[toUnit]),
-    // ok, so this is wild, but see the matrix in the tests
-    added = !sameSign && toMap[toUnit] !== 0 && Math.abs(raw) <= 1 ? antiTrunc(raw) : Math.trunc(raw);
-  toMap[toUnit] += added;
-  fromMap[fromUnit] -= added * conv;
+    added = Math.floor(raw);
+  toMap[toUnit] = removePrecisionIssue(toMap[toUnit] + added);
+  fromMap[fromUnit] = removePrecisionIssue(fromMap[fromUnit] - added * conv);
 }
 
 // NB: mutates parameters
@@ -70126,21 +70132,13 @@ class Duration {
       suppressSeconds: false,
       includePrefix: false,
       format: "extended",
-      ...opts
+      ...opts,
+      includeOffset: false
     };
-    const value = this.shiftTo("hours", "minutes", "seconds", "milliseconds");
-    let fmt = opts.format === "basic" ? "hhmm" : "hh:mm";
-    if (!opts.suppressSeconds || value.seconds !== 0 || value.milliseconds !== 0) {
-      fmt += opts.format === "basic" ? "ss" : ":ss";
-      if (!opts.suppressMilliseconds || value.milliseconds !== 0) {
-        fmt += ".SSS";
-      }
-    }
-    let str = value.toFormat(fmt);
-    if (opts.includePrefix) {
-      str = "T" + str;
-    }
-    return str;
+    const dateTime = DateTime.fromMillis(millis, {
+      zone: "UTC"
+    });
+    return dateTime.toISOTime(opts);
   }
 
   /**
@@ -70164,7 +70162,15 @@ class Duration {
    * @return {number}
    */
   toMillis() {
-    return this.as("milliseconds");
+    var _this$values$millisec;
+    let sum = (_this$values$millisec = this.values.milliseconds) != null ? _this$values$millisec : 0;
+    for (let unit of reverseUnits.slice(1)) {
+      var _this$values;
+      if ((_this$values = this.values) != null && _this$values[unit]) {
+        sum += this.values[unit] * this.matrix[unit]["milliseconds"];
+      }
+    }
+    return sum;
   }
 
   /**
@@ -70297,10 +70303,13 @@ class Duration {
   normalize() {
     if (!this.isValid) return this;
     const vals = this.toObject();
-    normalizeValues(this.matrix, vals);
-    return clone$1(this, {
-      values: vals
-    }, true);
+    if (this.valueOf() >= 0) {
+      normalizeValues(this.matrix, vals);
+      return clone$1(this, {
+        values: vals
+      }, true);
+    }
+    return this.negate().normalize().negate();
   }
 
   /**
@@ -71329,14 +71338,35 @@ function highOrderDiffs(cursor, later, units) {
   const results = {};
   const earlier = cursor;
   let lowestOrder, highWater;
+
+  /* This loop tries to diff using larger units first.
+     If we overshoot, we backtrack and try the next smaller unit.
+     "cursor" starts out at the earlier timestamp and moves closer and closer to "later"
+     as we use smaller and smaller units.
+     highWater keeps track of where we would be if we added one more of the smallest unit,
+     this is used later to potentially convert any difference smaller than the smallest higher order unit
+     into a fraction of that smallest higher order unit
+  */
   for (const [unit, differ] of differs) {
     if (units.indexOf(unit) >= 0) {
       lowestOrder = unit;
       results[unit] = differ(cursor, later);
       highWater = earlier.plus(results);
       if (highWater > later) {
+        // we overshot the end point, backtrack cursor by 1
         results[unit]--;
         cursor = earlier.plus(results);
+
+        // if we are still overshooting now, we need to backtrack again
+        // this happens in certain situations when diffing times in different zones,
+        // because this calculation ignores time zones
+        if (cursor > later) {
+          // keep the "overshot by 1" around as highWater
+          highWater = cursor;
+          // backtrack cursor by 1
+          results[unit]--;
+          cursor = earlier.plus(results);
+        }
       } else {
         cursor = highWater;
       }
@@ -71485,6 +71515,11 @@ function simple(regex) {
 function escapeToken(value) {
   return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
 }
+
+/**
+ * @param token
+ * @param {Locale} loc
+ */
 function unitForToken(token, loc) {
   const one = digitRegex(loc),
     two = digitRegex(loc, "{2}"),
@@ -71509,9 +71544,9 @@ function unitForToken(token, loc) {
       switch (t.val) {
         // era
         case "G":
-          return oneOf(loc.eras("short", false), 0);
+          return oneOf(loc.eras("short"), 0);
         case "GG":
-          return oneOf(loc.eras("long", false), 0);
+          return oneOf(loc.eras("long"), 0);
         // years
         case "y":
           return intUnit(oneToSix);
@@ -71529,17 +71564,17 @@ function unitForToken(token, loc) {
         case "MM":
           return intUnit(two);
         case "MMM":
-          return oneOf(loc.months("short", true, false), 1);
+          return oneOf(loc.months("short", true), 1);
         case "MMMM":
-          return oneOf(loc.months("long", true, false), 1);
+          return oneOf(loc.months("long", true), 1);
         case "L":
           return intUnit(oneOrTwo);
         case "LL":
           return intUnit(two);
         case "LLL":
-          return oneOf(loc.months("short", false, false), 1);
+          return oneOf(loc.months("short", false), 1);
         case "LLLL":
-          return oneOf(loc.months("long", false, false), 1);
+          return oneOf(loc.months("long", false), 1);
         // dates
         case "d":
           return intUnit(oneOrTwo);
@@ -71599,13 +71634,13 @@ function unitForToken(token, loc) {
         case "c":
           return intUnit(one);
         case "EEE":
-          return oneOf(loc.weekdays("short", false, false), 1);
+          return oneOf(loc.weekdays("short", false), 1);
         case "EEEE":
-          return oneOf(loc.weekdays("long", false, false), 1);
+          return oneOf(loc.weekdays("long", false), 1);
         case "ccc":
-          return oneOf(loc.weekdays("short", true, false), 1);
+          return oneOf(loc.weekdays("short", true), 1);
         case "cccc":
-          return oneOf(loc.weekdays("long", true, false), 1);
+          return oneOf(loc.weekdays("long", true), 1);
         // offset/zone
         case "Z":
         case "ZZ":
@@ -71651,10 +71686,14 @@ const partTypeStyleToTokenVal = {
   },
   dayperiod: "a",
   dayPeriod: "a",
-  hour: {
+  hour12: {
     numeric: "h",
     "2-digit": "hh"
   },
+  hour24: {
+    numeric: "H",
+    "2-digit": "HH"
+  },
   minute: {
     numeric: "m",
     "2-digit": "mm"
@@ -71668,7 +71707,7 @@ const partTypeStyleToTokenVal = {
     short: "ZZZ"
   }
 };
-function tokenForPart(part, formatOpts) {
+function tokenForPart(part, formatOpts, resolvedOpts) {
   const {
     type,
     value
@@ -71681,7 +71720,27 @@ function tokenForPart(part, formatOpts) {
     };
   }
   const style = formatOpts[type];
-  let val = partTypeStyleToTokenVal[type];
+
+  // The user might have explicitly specified hour12 or hourCycle
+  // if so, respect their decision
+  // if not, refer back to the resolvedOpts, which are based on the locale
+  let actualType = type;
+  if (type === "hour") {
+    if (formatOpts.hour12 != null) {
+      actualType = formatOpts.hour12 ? "hour12" : "hour24";
+    } else if (formatOpts.hourCycle != null) {
+      if (formatOpts.hourCycle === "h11" || formatOpts.hourCycle === "h12") {
+        actualType = "hour12";
+      } else {
+        actualType = "hour24";
+      }
+    } else {
+      // tokens only differentiate between 24 hours or not,
+      // so we do not need to check hourCycle here, which is less supported anyways
+      actualType = resolvedOpts.hour12 ? "hour12" : "hour24";
+    }
+  }
+  let val = partTypeStyleToTokenVal[actualType];
   if (typeof val === "object") {
     val = val[style];
   }
@@ -71857,8 +71916,10 @@ function formatOptsToTokens(formatOpts, locale) {
     return null;
   }
   const formatter = Formatter.create(locale, formatOpts);
-  const parts = formatter.formatDateTimeParts(getDummyDateTime());
-  return parts.map(p => tokenForPart(p, formatOpts));
+  const df = formatter.dtFormatter(getDummyDateTime());
+  const parts = df.formatToParts();
+  const resolvedOpts = df.resolvedOptions();
+  return parts.map(p => tokenForPart(p, formatOpts, resolvedOpts));
 }
 
 const nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
@@ -72194,13 +72255,13 @@ function toISOTime(o, extended, suppressSeconds, suppressMilliseconds, includeOf
   if (extended) {
     c += ":";
     c += padStart(o.c.minute);
-    if (o.c.second !== 0 || !suppressSeconds) {
+    if (o.c.millisecond !== 0 || o.c.second !== 0 || !suppressSeconds) {
       c += ":";
     }
   } else {
     c += padStart(o.c.minute);
   }
-  if (o.c.second !== 0 || !suppressSeconds) {
+  if (o.c.millisecond !== 0 || o.c.second !== 0 || !suppressSeconds) {
     c += padStart(o.c.second);
     if (o.c.millisecond !== 0 || !suppressMilliseconds) {
       c += ".";
@@ -72834,7 +72895,7 @@ class DateTime {
 
   /**
    * Create an invalid DateTime.
-   * @param {DateTime} reason - simple string of why this DateTime is invalid. Should not contain parameters or anything else data-dependent
+   * @param {string} reason - simple string of why this DateTime is invalid. Should not contain parameters or anything else data-dependent.
    * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
    * @return {DateTime}
    */
@@ -73193,6 +73254,41 @@ class DateTime {
     }
   }
 
+  /**
+   * Get those DateTimes which have the same local time as this DateTime, but a different offset from UTC
+   * in this DateTime's zone. During DST changes local time can be ambiguous, for example
+   * `2023-10-29T02:30:00` in `Europe/Berlin` can have offset `+01:00` or `+02:00`.
+   * This method will return both possible DateTimes if this DateTime's local time is ambiguous.
+   * @returns {DateTime[]}
+   */
+  getPossibleOffsets() {
+    if (!this.isValid || this.isOffsetFixed) {
+      return [this];
+    }
+    const dayMs = 86400000;
+    const minuteMs = 60000;
+    const localTS = objToLocalTS(this.c);
+    const oEarlier = this.zone.offset(localTS - dayMs);
+    const oLater = this.zone.offset(localTS + dayMs);
+    const o1 = this.zone.offset(localTS - oEarlier * minuteMs);
+    const o2 = this.zone.offset(localTS - oLater * minuteMs);
+    if (o1 === o2) {
+      return [this];
+    }
+    const ts1 = localTS - o1 * minuteMs;
+    const ts2 = localTS - o2 * minuteMs;
+    const c1 = tsToObj(ts1, o1);
+    const c2 = tsToObj(ts2, o2);
+    if (c1.hour === c2.hour && c1.minute === c2.minute && c1.second === c2.second && c1.millisecond === c2.millisecond) {
+      return [clone(this, {
+        ts: ts1
+      }), clone(this, {
+        ts: ts2
+      })];
+    }
+    return [this];
+  }
+
   /**
    * Returns true if this DateTime is in a leap year, false otherwise
    * @example DateTime.local(2016).isInLeapYear //=> true
@@ -74199,7 +74295,7 @@ function friendlyDateTime(dateTimeish) {
   }
 }
 
-const VERSION = "3.3.0";
+const VERSION = "3.4.0";
 
 exports.DateTime = DateTime;
 exports.Duration = Duration;