@hebcal/icalendar 7.0.2 → 7.0.4

package/dist/foldLine.js

@@ -1,6 +1,28 @@
 import { Buffer } from 'node:buffer';
 let foldSegmenter;
-const char74re = /.{1,74}/g;
+/**
+ * Number of UTF-8 octets used to encode the code point starting at `i`.
+ * Returns 4 for a surrogate pair (which occupies two UTF-16 units).
+ */
+function octetsAt(line, i) {
+    const c = line.charCodeAt(i);
+    if (c < 0x80) {
+        return 1;
+    }
+    if (c < 0x800) {
+        return 2;
+    }
+    // A high surrogate starts a 4-octet code point; an unpaired surrogate
+    // still encodes as 3 octets, but WHATWG replaces it with U+FFFD, which
+    // is also 3 octets, so the count stays correct either way.
+    if (c >= 0xd800 && c <= 0xdbff && i + 1 < line.length) {
+        const lo = line.charCodeAt(i + 1);
+        if (lo >= 0xdc00 && lo <= 0xdfff) {
+            return 4;
+        }
+    }
+    return 3;
+}
 export function foldLine(line) {
     const lineBytes = Buffer.byteLength(line);
     if (lineBytes <= 74) {
@@ -9,38 +31,58 @@ export function foldLine(line) {
     if (lineBytes === line.length) {
         // All-ASCII fast path: every UTF-16 unit encodes to one UTF-8 byte
         // iff the string is pure ASCII, so we can split by JS chars.
-        return line.match(char74re).join('\r\n ');
+        // A /.{1,74}/g regex looks tempting here but is wrong: `.` does not
+        // match \r or \n, so it silently drops those characters and returns
+        // null outright for a line built only from them.
+        const parts = [];
+        for (let i = 0; i < line.length; i += 74) {
+            parts.push(line.slice(i, i + 74));
+        }
+        return parts.join('\r\n ');
     }
-    // Walk grapheme clusters so we never split a multi-octet UTF-8
-    // sequence (or a combining/ZWJ/regional-indicator cluster) across
-    // a fold boundary. Reuse a single Segmenter to avoid per-call
-    // construction cost.
+    // Fold on code-point boundaries so a multi-octet UTF-8 sequence is never
+    // split, then pull each break back to the start of its grapheme cluster
+    // so combining marks, ZWJ sequences and regional-indicator pairs stay
+    // with their base character.
+    //
+    // Only the break positions need the Segmenter, and there are at most
+    // lineBytes/74 of them, so we ask it about those offsets via
+    // `containing()` rather than iterating every cluster in the line --
+    // the same fold points for a fraction of the work.
     if (!foldSegmenter) {
         foldSegmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
     }
+    const segments = foldSegmenter.segment(line);
     const parts = [];
+    const n = line.length;
     let chunkStart = 0;
     let len = 0;
-    for (const { segment, index } of foldSegmenter.segment(line)) {
-        const cp = segment.codePointAt(0);
-        // Most segments are a single code point; compute UTF-8 length
-        // arithmetically and skip the Buffer.byteLength call.
-        const cpUnits = cp >= 0x10000 ? 2 : 1;
-        let octets;
-        if (segment.length === cpUnits) {
-            octets = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
-        }
-        else {
-            octets = Buffer.byteLength(segment);
-        }
+    let i = 0;
+    while (i < n) {
+        const octets = octetsAt(line, i);
+        const units = octets === 4 ? 2 : 1;
         if (len + octets >= 75) {
-            parts.push(line.slice(chunkStart, index));
-            chunkStart = index;
-            len = octets;
+            let brk = i;
+            if (i > chunkStart) {
+                const cluster = segments.containing(i);
+                // Back up to the cluster start, unless that would consume the whole
+                // chunk -- a single cluster wider than the limit has to be split.
+                if (cluster && cluster.index > chunkStart && cluster.index < i) {
+                    brk = cluster.index;
+                }
+            }
+            parts.push(line.slice(chunkStart, brk));
+            chunkStart = brk;
+            // Anything we backed up over carries into the next chunk.
+            len = 0;
+            for (let k = brk; k < i + units; k += octetsAt(line, k) === 4 ? 2 : 1) {
+                len += octetsAt(line, k);
+            }
         }
         else {
             len += octets;
         }
+        i += units;
     }
     parts.push(line.slice(chunkStart));
     return parts.join('\r\n ');

package/dist/icalendar.js

@@ -59,6 +59,37 @@ const DAILY_LEARNING = flags.DAILY_LEARNING |
     flags.MISHNA_YOMI |
     flags.YERUSHALMI_YOMI |
     flags.NACH_YOMI;
+/** Formats a date-time string as `YYYYMMDDTHHMMSS` */
+function rfc5545DateTime(dt, hour, minute) {
+    return IcalEvent.formatYYYYMMDD(dt) + 'T' + pad2(hour) + pad2(minute) + '00';
+}
+/**
+ * Computes the DTSTART/DTEND date-time strings (in `YYYYMMDDTHHMMSS`
+ * format) for a timed event, adding `duration` minutes (if any) to the
+ * wall-clock start time. Adding to the wall clock (rather than to the
+ * underlying instant) keeps the result in the same timezone as DTSTART
+ * regardless of the host machine's own local timezone.
+ * @private
+ */
+function formatTimedStartEnd(ev) {
+    const [hourStr, minuteStr] = ev.eventTimeStr.split(':');
+    const hour = +hourStr;
+    const minute = +minuteStr;
+    const dt = ev.greg();
+    const startDate = rfc5545DateTime(dt, hour, minute);
+    if (!ev.duration) {
+        return { startDate, endDate: startDate };
+    }
+    const totalMinutes = hour * 60 + minute + ev.duration;
+    const endHour = Math.floor(totalMinutes / 60) % 24;
+    const endMinute = totalMinutes % 60;
+    const dayOffset = Math.floor(totalMinutes / 1440);
+    if (dayOffset) {
+        dt.setDate(dt.getDate() + dayOffset);
+    }
+    const endDate = rfc5545DateTime(dt, endHour, endMinute);
+    return { startDate, endDate };
+}
 /**
  * Represents an RFC 2445 iCalendar VEVENT
  */
@@ -117,11 +148,9 @@ export class IcalEvent {
         this.transp = 'TRANSPARENT';
         this.busyStatus = 'FREE';
         if (timed) {
-            let [hour, minute] = ev0.eventTimeStr.split(':');
-            hour = +hour;
-            minute = +minute;
-            this.startDate += 'T' + pad2(hour) + pad2(minute) + '00';
-            this.endDate = this.startDate;
+            const { startDate, endDate } = formatTimedStartEnd(ev);
+            this.startDate = startDate;
+            this.endDate = endDate;
             if (location?.getTzid()) {
                 this.dtargs = `;TZID=${location.getTzid()}`;
             }

package/dist/pkgVersion.d.ts

@@ -1 +1 @@
-export declare const version = "7.0.2";
+export declare const version = "7.0.4";

package/dist/pkgVersion.js

@@ -1,2 +1,2 @@
 // DO NOT EDIT THIS AUTO-GENERATED FILE!
-export const version = '7.0.2';
+export const version = '7.0.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebcal/icalendar",
-  "version": "7.0.2",
+  "version": "7.0.4",
   "author": "Michael J. Radwin (https://github.com/mjradwin)",
   "keywords": [
     "ical",
@@ -30,10 +30,10 @@
   },
   "homepage": "https://hebcal.github.io/api/icalendar/",
   "dependencies": {
-    "@hebcal/core": "^6.9.1",
-    "@hebcal/hdate": "^0.22.7",
+    "@hebcal/core": "^6.9.3",
+    "@hebcal/hdate": "^0.22.8",
     "@hebcal/murmurhash3": "^1.0.0",
-    "@hebcal/rest-api": "^7.1.1"
+    "@hebcal/rest-api": "^7.1.3"
   },
   "scripts": {
     "build:version": "node ./version.js package.json src/pkgVersion.ts",
@@ -48,11 +48,11 @@
   },
   "license": "BSD-2-Clause",
   "devDependencies": {
-    "@hebcal/learning": "^6.9.5",
-    "@types/node": "26.1.2",
-    "oxlint": "^1.76.0",
-    "prettier": "^3.9.6",
+    "@hebcal/learning": "^6.11.3",
+    "@types/node": "26.6.2",
+    "oxlint": "^1.83.0",
+    "prettier": "^3.9.8",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.1"
   }
 }