@wilm-ai/wilma-client 1.5.1 → 1.6.0

package/dist/parsers/gradebook.js

@@ -0,0 +1,44 @@
+import * as cheerio from "cheerio";
+/**
+ * The gradebook (Suoritukset): subjects, their syllabi and courses, each with
+ * a grade, scope and completion date. Rows carry their depth as a class
+ * ("level1", "level2", …), which gives the tree. An empty gradebook (nothing
+ * graded yet) has no table and gives [].
+ */
+export function parseGradebookHtml(html) {
+    const $ = cheerio.load(html);
+    const roots = [];
+    const stack = [];
+    $("table tbody tr").each((_, row) => {
+        const depthMatch = /\blevel(\d+)\b/.exec($(row).attr("class") ?? "");
+        const cells = $(row).find("td");
+        if (!depthMatch || cells.length < 2)
+            return;
+        const depth = Number(depthMatch[1]);
+        const text = (index) => $(cells[index]).text().replace(/\s+/g, " ").trim();
+        const label = text(0);
+        if (!label)
+            return;
+        const codeMatch = /^([\p{L}\d]+_[\p{L}\d.]*)\s+(.*)$/u.exec(label);
+        const entry = {
+            name: codeMatch ? codeMatch[2] : label,
+            code: codeMatch ? codeMatch[1] : null,
+            grade: text(1) || null,
+            credits: cells.length > 3 ? text(2) || null : null,
+            date: isoDate(text(cells.length > 3 ? 3 : 2)),
+            children: [],
+        };
+        while (stack.length && stack[stack.length - 1].depth >= depth)
+            stack.pop();
+        if (stack.length)
+            stack[stack.length - 1].entry.children.push(entry);
+        else
+            roots.push(entry);
+        stack.push({ depth, entry });
+    });
+    return roots;
+}
+function isoDate(value) {
+    const match = /^(\d{1,2})\.(\d{1,2})\.(\d{4})$/.exec(value);
+    return match ? `${match[3]}-${match[2].padStart(2, "0")}-${match[1].padStart(2, "0")}` : null;
+}

package/dist/parsers/html-text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Readable text from a fragment of Wilma HTML (message and reply bodies):
+ * paragraphs and line breaks kept, list items bulleted, and links written as
+ * "label (address)" so the address isn't lost.
+ */
+export declare function htmlToText(html: string | null | undefined): string;

package/dist/parsers/html-text.js

@@ -0,0 +1,42 @@
+import * as cheerio from "cheerio";
+const BLOCKS = "p, div, tr, h1, h2, h3, h4, h5, h6, blockquote, table, ul, ol";
+/**
+ * Readable text from a fragment of Wilma HTML (message and reply bodies):
+ * paragraphs and line breaks kept, list items bulleted, and links written as
+ * "label (address)" so the address isn't lost.
+ */
+export function htmlToText(html) {
+    if (!html)
+        return "";
+    const $ = cheerio.load(`<div id="wilmai-root">${html}</div>`);
+    const root = $("#wilmai-root");
+    root.find("script, style").remove();
+    root.find("a[href]").each((_, anchor) => {
+        const link = $(anchor);
+        const href = (link.attr("href") ?? "").trim();
+        const label = link.text().replace(/\s+/g, " ").trim();
+        if (!/^(https?:|mailto:)/i.test(href))
+            return;
+        const address = href.replace(/^mailto:/i, "");
+        if (!label)
+            link.text(address);
+        else if (!label.includes(address) && !address.includes(label))
+            link.text(`${label} (${address})`);
+    });
+    root.find("br").replaceWith("\n");
+    root.find("li").each((_, item) => {
+        $(item).prepend("- ");
+        $(item).append("\n");
+    });
+    root.find(BLOCKS).each((_, block) => {
+        $(block).prepend("\n");
+        $(block).append("\n");
+    });
+    return root
+        .text()
+        .replace(/ /g, " ")
+        .replace(/[ \t]+/g, " ")
+        .replace(/ *\n */g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}

package/dist/parsers/messages.d.ts

@@ -1,5 +1,9 @@
 import type { Message, MessageFolder } from "../types.js";
 export declare function parseMessagesList(data: unknown, folder: MessageFolder): Message[];
+/**
+ * A message thread from `/messages/<id>?format=json`: the message, who it went
+ * to, and every reply. Returns null when the data isn't a thread (older Wilma
+ * versions answer with the HTML page instead).
+ */
+export declare function parseMessageDetailJson(data: unknown, messageId: number): Message | null;
 export declare function parseMessageDetailHtml(html: string, messageId: number): Message;
-/** Export for debugging - returns raw field names from first message */
-export declare function debugMessageFields(data: unknown): string[];

package/dist/parsers/messages.js

@@ -1,11 +1,15 @@
 import * as cheerio from "cheerio";
 import { parseWilmaTimestamp } from "./dates.js";
+import { htmlToText } from "./html-text.js";
 export function parseMessagesList(data, folder) {
     const now = new Date();
     const list = normalizeMessagesList(data);
     return list.flatMap((item) => {
         try {
             const wilmaId = Number(item["id"] ?? item["Id"]);
+            // Without a usable id a message can't be opened; skip it rather than carry NaN.
+            if (!Number.isInteger(wilmaId) || wilmaId <= 0)
+                return [];
             const subject = compactText(String(item["Subject"] ?? item["subject"] ?? ""));
             // Try many possible field names for the timestamp
             const timeValue = item["Time"] ??
@@ -23,12 +27,17 @@ export function parseMessagesList(data, folder) {
                 item["created"] ??
                 item["CreatedAt"] ??
                 item["createdAt"];
+            const sender = item["Sender"] ?? item["sender"];
             return [
                 {
                     wilmaId,
                     subject,
                     sentAt: parseWilmaTimestamp(timeValue),
                     folder,
+                    senderName: typeof sender === "string" && sender.trim() ? compactText(sender) : null,
+                    // Wilma marks unopened messages with a truthy Status (shown in bold).
+                    unread: Boolean(item["Status"]),
+                    replyCount: Number(item["Replies"]) || 0,
                     fetchedAt: now,
                 },
             ];
@@ -38,6 +47,51 @@ export function parseMessagesList(data, folder) {
         }
     });
 }
+/**
+ * A message thread from `/messages/<id>?format=json`: the message, who it went
+ * to, and every reply. Returns null when the data isn't a thread (older Wilma
+ * versions answer with the HTML page instead).
+ */
+export function parseMessageDetailJson(data, messageId) {
+    const list = data?.messages;
+    const m = Array.isArray(list) ? list[0] : undefined;
+    if (!m || typeof m !== "object")
+        return null;
+    const str = (value) => (typeof value === "string" && value.trim() ? value.trim() : null);
+    const recipients = Array.isArray(m["Recipients"])
+        ? m["Recipients"].map(str).filter((r) => Boolean(r))
+        : str(m["Recipient"])
+            ? [str(m["Recipient"])]
+            : null;
+    const replies = Array.isArray(m["ReplyList"])
+        ? m["ReplyList"].flatMap((reply) => {
+            if (!reply || typeof reply !== "object")
+                return [];
+            return [
+                {
+                    id: Number(reply["Id"]) || 0,
+                    sentAt: parseWilmaTimestamp(reply["TimeStamp"]),
+                    senderName: str(reply["Sender"]),
+                    content: htmlToText(str(reply["ContentHtml"])),
+                },
+            ];
+        })
+        : [];
+    replies.sort((a, b) => a.sentAt.getTime() - b.sentAt.getTime());
+    return {
+        wilmaId: Number(m["Id"]) || messageId,
+        subject: compactText(String(m["Subject"] ?? "")),
+        sentAt: parseWilmaTimestamp(m["TimeStamp"]),
+        folder: String(m["Folder"] ?? "unknown"),
+        senderId: typeof m["SenderId"] === "number" ? m["SenderId"] : null,
+        senderType: typeof m["SenderType"] === "number" ? m["SenderType"] : null,
+        senderName: str(m["Sender"]),
+        content: htmlToText(str(m["ContentHtml"])),
+        recipients,
+        replies,
+        fetchedAt: new Date(),
+    };
+}
 export function parseMessageDetailHtml(html, messageId) {
     const $ = cheerio.load(html);
     const panelBody = $("div#page-content-area.panel-body");
@@ -171,14 +225,6 @@ function normalizeMessagesList(data) {
     }
     return [];
 }
-/** Export for debugging - returns raw field names from first message */
-export function debugMessageFields(data) {
-    const list = normalizeMessagesList(data);
-    if (list.length > 0) {
-        return Object.keys(list[0]);
-    }
-    return [];
-}
 function compactText(value) {
     return value.replace(/\s+/g, " ").trim();
 }

package/dist/parsers/news.js

@@ -7,6 +7,8 @@ export function parseNewsList(data) {
         return data.flatMap((item) => {
             try {
                 const wilmaId = Number(item["id"] ?? item["Id"]);
+                if (!Number.isInteger(wilmaId) || wilmaId <= 0)
+                    return [];
                 const title = String(item["Title"] ?? item["title"] ?? "");
                 const published = parseWilmaTimestamp(item["Published"] ?? item["published"]);
                 return [
@@ -26,7 +28,8 @@ export function parseNewsList(data) {
     return [];
 }
 export function parseNewsDetailJson(newsId, data, baseUrl) {
-    const content = (data["content"] ?? data["Content"]);
+    const rawContent = data["content"] ?? data["Content"];
+    const content = typeof rawContent === "string" ? rawContent : null;
     let resources = [];
     if (content && content.includes("<a")) {
         const $ = cheerio.load(content);
@@ -35,7 +38,7 @@ export function parseNewsDetailJson(newsId, data, baseUrl) {
     return {
         wilmaId: newsId,
         title: String(data["title"] ?? data["Title"] ?? ""),
-        subtitle: (data["subtitle"] ?? data["Subtitle"]),
+        subtitle: typeof (data["subtitle"] ?? data["Subtitle"]) === "string" ? (data["subtitle"] ?? data["Subtitle"]) : null,
         author: (data["author"] ?? data["Author"]),
         published: parseWilmaTimestamp(data["Published"] ?? data["published"]),
         content,
@@ -74,17 +77,31 @@ export function parseNewsDetailHtml(html, newsId, baseUrl) {
         proseOnly.find("a[href]").remove();
         content = proseOnly.text().trim() ? text : null;
     }
+    // "Sär (Teacher Name) Julkaistu 27.9." — the date (this year's lack the
+    // year) and the author's profile link sit together under the bulletin.
+    let published = null;
+    let author = null;
+    const meta = $("p, span, div")
+        .filter((_, el) => PUBLISHED_RE.test($(el).text()) && $(el).find("p, div").length === 0)
+        .first();
+    const publishedMatch = PUBLISHED_RE.exec(meta.text().replace(/\s+/g, " "));
+    if (publishedMatch) {
+        published = parseWilmaTimestamp(publishedMatch[1]);
+        const authorLink = meta.find("a.profile-link").first();
+        author = authorLink.attr("title")?.trim() || authorLink.text().trim() || null;
+    }
     return {
         wilmaId: newsId,
         title,
         subtitle,
-        author: null,
-        published: null,
+        author,
+        published,
         content,
         resources,
         fetchedAt: new Date(),
     };
 }
+const PUBLISHED_RE = /(?:Julkaistu|Publicerad|Published)\s*:?\s*(\d{1,2}\.\d{1,2}\.(?:\d{4})?)/i;
 function extractNewsResources($, contentElem, baseUrl) {
     const resources = [];
     const seen = new Set();
@@ -143,9 +160,6 @@ export function parseNewsListHtml(html) {
     const newsItems = [];
     const seenIds = new Set();
     const headers = $("div.left h2.no-border, h2.no-border");
-    if (!headers.length) {
-        return newsItems;
-    }
     headers.each((_, header) => {
         const headerEl = $(header);
         const timestampRaw = headerEl.text().trim();
@@ -202,11 +216,51 @@ export function parseNewsListHtml(html) {
                     subtitle,
                     author,
                     published,
+                    // A padlock icon marks a bulletin pinned to the page.
+                    pinned: container.find(".vismaicon-locked").length > 0,
+                    archived: false,
                     fetchedAt: now,
                 });
             }
             sib = sib.next();
         }
     });
+    // The side panels list pinned bulletins and older ones (titles only; the
+    // date is on each bulletin). Recognised by their heading, in Finnish,
+    // Swedish or English.
+    $("div.panel-body > h2").each((_, heading) => {
+        const label = $(heading).text().trim();
+        const pinned = SIDE_PANEL_PINNED.test(label);
+        const archived = SIDE_PANEL_OLDER.test(label);
+        if (!pinned && !archived)
+            return;
+        $(heading)
+            .parent()
+            .find("a[href*='/news/']")
+            .each((_, anchor) => {
+            const match = /\/news\/(\d+)/.exec($(anchor).attr("href") ?? "");
+            const newsId = match ? Number(match[1]) : null;
+            if (!newsId)
+                return;
+            const known = newsItems.find((item) => item.wilmaId === newsId);
+            if (known) {
+                if (pinned)
+                    known.pinned = true;
+                return;
+            }
+            newsItems.push({
+                wilmaId: newsId,
+                title: $(anchor).text().trim() || "Untitled News",
+                subtitle: null,
+                author: null,
+                published: null,
+                pinned,
+                archived,
+                fetchedAt: now,
+            });
+        });
+    });
     return newsItems;
 }
+const SIDE_PANEL_PINNED = /^(pysyvät|permanent|pinned|bestående|fasta|stående)/i;
+const SIDE_PANEL_OLDER = /^(vanhat|vanhemmat|old|older|gamla|äldre|arkiv|archive)/i;

package/dist/parsers/overview.d.ts

@@ -1,2 +1,3 @@
 import type { OverviewData } from "../types.js";
-export declare function parseOverview(raw: unknown): OverviewData;
+/** `now` decides which exams are upcoming (default: the current time). */
+export declare function parseOverview(raw: unknown, now?: Date): OverviewData;

package/dist/parsers/overview.js

@@ -1,3 +1,4 @@
+import { finnishDateString } from "../finnish-time.js";
 /* ------------------------------------------------------------------ */
 /*  Helpers                                                           */
 /* ------------------------------------------------------------------ */
@@ -23,10 +24,10 @@ function firstScheduleTeacher(teachers) {
 /* ------------------------------------------------------------------ */
 /*  Main parser                                                       */
 /* ------------------------------------------------------------------ */
-export function parseOverview(raw) {
+/** `now` decides which exams are upcoming (default: the current time). */
+export function parseOverview(raw, now = new Date()) {
     const data = (raw ?? {});
-    const now = new Date();
-    const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+    const today = finnishDateString(now);
     return {
         schedule: parseSchedule(data.Schedule ?? []),
         upcomingExams: parseUpcomingExams(data.Groups ?? [], today),

package/dist/parsers/printouts.d.ts

@@ -0,0 +1,3 @@
+import type { Printout } from "../types.js";
+/** Printouts (Tulosteet): PDF documents the school offers, e.g. report cards or absence reports. */
+export declare function parsePrintoutsHtml(html: string): Printout[];

package/dist/parsers/printouts.js

@@ -0,0 +1,20 @@
+import * as cheerio from "cheerio";
+/** Printouts (Tulosteet): PDF documents the school offers, e.g. report cards or absence reports. */
+export function parsePrintoutsHtml(html) {
+    const $ = cheerio.load(html);
+    const printouts = [];
+    const seen = new Set();
+    $("a[href]").each((_, anchor) => {
+        const href = $(anchor).attr("href") ?? "";
+        const match = /^(?:https?:\/\/[^/]+)?(\/(?:![^/]+\/)?printouts\/(\d+)\.pdf)(?:[?#].*)?$/.exec(href);
+        if (!match || seen.has(match[2]))
+            return;
+        seen.add(match[2]);
+        printouts.push({
+            id: match[2],
+            title: $(anchor).text().replace(/\s+/g, " ").trim() || `Printout ${match[2]}`,
+            path: match[1],
+        });
+    });
+    return printouts;
+}

package/dist/parsers/schedule.d.ts

@@ -1,2 +1,8 @@
 import type { ScheduleLesson } from "../types.js";
 export declare function parseScheduleHtml(html: string): ScheduleLesson[];
+/**
+ * Lessons from the timetable API (`/api/v1/schedules/timetable`): one entry
+ * per date a lesson takes place, with every teacher and room. Field values
+ * match the schedule page's ("BI_ Biologia", "Lastname Firstname").
+ */
+export declare function parseTimetableJson(payload: unknown): ScheduleLesson[];

package/dist/parsers/schedule.js

@@ -81,3 +81,40 @@ function firstTeacher(groups) {
 function firstSubjectToken(subject) {
     return subject.trim().split(/\s+/, 1)[0] ?? "";
 }
+/**
+ * Lessons from the timetable API (`/api/v1/schedules/timetable`): one entry
+ * per date a lesson takes place, with every teacher and room. Field values
+ * match the schedule page's ("BI_ Biologia", "Lastname Firstname").
+ */
+export function parseTimetableJson(payload) {
+    if (!Array.isArray(payload))
+        return [];
+    const lessons = [];
+    for (const lesson of payload) {
+        const start = (lesson.startAt ?? "").slice(0, 5);
+        const end = (lesson.endsAt ?? "").slice(0, 5);
+        for (const rawDate of lesson.dates ?? []) {
+            const date = rawDate.slice(0, 10);
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
+                continue;
+            for (const module of lesson.modules ?? []) {
+                const subject = (module.caption ?? "").trim();
+                const teachers = module.teachers ?? [];
+                const rooms = (module.rooms ?? []).map((room) => (room.abbreviation ?? room.caption ?? "").trim()).filter(Boolean);
+                lessons.push({
+                    date,
+                    dayOfWeek: new Date(`${date}T12:00:00Z`).getUTCDay(),
+                    start,
+                    end,
+                    subject,
+                    subjectCode: firstSubjectToken(subject),
+                    teacher: teachers.map((t) => [t.lastname, t.firstname].filter(Boolean).join(" ")).join(", "),
+                    teacherCode: teachers.map((t) => t.abbreviation ?? "").filter(Boolean).join(", "),
+                    groupId: Number(module.id) || 0,
+                    room: rooms.length ? rooms.join(", ") : null,
+                });
+            }
+        }
+    }
+    return lessons.sort((a, b) => a.date.localeCompare(b.date) || a.start.localeCompare(b.start));
+}

package/dist/parsers/students.d.ts

@@ -1,6 +1,12 @@
-export interface StudentInfo {
-    studentNumber: string;
-    name: string;
-    href: string;
-}
-export declare function parseStudentsFromHome(html: string): StudentInfo[];
+import type { StudentInfo } from "../types.js";
+export type { StudentInfo };
+export declare function studentNumberFromHref(href: string): string | null;
+export declare function parseStudentFromUrl(url: string): StudentInfo | null;
+/**
+ * Parse GET /api/v1/accounts/me/roles.
+ * Accepts `{ payload: AccountRole[] }` or a raw array.
+ * Skips the account itself (`type === "passwd"` / type 7). Guardian (and other
+ * non-passwd) roles contribute a student from `slug` + `name`.
+ */
+export declare function parseStudentsFromAccountsRoles(data: unknown): StudentInfo[];
+export declare function parseStudentsFromHome(html: string, pageUrl?: string): StudentInfo[];

package/dist/parsers/students.js

@@ -12,33 +12,150 @@ const NAV_KEYWORDS = [
     "printouts",
     "news",
 ];
-export function parseStudentsFromHome(html) {
-    const $ = cheerio.load(html);
+const STUDENT_HREF_RE = /\/!(\d+)(?:\/|$)/;
+export function studentNumberFromHref(href) {
+    const match = STUDENT_HREF_RE.exec(href);
+    return match ? match[1] : null;
+}
+function isPasswdAccountRole(type) {
+    return type === "passwd" || type === 7 || type === "7";
+}
+function studentNumberFromSlug(slug) {
+    const trimmed = slug.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (/^\d+$/.test(trimmed)) {
+        return trimmed;
+    }
+    const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    return studentNumberFromHref(withSlash);
+}
+export function parseStudentFromUrl(url) {
+    const studentNumber = studentNumberFromHref(url);
+    if (!studentNumber) {
+        return null;
+    }
+    return {
+        studentNumber,
+        name: studentNumber,
+        href: `/!${studentNumber}/`,
+    };
+}
+function roleType(rec) {
+    return rec.Type ?? rec.type ?? rec.RoleType ?? rec.roleType;
+}
+function roleName(rec, fallback) {
+    // First non-empty name; an empty Name must not drop the student.
+    for (const value of [rec.Name, rec.name, rec.Caption, rec.caption]) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return fallback;
+}
+function collectStudent(students, studentNumber, name) {
+    if (!students.has(studentNumber)) {
+        students.set(studentNumber, {
+            studentNumber,
+            name,
+            href: `/!${studentNumber}/`,
+        });
+    }
+}
+/**
+ * Parse GET /api/v1/accounts/me/roles.
+ * Accepts `{ payload: AccountRole[] }` or a raw array.
+ * Skips the account itself (`type === "passwd"` / type 7). Guardian (and other
+ * non-passwd) roles contribute a student from `slug` + `name`.
+ */
+export function parseStudentsFromAccountsRoles(data) {
     const students = new Map();
-    $("a[href^='/!']").each((_, anchor) => {
+    let roles = [];
+    if (Array.isArray(data)) {
+        roles = data;
+    }
+    else if (data && typeof data === "object") {
+        const rec = data;
+        const payload = rec.payload ?? rec.Payload;
+        if (Array.isArray(payload)) {
+            roles = payload;
+        }
+    }
+    for (const item of roles) {
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        const rec = item;
+        if (isPasswdAccountRole(roleType(rec))) {
+            continue;
+        }
+        const slug = String(rec.slug ?? rec.Slug ?? "");
+        const studentNumber = studentNumberFromSlug(slug);
+        if (!studentNumber) {
+            continue;
+        }
+        const name = roleName(rec, studentNumber);
+        if (!name) {
+            continue;
+        }
+        collectStudent(students, studentNumber, name);
+    }
+    return [...students.values()];
+}
+export function parseStudentsFromHome(html, pageUrl) {
+    const $ = cheerio.load(html);
+    const named = new Map();
+    // Names from links deeper than a student's root: used only when a student has no root link.
+    const deepNamed = new Map();
+    const fromHref = new Map();
+    $("a[href]").each((_, anchor) => {
         const href = $(anchor).attr("href") ?? "";
-        const match = /\/!(\d+)\//.exec(href);
-        if (!match) {
+        const studentNumber = studentNumberFromHref(href);
+        if (!studentNumber) {
             return;
         }
-        const studentNumber = match[1];
+        fromHref.set(studentNumber, {
+            studentNumber,
+            name: studentNumber,
+            href,
+        });
         const cloned = $(anchor).clone();
         cloned.find("small, span.lem").remove();
         const text = cloned.text().trim();
         if (!text) {
             return;
         }
-        const lower = text.toLowerCase();
-        if (NAV_KEYWORDS.some((kw) => lower.includes(kw))) {
+        // Keywords match whole words only, so a name like "Ella Newsome" isn't
+        // mistaken for "news".
+        const words = text.toLowerCase().split(/[\s()]+/);
+        if (NAV_KEYWORDS.some((kw) => words.includes(kw))) {
             return;
         }
-        if (!students.has(studentNumber)) {
-            students.set(studentNumber, {
+        // Menu links go deeper than the student's root (/!123/messages) and their
+        // text is usually a section name, so a root link's text wins.
+        const target = /\/!\d+\/[^/?#]+/.test(href) ? deepNamed : named;
+        if (!target.has(studentNumber)) {
+            target.set(studentNumber, {
                 studentNumber,
                 name: text,
                 href,
             });
         }
     });
-    return [...students.values()];
+    if (named.size > 0 || deepNamed.size > 0) {
+        // Every named student, in page order; none dropped for lacking a root link.
+        return [...fromHref.keys()]
+            .map((number) => named.get(number) ?? deepNamed.get(number))
+            .filter((student) => Boolean(student));
+    }
+    if (fromHref.size > 0) {
+        return [...fromHref.values()];
+    }
+    if (pageUrl) {
+        const fromUrl = parseStudentFromUrl(pageUrl);
+        if (fromUrl) {
+            return [fromUrl];
+        }
+    }
+    return [];
 }