@hebcal/icalendar 7.0.1 → 7.0.3

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/pkgVersion.d.ts

@@ -1 +1 @@
-export declare const version = "7.0.1";
+export declare const version = "7.0.3";

package/dist/pkgVersion.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebcal/icalendar",
-  "version": "7.0.1",
+  "version": "7.0.3",
   "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.8.2",
-    "@hebcal/hdate": "^0.22.5",
+    "@hebcal/core": "^6.9.1",
+    "@hebcal/hdate": "^0.22.7",
     "@hebcal/murmurhash3": "^1.0.0",
-    "@hebcal/rest-api": "^7.0.0"
+    "@hebcal/rest-api": "^7.1.3"
   },
   "scripts": {
     "build:version": "node ./version.js package.json src/pkgVersion.ts",
@@ -48,9 +48,9 @@
   },
   "license": "BSD-2-Clause",
   "devDependencies": {
-    "@hebcal/learning": "^6.9.5",
-    "@types/node": "26.1.1",
-    "oxlint": "^1.76.0",
+    "@hebcal/learning": "^6.9.7",
+    "@types/node": "26.2.0",
+    "oxlint": "^1.77.0",
     "prettier": "^3.9.6",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"