ezmedicationinput 0.1.9 → 0.1.12

package/dist/parser.js

@@ -1,13 +1,25 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokenize = tokenize;
 exports.parseInternal = parseInternal;
+exports.applySiteCoding = applySiteCoding;
+exports.applySiteCodingAsync = applySiteCodingAsync;
 const maps_1 = require("./maps");
 const context_1 = require("./context");
 const safety_1 = require("./safety");
 const types_1 = require("./types");
 const object_1 = require("./utils/object");
 const array_1 = require("./utils/array");
+const SNOMED_SYSTEM = "http://snomed.info/sct";
 const BODY_SITE_HINTS = new Set([
     "left",
     "right",
@@ -66,10 +78,14 @@ const BODY_SITE_HINTS = new Set([
     "veins",
     "vagina",
     "vaginal",
+    "penis",
+    "penile",
     "rectum",
     "rectal",
     "anus",
-    "perineum"
+    "perineum",
+    "temple",
+    "temples"
 ]);
 const SITE_CONNECTORS = new Set(["to", "in", "into", "on", "onto", "at"]);
 const SITE_FILLER_WORDS = new Set([
@@ -241,7 +257,7 @@ const OPHTHALMIC_CONTEXT_TOKENS = new Set([
     "be"
 ]);
 function normalizeTokenLower(token) {
-    return token.lower.replace(/\./g, "");
+    return token.lower.replace(/[.{}]/g, "");
 }
 function hasOphthalmicContextHint(tokens, index) {
     for (let offset = -3; offset <= 3; offset++) {
@@ -605,6 +621,68 @@ function tokenize(input) {
     }
     return tokens;
 }
+/**
+ * Locates the span of the detected site tokens within the caller's original
+ * input so downstream consumers can highlight or replace the exact substring.
+ */
+function computeSiteTextRange(input, tokens, indices) {
+    if (!indices.length) {
+        return undefined;
+    }
+    const lowerInput = input.toLowerCase();
+    let searchStart = 0;
+    let rangeStart;
+    let rangeEnd;
+    for (const tokenIndex of indices) {
+        const token = tokens[tokenIndex];
+        if (!token) {
+            continue;
+        }
+        const segment = token.original.trim();
+        if (!segment) {
+            continue;
+        }
+        const lowerSegment = segment.toLowerCase();
+        const foundIndex = lowerInput.indexOf(lowerSegment, searchStart);
+        if (foundIndex === -1) {
+            return undefined;
+        }
+        const segmentEnd = foundIndex + lowerSegment.length;
+        if (rangeStart === undefined) {
+            rangeStart = foundIndex;
+        }
+        rangeEnd = segmentEnd;
+        searchStart = segmentEnd;
+    }
+    if (rangeStart === undefined || rangeEnd === undefined) {
+        return undefined;
+    }
+    return { start: rangeStart, end: rangeEnd };
+}
+/**
+ * Prefers highlighting the sanitized site text when it can be located directly
+ * in the original input; otherwise falls back to the broader token-derived
+ * range.
+ */
+function refineSiteRange(input, sanitized, tokenRange) {
+    if (!input) {
+        return tokenRange;
+    }
+    const trimmed = sanitized.trim();
+    if (!trimmed) {
+        return tokenRange;
+    }
+    const lowerInput = input.toLowerCase();
+    const lowerSanitized = trimmed.toLowerCase();
+    let startIndex = tokenRange ? lowerInput.indexOf(lowerSanitized, tokenRange.start) : -1;
+    if (startIndex === -1) {
+        startIndex = lowerInput.indexOf(lowerSanitized);
+    }
+    if (startIndex === -1) {
+        return tokenRange;
+    }
+    return { start: startIndex, end: startIndex + lowerSanitized.length };
+}
 function splitToken(token) {
     if (/^[0-9]+(?:\.[0-9]+)?$/.test(token)) {
         return [token];
@@ -1169,7 +1247,8 @@ function parseInternal(input, options) {
         dayOfWeek: [],
         when: [],
         warnings: [],
-        siteTokenIndices: new Set()
+        siteTokenIndices: new Set(),
+        siteLookups: []
     };
     const context = (_a = options === null || options === void 0 ? void 0 : options.context) !== null && _a !== void 0 ? _a : undefined;
     const customRouteMap = (options === null || options === void 0 ? void 0 : options.routeMap)
@@ -1630,7 +1709,8 @@ function parseInternal(input, options) {
     const leftoverTokens = tokens.filter((t) => !internal.consumed.has(t.index));
     const siteCandidateIndices = new Set();
     for (const token of leftoverTokens) {
-        if (BODY_SITE_HINTS.has(token.lower)) {
+        const normalized = normalizeTokenLower(token);
+        if (BODY_SITE_HINTS.has(normalized)) {
             siteCandidateIndices.add(token.index);
         }
     }
@@ -1646,7 +1726,7 @@ function parseInternal(input, options) {
                 if (!token) {
                     break;
                 }
-                const lower = token.lower;
+                const lower = normalizeTokenLower(token);
                 if (SITE_CONNECTORS.has(lower) ||
                     BODY_SITE_HINTS.has(lower) ||
                     ROUTE_DESCRIPTOR_FILLER_WORDS.has(lower)) {
@@ -1662,7 +1742,7 @@ function parseInternal(input, options) {
                 if (!token) {
                     break;
                 }
-                const lower = token.lower;
+                const lower = normalizeTokenLower(token);
                 if (SITE_CONNECTORS.has(lower) ||
                     BODY_SITE_HINTS.has(lower) ||
                     ROUTE_DESCRIPTOR_FILLER_WORDS.has(lower)) {
@@ -1680,8 +1760,10 @@ function parseInternal(input, options) {
             if (!token) {
                 continue;
             }
-            const lower = token.lower;
-            if (!SITE_CONNECTORS.has(lower) && !SITE_FILLER_WORDS.has(lower)) {
+            const lower = normalizeTokenLower(token);
+            const trimmed = token.original.trim();
+            const isBraceToken = trimmed.length > 0 && /^[{}]+$/.test(trimmed);
+            if (!isBraceToken && !SITE_CONNECTORS.has(lower) && !SITE_FILLER_WORDS.has(lower)) {
                 displayWords.push(token.original);
             }
             mark(internal.consumed, token);
@@ -1691,16 +1773,45 @@ function parseInternal(input, options) {
             .join(" ")
             .trim();
         if (normalizedSite) {
-            const normalizedLower = normalizedSite.toLowerCase();
-            const strippedDescriptor = normalizeRouteDescriptorPhrase(normalizedLower);
-            const siteWords = normalizedLower.split(/\s+/).filter((word) => word.length > 0);
-            const hasNonSiteWords = siteWords.some((word) => !BODY_SITE_HINTS.has(word));
-            const shouldAttemptRouteDescriptor = strippedDescriptor !== normalizedLower || hasNonSiteWords || strippedDescriptor === "mouth";
-            const appliedRouteDescriptor = shouldAttemptRouteDescriptor && maybeApplyRouteDescriptor(normalizedSite);
-            if (!appliedRouteDescriptor) {
-                internal.siteText = normalizedSite;
-                if (!internal.siteSource) {
-                    internal.siteSource = "text";
+            const tokenRange = computeSiteTextRange(internal.input, tokens, sortedIndices);
+            let sanitized = normalizedSite;
+            let isProbe = false;
+            const probeMatch = sanitized.match(/^\{(.+)}$/);
+            if (probeMatch) {
+                // `{site}` placeholders flag interactive lookups so consumers can prompt
+                // for a coded selection even when the parser cannot resolve the entry.
+                isProbe = true;
+                sanitized = probeMatch[1];
+            }
+            // Remove stray braces and normalize whitespace so lookups and downstream
+            // displays operate on a clean phrase.
+            sanitized = sanitized.replace(/[{}]/g, " ").replace(/\s+/g, " ").trim();
+            const range = refineSiteRange(internal.input, sanitized, tokenRange);
+            const sourceText = range ? internal.input.slice(range.start, range.end) : undefined;
+            internal.siteLookupRequest = {
+                originalText: normalizedSite,
+                text: sanitized,
+                normalized: sanitized.toLowerCase(),
+                canonical: sanitized ? (0, maps_1.normalizeBodySiteKey)(sanitized) : "",
+                isProbe,
+                inputText: internal.input,
+                sourceText,
+                range
+            };
+            if (sanitized) {
+                const normalizedLower = sanitized.toLowerCase();
+                const strippedDescriptor = normalizeRouteDescriptorPhrase(normalizedLower);
+                const siteWords = normalizedLower.split(/\s+/).filter((word) => word.length > 0);
+                const hasNonSiteWords = siteWords.some((word) => !BODY_SITE_HINTS.has(word));
+                const shouldAttemptRouteDescriptor = strippedDescriptor !== normalizedLower || hasNonSiteWords || strippedDescriptor === "mouth";
+                const appliedRouteDescriptor = shouldAttemptRouteDescriptor && maybeApplyRouteDescriptor(sanitized);
+                if (!appliedRouteDescriptor) {
+                    // Preserve the clean site text for FHIR output and resolver context
+                    // whenever we keep the original phrase.
+                    internal.siteText = sanitized;
+                    if (!internal.siteSource) {
+                        internal.siteSource = "text";
+                    }
                 }
             }
         }
@@ -1734,6 +1845,249 @@ function parseInternal(input, options) {
     }
     return internal;
 }
+/**
+ * Resolves parsed site text against SNOMED dictionaries and synchronous
+ * callbacks, applying the best match to the in-progress parse result.
+ */
+function applySiteCoding(internal, options) {
+    runSiteCodingResolutionSync(internal, options);
+}
+/**
+ * Asynchronous counterpart to {@link applySiteCoding} that awaits resolver and
+ * suggestion callbacks so remote terminology services can be used.
+ */
+function applySiteCodingAsync(internal, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield runSiteCodingResolutionAsync(internal, options);
+    });
+}
+/**
+ * Attempts to resolve site codings using built-in dictionaries followed by any
+ * provided synchronous resolvers. Suggestions are collected when resolution
+ * fails or a `{probe}` placeholder requested an interactive lookup.
+ */
+function runSiteCodingResolutionSync(internal, options) {
+    internal.siteLookups = [];
+    const request = internal.siteLookupRequest;
+    if (!request) {
+        return;
+    }
+    const canonical = request.canonical;
+    const customDefinition = lookupBodySiteDefinition(options === null || options === void 0 ? void 0 : options.siteCodeMap, canonical);
+    let resolution = customDefinition;
+    if (!resolution) {
+        // Allow synchronous resolver callbacks to claim the site.
+        for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.siteCodeResolvers)) {
+            const result = resolver(request);
+            if (isPromise(result)) {
+                throw new Error("Site code resolver returned a Promise; use parseSigAsync for asynchronous site resolution.");
+            }
+            if (result) {
+                resolution = result;
+                break;
+            }
+        }
+    }
+    const defaultDefinition = canonical ? maps_1.DEFAULT_BODY_SITE_SNOMED[canonical] : undefined;
+    if (!resolution && defaultDefinition) {
+        // Fall back to bundled SNOMED lookups when no overrides claim the site.
+        resolution = defaultDefinition;
+    }
+    if (resolution) {
+        applySiteDefinition(internal, resolution);
+    }
+    else {
+        internal.siteCoding = undefined;
+    }
+    const needsSuggestions = request.isProbe || !resolution;
+    if (!needsSuggestions) {
+        return;
+    }
+    const suggestionMap = new Map();
+    if (customDefinition) {
+        addSuggestionToMap(suggestionMap, definitionToSuggestion(customDefinition));
+    }
+    if (defaultDefinition) {
+        addSuggestionToMap(suggestionMap, definitionToSuggestion(defaultDefinition));
+    }
+    for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.siteCodeSuggestionResolvers)) {
+        // Aggregates resolver suggestions while guarding against accidental async
+        // usage, mirroring the behavior of site resolvers.
+        const result = resolver(request);
+        if (isPromise(result)) {
+            throw new Error("Site code suggestion resolver returned a Promise; use parseSigAsync for asynchronous site suggestions.");
+        }
+        collectSuggestionResult(suggestionMap, result);
+    }
+    const suggestions = Array.from(suggestionMap.values());
+    if (suggestions.length || request.isProbe) {
+        internal.siteLookups.push({ request, suggestions });
+    }
+}
+/**
+ * Async version of {@link runSiteCodingResolutionSync} that awaits resolver
+ * results and suggestion providers, enabling remote terminology services.
+ */
+function runSiteCodingResolutionAsync(internal, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        internal.siteLookups = [];
+        const request = internal.siteLookupRequest;
+        if (!request) {
+            return;
+        }
+        const canonical = request.canonical;
+        const customDefinition = lookupBodySiteDefinition(options === null || options === void 0 ? void 0 : options.siteCodeMap, canonical);
+        let resolution = customDefinition;
+        if (!resolution) {
+            // Await asynchronous resolver callbacks (e.g., HTTP terminology services).
+            for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.siteCodeResolvers)) {
+                const result = yield resolver(request);
+                if (result) {
+                    resolution = result;
+                    break;
+                }
+            }
+        }
+        const defaultDefinition = canonical ? maps_1.DEFAULT_BODY_SITE_SNOMED[canonical] : undefined;
+        if (!resolution && defaultDefinition) {
+            resolution = defaultDefinition;
+        }
+        if (resolution) {
+            applySiteDefinition(internal, resolution);
+        }
+        else {
+            internal.siteCoding = undefined;
+        }
+        const needsSuggestions = request.isProbe || !resolution;
+        if (!needsSuggestions) {
+            return;
+        }
+        const suggestionMap = new Map();
+        if (customDefinition) {
+            addSuggestionToMap(suggestionMap, definitionToSuggestion(customDefinition));
+        }
+        if (defaultDefinition) {
+            addSuggestionToMap(suggestionMap, definitionToSuggestion(defaultDefinition));
+        }
+        for (const resolver of toArray(options === null || options === void 0 ? void 0 : options.siteCodeSuggestionResolvers)) {
+            // Async suggestion providers are awaited, allowing UI workflows to fetch
+            // candidate codes on demand.
+            const result = yield resolver(request);
+            collectSuggestionResult(suggestionMap, result);
+        }
+        const suggestions = Array.from(suggestionMap.values());
+        if (suggestions.length || request.isProbe) {
+            internal.siteLookups.push({ request, suggestions });
+        }
+    });
+}
+/**
+ * Looks up a body-site definition in a caller-provided map, honoring both
+ * direct keys and entries that normalize to the same canonical phrase.
+ */
+function lookupBodySiteDefinition(map, canonical) {
+    if (!map) {
+        return undefined;
+    }
+    const direct = map[canonical];
+    if (direct) {
+        return direct;
+    }
+    for (const [key, definition] of (0, object_1.objectEntries)(map)) {
+        if ((0, maps_1.normalizeBodySiteKey)(key) === canonical) {
+            return definition;
+        }
+    }
+    return undefined;
+}
+/**
+ * Applies the selected body-site definition onto the parser state, defaulting
+ * the coding system to SNOMED CT when the definition omits one.
+ */
+function applySiteDefinition(internal, definition) {
+    var _a;
+    const coding = definition.coding;
+    internal.siteCoding = {
+        code: coding.code,
+        display: coding.display,
+        system: (_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM
+    };
+    if (definition.text) {
+        internal.siteText = definition.text;
+    }
+}
+/**
+ * Converts a body-site definition into a suggestion payload so all suggestion
+ * sources share consistent structure.
+ */
+function definitionToSuggestion(definition) {
+    var _a;
+    return {
+        coding: {
+            code: definition.coding.code,
+            display: definition.coding.display,
+            system: (_a = definition.coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM
+        },
+        text: definition.text
+    };
+}
+/**
+ * Inserts a suggestion into a deduplicated map keyed by system and code.
+ */
+function addSuggestionToMap(map, suggestion) {
+    var _a, _b;
+    if (!suggestion) {
+        return;
+    }
+    const coding = suggestion.coding;
+    if (!(coding === null || coding === void 0 ? void 0 : coding.code)) {
+        return;
+    }
+    const key = `${(_a = coding.system) !== null && _a !== void 0 ? _a : SNOMED_SYSTEM}|${coding.code}`;
+    if (!map.has(key)) {
+        map.set(key, {
+            coding: {
+                code: coding.code,
+                display: coding.display,
+                system: (_b = coding.system) !== null && _b !== void 0 ? _b : SNOMED_SYSTEM
+            },
+            text: suggestion.text
+        });
+    }
+}
+/**
+ * Normalizes resolver outputs into a consistent array before merging them into
+ * the suggestion map.
+ */
+function collectSuggestionResult(map, result) {
+    if (!result) {
+        return;
+    }
+    const suggestions = Array.isArray(result)
+        ? result
+        : typeof result === "object" && "suggestions" in result
+            ? result.suggestions
+            : [result];
+    for (const suggestion of suggestions) {
+        addSuggestionToMap(map, suggestion);
+    }
+}
+/**
+ * Wraps scalar or array configuration into an array to simplify iteration.
+ */
+function toArray(value) {
+    if (!value) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+/**
+ * Detects thenables without relying on `instanceof Promise`, which can break
+ * across execution contexts.
+ */
+function isPromise(value) {
+    return !!value && typeof value.then === "function";
+}
 function normalizeUnit(token, options) {
     var _a;
     const override = enforceHouseholdUnitPolicy((_a = options === null || options === void 0 ? void 0 : options.unitMap) === null || _a === void 0 ? void 0 : _a[token], options);

package/dist/schedule.js

@@ -475,6 +475,14 @@ function nextDueDoses(dosage, options) {
     }
     const from = coerceDate(options.from, "from");
     const orderedAt = options.orderedAt === undefined ? null : coerceDate(options.orderedAt, "orderedAt");
+    const priorCountInput = options.priorCount;
+    if (priorCountInput !== undefined) {
+        if (!Number.isFinite(priorCountInput) || priorCountInput < 0) {
+            throw new Error("Invalid priorCount supplied to nextDueDoses");
+        }
+    }
+    let priorCount = priorCountInput !== undefined ? Math.floor(priorCountInput) : 0;
+    const needsDerivedPriorCount = priorCountInput === undefined && !!orderedAt;
     const baseTime = orderedAt !== null && orderedAt !== void 0 ? orderedAt : from;
     const providedConfig = options.config;
     const timeZone = (_b = options.timeZone) !== null && _b !== void 0 ? _b : providedConfig === null || providedConfig === void 0 ? void 0 : providedConfig.timeZone;
@@ -492,6 +500,13 @@ function nextDueDoses(dosage, options) {
     };
     const timing = dosage.timing;
     const repeat = timing === null || timing === void 0 ? void 0 : timing.repeat;
+    if (needsDerivedPriorCount &&
+        orderedAt &&
+        timing &&
+        repeat &&
+        repeat.count !== undefined) {
+        priorCount = derivePriorCountFromHistory(timing, repeat, config, orderedAt, from, timeZone);
+    }
     if (!timing || !repeat) {
         return [];
     }
@@ -500,7 +515,11 @@ function nextDueDoses(dosage, options) {
     if (normalizedCount === 0) {
         return [];
     }
-    const effectiveLimit = normalizedCount !== undefined ? Math.min(limit, normalizedCount) : limit;
+    const remainingCount = normalizedCount === undefined ? undefined : Math.max(0, normalizedCount - priorCount);
+    if (remainingCount === 0) {
+        return [];
+    }
+    const effectiveLimit = remainingCount !== undefined ? Math.min(limit, remainingCount) : limit;
     const results = [];
     const seen = new Set();
     const dayFilter = new Set(((_g = repeat.dayOfWeek) !== null && _g !== void 0 ? _g : []).map((day) => day.toLowerCase()));
@@ -628,6 +647,145 @@ function nextDueDoses(dosage, options) {
     }
     return [];
 }
+function derivePriorCountFromHistory(timing, repeat, config, orderedAt, from, timeZone) {
+    var _a, _b, _c;
+    if (from <= orderedAt) {
+        return 0;
+    }
+    const normalizedCount = repeat.count === undefined
+        ? undefined
+        : Math.max(0, Math.floor(repeat.count));
+    if (normalizedCount === 0) {
+        return 0;
+    }
+    const dayFilter = new Set(((_a = repeat.dayOfWeek) !== null && _a !== void 0 ? _a : []).map((day) => day.toLowerCase()));
+    const enforceDayFilter = dayFilter.size > 0;
+    const seen = new Set();
+    let count = 0;
+    const recordCandidate = (candidate) => {
+        if (!candidate) {
+            return false;
+        }
+        if (candidate < orderedAt || candidate >= from) {
+            return false;
+        }
+        const iso = formatZonedIso(candidate, timeZone);
+        if (seen.has(iso)) {
+            return false;
+        }
+        seen.add(iso);
+        count += 1;
+        return true;
+    };
+    const whenCodes = (_b = repeat.when) !== null && _b !== void 0 ? _b : [];
+    const timeOfDayEntries = (_c = repeat.timeOfDay) !== null && _c !== void 0 ? _c : [];
+    if (whenCodes.length > 0 || timeOfDayEntries.length > 0) {
+        const expanded = expandWhenCodes(whenCodes, config, repeat);
+        if (timeOfDayEntries.length > 0) {
+            for (const clock of timeOfDayEntries) {
+                expanded.push({ time: normalizeClock(clock), dayShift: 0 });
+            }
+            expanded.sort((a, b) => {
+                if (a.dayShift !== b.dayShift) {
+                    return a.dayShift - b.dayShift;
+                }
+                return a.time.localeCompare(b.time);
+            });
+        }
+        if ((0, array_1.arrayIncludes)(whenCodes, types_1.EventTiming.Immediate)) {
+            if (recordCandidate(orderedAt) && normalizedCount !== undefined && seen.size >= normalizedCount) {
+                return count;
+            }
+        }
+        if (expanded.length === 0) {
+            return count;
+        }
+        let currentDay = startOfLocalDay(orderedAt, timeZone);
+        let iterations = 0;
+        const maxIterations = normalizedCount !== undefined ? normalizedCount * 31 : 31 * 365;
+        while (currentDay < from && iterations < maxIterations) {
+            const weekday = getLocalWeekday(currentDay, timeZone);
+            if (!enforceDayFilter || dayFilter.has(weekday)) {
+                for (const entry of expanded) {
+                    const targetDay = entry.dayShift === 0
+                        ? currentDay
+                        : addLocalDays(currentDay, entry.dayShift, timeZone);
+                    const zoned = makeZonedDateFromDay(targetDay, timeZone, entry.time);
+                    if (!zoned) {
+                        continue;
+                    }
+                    if (zoned < orderedAt || zoned >= from) {
+                        continue;
+                    }
+                    if (recordCandidate(zoned) && normalizedCount !== undefined && seen.size >= normalizedCount) {
+                        return count;
+                    }
+                }
+            }
+            currentDay = addLocalDays(currentDay, 1, timeZone);
+            iterations += 1;
+        }
+        return count;
+    }
+    const treatAsInterval = !!repeat.period &&
+        !!repeat.periodUnit &&
+        (!repeat.frequency ||
+            repeat.periodUnit !== "d" ||
+            (repeat.frequency === 1 && repeat.period > 1));
+    if (treatAsInterval) {
+        const increment = createIntervalStepper(repeat, timeZone);
+        if (!increment) {
+            return count;
+        }
+        let current = orderedAt;
+        let guard = 0;
+        const maxIterations = normalizedCount !== undefined ? normalizedCount * 1000 : 1000;
+        while (current < from && guard < maxIterations) {
+            const weekday = getLocalWeekday(current, timeZone);
+            if (!enforceDayFilter || dayFilter.has(weekday)) {
+                if (recordCandidate(current) && normalizedCount !== undefined && seen.size >= normalizedCount) {
+                    return count;
+                }
+            }
+            const next = increment(current);
+            if (!next || next.getTime() === current.getTime()) {
+                break;
+            }
+            current = next;
+            guard += 1;
+        }
+        return count;
+    }
+    if (repeat.frequency && repeat.period && repeat.periodUnit) {
+        const clocks = resolveFrequencyClocks(timing, config);
+        if (clocks.length === 0) {
+            return count;
+        }
+        let currentDay = startOfLocalDay(orderedAt, timeZone);
+        let iterations = 0;
+        const maxIterations = normalizedCount !== undefined ? normalizedCount * 31 : 31 * 365;
+        while (currentDay < from && iterations < maxIterations) {
+            const weekday = getLocalWeekday(currentDay, timeZone);
+            if (!enforceDayFilter || dayFilter.has(weekday)) {
+                for (const clock of clocks) {
+                    const zoned = makeZonedDateFromDay(currentDay, timeZone, clock);
+                    if (!zoned) {
+                        continue;
+                    }
+                    if (zoned < orderedAt || zoned >= from) {
+                        continue;
+                    }
+                    if (recordCandidate(zoned) && normalizedCount !== undefined && seen.size >= normalizedCount) {
+                        return count;
+                    }
+                }
+            }
+            currentDay = addLocalDays(currentDay, 1, timeZone);
+            iterations += 1;
+        }
+    }
+    return count;
+}
 /**
  * Generates an interval-based series by stepping forward from the base time
  * until the requested number of timestamps have been produced.