@smcv/opening-hours 1.0.0

package/dist/index.global.js

@@ -0,0 +1,1009 @@
+(() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  function __accessProp(key) {
+    return this[key];
+  }
+  var __toCommonJS = (from) => {
+    var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+    if (entry)
+      return entry;
+    entry = __defProp({}, "__esModule", { value: true });
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (var key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(entry, key))
+          __defProp(entry, key, {
+            get: __accessProp.bind(from, key),
+            enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+          });
+    }
+    __moduleCache.set(from, entry);
+    return entry;
+  };
+  var __moduleCache;
+  var __returnValue = (v) => v;
+  function __exportSetter(name, newValue) {
+    this[name] = __returnValue.bind(null, newValue);
+  }
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, {
+        get: all[name],
+        enumerable: true,
+        configurable: true,
+        set: __exportSetter.bind(all, name)
+      });
+  };
+
+  // src/index.ts
+  var exports_src = {};
+  __export(exports_src, {
+    TimeRange: () => TimeRange,
+    Time: () => Time,
+    OpeningHoursForDay: () => OpeningHoursForDay,
+    OpeningHours: () => OpeningHours,
+    Days: () => Days
+  });
+
+  // src/types.ts
+  var Days = {
+    sunday: 0,
+    monday: 1,
+    tuesday: 2,
+    wednesday: 3,
+    thursday: 4,
+    friday: 5,
+    saturday: 6
+  };
+
+  // src/classes/Time.ts
+  class Time {
+    hour;
+    minute;
+    constructor(hour, minute = 0) {
+      this.hour = hour;
+      this.minute = minute;
+    }
+    static fromString(timeString) {
+      const isoMatch = timeString.match(/^(\d{2}):(\d{2})(?::\d{2})?(?:Z|[+-]\d{2}:\d{2})?$/);
+      if (isoMatch) {
+        const hour2 = Number.parseInt(isoMatch[1], 10);
+        const minute2 = Number.parseInt(isoMatch[2], 10);
+        return new Time(hour2, minute2);
+      }
+      const parts = timeString.split(":").map(Number);
+      const hour = parts[0] || 0;
+      const minute = parts[1] || 0;
+      return new Time(hour, minute);
+    }
+    static fromDate(date) {
+      return new Time(date.getHours(), date.getMinutes());
+    }
+    getHour() {
+      return this.hour;
+    }
+    getMinute() {
+      return this.minute;
+    }
+    format(format = "H:i") {
+      const replacements = {
+        H: this.hour.toString().padStart(2, "0"),
+        G: this.hour.toString(),
+        h: (this.hour % 12 || 12).toString().padStart(2, "0"),
+        g: (this.hour % 12 || 12).toString(),
+        i: this.minute.toString().padStart(2, "0"),
+        a: this.hour < 12 ? "am" : "pm",
+        A: this.hour < 12 ? "AM" : "PM"
+      };
+      return format.replace(/[HGhgiaA]/g, (match) => replacements[match] || match);
+    }
+    toString() {
+      return this.format();
+    }
+    isBefore(time) {
+      if (this.hour < time.hour) {
+        return true;
+      }
+      if (this.hour === time.hour && this.minute < time.minute) {
+        return true;
+      }
+      return false;
+    }
+    isAfter(time) {
+      if (this.hour > time.hour) {
+        return true;
+      }
+      if (this.hour === time.hour && this.minute > time.minute) {
+        return true;
+      }
+      return false;
+    }
+    isEqual(time) {
+      return this.hour === time.hour && this.minute === time.minute;
+    }
+    addMinutes(minutes) {
+      const date = new Date(0, 0, 0, this.hour, this.minute);
+      date.setMinutes(date.getMinutes() + minutes);
+      return Time.fromDate(date);
+    }
+    toMinutesSinceMidnight() {
+      return this.hour * 60 + this.minute;
+    }
+    diffInMinutes(time) {
+      return Math.abs(this.toMinutesSinceMidnight() - time.toMinutesSinceMidnight());
+    }
+    toDate(baseDate = new Date) {
+      const date = new Date(baseDate);
+      date.setHours(this.hour, this.minute, 0, 0);
+      return date;
+    }
+  }
+
+  // src/classes/OpeningHoursForDay.ts
+  class OpeningHoursForDay {
+    timeRanges;
+    overflow;
+    displayOptions;
+    data;
+    constructor(timeRanges = [], overflow = false, displayOptions, data) {
+      this.timeRanges = timeRanges;
+      this.overflow = overflow;
+      this.displayOptions = displayOptions;
+      this.data = data;
+    }
+    isOpenAt(time) {
+      return this.timeRanges.some((range) => range.containsTime(time, this.overflow));
+    }
+    isOpenAtDateTime(dateTime) {
+      const time = Time.fromDate(dateTime);
+      return this.isOpenAt(time);
+    }
+    isOpenDuringDay() {
+      return this.timeRanges.length > 0;
+    }
+    getTimeRanges() {
+      return this.timeRanges;
+    }
+    getData() {
+      return this.data;
+    }
+    getCurrentOpenRange(time) {
+      for (const range of this.timeRanges) {
+        if (range.containsTime(time, this.overflow)) {
+          return range;
+        }
+      }
+      return null;
+    }
+    getCurrentOpenRangeAtDateTime(dateTime) {
+      const time = Time.fromDate(dateTime);
+      return this.getCurrentOpenRange(time);
+    }
+    equals(openingHoursForDay) {
+      if (this.timeRanges.length !== openingHoursForDay.timeRanges.length) {
+        return false;
+      }
+      for (let i = 0;i < this.timeRanges.length; i++) {
+        const thisRange = this.timeRanges[i];
+        const otherRange = openingHoursForDay.getTimeRanges()[i];
+        if (!thisRange || !otherRange) {
+          return false;
+        }
+        const thisStart = thisRange.getStart();
+        const otherStart = otherRange.getStart();
+        const thisEnd = thisRange.getEnd();
+        const otherEnd = otherRange.getEnd();
+        if (!thisStart.isEqual(otherStart) || !thisEnd.isEqual(otherEnd)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    formatTimeRange(timeRange, options = {}) {
+      const {
+        timeRangeSeparator = "-",
+        timeFormat,
+        locale = "en-US"
+      } = {
+        ...this.displayOptions,
+        ...options
+      };
+      const defaultFormat = locale === "en-US" ? "gA" : "H:i";
+      const format = timeFormat || defaultFormat;
+      const startStr = timeRange.getStart().format(format);
+      const endStr = timeRange.getEnd().format(format);
+      let result = startStr + timeRangeSeparator + endStr;
+      const data = timeRange.getData();
+      if (data && typeof data.note === "string" && data.note.length > 0) {
+        result += ` (${data.note})`;
+      }
+      return result;
+    }
+    toString(options = {}) {
+      if (this.timeRanges.length === 0) {
+        const { closedText = "Closed" } = {
+          ...this.displayOptions,
+          ...options
+        };
+        const note = this.data?.note;
+        return (typeof note === "string" && note.length > 0 ? note : null) ?? closedText;
+      }
+      const mergedOptions = { ...this.displayOptions, ...options };
+      const { timeRangesSeparator = ", " } = mergedOptions;
+      return this.timeRanges.map((range) => this.formatTimeRange(range, mergedOptions)).join(timeRangesSeparator);
+    }
+  }
+
+  // src/classes/TimeRange.ts
+  class TimeRange {
+    start;
+    end;
+    data;
+    constructor(start, end, data) {
+      this.start = start;
+      this.end = end;
+      this.data = data;
+    }
+    static fromString(rangeString, data) {
+      const parts = rangeString.split("-").map((part) => part.trim());
+      if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        throw new Error(`Invalid time range format: ${rangeString}`);
+      }
+      const [startStr, endStr] = parts;
+      const start = Time.fromString(startStr);
+      const end = Time.fromString(endStr);
+      return new TimeRange(start, end, data);
+    }
+    getStart() {
+      return this.start;
+    }
+    getEnd() {
+      return this.end;
+    }
+    getData() {
+      return this.data;
+    }
+    containsTime(time, overflow = false) {
+      if (overflow && this.spansOvernight()) {
+        return time.isAfter(this.start) || time.isBefore(this.end) || time.isEqual(this.start) || time.isEqual(this.end);
+      }
+      return (time.isAfter(this.start) || time.isEqual(this.start)) && (time.isBefore(this.end) || time.isEqual(this.end));
+    }
+    spansOvernight() {
+      return this.end.isBefore(this.start);
+    }
+    overlaps(timeRange, overflow = false) {
+      const thisSpansOvernight = this.spansOvernight();
+      const otherSpansOvernight = timeRange.spansOvernight();
+      if (thisSpansOvernight === otherSpansOvernight) {
+        if (overflow && thisSpansOvernight) {
+          return true;
+        }
+        return this.containsTime(timeRange.getStart(), overflow) || this.containsTime(timeRange.getEnd(), overflow) || timeRange.containsTime(this.start, overflow) || timeRange.containsTime(this.end, overflow);
+      }
+      if (thisSpansOvernight) {
+        return this.containsTime(timeRange.getStart(), overflow) || this.containsTime(timeRange.getEnd(), overflow);
+      }
+      return timeRange.containsTime(this.start, overflow) || timeRange.containsTime(this.end, overflow);
+    }
+    durationInMinutes(overflow = false) {
+      if (overflow && this.spansOvernight()) {
+        const minutesUntilMidnight = 24 * 60 - this.start.toMinutesSinceMidnight();
+        const minutesAfterMidnight = this.end.toMinutesSinceMidnight();
+        return minutesUntilMidnight + minutesAfterMidnight;
+      }
+      return this.end.toMinutesSinceMidnight() - this.start.toMinutesSinceMidnight();
+    }
+    toString() {
+      return `${this.start.toString()}-${this.end.toString()}`;
+    }
+  }
+
+  // src/classes/OpeningHours.ts
+  class OpeningHours {
+    config;
+    schedule;
+    exceptions;
+    filters;
+    timezone;
+    overflow;
+    displayOptions;
+    constructor(config) {
+      const {
+        locale,
+        weekday,
+        firstDayOfWeek,
+        dayRangeSeparator,
+        timeRangeSeparator,
+        timeFormat,
+        timeRangesSeparator,
+        showTimezone,
+        timeZoneName,
+        closedText,
+        ...configOptions
+      } = config;
+      this.displayOptions = {
+        locale,
+        weekday,
+        firstDayOfWeek,
+        dayRangeSeparator,
+        timeRangeSeparator,
+        timeFormat,
+        timeRangesSeparator,
+        showTimezone,
+        timeZoneName,
+        closedText
+      };
+      this.config = configOptions;
+      this.schedule = new Map;
+      this.exceptions = new Map(Object.entries(this.config.exceptions || {}));
+      this.filters = this.config.filters || [];
+      this.timezone = this.config.timezone;
+      this.overflow = this.config.overflow || false;
+      this.initializeSchedule();
+    }
+    initializeSchedule() {
+      for (const [day, schedule] of Object.entries(this.config)) {
+        if (day in Days) {
+          this.schedule.set(day, this.normalizeTimeRanges(schedule));
+        }
+      }
+      for (const [dayRange, schedule] of Object.entries(this.config)) {
+        if (dayRange.includes("...")) {
+          const [startDay, endDay] = dayRange.split("...");
+          if (typeof startDay === "string" && typeof endDay === "string" && startDay in Days && endDay in Days) {
+            const startIndex = Days[startDay];
+            const endIndex = Days[endDay];
+            for (let i = startIndex;i <= endIndex; i++) {
+              const currentDay = Object.keys(Days).find((key) => Days[key] === i);
+              if (currentDay && !this.schedule.has(currentDay)) {
+                this.schedule.set(currentDay, this.normalizeTimeRanges(schedule));
+              }
+            }
+          }
+        }
+      }
+    }
+    normalizeTimeRanges(schedule) {
+      if (!Array.isArray(schedule)) {
+        return [schedule];
+      }
+      return schedule;
+    }
+    isMetadataOnly(item) {
+      if (typeof item === "string")
+        return false;
+      return !item.hours && !item.time;
+    }
+    filterActualRanges(schedule) {
+      return schedule.filter((item) => !this.isMetadataOnly(item));
+    }
+    extractDataFromSchedule(schedule) {
+      for (const item of schedule) {
+        if (this.isMetadataOnly(item) && typeof item !== "string") {
+          const {
+            time: _t,
+            hours: _h,
+            ...rest
+          } = item;
+          return rest;
+        }
+      }
+      return;
+    }
+    getDataForDate(date) {
+      const dateString = this.formatDate(date);
+      const exception = this.exceptions.get(dateString);
+      if (Array.isArray(exception)) {
+        return this.extractDataFromSchedule(exception);
+      }
+      return;
+    }
+    convertToTimeRange(timeRangeData) {
+      if (typeof timeRangeData === "string") {
+        return TimeRange.fromString(timeRangeData);
+      }
+      const timeStr = timeRangeData.time || timeRangeData.hours || "";
+      const data = { ...timeRangeData };
+      data.time = undefined;
+      data.hours = undefined;
+      return TimeRange.fromString(timeStr, data);
+    }
+    getDayName(date) {
+      const dayIndex = date.getDay();
+      return Object.keys(Days).find((key) => Days[key] === dayIndex);
+    }
+    formatDate(date) {
+      return date.toISOString().split("T")[0];
+    }
+    getTimeRangesForDate(date) {
+      const dateString = this.formatDate(date);
+      if (this.exceptions.has(dateString)) {
+        const exception = this.exceptions.get(dateString);
+        if (typeof exception === "function") {
+          return exception(date).map((tr) => this.convertToTimeRange(tr));
+        }
+        if (Array.isArray(exception)) {
+          return this.filterActualRanges(exception).map((tr) => this.convertToTimeRange(tr));
+        }
+        return [];
+      }
+      const filterRanges = [];
+      for (const filter of this.filters) {
+        const ranges = filter(date);
+        filterRanges.push(...ranges.map((tr) => this.convertToTimeRange(tr)));
+      }
+      if (filterRanges.length > 0) {
+        return filterRanges;
+      }
+      const dayName = this.getDayName(date);
+      const daySchedule = this.schedule.get(dayName) || [];
+      return daySchedule.map((tr) => this.convertToTimeRange(tr));
+    }
+    static create(config) {
+      return new OpeningHours(config);
+    }
+    isOpenOn(day) {
+      const timeRanges = this.schedule.get(day) || [];
+      return timeRanges.length > 0;
+    }
+    isOpenAt(dateTime) {
+      const adjustedDateTime = this.toTimezone(dateTime);
+      return this.forDate(adjustedDateTime).isOpenAtDateTime(adjustedDateTime);
+    }
+    isClosedAt(dateTime) {
+      return !this.isOpenAt(dateTime);
+    }
+    forDay(day) {
+      const timeRanges = this.schedule.get(day) || [];
+      const ranges = timeRanges.map((tr) => this.convertToTimeRange(tr));
+      return new OpeningHoursForDay(ranges, this.overflow, this.displayOptions);
+    }
+    forWeek() {
+      const result = {};
+      for (const day in Days) {
+        result[day] = this.forDay(day);
+      }
+      return result;
+    }
+    forDate(date) {
+      const adjustedDate = this.toTimezone(date);
+      const timeRanges = this.getTimeRangesForDate(adjustedDate);
+      const data = this.getDataForDate(adjustedDate);
+      return new OpeningHoursForDay(timeRanges, this.overflow, this.displayOptions, data);
+    }
+    getExceptions() {
+      const result = {};
+      for (const [dateString, exception] of this.exceptions.entries()) {
+        const date = new Date(dateString);
+        if (typeof exception === "function") {
+          const ranges = exception(date).map((tr) => this.convertToTimeRange(tr));
+          result[dateString] = new OpeningHoursForDay(ranges, this.overflow, this.displayOptions);
+        } else if (Array.isArray(exception)) {
+          const ranges = this.filterActualRanges(exception).map((tr) => this.convertToTimeRange(tr));
+          const data = this.extractDataFromSchedule(exception);
+          result[dateString] = new OpeningHoursForDay(ranges, this.overflow, this.displayOptions, data);
+        }
+      }
+      return result;
+    }
+    diffInOpenHours(startDate, endDate) {
+      return this.diffInOpenMinutes(startDate, endDate) / 60;
+    }
+    diffInOpenMinutes(startDate, endDate) {
+      let start = this.toTimezone(startDate);
+      let end = this.toTimezone(endDate);
+      if (start > end) {
+        const temp = start;
+        start = end;
+        end = temp;
+      }
+      let openMinutes = 0;
+      const currentDate = new Date(start);
+      while (currentDate < end) {
+        const nextDay = new Date(currentDate);
+        nextDay.setDate(nextDay.getDate() + 1);
+        nextDay.setHours(0, 0, 0, 0);
+        const endOfSegment = new Date(Math.min(nextDay.getTime(), end.getTime()));
+        openMinutes += this.calculateOpenMinutesForTimespan(currentDate, endOfSegment);
+        currentDate.setTime(nextDay.getTime());
+      }
+      if (this.hasExceptionBetween(start, end)) {
+        const fullDayMinutes = this.forDate(end).getTimeRanges().reduce((sum, range) => sum + range.durationInMinutes(this.overflow), 0);
+        const startOfEnd = new Date(end);
+        startOfEnd.setHours(0, 0, 0, 0);
+        const partialEnd = this.calculateOpenMinutesForTimespan(startOfEnd, end);
+        openMinutes += fullDayMinutes - partialEnd;
+      }
+      return openMinutes;
+    }
+    calculateOpenMinutesForTimespan(start, end) {
+      const openingHoursForDay = this.forDate(start);
+      if (!openingHoursForDay.isOpenDuringDay()) {
+        return 0;
+      }
+      let openMinutes = 0;
+      const timeRanges = openingHoursForDay.getTimeRanges();
+      for (const range of timeRanges) {
+        const rangeStart = range.getStart().toDate(start);
+        const rangeEnd = range.getEnd().toDate(start);
+        if (range.spansOvernight() && this.overflow) {
+          rangeEnd.setDate(rangeEnd.getDate() + 1);
+        }
+        if (rangeEnd <= start || rangeStart >= end) {
+          continue;
+        }
+        const overlapStart = new Date(Math.max(rangeStart.getTime(), start.getTime()));
+        const overlapEnd = new Date(Math.min(rangeEnd.getTime(), end.getTime()));
+        openMinutes += (overlapEnd.getTime() - overlapStart.getTime()) / (60 * 1000);
+      }
+      return openMinutes;
+    }
+    hasExceptionBetween(start, end) {
+      const current = new Date(start);
+      current.setDate(current.getDate() + 1);
+      current.setHours(0, 0, 0, 0);
+      const endDate = new Date(end);
+      endDate.setHours(0, 0, 0, 0);
+      while (current < endDate) {
+        if (this.exceptions.has(this.formatDate(current))) {
+          return true;
+        }
+        current.setDate(current.getDate() + 1);
+      }
+      return false;
+    }
+    diffInOpenSeconds(startDate, endDate) {
+      return this.diffInOpenMinutes(startDate, endDate) * 60;
+    }
+    diffInClosedHours(startDate, endDate) {
+      return this.diffInClosedMinutes(startDate, endDate) / 60;
+    }
+    diffInClosedMinutes(startDate, endDate) {
+      const totalMinutes = Math.abs(endDate.getTime() - startDate.getTime()) / (60 * 1000);
+      const openMinutes = this.diffInOpenMinutes(startDate, endDate);
+      return totalMinutes - openMinutes;
+    }
+    diffInClosedSeconds(startDate, endDate) {
+      return this.diffInClosedMinutes(startDate, endDate) * 60;
+    }
+    currentOpenRange(dateTime) {
+      const adjustedDateTime = this.toTimezone(dateTime);
+      return this.forDate(adjustedDateTime).getCurrentOpenRangeAtDateTime(adjustedDateTime);
+    }
+    currentOpenRangeStart(dateTime) {
+      const adjustedDateTime = this.toTimezone(dateTime);
+      const range = this.forDate(adjustedDateTime).getCurrentOpenRangeAtDateTime(adjustedDateTime);
+      if (!range) {
+        return null;
+      }
+      const result = range.getStart().toDate(adjustedDateTime);
+      if (this.overflow) {
+        const midnight = new Date(adjustedDateTime);
+        midnight.setHours(0, 0, 0, 0);
+        if (result < midnight && adjustedDateTime >= midnight) {
+          result.setDate(result.getDate() - 1);
+        }
+      }
+      return this.timezone ? this.fromTimezone(result) : result;
+    }
+    currentOpenRangeEnd(dateTime) {
+      const adjustedDateTime = this.toTimezone(dateTime);
+      const range = this.forDate(adjustedDateTime).getCurrentOpenRangeAtDateTime(adjustedDateTime);
+      if (!range) {
+        return null;
+      }
+      const result = range.getEnd().toDate(adjustedDateTime);
+      if (this.overflow && range.spansOvernight()) {
+        result.setDate(result.getDate() + 1);
+      }
+      return this.timezone ? this.fromTimezone(result) : result;
+    }
+    findNextOpenRange(dateTime) {
+      let searchDate = this.toTimezone(dateTime);
+      let comparisonTime = new Date(searchDate);
+      for (let i = 0;i < 14; i++) {
+        const dayHours = this.forDate(searchDate);
+        const ranges = dayHours.getTimeRanges();
+        for (const range of ranges) {
+          const start = range.getStart().toDate(searchDate);
+          const end = range.getEnd().toDate(searchDate);
+          if (this.overflow && range.spansOvernight()) {
+            end.setDate(end.getDate() + 1);
+          }
+          if (end <= comparisonTime) {
+            continue;
+          }
+          if (start > comparisonTime) {
+            return { range, date: new Date(searchDate) };
+          }
+        }
+        searchDate = new Date(searchDate);
+        searchDate.setDate(searchDate.getDate() + 1);
+        searchDate.setHours(0, 0, 0, 0);
+        comparisonTime = searchDate;
+      }
+      return null;
+    }
+    findPreviousOpenRange(dateTime) {
+      let searchDate = this.toTimezone(dateTime);
+      let comparisonTime = new Date(searchDate);
+      for (let i = 0;i < 14; i++) {
+        const dayHours = this.forDate(searchDate);
+        const ranges = dayHours.getTimeRanges();
+        for (let j = ranges.length - 1;j >= 0; j--) {
+          const range = ranges[j];
+          if (!range)
+            continue;
+          const start = range.getStart().toDate(searchDate);
+          const end = range.getEnd().toDate(searchDate);
+          if (this.overflow && range.spansOvernight()) {
+            end.setDate(end.getDate() + 1);
+          }
+          if (start <= comparisonTime && end > comparisonTime) {
+            return { range, date: new Date(searchDate) };
+          }
+          if (end < comparisonTime) {
+            return { range, date: new Date(searchDate) };
+          }
+        }
+        searchDate = new Date(searchDate);
+        searchDate.setDate(searchDate.getDate() - 1);
+        searchDate.setHours(0, 0, 0, 0);
+        comparisonTime = new Date(searchDate);
+        comparisonTime.setHours(23, 59, 59, 999);
+      }
+      return null;
+    }
+    nextOpenRange(dateTime) {
+      const result = this.findNextOpenRange(dateTime);
+      return result ? result.range : null;
+    }
+    nextOpenRangeStart(dateTime) {
+      const result = this.findNextOpenRange(dateTime);
+      if (!result) {
+        return null;
+      }
+      const start = result.range.getStart().toDate(result.date);
+      return this.timezone ? this.fromTimezone(start) : start;
+    }
+    nextOpenRangeEnd(dateTime) {
+      const result = this.findNextOpenRange(dateTime);
+      if (!result) {
+        return null;
+      }
+      const end = result.range.getEnd().toDate(result.date);
+      if (this.overflow && result.range.spansOvernight()) {
+        end.setDate(end.getDate() + 1);
+      }
+      return this.timezone ? this.fromTimezone(end) : end;
+    }
+    nextOpen(dateTime) {
+      return this.nextOpenRangeStart(dateTime);
+    }
+    nextClose(dateTime) {
+      if (this.isOpenAt(dateTime)) {
+        return this.currentOpenRangeEnd(dateTime);
+      }
+      return this.nextOpenRangeEnd(dateTime);
+    }
+    previousOpenRange(dateTime) {
+      const result = this.findPreviousOpenRange(dateTime);
+      return result ? result.range : null;
+    }
+    previousOpenRangeStart(dateTime) {
+      const result = this.findPreviousOpenRange(dateTime);
+      if (!result) {
+        return null;
+      }
+      const start = result.range.getStart().toDate(result.date);
+      return this.timezone ? this.fromTimezone(start) : start;
+    }
+    previousOpenRangeEnd(dateTime) {
+      const result = this.findPreviousOpenRange(dateTime);
+      if (!result) {
+        return null;
+      }
+      const end = result.range.getEnd().toDate(result.date);
+      if (this.overflow && result.range.spansOvernight()) {
+        end.setDate(end.getDate() + 1);
+      }
+      return this.timezone ? this.fromTimezone(end) : end;
+    }
+    static from(config) {
+      return new OpeningHours(config);
+    }
+    static createFromStructuredData(inputData, displayOptions = {}) {
+      let data = inputData;
+      if (typeof data === "string") {
+        try {
+          data = JSON.parse(data);
+        } catch (_e) {
+          throw new Error("Invalid JSON string for structured data");
+        }
+      }
+      if (!Array.isArray(data)) {
+        throw new Error("Structured data must be an array of OpeningHoursSpecification");
+      }
+      const config = {};
+      const exceptions = {};
+      for (const item of data) {
+        const opens = item.opens;
+        const closes = item.closes;
+        if (!opens || !closes) {
+          continue;
+        }
+        const startStr = Time.fromString(opens).toString();
+        const endStr = Time.fromString(closes).toString();
+        const timeRange = `${startStr}-${endStr}`;
+        if (item.validFrom && item.validThrough) {
+          const fromDate = new Date(item.validFrom);
+          const throughDate = new Date(item.validThrough);
+          const current = new Date(fromDate);
+          while (current <= throughDate) {
+            const dateStr = current.toISOString().split("T")[0];
+            if (!exceptions[dateStr]) {
+              exceptions[dateStr] = [];
+            }
+            exceptions[dateStr]?.push(timeRange);
+            current.setDate(current.getDate() + 1);
+          }
+          continue;
+        }
+        if (item.dayOfWeek) {
+          const days = Array.isArray(item.dayOfWeek) ? item.dayOfWeek : [item.dayOfWeek];
+          for (const day of days) {
+            let dayName;
+            if (typeof day === "string" && day.includes("schema.org/")) {
+              const parts = day.split("/");
+              const lastPart = parts[parts.length - 1];
+              dayName = lastPart.toLowerCase();
+            } else {
+              dayName = day.toLowerCase();
+            }
+            if (dayName in Days) {
+              if (!config[dayName]) {
+                config[dayName] = [];
+              }
+              config[dayName].push(timeRange);
+            }
+          }
+        }
+      }
+      if (Object.keys(exceptions).length > 0) {
+        config.exceptions = exceptions;
+      }
+      return new OpeningHours({ ...config, ...displayOptions });
+    }
+    formatISOTime(time, timezone) {
+      const hh = time.getHour().toString().padStart(2, "0");
+      const mm = time.getMinute().toString().padStart(2, "0");
+      const ss = "00";
+      if (timezone) {
+        try {
+          const formatter = new Intl.DateTimeFormat("en", {
+            timeZone: timezone,
+            timeZoneName: "longOffset"
+          });
+          const parts = formatter.formatToParts(new Date);
+          const offsetPart = parts.find((part) => part.type === "timeZoneName");
+          if (offsetPart?.value.match(/GMT[+-]\d{2}:\d{2}/)) {
+            const offset = offsetPart.value.replace("GMT", "");
+            return `${hh}:${mm}:${ss}${offset}`;
+          }
+        } catch (_error) {}
+        return `${hh}:${mm}:${ss}`;
+      }
+      return `${hh}:${mm}:${ss}Z`;
+    }
+    asStructuredData(timezone) {
+      const usedTimezone = timezone || this.timezone || null;
+      const result = [];
+      const dayMap = {};
+      for (const day in Days) {
+        const dayRanges = this.forDay(day).getTimeRanges();
+        for (const range of dayRanges) {
+          const key = range.toString();
+          if (!dayMap[key]) {
+            dayMap[key] = [];
+          }
+          dayMap[key].push(range);
+        }
+      }
+      for (const [timeRangeStr, ranges] of Object.entries(dayMap)) {
+        const days = [];
+        if (ranges.length === 0) {
+          continue;
+        }
+        const timeRange = ranges[0];
+        for (const day in Days) {
+          const dayRanges = this.forDay(day).getTimeRanges();
+          if (dayRanges.some((r) => r.toString() === timeRangeStr)) {
+            days.push(`https://schema.org/${day.charAt(0).toUpperCase() + day.slice(1)}`);
+          }
+        }
+        if (days.length > 0) {
+          result.push({
+            "@type": "OpeningHoursSpecification",
+            dayOfWeek: days,
+            opens: this.formatISOTime(timeRange.getStart(), usedTimezone),
+            closes: this.formatISOTime(timeRange.getEnd(), usedTimezone)
+          });
+        }
+      }
+      for (const [dateStr, openingHours] of Object.entries(this.getExceptions())) {
+        const ranges = openingHours.getTimeRanges();
+        if (ranges.length === 0) {
+          result.push({
+            "@type": "OpeningHoursSpecification",
+            validFrom: dateStr,
+            validThrough: dateStr,
+            opens: "00:00:00Z",
+            closes: "00:00:00Z"
+          });
+        } else {
+          for (const range of ranges) {
+            result.push({
+              "@type": "OpeningHoursSpecification",
+              validFrom: dateStr,
+              validThrough: dateStr,
+              opens: this.formatISOTime(range.getStart(), usedTimezone),
+              closes: this.formatISOTime(range.getEnd(), usedTimezone)
+            });
+          }
+        }
+      }
+      return result;
+    }
+    toTimezone(date) {
+      if (!this.timezone) {
+        return new Date(date);
+      }
+      try {
+        return new Date(date.toLocaleString("en-US", { timeZone: this.timezone }));
+      } catch (_e) {
+        console.warn(`Invalid timezone: ${this.timezone}. Using local timezone.`);
+        return new Date(date);
+      }
+    }
+    fromTimezone(date) {
+      if (!this.timezone) {
+        return new Date(date);
+      }
+      try {
+        const inv = new Date(date.toLocaleString("en-US", { timeZone: this.timezone }));
+        const diff = inv.getTime() - date.getTime();
+        return new Date(date.getTime() - diff);
+      } catch (_e) {
+        console.warn(`Invalid timezone: ${this.timezone}. Using local timezone.`);
+        return new Date(date);
+      }
+    }
+    getScheduleStringForDay(day) {
+      const timeRanges = this.getTimeRangesForDayOfWeek(day);
+      return timeRanges.map((tr) => tr.toString()).join(",");
+    }
+    getTimeRangesForDayOfWeek(day) {
+      const schedule = this.schedule.get(day) || [];
+      return schedule.map((tr) => this.convertToTimeRange(tr));
+    }
+    formatDayRange(days, options = {}) {
+      const { locale = "en-US", weekday = "short", dayRangeSeparator = "..." } = options;
+      const first = this.formatDayName(days[0], locale, weekday);
+      if (days.length === 1) {
+        return first;
+      }
+      const last = this.formatDayName(days[days.length - 1], locale, weekday);
+      return `${first}${dayRangeSeparator}${last}`;
+    }
+    formatTimeRange(timeRange, options = {}) {
+      const {
+        timeRangeSeparator = "-",
+        timeFormat,
+        locale = "en-US"
+      } = {
+        ...this.displayOptions,
+        ...options
+      };
+      const defaultFormat = locale === "en-US" ? "gA" : "H:i";
+      const format = timeFormat || defaultFormat;
+      const startStr = timeRange.getStart().format(format);
+      const endStr = timeRange.getEnd().format(format);
+      let result = startStr + timeRangeSeparator + endStr;
+      const data = timeRange.getData();
+      if (data && typeof data.note === "string" && data.note.length > 0) {
+        result += ` (${data.note})`;
+      }
+      return result;
+    }
+    toArray(options = {}) {
+      const mergedOptions = { ...this.displayOptions, ...options };
+      const {
+        locale = "en-US",
+        weekday = "short",
+        firstDayOfWeek = "monday",
+        showTimezone = !!this.timezone,
+        timeZoneName = "shortGeneric",
+        closedText = "Closed",
+        dayRangeSeparator = "..."
+      } = mergedOptions;
+      const tz = showTimezone ? this.getTimezoneName(locale, timeZoneName) : "";
+      const orderedDays = firstDayOfWeek === "sunday" ? ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"] : [
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+        "sunday"
+      ];
+      const groups = [];
+      let currentGroup = [];
+      let currentSchedule = "";
+      for (const day of orderedDays) {
+        const schedule = this.getScheduleStringForDay(day);
+        if (currentGroup.length === 0 || schedule === currentSchedule) {
+          currentGroup.push(day);
+        } else {
+          groups.push(currentGroup);
+          currentGroup = [day];
+        }
+        currentSchedule = schedule;
+      }
+      if (currentGroup.length > 0) {
+        groups.push(currentGroup);
+      }
+      const result = [];
+      for (const group of groups) {
+        const dayRange = this.formatDayRange(group, {
+          locale,
+          weekday,
+          dayRangeSeparator
+        });
+        const day = group[0];
+        const timeRanges = this.getTimeRangesForDayOfWeek(day);
+        if (timeRanges.length === 0) {
+          result.push([dayRange, closedText]);
+          continue;
+        }
+        const formatted = timeRanges.map((tr) => this.formatTimeRange(tr, mergedOptions));
+        if (tz && formatted.length > 0) {
+          formatted[formatted.length - 1] += ` ${tz}`;
+        }
+        result.push([dayRange, ...formatted]);
+      }
+      return result;
+    }
+    formatDayName(day, locale = "en-US", weekday = "short") {
+      const dayIndex = Days[day];
+      const date = new Date(2023, 0, 1 + dayIndex);
+      return new Intl.DateTimeFormat(locale, { weekday }).format(date);
+    }
+    getTimezoneName(locale, timeZoneName = "shortGeneric") {
+      const zone = this.timezone;
+      if (!zone) {
+        return "";
+      }
+      const formatter = new Intl.DateTimeFormat(locale, {
+        timeZone: zone,
+        timeZoneName
+      });
+      const parts = formatter.formatToParts(new Date);
+      const tzPart = parts.find((p) => p.type === "timeZoneName");
+      return tzPart?.value || "";
+    }
+    toString(options = {}) {
+      const mergedOptions = { ...this.displayOptions, ...options };
+      const { timeRangesSeparator = ", " } = mergedOptions;
+      return this.toArray(mergedOptions).map((row) => {
+        if (row.length <= 1)
+          return row.join("");
+        const [dayPart, ...timeRanges] = row;
+        return `${dayPart} ${timeRanges.join(timeRangesSeparator)}`;
+      }).join(`
+`);
+    }
+  }
+})();