canvas-lms-mcp 2.0.0 → 2.2.0

package/dist/{chunk-KHJEIVEQ.js → chunk-FKTJGYLG.js}

@@ -25,11 +25,11 @@ import {
   compareCanvasIds,
   mapWithConcurrency,
   normalizeCanvasIdInput
-} from "./chunk-5B3JDDYC.js";
+} from "./chunk-FP4A34TD.js";
 import {
   CanvasApiError,
   version
-} from "./chunk-VVIZW7HE.js";
+} from "./chunk-W5DF5YBG.js";
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -148,6 +148,8 @@ function isNoEntError(err) {
 }
 
 // src/pseudonym/pseudonymizer.ts
+var STREAM_NO_CONTEXT_SCOPE = "_stream_nocontext";
+var WITHHELD_AUTHOR_NAME = "Author name withheld";
 var Pseudonymizer = class {
   host;
   rootDir;
@@ -304,6 +306,83 @@ var Pseudonymizer = class {
     );
     return { ...group, appointments };
   }
+  /**
+   * Pseudonymize the PII arms of a `GET /users/self/activity_stream` response.
+   *
+   * **Scope.** The stream is cross-course by construction, so there is no single
+   * course to key the pseudonym map on. Each item is scoped individually by its
+   * own `course_id`, which is what every other wrapped tool already does — so
+   * the stream agrees with `list_submissions` on the same student in the same
+   * course. A group-context item carries no `course_id` at all (Canvas emits one
+   * key, named after the context type), and gets the isolated synthetic scope
+   * `_group_<group_id>`, following the `_apptgrp_<id>` precedent above. Course
+   * and group identity maps are never merged.
+   *
+   * **Three arms carry a name; the fourth does not.** Measured against
+   * `lib/api/v1/stream_item.rb#stream_item_json`:
+   *
+   * - `root_discussion_entries[].user.user_name` — a name WITH an id, so it gets
+   *   an ordinary scope-stable pseudonym.
+   * - the `Submission` arm's `user` + `submission_comments[].author_name` —
+   *   delegated to `anonymizeSubmission`, after pre-warming the non-grader
+   *   comment authors so a peer reviewer's name cannot survive on a
+   *   single-submission payload (see the inline note below).
+   * - `author_name` on a `DiscussionEntry` item — a name with NO identifier
+   *   anywhere in the item, so no stable pseudonym is derivable. Withheld
+   *   outright rather than left in place: failing closed is the only safe
+   *   reading, and `html_url` still reaches the pseudonymized entry through
+   *   `get_discussion`.
+   * - the `Conversation` arm's `latest_messages[]` is `{id, created_at,
+   *   author_id, message, participating_user_ids}` — identifiers and text, no
+   *   name. Nothing to rewrite; ids are preserved by every existing
+   *   `anonymize*` method too (`applyPseudonymToUser` keeps `user.id`), and the
+   *   message text is provenance-fenced rather than pseudonymized.
+   */
+  async anonymizeActivityStream(items) {
+    if (!this.isEnabled() || !this.host) return [...items];
+    const out = [];
+    for (const item of items) {
+      out.push(await this.anonymizeActivityStreamEntry(item));
+    }
+    return out;
+  }
+  /**
+   * Pseudonymize the PII arm of a `GET /planner/items` response (BRU-2878).
+   *
+   * `submissions.feedback` (from `submission_statuses_for`) carries an
+   * `author_name` with NO identifier anywhere on the item — the plannable set
+   * includes `assessment_request` / `peer_review_sub_assignment`, where this
+   * feedback can originate from a peer reviewer rather than the grader, and
+   * there is no `author_id` sibling to classify against like
+   * `anonymizeSubmission` does. This is the exact shape already handled for
+   * `author_name` on a `DiscussionEntry` activity-stream item above: nothing
+   * to key a stable pseudonym on, so it is withheld outright rather than left
+   * in place — failing closed is the only safe reading. `author_avatar_url` is
+   * cleared alongside it, matching `applyPseudonymToUser`'s treatment of
+   * `avatar_url`: a masked name next to the real author's photo would defeat
+   * the point. No other arm of a planner item carries a third-party name.
+   */
+  async anonymizePlannerItems(items) {
+    if (!this.isEnabled()) return [...items];
+    return items.map((item) => {
+      if (item.submissions === false) return item;
+      const feedback = item.submissions.feedback;
+      if (typeof feedback?.author_name !== "string" || feedback.author_name.length === 0) {
+        return item;
+      }
+      return {
+        ...item,
+        submissions: {
+          ...item.submissions,
+          feedback: {
+            ...feedback,
+            author_name: WITHHELD_AUTHOR_NAME,
+            author_avatar_url: feedback.author_avatar_url == null ? feedback.author_avatar_url : null
+          }
+        }
+      };
+    });
+  }
   /**
    * Look up the real user_id behind a pseudonym. Returns `null` when reverse
    * lookup is disabled, the host is invalid, or the pseudonym is unknown.
@@ -335,6 +414,77 @@ var Pseudonymizer = class {
     return null;
   }
   // --- Internals --------------------------------------------------------------
+  /**
+   * The pseudonym scope for one activity-stream item. Exactly one of
+   * `course_id` / `group_id` is present on a real item; `STREAM_NO_CONTEXT_SCOPE`
+   * is the fail-closed backstop for neither, so an unexpected shape still gets
+   * a pseudonym rather than passing a real name through.
+   */
+  activityStreamScope(item) {
+    if (item.course_id !== void 0) return item.course_id;
+    if (item.group_id !== void 0) return `_group_${item.group_id}`;
+    return STREAM_NO_CONTEXT_SCOPE;
+  }
+  async anonymizeActivityStreamEntry(item) {
+    const scope = this.activityStreamScope(item);
+    let out = item;
+    if (item.root_discussion_entries && item.root_discussion_entries.length > 0) {
+      const entries = [];
+      for (const entry of item.root_discussion_entries) {
+        if (!entry.user) {
+          entries.push(entry);
+          continue;
+        }
+        const rootUserId = entry.user.user_id;
+        const resolvedName = rootUserId === void 0 || rootUserId === null ? WITHHELD_AUTHOR_NAME : (await this.anonymizeUser(scope, {
+          id: rootUserId,
+          name: entry.user.user_name
+        })).name;
+        entries.push({ ...entry, user: { ...entry.user, user_name: resolvedName } });
+      }
+      out = { ...out, root_discussion_entries: entries };
+    }
+    if (typeof item.author_name === "string" && item.author_name.length > 0) {
+      out = { ...out, author_name: WITHHELD_AUTHOR_NAME };
+    }
+    if (item.user !== void 0 || item.submission_comments !== void 0) {
+      if (item.user !== void 0) await this.anonymizeUser(scope, item.user);
+      const graderKey = item.grader_id == null ? null : String(item.grader_id);
+      for (const comment of item.submission_comments ?? []) {
+        const authorKey = submissionCommentAuthorKey(comment);
+        if (authorKey === null) continue;
+        if (graderKey !== null && authorKey === graderKey) continue;
+        await this.anonymizeUser(scope, {
+          id: comment.author_id,
+          name: comment.author_name
+        });
+      }
+      const anonymized = await this.anonymizeSubmission(scope, item);
+      out = { ...out };
+      if (anonymized.user !== void 0) out.user = anonymized.user;
+      if (anonymized.submission_comments !== void 0) {
+        out.submission_comments = anonymized.submission_comments;
+      }
+    }
+    if (item.discussion_entries && item.discussion_entries.length > 0) {
+      out = {
+        ...out,
+        discussion_entries: await this.anonymizeSubmissionDiscussionEntries(
+          scope,
+          item.discussion_entries
+        )
+      };
+    }
+    if (typeof item.proxy_submitter === "string" && item.proxy_submitter.length > 0) {
+      const id = item.proxy_submitter_id;
+      const resolved = id === void 0 || id === null ? WITHHELD_AUTHOR_NAME : (await this.anonymizeUser(scope, {
+        id,
+        name: item.proxy_submitter
+      })).name;
+      out = { ...out, proxy_submitter: resolved };
+    }
+    return out;
+  }
   async anonymizeCalendarEventUser(apptGroupId, event) {
     if (!event.user) return event;
     const anonymizedUser = await this.anonymizeUser(`_apptgrp_${apptGroupId}`, event.user);
@@ -397,12 +547,74 @@ var Pseudonymizer = class {
     const map = this.host ? await this.loadCourseMap(this.host, courseId) ?? null : null;
     const out = [];
     for (const c of comments) {
-      const pseudonym = map?.students[String(c.author_id)]?.pseudonym;
+      const authorKey = submissionCommentAuthorKey(c);
+      const pseudonym = authorKey === null ? void 0 : map?.students[authorKey]?.pseudonym;
+      const next = { ...c };
       if (pseudonym) {
-        out.push({ ...c, author_name: pseudonym });
-      } else {
-        out.push({ ...c });
+        next.author_name = pseudonym;
+        if (c.author) next.author = applyPseudonymToDisplay(c.author, pseudonym);
+      }
+      out.push(next);
+    }
+    return out;
+  }
+  /**
+   * Pseudonymize a Canvas `user_display_json` object, which spells the name
+   * `display_name` rather than `name`.
+   *
+   * Role classification runs through {@link anonymizeUser}, so staff keep their
+   * name here exactly as they do everywhere else. A display object with a name
+   * but NO `id` has nothing to key a stable pseudonym on, so the name is
+   * withheld rather than passed through — the same fail-closed reading as the
+   * `DiscussionEntry` arm's bare `author_name`.
+   */
+  async anonymizeDisplayUser(scope, display) {
+    const name = display.display_name;
+    if (typeof name !== "string" || name.length === 0) return display;
+    if (display.id === void 0 || display.id === null) {
+      return applyPseudonymToDisplay(display, WITHHELD_AUTHOR_NAME);
+    }
+    const resolved = await this.anonymizeUser(scope, {
+      id: display.id,
+      name
+    });
+    if (resolved.name === name) return display;
+    return applyPseudonymToDisplay(display, resolved.name);
+  }
+  /**
+   * Pseudonymize a `discussion_entries[]` array from the Submission arm,
+   * recursing through `recent_replies`.
+   *
+   * Three identity surfaces per entry and they do not co-occur — `user_name`
+   * and `user_id` are dropped on a deleted entry while the `user` display
+   * object survives it — so each is resolved independently. Both resolve
+   * through the same per-user map entry, so one person gets one label however
+   * many keys spell their name.
+   */
+  async anonymizeSubmissionDiscussionEntries(scope, entries) {
+    const out = [];
+    for (const entry of entries) {
+      let next = entry;
+      if (typeof entry.user_name === "string" && entry.user_name.length > 0) {
+        const resolved = entry.user_id === void 0 || entry.user_id === null ? WITHHELD_AUTHOR_NAME : (await this.anonymizeUser(scope, {
+          id: entry.user_id,
+          name: entry.user_name
+        })).name;
+        next = { ...next, user_name: resolved };
+      }
+      if (entry.user) {
+        next = { ...next, user: await this.anonymizeDisplayUser(scope, entry.user) };
+      }
+      if (entry.recent_replies && entry.recent_replies.length > 0) {
+        next = {
+          ...next,
+          recent_replies: await this.anonymizeSubmissionDiscussionEntries(
+            scope,
+            entry.recent_replies
+          )
+        };
       }
+      out.push(next);
     }
     return out;
   }
@@ -463,9 +675,18 @@ var Pseudonymizer = class {
     }
   }
 };
+function submissionCommentAuthorKey(comment) {
+  return comment.author_id == null ? null : String(comment.author_id);
+}
 function classifyRoleFromEnrollment(enrollment) {
   return classifyRole({}, [enrollment]);
 }
+function applyPseudonymToDisplay(display, pseudonym) {
+  const out = { ...display, display_name: pseudonym };
+  if (display.avatar_image_url !== void 0) out.avatar_image_url = null;
+  if (display.pronouns !== void 0) out.pronouns = null;
+  return out;
+}
 function applyPseudonymToUser(user, pseudonym) {
   const out = {
     ...user,
@@ -540,6 +761,45 @@ var UNTRUSTED_FIELDS = {
   // today and exists so a widened projection is covered the day it lands.
   list_submissions_awaiting_grading: { body: "submission body", comment: "submission comment" },
   get_my_submission_feedback: { comment: "submission comment" },
+  // The cross-course activity stream. `message` covers the DiscussionTopic /
+  // Announcement arm, each `root_discussion_entries[].message`, and each
+  // `latest_messages[].message` on a Conversation item; `body` and `comment`
+  // cover the Submission arm, whose merged `submission_json` carries the
+  // submission body and `submission_comments[]` (Canvas sets each comment's
+  // `body` from its `comment`, so both keys hold the same text).
+  //
+  // Three deliberate omissions. `title` is NOT fenced, following
+  // list_discussions / get_discussion — and here it would also hit the Message
+  // arm's Canvas-generated notification subject and the AssessmentRequest
+  // arm's synthesised "Peer Review for …" string, both server-authored.
+  // `name` is NOT fenced: the Submission arm merges `includes = %w[… assignment
+  // course …]`, so it would fence course and assignment names — the exact
+  // over-match this header warns about. `author_name` is NOT fenced because it
+  // is a name, and names are the pseudonymizer's job; the two layers must not
+  // both rewrite one value.
+  get_my_activity_stream: {
+    message: "activity stream message",
+    body: "submission body",
+    comment: "submission comment"
+  },
+  // The cross-course planner. Despite carrying a `discussion_topic` /
+  // `announcement` plannable type, NEITHER arm's actual message text reaches
+  // this response: `lib/api/v1/planner_item.rb#plannable_json` slices every
+  // plannable down to `API_PLANNABLE_FIELDS` (+ a small per-type extra-field
+  // list), and `message`/`body` are in neither — a discussion's real message
+  // is dropped entirely at the planner layer (read at pinned SHA
+  // 1c9f0bb8013ed69c4f2efe11fd483025469b7e6c, verified by re-deriving the
+  // slice from source rather than assuming the activity-stream registry
+  // entry carries over). The one free-text field that DOES survive the slice
+  // is a calendar event's `description` (`CALENDAR_PLANNABLE_FIELDS`), which
+  // can be course-wide and teacher-authored. `planner_note`'s own `details`
+  // field is excluded on purpose: it is the CALLER'S OWN note text, not
+  // third-party Canvas content, matching the authorship test this fencing
+  // design is built on. `title`, `location_name` and `location_address` are
+  // short metadata, not prose, and follow the existing title precedent.
+  list_my_planner_items: {
+    description: "calendar event description"
+  },
   // Rank 2 — any enrolled student can author a discussion message, and
   // `post_discussion_entry` / `update_discussion` publish as the operator.
   get_discussion: { message: "discussion message" },
@@ -6056,6 +6316,17 @@ var MY_SUBMISSION_FEEDBACK_INCLUDE = [
   "course",
   "read_status"
 ];
+var ACTIVITY_STREAM_DEFAULT_MAX_ITEMS = 100;
+var ACTIVITY_STREAM_RETENTION_NOTE = "Canvas keeps activity-stream items for a limited window \u2014 typically the last ~4 weeks, set per Canvas instance (stream_items_ttl) and not readable through the API. Items older than that window are gone from this endpoint even though the underlying courses, discussions and submissions still exist, so an empty or short result is not evidence that nothing happened.";
+var PLANNER_ITEMS_DEFAULT_MAX_ITEMS = 100;
+var PLANNER_DEFAULT_WINDOW_DAYS = 14;
+var PLANNER_CONTEXT_CODE_PATTERN = /^(course|group)_[1-9][0-9]{0,18}$/;
+function isoDateAtUtcMidnight(daysFromNow) {
+  const date = /* @__PURE__ */ new Date();
+  date.setUTCHours(0, 0, 0, 0);
+  date.setUTCDate(date.getUTCDate() + daysFromNow);
+  return date.toISOString();
+}
 function classifyCommentAuthor(comment, submission) {
   if (comment.author_id === submission.user_id) return "self";
   if (submission.grader_id != null && comment.author_id === submission.grader_id) return "teacher";
@@ -6201,10 +6472,12 @@ function studentTools(canvas, pseudonymizer) {
           const peerAuthors = /* @__PURE__ */ new Map();
           for (const { courseId, submission } of candidates) {
             for (const comment of submission.submission_comments ?? []) {
+              const authorKey = submissionCommentAuthorKey(comment);
+              if (authorKey === null) continue;
               if (classifyCommentAuthor(comment, submission) === "peer") {
-                peerAuthors.set(`${courseId}:${comment.author_id}`, {
+                peerAuthors.set(`${courseId}:${authorKey}`, {
                   courseId,
-                  id: comment.author_id,
+                  id: authorKey,
                   name: comment.author_name
                 });
               }
@@ -6261,6 +6534,134 @@ function studentTools(canvas, pseudonymizer) {
           findings
         };
       }
+    },
+    {
+      name: "get_my_activity_stream_summary",
+      title: "Get My Activity Stream Summary",
+      description: `Count unread and total items in the authenticated student's cross-course activity stream, grouped by Canvas item type (e.g. DiscussionTopic, Announcement, Submission, Conversation). No item content \u2014 counts only. A good first call in a daily workflow to check "is there anything to look at?" before fetching the full stream.`,
+      inputSchema: {
+        only_active_courses: z29.boolean().optional().describe(
+          "Only count activity in courses the student is actively participating in. Omit to count across all courses, including concluded ones."
+        )
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        const onlyActiveCourses = params.only_active_courses;
+        return canvas.activityStream.getSummary(onlyActiveCourses);
+      }
+    },
+    {
+      name: "get_my_activity_stream",
+      title: "Get My Activity Stream",
+      description: "The authenticated student's cross-course activity stream: new discussion posts, announcements, conversation messages, graded submissions, peer-review requests and conference invitations from every course at once, newest first. Four caveats, none of them visible in the response: (1) RECENT ACTIVITY ONLY \u2014 typically the last ~4 weeks; the retention window is a per-Canvas-instance setting and cannot be read through the API, so \"nothing found\" is not evidence that nothing happened. (2) Each item's `message` was truncated to 4096 characters when Canvas stored it, with no marker \u2014 follow the item's `html_url` object with get_discussion or get_conversation for the full text. (3) At most 3 `root_discussion_entries` per discussion item and 3 `latest_messages` per conversation item. (4) Exactly one of `course_id` / `group_id` is present on each item and the other key is ABSENT, not null \u2014 join on `course_id`, and read `context_type` to tell which you have.",
+      inputSchema: {
+        only_active_courses: z29.boolean().optional().describe(
+          "Only return activity in courses the student is actively participating in. Omit to include all courses, including concluded ones."
+        ),
+        max_items: z29.number().int().positive().max(500).optional().describe(
+          `Maximum items to return (default ${ACTIVITY_STREAM_DEFAULT_MAX_ITEMS}). When the limit is reached, \`truncated\` is true and \`truncation_note\` explains how to narrow the query.`
+        )
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        const onlyActiveCourses = params.only_active_courses;
+        const limit = params.max_items ?? ACTIVITY_STREAM_DEFAULT_MAX_ITEMS;
+        const fetched = await canvas.activityStream.getStream({
+          onlyActiveCourses,
+          maxItems: limit + 1
+        });
+        const truncated = fetched.length > limit;
+        const page = truncated ? fetched.slice(0, limit) : fetched;
+        const items = pseudonymizer?.isEnabled() ? await pseudonymizer.anonymizeActivityStream(page) : page;
+        return {
+          items,
+          total_items: items.length,
+          truncated,
+          truncation_note: truncated ? `Stopped after max_items (${limit}) items; more recent activity exists. Raise max_items (maximum 500), or set only_active_courses to true to drop concluded courses. get_my_activity_stream_summary gives per-type counts for the whole window without fetching items.` : null,
+          // Unconditional on purpose. `truncated` answers "did WE stop early?";
+          // it cannot answer "did Canvas already forget?", and that horizon is
+          // an instance Setting invisible to the API — there is no value to
+          // compute and no condition under which the flag could be set
+          // correctly. A nullable note would read as "not truncated by
+          // retention", which this server can never assert.
+          retention_note: ACTIVITY_STREAM_RETENTION_NOTE
+        };
+      }
+    },
+    {
+      name: "list_my_planner_items",
+      title: "List My Planner Items",
+      description: 'The authenticated student\'s planner: assignments, ungraded quizzes, planner notes, wiki pages, ungraded discussions, calendar events, peer reviews, sub-assignments and peer-review sub-assignments \u2014 everything with a due or to-do date, across every course and group at once. Strictly richer than get_todo_items, which covers only assignments needing submitting or grading. Four caveats: (1) start_date and end_date must be given TOGETHER or OMITTED TOGETHER \u2014 supplying only one makes Canvas silently default the other side to a ten-year window, so a half-specified range is rejected outright; omitting both resolves to Canvas\'s own ~2-week default, echoed back as the response\'s `start_date`/`end_date`. (2) `context_codes` (e.g. "course_123", "group_7") restricts to those contexts; omit it for every context the student belongs to \u2014 an empty array is rejected rather than silently meaning "all". (3) `submissions` is `false` when the item has no gradable submission, or an object when it does \u2014 never null. (4) a planner note has no `html_url` (Canvas exposes none for individual planner notes).',
+      inputSchema: {
+        start_date: z29.string().optional().describe(
+          "Inclusive start, YYYY-MM-DD or ISO 8601. Must be given together with end_date."
+        ),
+        end_date: z29.string().optional().describe(
+          "Inclusive end, YYYY-MM-DD or ISO 8601. Must be given together with start_date."
+        ),
+        context_codes: z29.array(
+          z29.string().regex(
+            PLANNER_CONTEXT_CODE_PATTERN,
+            'Each context code must be "course_<id>" or "group_<id>" (no leading zeros)'
+          )
+        ).min(
+          1,
+          "context_codes must not be empty \u2014 omit the field for every context the student belongs to, rather than sending an empty list."
+        ).optional().describe(
+          'Restrict to these contexts, e.g. ["course_123","group_7"]. Defaults to every context the student belongs to.'
+        ),
+        filter: z29.enum(["new_activity", "incomplete_items", "complete_items"]).optional().describe(
+          "new_activity = unread/new only; incomplete_items / complete_items filter on planner-override completion and submission state."
+        ),
+        max_items: z29.number().int().positive().max(500).optional().describe(
+          `Maximum items to return (default ${PLANNER_ITEMS_DEFAULT_MAX_ITEMS}). When the limit is reached, \`truncated\` is true and \`truncation_note\` explains how to narrow the query.`
+        )
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        const startDate = params.start_date;
+        const endDate = params.end_date;
+        if (startDate === void 0 !== (endDate === void 0)) {
+          throw new Error(
+            "start_date and end_date must be given together, or neither. Canvas fills a missing side with its own 10-year default (10 years ago or 10 years from now), silently producing a window up to a decade wide \u2014 supply both explicitly, or omit both to use Canvas's ~2-week default."
+          );
+        }
+        const contextCodes = params.context_codes;
+        const filter = params.filter;
+        const limit = params.max_items ?? PLANNER_ITEMS_DEFAULT_MAX_ITEMS;
+        const fetched = await canvas.planner.listItems({
+          startDate,
+          endDate,
+          contextCodes,
+          filter,
+          maxItems: limit + 1
+        });
+        const truncated = fetched.length > limit;
+        const capped = truncated ? fetched.slice(0, limit) : fetched;
+        const items = pseudonymizer?.isEnabled() ? await pseudonymizer.anonymizePlannerItems(capped) : capped;
+        return {
+          items,
+          total_items: items.length,
+          truncated,
+          truncation_note: truncated ? `Stopped after max_items (${limit}) items; more planner items exist in this window. Raise max_items (maximum 500), or narrow start_date/end_date or context_codes.` : null,
+          // Resolved window: when the caller passed neither date, Canvas
+          // applies its own ±2-week default server-side and never echoes it
+          // back. This is computed independently rather than read off the
+          // response, so it is an approximation of what Canvas used, not a
+          // read of it (BRU-2797 §7.1).
+          start_date: startDate ?? isoDateAtUtcMidnight(-PLANNER_DEFAULT_WINDOW_DAYS),
+          end_date: endDate ?? isoDateAtUtcMidnight(PLANNER_DEFAULT_WINDOW_DAYS)
+        };
+      }
     }
   ];
 }
@@ -9620,4 +10021,4 @@ export {
   createSharedPseudonymizer,
   createCanvasMCPServer
 };
-//# sourceMappingURL=chunk-KHJEIVEQ.js.map
+//# sourceMappingURL=chunk-FKTJGYLG.js.map