dabke 0.82.0 → 0.84.0

package/dist/schedule/rules.js

@@ -0,0 +1,554 @@
+/**
+ * Scheduling rules: constraints, preferences, and time-off.
+ *
+ * Rules answer "what schedules are allowed or preferred?". Use
+ * {@link cover} for lower-bound demand, then use rules for caps, limits, rest
+ * periods, time off, fairness, and other constraints on assignments.
+ *
+ * @example
+ * ```typescript
+ * rules: [
+ *   // Hour and day limits
+ *   maxHoursPerDay(10),
+ *   maxHoursPerWeek(48),
+ *   maxHoursPerWeek(20, { appliesTo: "part-time" }),
+ *   maxDaysPerWeek(5, { priority: "HIGH" }),
+ *   targetDaysPerWeek(4, { appliesTo: "full-time", priority: "HIGH" }),
+ *   minDaysPerWeek(4, { appliesTo: "full-time", priority: "HIGH" }),
+ *   maxShiftsPerDay(1),
+ *   maxConcurrentAssignments(5, { appliesTo: "chair_stylist" }),
+ *   targetPeakConcurrentAssignments(5, { appliesTo: "chair_stylist", dayOfWeek: ["thursday"], priority: "HIGH" }),
+ *   minRestBetweenShifts(11),
+ *
+ *   // Staffing obligations and preferences
+ *   mustAssign({ appliesTo: ["diana", "yavuz"] }),
+ *   timeOff({ appliesTo: "alice", dateRange: { start: "2024-02-01", end: "2024-02-05" } }),
+ *   timeOff({ appliesTo: "student", dayOfWeek: ["wednesday"], from: t(14) }),
+ *   preferAssignment({ appliesTo: "waiter" }),
+ *   avoidAssignment({ appliesTo: "student", dayOfWeek: weekdays }),
+ *   assignTogether(["alice", "bob"]),
+ * ]
+ * ```
+ *
+ * Custom rules can stay type-safe too:
+ *
+ * ```typescript
+ * const debugRuleRegistry = createCpsatRuleRegistry({
+ *   debug: defineRuleDescriptor({
+ *     name: "debug",
+ *     schema: z.object({ flag: z.boolean() }),
+ *     compile() {
+ *       return { rule: "debug", artifacts: [] };
+ *     },
+ *   }),
+ * });
+ *
+ * const defineDebugRule = defineRuleFor(debugRuleRegistry);
+ *
+ * schedule({
+ *   roleIds: ["waiter"],
+ *   times: { lunch: time({ startTime: t(12), endTime: t(15) }) },
+ *   coverage: [cover("lunch", "waiter", 1)],
+ *   shiftPatterns: [shift("lunch", t(12), t(15))],
+ *   ruleRegistry: debugRuleRegistry,
+ *   rules: [defineDebugRule("debug", { flag: true })],
+ * });
+ * ```
+ *
+ * @module
+ */
+export function defineRule(name, fields, resolve) {
+    const safeFields = { ...fields };
+    delete safeFields._type;
+    delete safeFields._rule;
+    const entry = {
+        _type: "rule",
+        _rule: name,
+        ...safeFields,
+    };
+    if (resolve) {
+        Object.defineProperty(entry, "_resolve", { value: resolve, enumerable: false });
+    }
+    return entry;
+}
+/**
+ * Creates a registry-bound `defineRule` helper.
+ *
+ * @remarks
+ * Use this when authoring custom rules directly and you want immediate
+ * compile-time validation of the rule name and config fields against a specific
+ * rule registry.
+ *
+ * @category Rules
+ */
+export function defineRuleFor(ruleRegistry) {
+    void ruleRegistry;
+    return (name, fields, resolve) => defineRule(name, fields, resolve);
+}
+function makeRule(rule, fields) {
+    return defineRule(rule, fields);
+}
+// ============================================================================
+// Constraint Rules
+// ============================================================================
+/**
+ * Limits hours per day.
+ *
+ * @remarks
+ * Use this when the requirements or operating constraints explicitly impose a
+ * daily hours cap. Do not infer it just from the chosen shift pattern lengths.
+ *
+ * @category Rules
+ */
+export function maxHoursPerDay(hours, opts) {
+    return makeRule("max-hours-day", { hours, ...opts });
+}
+/**
+ * Limits hours per scheduling week.
+ *
+ * @remarks
+ * Use this when the requirements or operating constraints explicitly impose a
+ * weekly hours cap. Do not infer it just from a stated working pattern such
+ * as "4-day week" unless the requirements also make the hour limit explicit.
+ *
+ * @category Rules
+ */
+export function maxHoursPerWeek(hours, opts) {
+    return makeRule("max-hours-week", { hours, ...opts });
+}
+/**
+ * Minimum hours when assigned on a day.
+ *
+ * @category Rules
+ */
+export function minHoursPerDay(hours, opts) {
+    return makeRule("min-hours-day", { hours, ...opts });
+}
+/**
+ * Minimum hours per scheduling week.
+ *
+ * @category Rules
+ */
+export function minHoursPerWeek(hours, opts) {
+    return makeRule("min-hours-week", { hours, ...opts });
+}
+/**
+ * Caps assigned days per scheduling week.
+ *
+ * @remarks
+ * Use this when the requirements explicitly impose a weekly day cap. If the same
+ * number is the normal weekly pattern rather than just a hard limit, pair it
+ * with {@link targetDaysPerWeek}.
+ *
+ * @category Rules
+ */
+export function maxDaysPerWeek(days, opts) {
+    return makeRule("max-days-week", { days, ...opts });
+}
+/**
+ * Enforces a minimum number of assigned days per scheduling week.
+ *
+ * @remarks
+ * Use this when the requirements explicitly require a weekly minimum. Language like
+ * "works a 4-day week" often implies a hard cap via {@link maxDaysPerWeek}
+ * and possibly a softer target via {@link targetDaysPerWeek}, not a mandatory
+ * weekly minimum for every member.
+ *
+ * @category Rules
+ */
+export function minDaysPerWeek(days, opts) {
+    return makeRule("min-days-week", { days, ...opts });
+}
+/**
+ * Softly targets assigned days per scheduling week.
+ *
+ * @remarks
+ * Use this for stated working patterns like "works a 4-day week" when the
+ * pattern should remain the norm but can flex around holidays, time off, or
+ * other tradeoffs. Deviations in either direction are penalized, so working
+ * fewer days or more days than the target both count as misses. Pair it with
+ * {@link maxDaysPerWeek} when the same number is also a hard cap, and use
+ * {@link minDaysPerWeek} only when the requirements explicitly require a minimum.
+ *
+ * @param days - Target number of assigned days per scheduling week.
+ * @param opts - Optional entity scope and soft priority.
+ *
+ * @category Rules
+ */
+export function targetDaysPerWeek(days, opts) {
+    return makeRule("target-days-week", { days, ...opts });
+}
+/**
+ * Maximum distinct shifts per day.
+ *
+ * @category Rules
+ */
+export function maxShiftsPerDay(shifts, opts) {
+    return makeRule("max-shifts-day", { shifts, ...opts });
+}
+/**
+ * Caps how many targeted assignments may overlap at the same time.
+ *
+ * @remarks
+ * Use this for hard productive capacity limits that should stay separate from
+ * the minimum staffing requirement expressed by {@link cover}. Pair a
+ * lower-bound `cover(...)` with `maxConcurrentAssignments(...)` when the
+ * business needs both demand and capacity modeled explicitly.
+ *
+ * On days with staggered opening and closing shifts, keep lower-bound coverage
+ * scoped to the windows that truly need minimum staffing. Do not turn a total
+ * daily headcount target into a whole-day lower-bound `cover(...)` unless the
+ * business explicitly requires that many people in every overlapping bucket.
+ *
+ * Unlike {@link maxShiftsPerDay}, this limits simultaneous overlap, not total
+ * assignments on a day.
+ *
+ * @param assignments - Maximum number of concurrent overlapping assignments.
+ * @param opts - Optional scope and time-window settings.
+ *
+ * @category Rules
+ */
+export function maxConcurrentAssignments(assignments, opts) {
+    return makeRule("max-concurrent-assignments", { assignments, ...opts });
+}
+/**
+ * Softly targets the daily peak number of concurrent overlapping assignments.
+ *
+ * @remarks
+ * Use this when the business wants to hit full productive occupancy at the
+ * busy point of a day, but does not mean that same number must be present
+ * throughout the full span. This is not a whole-day lower bound. Pair it with
+ * {@link cover} for edge minima and with
+ * {@link maxConcurrentAssignments} when the same value is also a hard cap.
+ * Prefer this over a whole-day `cover(...)` when the brief means "reach the
+ * peak" rather than "maintain this minimum throughout the day".
+ *
+ * This is a rule-level peak target, not a variant of {@link cover}. Do not
+ * introduce a synthetic semantic time just to attach a whole-window
+ * `cover(...)` when the requirement is really about the day's peak.
+ *
+ * @param assignments - Target peak number of concurrent overlapping assignments.
+ * @param opts - Optional scope and soft priority.
+ *
+ * @category Rules
+ */
+export function targetPeakConcurrentAssignments(assignments, opts) {
+    return makeRule("target-peak-concurrent-assignments", { assignments, ...opts });
+}
+/**
+ * Maximum consecutive assigned days.
+ *
+ * @category Rules
+ */
+export function maxConsecutiveDays(days, opts) {
+    return makeRule("max-consecutive-days", { days, ...opts });
+}
+/**
+ * Once working, continue for at least this many consecutive days.
+ *
+ * @category Rules
+ */
+export function minConsecutiveDays(days, opts) {
+    return makeRule("min-consecutive-days", { days, ...opts });
+}
+/**
+ * Minimum rest hours between shifts.
+ *
+ * @category Rules
+ */
+export function minRestBetweenShifts(hours, opts) {
+    return makeRule("min-rest-between-shifts", { hours, ...opts });
+}
+/**
+ * Nudge the solver toward scheduling targeted members.
+ *
+ * @remarks
+ * Soft constraint. The solver adds a bonus for each assignment of the
+ * targeted members, making them more likely to appear on the schedule.
+ * Use `priority` to control how strong the nudge is; higher priority
+ * means a larger bonus. Even at `"MANDATORY"` strength the solver can
+ * still leave a member unassigned if hard constraints prevent it.
+ *
+ * Opposite of {@link avoidAssignment}. Both map to the same underlying
+ * `assignment-priority` rule with different directions.
+ *
+ * @param opts - See {@link RuleOptions}
+ *
+ * @category Rules
+ */
+export function preferAssignment(opts) {
+    return makeRule("assignment-priority", { preference: "prefer", ...opts });
+}
+/**
+ * Nudge the solver away from scheduling targeted members.
+ *
+ * @remarks
+ * Soft constraint. The solver adds a penalty for each assignment of the
+ * targeted members, making them less likely to appear on the schedule.
+ * The member is still assigned when coverage requires it; the penalty
+ * only matters when the solver has a choice.
+ *
+ * Opposite of {@link preferAssignment}. Both map to the same underlying
+ * `assignment-priority` rule with different directions.
+ *
+ * @param opts - See {@link RuleOptions}
+ *
+ * @category Rules
+ */
+export function avoidAssignment(opts) {
+    return makeRule("assignment-priority", { preference: "avoid", ...opts });
+}
+/**
+ * Steer a multi-role member toward shifts tagged with a specific role.
+ *
+ * @remarks
+ * Penalizes assignment to shift patterns whose `roleIds` do not include
+ * the preferred role. The member is still assigned to other roles when
+ * coverage requires it; the penalty only matters when the solver has a
+ * choice. Shift patterns without any `roleIds` (open to all) are also
+ * penalized since they are not explicitly tagged with the preferred role.
+ *
+ * The targeted members must actually hold the preferred role in their
+ * `roleIds`. If none of them do, compilation reports an error because
+ * the rule would silently penalize all their assignments (the opposite
+ * of the intent).
+ *
+ * Typical use case: a waiter who can cover kitchen pass shifts in a
+ * pinch. Give the member both roles (`roleIds: ["waiter", "pass"]`)
+ * and use `preferRole("waiter", ...)` so the solver keeps them on the
+ * floor unless the pass team is short-staffed.
+ *
+ * @param roleId - The role to prefer
+ * @param opts - See {@link EntityOnlyRuleOptions}
+ *
+ * @category Rules
+ */
+export function preferRole(roleId, opts) {
+    return makeRule("role-preference", { roleId, ...opts });
+}
+/**
+ * Steer a member toward shifts at a specific location.
+ *
+ * @remarks
+ * Penalizes assignment to shift patterns whose `locationId` does not
+ * match the preferred location. The member is still assigned elsewhere
+ * when coverage requires it.
+ *
+ * @param locationId - The location to prefer
+ * @param opts - See {@link EntityOnlyRuleOptions}
+ *
+ * @category Rules
+ */
+export function preferLocation(locationId, opts) {
+    return makeRule("location-preference", { locationId, ...opts });
+}
+/**
+ * Guarantees that targeted members appear on the schedule each week.
+ *
+ * @remarks
+ * Use for staffing obligations: salaried employees who are paid regardless
+ * of whether they work, or contracted staff who must be rostered. The solver
+ * ensures each targeted member has at least one assignment per scheduling week.
+ *
+ * Always a soft constraint (HIGH priority internally). The schedule still
+ * generates when a member genuinely cannot be placed (e.g., full week of
+ * absences). Violations surface as validation warnings with distinct
+ * messaging from {@link minDaysPerWeek}. Priority is not configurable;
+ * the rule name communicates the intent.
+ *
+ * @category Rules
+ */
+export function mustAssign(opts) {
+    return makeRule("must-assign", { ...opts });
+}
+// ============================================================================
+// Special Rules (custom resolvers)
+// ============================================================================
+/**
+ * Block assignments during specified periods.
+ * Requires at least one time scope (`dayOfWeek`, `dateRange`, `dates`, or `from`/`until`).
+ *
+ * @category Rules
+ */
+export function timeOff(opts) {
+    const { from, until, ...rest } = opts;
+    return defineRule("time-off", { from, until, ...rest }, (ctx) => {
+        if (!rest.dayOfWeek && !rest.dateRange && !rest.dates && !rest.recurringPeriods) {
+            throw new Error("timeOff() requires at least one time scope (dayOfWeek, dateRange, dates, or recurringPeriods).");
+        }
+        const { appliesTo, dates, priority, ...passthrough } = rest;
+        const entityScope = resolveAppliesTo(appliesTo, ctx.roles, ctx.skills, ctx.memberIds);
+        const resolvedDates = dates ? { specificDates: dates } : {};
+        const partialDay = {};
+        if (from && until) {
+            partialDay.startTime = from;
+            partialDay.endTime = until;
+        }
+        else if (from) {
+            partialDay.startTime = from;
+            partialDay.endTime = { hours: 23, minutes: 59 };
+        }
+        else if (until) {
+            partialDay.startTime = { hours: 0, minutes: 0 };
+            partialDay.endTime = until;
+        }
+        const resolved = {
+            name: "time-off",
+            priority: priority ?? "MANDATORY",
+            ...passthrough,
+            ...entityScope,
+            ...resolvedDates,
+            ...partialDay,
+        };
+        return resolved;
+    });
+}
+/**
+ * Members work the same shifts on days they are both assigned.
+ *
+ * @category Rules
+ */
+export function assignTogether(memberIds, opts) {
+    return defineRule("assign-together", { members: memberIds, ...opts }, (ctx) => {
+        for (const member of memberIds) {
+            if (!ctx.memberIds.has(member)) {
+                throw new Error(`assignTogether references unknown member "${member}". ` +
+                    `Known member IDs: ${[...ctx.memberIds].join(", ")}`);
+            }
+        }
+        const resolved = {
+            name: "assign-together",
+            groupMemberIds: memberIds,
+            priority: opts?.priority ?? "MANDATORY",
+        };
+        return resolved;
+    });
+}
+/**
+ * Caps how many times a person works on specific days of the week within
+ * each period.
+ *
+ * @remarks
+ * The scheduling window is divided into non-overlapping chunks of the
+ * configured period length. Within each chunk, only days matching the
+ * `dayOfWeek` filter are counted. The constraint bounds that count.
+ *
+ * @param days - Maximum number of matching days allowed per period.
+ * @param dayOfWeek - Which days of the week count toward the limit.
+ * @param opts - Period length and optional scoping.
+ *
+ * @category Rules
+ */
+export function maxDaysOfWeekPerPeriod(days, dayOfWeek, opts) {
+    const { appliesTo, priority, ...periodOpts } = opts;
+    const period = "weeks" in periodOpts && periodOpts.weeks != null
+        ? { type: "weeks", value: periodOpts.weeks }
+        : { type: "months", value: periodOpts.months };
+    return defineRule("max-days-of-week-per-period", { days, dayOfWeek: [...dayOfWeek], period, appliesTo, priority }, (ctx) => {
+        const entityScope = resolveAppliesTo(appliesTo, ctx.roles, ctx.skills, ctx.memberIds);
+        const resolved = {
+            name: "max-days-of-week-per-period",
+            days,
+            dayOfWeek: [...dayOfWeek],
+            period,
+            priority: priority ?? "MANDATORY",
+            ...entityScope,
+        };
+        return resolved;
+    });
+}
+/**
+ * Enforces a minimum number of times a person works on specific days of the
+ * week within each period.
+ *
+ * @remarks
+ * The scheduling window is divided into non-overlapping chunks of the
+ * configured period length. Within each chunk, only days matching the
+ * `dayOfWeek` filter are counted. The constraint ensures the count meets
+ * the minimum.
+ *
+ * When the scheduling window does not align evenly with the period
+ * boundaries, the last chunk may contain fewer matching days than the
+ * minimum. A MANDATORY priority will make the model infeasible in that
+ * case. Use a soft priority (HIGH, MEDIUM, LOW) if partial periods at
+ * the edges of the window are expected.
+ *
+ * @param days - Minimum number of matching days required per period.
+ * @param dayOfWeek - Which days of the week count toward the limit.
+ * @param opts - Period length and optional scoping.
+ *
+ * @category Rules
+ */
+export function minDaysOfWeekPerPeriod(days, dayOfWeek, opts) {
+    const { appliesTo, priority, ...periodOpts } = opts;
+    const period = "weeks" in periodOpts && periodOpts.weeks != null
+        ? { type: "weeks", value: periodOpts.weeks }
+        : { type: "months", value: periodOpts.months };
+    return defineRule("min-days-of-week-per-period", { days, dayOfWeek: [...dayOfWeek], period, appliesTo, priority }, (ctx) => {
+        const entityScope = resolveAppliesTo(appliesTo, ctx.roles, ctx.skills, ctx.memberIds);
+        const resolved = {
+            name: "min-days-of-week-per-period",
+            days,
+            dayOfWeek: [...dayOfWeek],
+            period,
+            priority: priority ?? "MANDATORY",
+            ...entityScope,
+        };
+        return resolved;
+    });
+}
+// ============================================================================
+// Internal: appliesTo resolution (shared with definition.ts)
+// ============================================================================
+/**
+ * Resolves an `appliesTo` value into entity scope fields.
+ *
+ * Each target string is checked against roles, skills, then member IDs.
+ * If all targets resolve to the same namespace, they are combined into one
+ * scope field. If they span namespaces, an error is thrown; the caller
+ * should use separate rule entries instead.
+ *
+ * @internal
+ */
+export function resolveAppliesTo(appliesTo, roles, skills, memberIds) {
+    if (!appliesTo)
+        return {};
+    const targets = Array.isArray(appliesTo) ? appliesTo : [appliesTo];
+    if (targets.length === 0)
+        return {};
+    const resolvedRoles = [];
+    const resolvedSkills = [];
+    const resolvedMembers = [];
+    for (const target of targets) {
+        if (roles.has(target)) {
+            resolvedRoles.push(target);
+        }
+        else if (skills.has(target)) {
+            resolvedSkills.push(target);
+        }
+        else if (memberIds.has(target)) {
+            resolvedMembers.push(target);
+        }
+        else {
+            throw new Error(`appliesTo target "${target}" is not a declared role, skill, or member ID.`);
+        }
+    }
+    // Count how many namespaces were used
+    const namespacesUsed = [resolvedRoles, resolvedSkills, resolvedMembers].filter((arr) => arr.length > 0).length;
+    if (namespacesUsed > 1) {
+        throw new Error(`appliesTo targets span multiple namespaces (roles: [${resolvedRoles.join(", ")}], ` +
+            `skills: [${resolvedSkills.join(", ")}], members: [${resolvedMembers.join(", ")}]). ` +
+            `Use separate rule entries for each namespace.`);
+    }
+    if (resolvedRoles.length > 0) {
+        return { roleIds: resolvedRoles };
+    }
+    if (resolvedSkills.length > 0) {
+        return { skillIds: resolvedSkills };
+    }
+    if (resolvedMembers.length > 0) {
+        return { memberIds: resolvedMembers };
+    }
+    return {};
+}
+//# sourceMappingURL=rules.js.map

package/dist/schedule/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../src/schedule/rules.ts"],"names":[],"mappings":"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"}

package/dist/schedule/shift-patterns.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shift pattern definitions: time slots available for employee assignment.
+ *
+ * @module
+ */
+import type { TimeOfDay } from "../types.js";
+import type { ShiftPattern } from "../cpsat/types.js";
+/**
+ * Define a shift pattern: a time slot available for employee assignment.
+ *
+ * @remarks
+ * Each pattern repeats daily unless filtered by `dayOfWeek`.
+ *
+ * @category Shift Patterns
+ */
+export declare function shift(id: string, startTime: TimeOfDay, endTime: TimeOfDay, opts?: Pick<ShiftPattern, "roleIds" | "dayOfWeek" | "locationId">): ShiftPattern;
+//# sourceMappingURL=shift-patterns.d.ts.map

package/dist/schedule/shift-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shift-patterns.d.ts","sourceRoot":"","sources":["../../src/schedule/shift-patterns.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;;;GAOG;AACH,wBAAgB,KAAK,CACnB,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,SAAS,EAClB,IAAI,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,WAAW,GAAG,YAAY,CAAC,GAChE,YAAY,CAMd"}

package/dist/schedule/shift-patterns.js

@@ -0,0 +1,24 @@
+/**
+ * Shift pattern definitions: time slots available for employee assignment.
+ *
+ * @module
+ */
+/**
+ * Define a shift pattern: a time slot available for employee assignment.
+ *
+ * @remarks
+ * Each pattern repeats daily unless filtered by `dayOfWeek`.
+ *
+ * @category Shift Patterns
+ */
+export function shift(id, startTime, endTime, opts) {
+    const pattern = { id, startTime, endTime };
+    if (opts?.roleIds)
+        pattern.roleIds = opts.roleIds;
+    if (opts?.dayOfWeek)
+        pattern.dayOfWeek = opts.dayOfWeek;
+    if (opts?.locationId)
+        pattern.locationId = opts.locationId;
+    return pattern;
+}
+//# sourceMappingURL=shift-patterns.js.map

package/dist/schedule/shift-patterns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shift-patterns.js","sourceRoot":"","sources":["../../src/schedule/shift-patterns.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CACnB,EAAU,EACV,SAAoB,EACpB,OAAkB,EAClB,IAAiE;IAEjE,MAAM,OAAO,GAAiB,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;IACzD,IAAI,IAAI,EAAE,OAAO;QAAE,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAClD,IAAI,IAAI,EAAE,SAAS;QAAE,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;IACxD,IAAI,IAAI,EAAE,UAAU;QAAE,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;IAC3D,OAAO,OAAO,CAAC;AACjB,CAAC"}