@sbb-esta/lyne-elements 4.3.0 → 4.4.0

package/{core/datetime/native-date-adapter.d.ts → development/core/datetime/temporal-date-adapter.d.ts}

@@ -1,17 +1,15 @@
 import { DateAdapter } from './date-adapter.ts';
-export declare class NativeDateAdapter extends DateAdapter<Date> {
-    private readonly _cutoffYearOffset;
-    constructor(cutoffYearOffset?: number);
+export declare class TemporalDateAdapter extends DateAdapter<Temporal.PlainDate> {
     /** Gets the year of the input date. */
-    getYear(date: Date): number;
+    getYear(date: Temporal.PlainDate): number;
     /** Gets the month of the input date. */
-    getMonth(date: Date): number;
+    getMonth(date: Temporal.PlainDate): number;
     /** Gets the day of the input date. */
-    getDate(date: Date): number;
+    getDate(date: Temporal.PlainDate): number;
     /** Gets the day of the week of the input date. */
-    getDayOfWeek(date: Date): number;
+    getDayOfWeek(date: Temporal.PlainDate): number;
     /** Gets the date in the local format. */
-    getAccessibilityFormatDate(date: Date | string): string;
+    getAccessibilityFormatDate(date: Temporal.PlainDate | string): string;
     /**
      * Creates an array of strings with length = 12, filled with the name of the months starting from January, in the document language.
      * @param style See `month` in `DateTimeFormatOptions`: `long` for full name, `short` for short name, `narrow` for single letter,
@@ -29,44 +27,41 @@ export declare class NativeDateAdapter extends DateAdapter<Date> {
     /** Defines which is the first day of the week (0: sunday; 1: monday; etc.). */
     getFirstDayOfWeek(): number;
     /** Calculates the number of days in a month given the year and the month. */
-    getNumDaysInMonth(date: Date): number;
+    getNumDaysInMonth(date: Temporal.PlainDate): number;
     /** Creates today's date. */
-    today(): Date;
+    today(): Temporal.PlainDate;
     /** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */
-    createDate(year: number, month: number, date: number): Date;
-    /** Checks whether the given `obj` is a Date. */
+    createDate(year: number, month: number, day: number): Temporal.PlainDate;
+    /** Checks whether the given `obj` is a Temporal.PlainDate. */
     isDateInstance(obj: any): boolean;
-    /** Checks whether the given `date` is a valid Date. */
-    isValid(date: Date | null | undefined): date is Date;
+    /** Checks whether the given `date` is a valid Temporal.PlainDate. */
+    isValid(date: Temporal.PlainDate | null | undefined): date is Temporal.PlainDate;
     /** Creates a new date by cloning the given one. */
-    clone(date: Date): Date;
+    clone(date: Temporal.PlainDate): Temporal.PlainDate;
     /**
      * Creates a new date adding the number of provided `years` to the provided `date`.
      * @param date The starting date.
      * @param years The number of years to add.
      */
-    addCalendarYears(date: Date, years: number): Date;
+    addCalendarYears(date: Temporal.PlainDate, years: number): Temporal.PlainDate;
     /**
      * Creates a new date adding the number of provided `months` to the provided `date`.
      * If the calculated month has fewer days than the original one, the date is set to the last day of the month.
-     * E.g., with `date` = new Date(2022, 0, 31) and `months` = 1, it returns new Date(2022, 1, 28).
+     * E.g., with `date` = new Temporal.PlainDate(2022, 0, 31) and `months` = 1, it returns new Temporal.PlainDate(2022, 1, 28).
      */
-    addCalendarMonths(date: Date, months: number): Date;
+    addCalendarMonths(date: Temporal.PlainDate, months: number): Temporal.PlainDate;
     /** Creates a new date by adding the number of provided `days` to the provided `date`. */
-    addCalendarDays(date: Date, days: number): Date;
-    /** Creates a Date from a valid input (Date or ISO string). */
-    deserialize(date: Date | string | null | undefined): Date | null;
-    /** Returns the right format for the `valueAsDate` property. */
-    parse(value: string | null | undefined): Date | null;
-    invalid(): Date;
+    addCalendarDays(date: Temporal.PlainDate, days: number): Temporal.PlainDate;
+    /** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */
+    deserialize(date: Temporal.PlainDate | string | null | undefined): Temporal.PlainDate | null;
+    invalid(): Temporal.PlainDate;
+    toIso8601(date: Temporal.PlainDate): string;
     /**
      * Creates an array with the given length and fills it by mapping with the provided function.
      * @param length The length of the array to be created.
      * @param valueFunction The function of array's index used to fill the array.
      */
     private _range;
-    /** Creates a date but allows the month and date to overflow. */
-    private _createDateWithOverflow;
 }
-export declare const defaultDateAdapter: NativeDateAdapter;
-//# sourceMappingURL=native-date-adapter.d.ts.map
+export declare const temporalDateAdapter: TemporalDateAdapter;
+//# sourceMappingURL=temporal-date-adapter.d.ts.map

package/development/core/datetime/temporal-date-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-date-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/datetime/temporal-date-adapter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAgBhD,qBAAa,mBAAoB,SAAQ,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC;IACtE,uCAAuC;IAChC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAIhD,wCAAwC;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAIjD,sCAAsC;IAC/B,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAIhD,kDAAkD;IAC3C,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAMrD,yCAAyC;IAClC,0BAA0B,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM,GAAG,MAAM;IAS5E;;;;OAIG;IACI,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,EAAE;IAOlE,iGAAiG;IAC1F,YAAY,IAAI,MAAM,EAAE;IAO/B;;;;OAIG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,EAAE;IAOtE,+EAA+E;IACxE,iBAAiB,IAAI,MAAM;IAIlC,6EAA6E;IACtE,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAI1D,4BAA4B;IACrB,KAAK,IAAI,QAAQ,CAAC,SAAS;IAIlC,+FAA+F;IACxF,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS;IAe/E,8DAA8D;IACvD,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;IAIxC,qEAAqE;IAC9D,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,QAAQ,CAAC,SAAS;IAIvF,mDAAmD;IAC5C,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS;IAI1D;;;;OAIG;IACI,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS;IAIpF;;;;OAIG;IACI,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS;IAItF,yFAAyF;IAClF,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS;IAIlF,0FAA0F;IAC1E,WAAW,CACzB,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GACnD,QAAQ,CAAC,SAAS,GAAG,IAAI;IAYZ,OAAO,IAAI,QAAQ,CAAC,SAAS;IAK7B,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,MAAM;IAI3D;;;;OAIG;IACH,OAAO,CAAC,MAAM;CAGf;AAED,eAAO,MAAM,mBAAmB,qBAA4B,CAAC"}

package/development/core/datetime/temporal-date-adapter.js

@@ -0,0 +1,144 @@
+import { SbbLanguageController } from "../controllers.js";
+import { DateAdapter } from "./date-adapter.js";
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+if (typeof Temporal !== "object") {
+  throw new Error("Temporal is not available in the current environment. Please make sure to include the temporal polyfill.");
+}
+class TemporalDateAdapter extends DateAdapter {
+  /** Gets the year of the input date. */
+  getYear(date) {
+    return date.year;
+  }
+  /** Gets the month of the input date. */
+  getMonth(date) {
+    return date.month;
+  }
+  /** Gets the day of the input date. */
+  getDate(date) {
+    return date.day;
+  }
+  /** Gets the day of the week of the input date. */
+  getDayOfWeek(date) {
+    return date.dayOfWeek % 7;
+  }
+  /** Gets the date in the local format. */
+  getAccessibilityFormatDate(date) {
+    const options = {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    };
+    return this.deserialize(date).toLocaleString(SbbLanguageController.current, options);
+  }
+  /**
+   * Creates an array of strings with length = 12, filled with the name of the months starting from January, in the document language.
+   * @param style See `month` in `DateTimeFormatOptions`: `long` for full name, `short` for short name, `narrow` for single letter,
+   * E.g., with January in en-gb: `long` returns "January", `short` returns "Jan", `narrow` returns "J".
+   */
+  getMonthNames(style) {
+    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { month: style });
+    return this._range(12, (i) => formatter.format(Temporal.PlainDate.from({ year: 2017, month: i + 1, day: 1 })));
+  }
+  /** Creates a string array with length = 31, filled with the days in a month, starting from 1. */
+  getDateNames() {
+    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { day: "numeric" });
+    return this._range(31, (i) => formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })));
+  }
+  /**
+   * Creates a string array with length = 7, filled with the name of the days in a week starting from Sunday, in the document language.
+   * @param style See `weekday` in `DateTimeFormatOptions` - 'long' for full name, 'short' for short name, 'narrow' for single letter;
+   * E.g., with Monday in en-gb: `long` returns "Monday", `short` returns "Mon", `narrow` returns "M".
+   */
+  getDayOfWeekNames(style) {
+    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { weekday: style });
+    return this._range(7, (i) => formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })));
+  }
+  /** Defines which is the first day of the week (0: sunday; 1: monday; etc.). */
+  getFirstDayOfWeek() {
+    return 1;
+  }
+  /** Calculates the number of days in a month given the year and the month. */
+  getNumDaysInMonth(date) {
+    return date.daysInMonth;
+  }
+  /** Creates today's date. */
+  today() {
+    return Temporal.Now.plainDateISO();
+  }
+  /** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */
+  createDate(year, month, day) {
+    if (month < 1 || month > 12) {
+      throw Error(`Invalid month "${month}". Month has to be between 1 and 12.`);
+    } else if (day < 1) {
+      throw Error(`Invalid day "${day}". Day has to be greater than 0.`);
+    }
+    try {
+      return Temporal.PlainDate.from({ year, month, day }, { overflow: "reject" });
+    } catch {
+      throw Error(`Invalid date "${day}" for month with index "${month}".`);
+    }
+  }
+  /** Checks whether the given `obj` is a Temporal.PlainDate. */
+  isDateInstance(obj) {
+    return obj instanceof Temporal.PlainDate;
+  }
+  /** Checks whether the given `date` is a valid Temporal.PlainDate. */
+  isValid(date) {
+    return this.isDateInstance(date);
+  }
+  /** Creates a new date by cloning the given one. */
+  clone(date) {
+    return Temporal.PlainDate.from(date);
+  }
+  /**
+   * Creates a new date adding the number of provided `years` to the provided `date`.
+   * @param date The starting date.
+   * @param years The number of years to add.
+   */
+  addCalendarYears(date, years) {
+    return date.add({ years });
+  }
+  /**
+   * Creates a new date adding the number of provided `months` to the provided `date`.
+   * If the calculated month has fewer days than the original one, the date is set to the last day of the month.
+   * E.g., with `date` = new Temporal.PlainDate(2022, 0, 31) and `months` = 1, it returns new Temporal.PlainDate(2022, 1, 28).
+   */
+  addCalendarMonths(date, months) {
+    return date.add({ months });
+  }
+  /** Creates a new date by adding the number of provided `days` to the provided `date`. */
+  addCalendarDays(date, days) {
+    return date.add({ days });
+  }
+  /** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */
+  deserialize(date) {
+    if (typeof date === "string") {
+      if (!date) {
+        return null;
+      } else if (ISO_8601_REGEX.test(date)) {
+        return this.getValidDateOrNull(Temporal.PlainDate.from(date.split("T")[0]));
+      }
+    }
+    return super.deserialize(date);
+  }
+  invalid() {
+    return null;
+  }
+  toIso8601(date) {
+    return date.toJSON();
+  }
+  /**
+   * Creates an array with the given length and fills it by mapping with the provided function.
+   * @param length The length of the array to be created.
+   * @param valueFunction The function of array's index used to fill the array.
+   */
+  _range(length, valueFunction) {
+    return Array.from({ length }).map((_, i) => valueFunction(i));
+  }
+}
+const temporalDateAdapter = new TemporalDateAdapter();
+export {
+  TemporalDateAdapter,
+  temporalDateAdapter
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"temporal-date-adapter.js","sources":["../../../../../src/elements/core/datetime/temporal-date-adapter.ts"],"sourcesContent":["/// <reference types=\"temporal-polyfill/global\" />\n\nimport { SbbLanguageController } from '../controllers.ts';\n\nimport { DateAdapter } from './date-adapter.ts';\n\n/**\n * Matches strings that have the form of a valid RFC 3339 string\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\n * because the regex will match strings an without of bounds month, date, etc.\n */\nconst ISO_8601_REGEX =\n  /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\n\nif (typeof Temporal !== 'object') {\n  throw new Error(\n    'Temporal is not available in the current environment. Please make sure to include the temporal polyfill.',\n  );\n}\n\nexport class TemporalDateAdapter extends DateAdapter<Temporal.PlainDate> {\n  /** Gets the year of the input date. */\n  public getYear(date: Temporal.PlainDate): number {\n    return date.year;\n  }\n\n  /** Gets the month of the input date. */\n  public getMonth(date: Temporal.PlainDate): number {\n    return date.month;\n  }\n\n  /** Gets the day of the input date. */\n  public getDate(date: Temporal.PlainDate): number {\n    return date.day;\n  }\n\n  /** Gets the day of the week of the input date. */\n  public getDayOfWeek(date: Temporal.PlainDate): number {\n    // Our expectation is 0 = Sunday but Temporal.PlainDate.dayOfWeek returns 7 = Sunday\n    // TODO: Remove this with a future release.\n    return date.dayOfWeek % 7;\n  }\n\n  /** Gets the date in the local format. */\n  public getAccessibilityFormatDate(date: Temporal.PlainDate | string): string {\n    const options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: 'long',\n      day: 'numeric',\n    };\n    return this.deserialize(date)!.toLocaleString(SbbLanguageController.current, options);\n  }\n\n  /**\n   * Creates an array of strings with length = 12, filled with the name of the months starting from January, in the document language.\n   * @param style See `month` in `DateTimeFormatOptions`: `long` for full name, `short` for short name, `narrow` for single letter,\n   * E.g., with January in en-gb: `long` returns \"January\", `short` returns \"Jan\", `narrow` returns \"J\".\n   */\n  public getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { month: style });\n    return this._range(12, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: i + 1, day: 1 })),\n    );\n  }\n\n  /** Creates a string array with length = 31, filled with the days in a month, starting from 1. */\n  public getDateNames(): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { day: 'numeric' });\n    return this._range(31, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })),\n    );\n  }\n\n  /**\n   * Creates a string array with length = 7, filled with the name of the days in a week starting from Sunday, in the document language.\n   * @param style See `weekday` in `DateTimeFormatOptions` - 'long' for full name, 'short' for short name, 'narrow' for single letter;\n   * E.g., with Monday in en-gb: `long` returns \"Monday\", `short` returns \"Mon\", `narrow` returns \"M\".\n   */\n  public getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\n    const formatter = new Intl.DateTimeFormat(SbbLanguageController.current, { weekday: style });\n    return this._range(7, (i) =>\n      formatter.format(Temporal.PlainDate.from({ year: 2017, month: 1, day: i + 1 })),\n    );\n  }\n\n  /** Defines which is the first day of the week (0: sunday; 1: monday; etc.). */\n  public getFirstDayOfWeek(): number {\n    return 1;\n  }\n\n  /** Calculates the number of days in a month given the year and the month. */\n  public getNumDaysInMonth(date: Temporal.PlainDate): number {\n    return date.daysInMonth;\n  }\n\n  /** Creates today's date. */\n  public today(): Temporal.PlainDate {\n    return Temporal.Now.plainDateISO();\n  }\n\n  /** Creates a new date, given day, month and year; the method doesn't allow date's overflow. */\n  public createDate(year: number, month: number, day: number): Temporal.PlainDate {\n    // Check for invalid month and date (except upper bound on date which we have to check after creating the Temporal.PlainDate).\n    if (month < 1 || month > 12) {\n      throw Error(`Invalid month \"${month}\". Month has to be between 1 and 12.`);\n    } else if (day < 1) {\n      throw Error(`Invalid day \"${day}\". Day has to be greater than 0.`);\n    }\n\n    try {\n      return Temporal.PlainDate.from({ year, month, day: day }, { overflow: 'reject' });\n    } catch {\n      throw Error(`Invalid date \"${day}\" for month with index \"${month}\".`);\n    }\n  }\n\n  /** Checks whether the given `obj` is a Temporal.PlainDate. */\n  public isDateInstance(obj: any): boolean {\n    return obj instanceof Temporal.PlainDate;\n  }\n\n  /** Checks whether the given `date` is a valid Temporal.PlainDate. */\n  public isValid(date: Temporal.PlainDate | null | undefined): date is Temporal.PlainDate {\n    return this.isDateInstance(date);\n  }\n\n  /** Creates a new date by cloning the given one. */\n  public clone(date: Temporal.PlainDate): Temporal.PlainDate {\n    return Temporal.PlainDate.from(date);\n  }\n\n  /**\n   * Creates a new date adding the number of provided `years` to the provided `date`.\n   * @param date The starting date.\n   * @param years The number of years to add.\n   */\n  public addCalendarYears(date: Temporal.PlainDate, years: number): Temporal.PlainDate {\n    return date.add({ years });\n  }\n\n  /**\n   * Creates a new date adding the number of provided `months` to the provided `date`.\n   * If the calculated month has fewer days than the original one, the date is set to the last day of the month.\n   * E.g., with `date` = new Temporal.PlainDate(2022, 0, 31) and `months` = 1, it returns new Temporal.PlainDate(2022, 1, 28).\n   */\n  public addCalendarMonths(date: Temporal.PlainDate, months: number): Temporal.PlainDate {\n    return date.add({ months });\n  }\n\n  /** Creates a new date by adding the number of provided `days` to the provided `date`. */\n  public addCalendarDays(date: Temporal.PlainDate, days: number): Temporal.PlainDate {\n    return date.add({ days });\n  }\n\n  /** Creates a Temporal.PlainDate from a valid input (Temporal.PlainDate or ISO string). */\n  public override deserialize(\n    date: Temporal.PlainDate | string | null | undefined,\n  ): Temporal.PlainDate | null {\n    if (typeof date === 'string') {\n      if (!date) {\n        return null;\n      } else if (ISO_8601_REGEX.test(date)) {\n        // `Temporal.PlainDate.from` only accepts ISO 8601 date strings without time components.\n        return this.getValidDateOrNull(Temporal.PlainDate.from(date.split('T')[0]));\n      }\n    }\n    return super.deserialize(date);\n  }\n\n  public override invalid(): Temporal.PlainDate {\n    // It is not possible to create an invalid Temporal.PlainDate, so we return null.\n    return null!;\n  }\n\n  public override toIso8601(date: Temporal.PlainDate): string {\n    return date.toJSON();\n  }\n\n  /**\n   * Creates an array with the given length and fills it by mapping with the provided function.\n   * @param length The length of the array to be created.\n   * @param valueFunction The function of array's index used to fill the array.\n   */\n  private _range<T>(length: number, valueFunction: (index: number) => T): T[] {\n    return Array.from({ length }).map((_, i) => valueFunction(i));\n  }\n}\n\nexport const temporalDateAdapter = new TemporalDateAdapter();\n"],"names":[],"mappings":";;AAWA,MAAM,iBACJ;AAEF,IAAI,OAAO,aAAa,UAAU;AAChC,QAAM,IAAI,MACR,0GAA0G;AAE9G;AAEM,MAAO,4BAA4B,YAA+B;AAAA;AAAA,EAE/D,QAAQ,MAAwB;AACrC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGO,SAAS,MAAwB;AACtC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGO,QAAQ,MAAwB;AACrC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGO,aAAa,MAAwB;AAG1C,WAAO,KAAK,YAAY;AAAA,EAC1B;AAAA;AAAA,EAGO,2BAA2B,MAAiC;AACjE,UAAM,UAAsC;AAAA,MAC1C,MAAM;AAAA,MACN,OAAO;AAAA,MACP,KAAK;AAAA,IAAA;AAEP,WAAO,KAAK,YAAY,IAAI,EAAG,eAAe,sBAAsB,SAAS,OAAO;AAAA,EACtF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,cAAc,OAAkC;AACrD,UAAM,YAAY,IAAI,KAAK,eAAe,sBAAsB,SAAS,EAAE,OAAO,OAAO;AACzF,WAAO,KAAK,OAAO,IAAI,CAAC,MACtB,UAAU,OAAO,SAAS,UAAU,KAAK,EAAE,MAAM,MAAM,OAAO,IAAI,GAAG,KAAK,EAAA,CAAG,CAAC,CAAC;AAAA,EAEnF;AAAA;AAAA,EAGO,eAAY;AACjB,UAAM,YAAY,IAAI,KAAK,eAAe,sBAAsB,SAAS,EAAE,KAAK,WAAW;AAC3F,WAAO,KAAK,OAAO,IAAI,CAAC,MACtB,UAAU,OAAO,SAAS,UAAU,KAAK,EAAE,MAAM,MAAM,OAAO,GAAG,KAAK,IAAI,EAAA,CAAG,CAAC,CAAC;AAAA,EAEnF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,kBAAkB,OAAkC;AACzD,UAAM,YAAY,IAAI,KAAK,eAAe,sBAAsB,SAAS,EAAE,SAAS,OAAO;AAC3F,WAAO,KAAK,OAAO,GAAG,CAAC,MACrB,UAAU,OAAO,SAAS,UAAU,KAAK,EAAE,MAAM,MAAM,OAAO,GAAG,KAAK,IAAI,EAAA,CAAG,CAAC,CAAC;AAAA,EAEnF;AAAA;AAAA,EAGO,oBAAiB;AACtB,WAAO;AAAA,EACT;AAAA;AAAA,EAGO,kBAAkB,MAAwB;AAC/C,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGO,QAAK;AACV,WAAO,SAAS,IAAI,aAAA;AAAA,EACtB;AAAA;AAAA,EAGO,WAAW,MAAc,OAAe,KAAW;AAExD,QAAI,QAAQ,KAAK,QAAQ,IAAI;AAC3B,YAAM,MAAM,kBAAkB,KAAK,sCAAsC;AAAA,IAC3E,WAAW,MAAM,GAAG;AAClB,YAAM,MAAM,gBAAgB,GAAG,kCAAkC;AAAA,IACnE;AAEA,QAAI;AACF,aAAO,SAAS,UAAU,KAAK,EAAE,MAAM,OAAO,OAAY,EAAE,UAAU,UAAU;AAAA,IAClF,QAAQ;AACN,YAAM,MAAM,iBAAiB,GAAG,2BAA2B,KAAK,IAAI;AAAA,IACtE;AAAA,EACF;AAAA;AAAA,EAGO,eAAe,KAAQ;AAC5B,WAAO,eAAe,SAAS;AAAA,EACjC;AAAA;AAAA,EAGO,QAAQ,MAA2C;AACxD,WAAO,KAAK,eAAe,IAAI;AAAA,EACjC;AAAA;AAAA,EAGO,MAAM,MAAwB;AACnC,WAAO,SAAS,UAAU,KAAK,IAAI;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,iBAAiB,MAA0B,OAAa;AAC7D,WAAO,KAAK,IAAI,EAAE,OAAO;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,kBAAkB,MAA0B,QAAc;AAC/D,WAAO,KAAK,IAAI,EAAE,QAAQ;AAAA,EAC5B;AAAA;AAAA,EAGO,gBAAgB,MAA0B,MAAY;AAC3D,WAAO,KAAK,IAAI,EAAE,MAAM;AAAA,EAC1B;AAAA;AAAA,EAGgB,YACd,MAAoD;AAEpD,QAAI,OAAO,SAAS,UAAU;AAC5B,UAAI,CAAC,MAAM;AACT,eAAO;AAAA,MACT,WAAW,eAAe,KAAK,IAAI,GAAG;AAEpC,eAAO,KAAK,mBAAmB,SAAS,UAAU,KAAK,KAAK,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC;AAAA,MAC5E;AAAA,IACF;AACA,WAAO,MAAM,YAAY,IAAI;AAAA,EAC/B;AAAA,EAEgB,UAAO;AAErB,WAAO;AAAA,EACT;AAAA,EAEgB,UAAU,MAAwB;AAChD,WAAO,KAAK,OAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,OAAU,QAAgB,eAAmC;AACnE,WAAO,MAAM,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,GAAG,MAAM,cAAc,CAAC,CAAC;AAAA,EAC9D;AACD;AAEM,MAAM,sBAAsB,IAAI,oBAAA;"}

package/development/core/decorators/id-reference.js

@@ -90,10 +90,6 @@ const idReference = () => {
           if (typeof value !== "string") {
             idReferences.delete(this);
             if (value instanceof HTMLElement && this.hasAttribute(attributeName) && value.id !== this.getAttribute(attributeName)) {
-              {
-                const elementIdentity = value.id ? `#${value.id}` : value.classList.value.split(" ").map((c) => `.${c}`).join("");
-                console.warn(`An element (${value.localName + elementIdentity}) was passed to the ${this.localName}.${name} property, which does not match the existing id reference attribute ${attributeName} with value ${this.getAttribute(attributeName)}. This will remove the current attribute value.`);
-              }
               this.removeAttribute(attributeName);
             }
           } else if (this.hasAttribute(attributeName) && this.getAttribute(attributeName) !== value) {
@@ -117,4 +113,4 @@ const idReference = () => {
 export {
   idReference
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"id-reference.js","sources":["../../../../../src/elements/core/decorators/id-reference.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveElement } from 'lit';\n\nimport type { Interface } from './base.ts';\n\ninterface IdReferenceController extends ReactiveController {\n  host: Interface<ReactiveElement>;\n  rootNode: Document | ShadowRoot | null;\n  checkIdReference: (changedIds?: Set<string>) => void;\n}\n\n/**\n * We keep track of the observers for each root node, which is either a document\n * or a shadow root.\n * Each observer is associated with a set of controllers that each represent\n * an id reference.\n * Whenever the MutationObserver detects a change that affects a potential id\n * reference, it notifies all controllers associated with that observer.\n */\nconst observers = new WeakMap<\n  Node,\n  {\n    observer: MutationObserver;\n    controllers: Set<IdReferenceController>;\n  }\n>();\n/**\n * Whenever an id string is passed to the setter and no reference is found,\n * we store it in this WeakMap.\n * The key is the host element and the value is the id string.\n * Please note that if an id reference property has both an entry\n * in this WeakMap and an associated attribute, the attribute will take precedence.\n */\nconst idReferences = new WeakMap<object, string | null>();\n\n/**\n * Accessor decorator that resolves id references dynamically.\n * If a string is passed (e.g. from an attribute), it will be resolved to the element with that id.\n * This decorator observes the connected document fragment for changes to the id attribute\n * and child elements and if any id reference is established or removed, it will\n * update the associated property.\n */\nexport const idReference = <C extends Interface<ReactiveElement>, V>() => {\n  return (\n    target: ClassAccessorDecoratorTarget<C, V>,\n    context: ClassAccessorDecoratorContext<C, V>,\n  ): any => {\n    const { kind, metadata, name } = context;\n    if (kind === 'accessor') {\n      if (isServer) {\n        return {};\n      }\n\n      const attribute = globalThis.litPropertyMetadata.get(metadata)?.get(name)?.attribute;\n      const attributeName = typeof attribute === 'string' ? attribute : (name as string);\n      context.addInitializer(function () {\n        this.addController({\n          host: this,\n          rootNode: null,\n          checkIdReference(changedIds?: Set<string>): void {\n            const id = this.host.getAttribute(attributeName) ?? idReferences.get(this.host);\n            if (id && typeof id === 'string' && (!changedIds || changedIds.has(id))) {\n              const value = (this.rootNode?.getElementById?.(id) ?? null) as unknown as V;\n              if (context.access.get(this.host as C) !== value) {\n                context.access.set(this.host as C, value);\n              }\n            }\n          },\n          hostConnected() {\n            this.rootNode = this.host.getRootNode() as Document | ShadowRoot;\n            this.checkIdReference();\n            const observerContext = observers.get(this.rootNode);\n\n            if (observerContext) {\n              observerContext.controllers.add(this);\n            } else {\n              const controllers = new Set([this]);\n              const observer = new MutationObserver((mutations) => {\n                const mutatedIds = new Set<string>();\n\n                for (const mutation of mutations) {\n                  if (mutation.type === 'attributes') {\n                    if (mutation.oldValue) {\n                      mutatedIds.add(mutation.oldValue!);\n                    }\n                    if ((mutation.target as HTMLElement).id) {\n                      mutatedIds.add((mutation.target as HTMLElement).id);\n                    }\n                  } else if (mutation.type === 'childList') {\n                    for (const node of [...mutation.addedNodes, ...mutation.removedNodes]) {\n                      if (node instanceof HTMLElement) {\n                        if (node.id) {\n                          mutatedIds.add(node.id);\n                        }\n                        node.querySelectorAll('[id]').forEach((e) => {\n                          if (e.id) {\n                            mutatedIds.add(e.id);\n                          }\n                        });\n                      }\n                    }\n                  }\n                }\n\n                controllers.forEach((c) => c.checkIdReference(mutatedIds));\n              });\n\n              observer.observe(this.rootNode, {\n                attributeFilter: ['id'],\n                attributeOldValue: true,\n                childList: true,\n                subtree: true,\n              });\n\n              observers.set(this.rootNode, { observer, controllers });\n            }\n          },\n          hostDisconnected() {\n            if (isServer || !this.rootNode) {\n              return;\n            }\n\n            const observerContext = observers.get(this.rootNode);\n            if (!observerContext) {\n              this.rootNode = null;\n              return;\n            }\n\n            observerContext.controllers.delete(this);\n            if (observerContext.controllers.size === 0) {\n              observerContext.observer.disconnect();\n              observers.delete(this.rootNode);\n            }\n\n            this.rootNode = null;\n          },\n        } as IdReferenceController);\n      });\n      return {\n        set(this: C, value) {\n          if (typeof value !== 'string') {\n            idReferences.delete(this);\n            if (\n              value instanceof HTMLElement &&\n              this.hasAttribute(attributeName) &&\n              value.id !== this.getAttribute(attributeName)\n            ) {\n              if (import.meta.env.DEV) {\n                const elementIdentity = value.id\n                  ? `#${value.id}`\n                  : value.classList.value\n                      .split(' ')\n                      .map((c) => `.${c}`)\n                      .join('');\n                console.warn(\n                  `An element (${value.localName + elementIdentity}) was ` +\n                    `passed to the ${this.localName}.${name as string} property, ` +\n                    `which does not match the existing id reference attribute ` +\n                    `${attributeName} with value ${this.getAttribute(attributeName)}. ` +\n                    `This will remove the current attribute value.`,\n                );\n              }\n              this.removeAttribute(attributeName);\n            }\n          } else if (\n            this.hasAttribute(attributeName) &&\n            this.getAttribute(attributeName) !== value\n          ) {\n            // When a string is passed to the setter but the attribute is set to a\n            // different value, we ignore the passed value.\n            return;\n          } else {\n            const element = value\n              ? (this.getRootNode?.() as Document | ShadowRoot)?.getElementById?.(value)\n              : null;\n            if (element) {\n              value = element as unknown as V;\n            } else if (value) {\n              // If we are unable to resolve the id reference, we temporarily store it\n              // to try to resolve it later.\n              idReferences.set(this, value as string);\n              value = null!;\n            }\n          }\n\n          (target as ClassAccessorDecoratorTarget<C, V>).set.call(this as unknown as C, value);\n        },\n      } satisfies ClassAccessorDecoratorResult<C, V>;\n    }\n\n    throw new Error(`Unsupported decorator location: ${kind}`);\n  };\n};\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"id-reference.js","sources":["../../../../../src/elements/core/decorators/id-reference.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveElement } from 'lit';\n\nimport type { Interface } from './base.ts';\n\ninterface IdReferenceController extends ReactiveController {\n  host: Interface<ReactiveElement>;\n  rootNode: Document | ShadowRoot | null;\n  checkIdReference: (changedIds?: Set<string>) => void;\n}\n\n/**\n * We keep track of the observers for each root node, which is either a document\n * or a shadow root.\n * Each observer is associated with a set of controllers that each represent\n * an id reference.\n * Whenever the MutationObserver detects a change that affects a potential id\n * reference, it notifies all controllers associated with that observer.\n */\nconst observers = new WeakMap<\n  Node,\n  {\n    observer: MutationObserver;\n    controllers: Set<IdReferenceController>;\n  }\n>();\n/**\n * Whenever an id string is passed to the setter and no reference is found,\n * we store it in this WeakMap.\n * The key is the host element and the value is the id string.\n * Please note that if an id reference property has both an entry\n * in this WeakMap and an associated attribute, the attribute will take precedence.\n */\nconst idReferences = new WeakMap<object, string | null>();\n\n/**\n * Accessor decorator that resolves id references dynamically.\n * If a string is passed (e.g. from an attribute), it will be resolved to the element with that id.\n * This decorator observes the connected document fragment for changes to the id attribute\n * and child elements and if any id reference is established or removed, it will\n * update the associated property.\n */\nexport const idReference = <C extends Interface<ReactiveElement>, V>() => {\n  return (\n    target: ClassAccessorDecoratorTarget<C, V>,\n    context: ClassAccessorDecoratorContext<C, V>,\n  ): any => {\n    const { kind, metadata, name } = context;\n    if (kind === 'accessor') {\n      if (isServer) {\n        return {};\n      }\n\n      const attribute = globalThis.litPropertyMetadata.get(metadata)?.get(name)?.attribute;\n      const attributeName = typeof attribute === 'string' ? attribute : (name as string);\n      context.addInitializer(function () {\n        this.addController({\n          host: this,\n          rootNode: null,\n          checkIdReference(changedIds?: Set<string>): void {\n            const id = this.host.getAttribute(attributeName) ?? idReferences.get(this.host);\n            if (id && typeof id === 'string' && (!changedIds || changedIds.has(id))) {\n              const value = (this.rootNode?.getElementById?.(id) ?? null) as unknown as V;\n              if (context.access.get(this.host as C) !== value) {\n                context.access.set(this.host as C, value);\n              }\n            }\n          },\n          hostConnected() {\n            this.rootNode = this.host.getRootNode() as Document | ShadowRoot;\n            this.checkIdReference();\n            const observerContext = observers.get(this.rootNode);\n\n            if (observerContext) {\n              observerContext.controllers.add(this);\n            } else {\n              const controllers = new Set([this]);\n              const observer = new MutationObserver((mutations) => {\n                const mutatedIds = new Set<string>();\n\n                for (const mutation of mutations) {\n                  if (mutation.type === 'attributes') {\n                    if (mutation.oldValue) {\n                      mutatedIds.add(mutation.oldValue!);\n                    }\n                    if ((mutation.target as HTMLElement).id) {\n                      mutatedIds.add((mutation.target as HTMLElement).id);\n                    }\n                  } else if (mutation.type === 'childList') {\n                    for (const node of [...mutation.addedNodes, ...mutation.removedNodes]) {\n                      if (node instanceof HTMLElement) {\n                        if (node.id) {\n                          mutatedIds.add(node.id);\n                        }\n                        node.querySelectorAll('[id]').forEach((e) => {\n                          if (e.id) {\n                            mutatedIds.add(e.id);\n                          }\n                        });\n                      }\n                    }\n                  }\n                }\n\n                controllers.forEach((c) => c.checkIdReference(mutatedIds));\n              });\n\n              observer.observe(this.rootNode, {\n                attributeFilter: ['id'],\n                attributeOldValue: true,\n                childList: true,\n                subtree: true,\n              });\n\n              observers.set(this.rootNode, { observer, controllers });\n            }\n          },\n          hostDisconnected() {\n            if (isServer || !this.rootNode) {\n              return;\n            }\n\n            const observerContext = observers.get(this.rootNode);\n            if (!observerContext) {\n              this.rootNode = null;\n              return;\n            }\n\n            observerContext.controllers.delete(this);\n            if (observerContext.controllers.size === 0) {\n              observerContext.observer.disconnect();\n              observers.delete(this.rootNode);\n            }\n\n            this.rootNode = null;\n          },\n        } as IdReferenceController);\n      });\n      return {\n        set(this: C, value) {\n          if (typeof value !== 'string') {\n            idReferences.delete(this);\n            if (\n              value instanceof HTMLElement &&\n              this.hasAttribute(attributeName) &&\n              value.id !== this.getAttribute(attributeName)\n            ) {\n              if (import.meta.env.DEV) {\n                const elementIdentity = value.id\n                  ? `#${value.id}`\n                  : value.classList.value\n                      .split(' ')\n                      .map((c) => `.${c}`)\n                      .join('');\n                console.warn(\n                  `An element (${value.localName + elementIdentity}) was ` +\n                    `passed to the ${this.localName}.${name as string} property, ` +\n                    `which does not match the existing id reference attribute ` +\n                    `${attributeName} with value ${this.getAttribute(attributeName)}. ` +\n                    `This will remove the current attribute value.`,\n                );\n              }\n              this.removeAttribute(attributeName);\n            }\n          } else if (\n            this.hasAttribute(attributeName) &&\n            this.getAttribute(attributeName) !== value\n          ) {\n            // When a string is passed to the setter but the attribute is set to a\n            // different value, we ignore the passed value.\n            return;\n          } else {\n            const element = value\n              ? (this.getRootNode?.() as Document | ShadowRoot)?.getElementById?.(value)\n              : null;\n            if (element) {\n              value = element as unknown as V;\n            } else if (value) {\n              // If we are unable to resolve the id reference, we temporarily store it\n              // to try to resolve it later.\n              idReferences.set(this, value as string);\n              value = null!;\n            }\n          }\n\n          (target as ClassAccessorDecoratorTarget<C, V>).set.call(this as unknown as C, value);\n        },\n      } satisfies ClassAccessorDecoratorResult<C, V>;\n    }\n\n    throw new Error(`Unsupported decorator location: ${kind}`);\n  };\n};\n"],"names":[],"mappings":"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"}

package/development/core/testing/event-spy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-spy.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/event-spy.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,KAAK;IAsBjC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAvB3B,IAAW,KAAK,IAAI,MAAM,CAEzB;IACD,OAAO,CAAC,MAAM,CAAa;IAE3B,IAAW,MAAM,IAAI,CAAC,EAAE,CAEvB;IACD,OAAO,CAAC,OAAO,CAAW;IAE1B,IAAW,UAAU,IAAI,CAAC,GAAG,IAAI,CAEhC;IAED,IAAW,SAAS,IAAI,CAAC,GAAG,IAAI,CAE/B;IAED,OAAO,CAAC,gBAAgB,CAA6C;gBAG3D,MAAM,EAAE,MAAM,EACL,OAAO,GAAE,IAAI,GAAG,IAAW,EAC3B,QAAQ,GAAE,uBAAuB,GAAG,IAAW;IAS3D,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAIxC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IA6B7D,OAAO,CAAC,uBAAuB;IAa/B,OAAO,CAAC,eAAe;CAWxB"}
+{"version":3,"file":"event-spy.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/event-spy.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,KAAK;IAsBjC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAvB3B,IAAW,KAAK,IAAI,MAAM,CAEzB;IACD,OAAO,CAAC,MAAM,CAAa;IAE3B,IAAW,MAAM,IAAI,CAAC,EAAE,CAEvB;IACD,OAAO,CAAC,OAAO,CAAW;IAE1B,IAAW,UAAU,IAAI,CAAC,GAAG,IAAI,CAEhC;IAED,IAAW,SAAS,IAAI,CAAC,GAAG,IAAI,CAE/B;IAED,OAAO,CAAC,gBAAgB,CAA6C;gBAG3D,MAAM,EAAE,MAAM,EACL,OAAO,GAAE,IAAI,GAAG,IAAW,EAC3B,QAAQ,GAAE,uBAAuB,GAAG,IAAW;IAS3D,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAIxC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IA6B7D,OAAO,CAAC,uBAAuB;IAgB/B,OAAO,CAAC,eAAe;CAWxB"}

package/development/core/testing/event-spy.js

@@ -28,7 +28,7 @@ class EventSpy {
   }
   calledTimes(count, timeout = 2e3) {
     if (this.count > count) {
-      return Promise.reject(`Event has been emitted more than expected (expected ${count}, actual ${this.count}`);
+      return Promise.reject(`Event '${this._event}' has been emitted more than expected (expected ${count}, actual ${this.count}`);
     } else if (this.count === count) {
       return Promise.resolve(this.events[count - 1]);
     } else if (this._promiseEventMap.has(count)) {
@@ -50,7 +50,7 @@ class EventSpy {
     }
   }
   _wrapPromiseWithTimeout(promiseWithExecutor, count, timeout) {
-    const clearTimeoutId = setTimeout(() => promiseWithExecutor.reject(`awaiting calledTimes(${count}) results in timeout`), timeout);
+    const clearTimeoutId = setTimeout(() => promiseWithExecutor.reject(`awaiting calledTimes(${count}) for event '${this._event}' results in timeout`), timeout);
     promiseWithExecutor.promise.then(() => clearTimeout(clearTimeoutId));
     return promiseWithExecutor.promise;
   }
@@ -65,4 +65,4 @@ class EventSpy {
 export {
   EventSpy
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/datepicker/datepicker-toggle/datepicker-toggle.component.js

@@ -35,10 +35,6 @@ let SbbDatepickerToggleElement = (() => {
       __privateSet(this, _datepicker_accessor_storage, __runInitializers(this, _datepicker_initializers, null));
       __runInitializers(this, _datepicker_extraInitializers);
       this.addEventListener?.("click", () => {
-        if (!this.datepicker) {
-          console.warn("sbb-datepicker-toggle: No datepicker connected.");
-          console.log(this);
-        }
         if (!this.datepicker?.isOpen) {
           this.datepicker?.open();
         }
@@ -82,4 +78,4 @@ let SbbDatepickerToggleElement = (() => {
 export {
   SbbDatepickerToggleElement
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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