brightspace-d2l-mcp 1.0.0

package/build/utils/config.js

@@ -0,0 +1,60 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeFileAtomicSync } from "./atomic-write.js";
+import { configPath } from "./paths.js";
+export function readStoredConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(configPath(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeStoredConfig(update) {
+    const next = { ...readStoredConfig(), ...update };
+    fs.mkdirSync(path.dirname(configPath()), { recursive: true, mode: 0o700 });
+    writeFileAtomicSync(configPath(), JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+    return next;
+}
+export function normalizeSchoolUrl(input) {
+    const trimmed = input.trim().replace(/^["']|["']$/g, "");
+    if (!trimmed)
+        return null;
+    try {
+        const url = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`);
+        if (url.username || url.password || !url.hostname.includes("."))
+            return null;
+        url.protocol = "https:";
+        return url.origin;
+    }
+    catch {
+        return null;
+    }
+}
+function parseIds(value) {
+    if (!value)
+        return undefined;
+    return value.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n));
+}
+export function loadConfig() {
+    const store = readStoredConfig();
+    const rawUrl = process.env.D2L_BASE_URL || store.baseUrl;
+    const baseUrl = rawUrl ? normalizeSchoolUrl(rawUrl) : null;
+    const activeOnly = process.env.D2L_ACTIVE_ONLY !== undefined
+        ? process.env.D2L_ACTIVE_ONLY !== "false"
+        : store.activeOnly ?? true;
+    const autoLogin = process.env.D2L_AUTO_LOGIN !== undefined
+        ? process.env.D2L_AUTO_LOGIN !== "false"
+        : store.autoLogin ?? true;
+    return {
+        baseUrl: baseUrl ?? "",
+        tokenTtl: process.env.D2L_TOKEN_TTL ? parseInt(process.env.D2L_TOKEN_TTL, 10) : 3600,
+        autoLogin,
+        courseFilter: {
+            includeCourseIds: parseIds(process.env.D2L_INCLUDE_COURSES) ?? store.includeCourses,
+            excludeCourseIds: parseIds(process.env.D2L_EXCLUDE_COURSES) ?? store.excludeCourses,
+            activeOnly,
+        },
+    };
+}
+//# sourceMappingURL=config.js.map

package/build/utils/course-filter.js

@@ -0,0 +1,24 @@
+import { log } from "./logger.js";
+export function applyCourseFilter(courses, config) {
+    let filtered = courses;
+    const originalCount = courses.length;
+    if (config.activeOnly) {
+        filtered = filtered.filter(c => c.isActive);
+        filtered = filtered.filter(c => c.canAccess !== false);
+    }
+    if (config.includeCourseIds && config.includeCourseIds.length > 0) {
+        filtered = filtered.filter(c => config.includeCourseIds.includes(c.id));
+    }
+    if (config.excludeCourseIds && config.excludeCourseIds.length > 0) {
+        filtered = filtered.filter(c => !config.excludeCourseIds.includes(c.id));
+    }
+    if (filtered.length !== originalCount) {
+        log("DEBUG", `Course filter: ${originalCount} -> ${filtered.length} courses`, {
+            activeOnly: config.activeOnly,
+            include: config.includeCourseIds,
+            exclude: config.excludeCourseIds,
+        });
+    }
+    return filtered;
+}
+//# sourceMappingURL=course-filter.js.map

package/build/utils/deep-links.js

@@ -0,0 +1,13 @@
+function trimBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+export function assignmentUrl(baseUrl, courseId, folderId) {
+    return `${trimBaseUrl(baseUrl)}/d2l/lms/dropbox/user/folder_submit_files.d2l?db=${folderId}&grpid=0&ou=${courseId}`;
+}
+export function quizUrl(baseUrl, courseId, quizId) {
+    return `${trimBaseUrl(baseUrl)}/d2l/lms/quizzing/user/quiz_summary.d2l?qi=${quizId}&ou=${courseId}`;
+}
+export function gradebookUrl(baseUrl, courseId) {
+    return `${trimBaseUrl(baseUrl)}/d2l/lms/grades/my_grades/main.d2l?ou=${courseId}`;
+}
+//# sourceMappingURL=deep-links.js.map

package/build/utils/download-errors.js

@@ -0,0 +1,14 @@
+export class DownloadError extends Error {
+    kind;
+    detail;
+    constructor(kind, message, detail) {
+        super(message);
+        this.kind = kind;
+        this.detail = detail;
+        this.name = "DownloadError";
+    }
+}
+export function isSafeDetail(value) {
+    return value.length <= 64 && /^[a-z0-9][a-z0-9.+-]*\/[a-z0-9][a-z0-9.+-]*$/.test(value);
+}
+//# sourceMappingURL=download-errors.js.map

package/build/utils/download-helpers.js

@@ -0,0 +1,73 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { validateDownloadPath, validateFileType, MAX_FILE_SIZE } from "./file-validator.js";
+import { log } from "./logger.js";
+export async function resolveFilenameConflict(dir, filename) {
+    const fullPath = path.join(dir, filename);
+    try {
+        await fs.access(fullPath);
+        // File exists, need to resolve conflict
+    }
+    catch {
+        // File doesn't exist, use original name
+        return filename;
+    }
+    // Parse filename into name and extension
+    const ext = path.extname(filename);
+    const basename = path.basename(filename, ext);
+    // Try filename(1), filename(2), etc.
+    for (let i = 1; i <= 100; i++) {
+        const candidate = `${basename}(${i})${ext}`;
+        const candidatePath = path.join(dir, candidate);
+        try {
+            await fs.access(candidatePath);
+            // File exists, try next
+        }
+        catch {
+            // File doesn't exist, use this name
+            return candidate;
+        }
+    }
+    throw new Error("Could not resolve filename conflict after 100 attempts");
+}
+export async function secureDownload(options) {
+    const { targetDir, filename, data, allowedTypes } = options;
+    log("DEBUG", `secureDownload: starting download of ${filename} to ${targetDir}`);
+    // Validate target directory exists and is a directory
+    try {
+        const stats = await fs.stat(targetDir);
+        if (!stats.isDirectory()) {
+            throw new Error(`Target path is not a directory: ${targetDir}`);
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Target directory does not exist: ${targetDir}`);
+        }
+        throw error;
+    }
+    // Validate file size
+    const size = data.byteLength;
+    if (size > MAX_FILE_SIZE) {
+        throw new Error(`File size (${size} bytes) exceeds maximum allowed (${MAX_FILE_SIZE} bytes)`);
+    }
+    log("DEBUG", `secureDownload: file size ${size} bytes (within limit)`);
+    const { mime } = await validateFileType(data, allowedTypes, filename);
+    log("DEBUG", `secureDownload: file type validated as ${mime}`);
+    // Validate download path (prevent path traversal)
+    const validatedPath = validateDownloadPath(targetDir, filename);
+    log("DEBUG", `secureDownload: path validated as ${validatedPath}`);
+    // Resolve filename conflicts
+    const resolvedFilename = await resolveFilenameConflict(targetDir, filename);
+    const finalPath = path.join(targetDir, resolvedFilename);
+    log("DEBUG", `secureDownload: resolved filename to ${resolvedFilename}`);
+    // Write file to disk
+    await fs.writeFile(finalPath, data);
+    log("INFO", `Downloaded file to ${finalPath} (${size} bytes, ${mime})`);
+    return {
+        path: finalPath,
+        size,
+        mime,
+    };
+}
+//# sourceMappingURL=download-helpers.js.map

package/build/utils/errors.js

@@ -0,0 +1,31 @@
+export class AuthError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(`[PBMCP-1001] ${message}`);
+        this.cause = cause;
+        this.name = "AuthError";
+    }
+}
+export class TokenExpiredError extends AuthError {
+    expiredAt;
+    constructor(expiredAt) {
+        super(`[PBMCP-1002] Token expired at ${new Date(expiredAt).toISOString()}`);
+        this.expiredAt = expiredAt;
+        this.name = "TokenExpiredError";
+    }
+}
+export class BrowserAuthError extends AuthError {
+    step;
+    constructor(message, step, cause) {
+        super(`[PBMCP-1003] Browser auth failed at step "${step}": ${message}`, cause);
+        this.step = step;
+        this.name = "BrowserAuthError";
+    }
+}
+export class SessionStoreError extends AuthError {
+    constructor(message, cause) {
+        super(`[PBMCP-1004] Session store error: ${message}`, cause);
+        this.name = "SessionStoreError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/build/utils/file-validator.js

@@ -0,0 +1,121 @@
+import path from "node:path";
+import { fileTypeFromBuffer } from "file-type";
+import sanitizeFilename from "sanitize-filename";
+import { DownloadError } from "./download-errors.js";
+const CFB_MIME = "application/x-cfb";
+const CFB_EXTENSION_MIMES = {
+    ".doc": "application/msword",
+    ".dot": "application/msword",
+    ".xls": "application/vnd.ms-excel",
+    ".xlt": "application/vnd.ms-excel",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pot": "application/vnd.ms-powerpoint",
+    ".pps": "application/vnd.ms-powerpoint",
+};
+export const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50 MB
+export const ALLOWED_MIME_TYPES = [
+    // Documents
+    "application/pdf",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/msword",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.ms-excel",
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+    "image/svg+xml",
+    // Text
+    "text/plain",
+    "text/csv",
+    "text/html",
+    // Data
+    "application/json",
+    // Archives
+    "application/zip",
+    "application/x-zip-compressed",
+    // Media
+    "video/mp4",
+    "audio/mpeg",
+    "audio/wav",
+];
+export function validateDownloadPath(baseDir, filename) {
+    let decoded;
+    try {
+        decoded = decodeURIComponent(filename);
+    }
+    catch {
+        decoded = filename;
+    }
+    // Sanitize filename (removes path separators, null bytes, etc.)
+    const sanitized = sanitizeFilename(decoded);
+    if (!sanitized || sanitized.length === 0) {
+        throw new DownloadError("badFilename", "Invalid filename after sanitization");
+    }
+    // Resolve full path
+    const fullPath = path.resolve(baseDir, sanitized);
+    const resolvedBase = path.resolve(baseDir);
+    // Verify resolved path is within base directory
+    if (!fullPath.startsWith(resolvedBase + path.sep) &&
+        fullPath !== resolvedBase) {
+        throw new DownloadError("pathTraversal", "Path traversal detected");
+    }
+    return fullPath;
+}
+export async function validateFileType(buffer, allowedTypes = ALLOWED_MIME_TYPES, filename) {
+    // Try magic byte detection first
+    const detected = await fileTypeFromBuffer(buffer);
+    if (detected) {
+        if (detected.mime === CFB_MIME) {
+            const ext = filename ? path.extname(filename).toLowerCase() : "";
+            const resolved = CFB_EXTENSION_MIMES[ext];
+            if (resolved && allowedTypes.includes(resolved)) {
+                return { mime: resolved, ext: ext.slice(1) };
+            }
+            throw new DownloadError("unsupportedType", `Compound File Binary with extension '${ext || "none"}' is not an allowed Office format`, CFB_MIME);
+        }
+        if (!allowedTypes.includes(detected.mime)) {
+            throw new DownloadError("unsupportedType", `File type '${detected.mime}' not allowed`, detected.mime);
+        }
+        return { mime: detected.mime, ext: detected.ext };
+    }
+    // Fallback for text-based files with no magic-byte signature: accept if the
+    // buffer decodes as UTF-8 (rejecting binaries and NUL bytes), then sniff HTML.
+    if (!buffer.includes(0)) {
+        let decoded = null;
+        try {
+            decoded = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+        }
+        catch {
+            // Invalid UTF-8, so treat as binary.
+        }
+        if (decoded !== null) {
+            const noBom = decoded.charCodeAt(0) === 0xfeff ? decoded.slice(1) : decoded;
+            const head = noBom.trimStart().toLowerCase();
+            const isHtml = head.startsWith("<!doctype html") || head.startsWith("<html");
+            const mime = isHtml ? "text/html" : "text/plain";
+            const ext = isHtml ? "html" : "txt";
+            if (allowedTypes.includes(mime)) {
+                return { mime, ext };
+            }
+        }
+    }
+    throw new DownloadError("undetectableType", "Could not determine file type or type not allowed");
+}
+export function validateContentId(id) {
+    if (typeof id !== "number") {
+        throw new Error("Content ID must be a number");
+    }
+    if (!Number.isInteger(id) || id <= 0) {
+        throw new Error("Content ID must be a positive integer");
+    }
+    return id;
+}
+export function validateBaseUrl(url, expectedBaseUrl) {
+    if (!url.startsWith(expectedBaseUrl)) {
+        throw new Error(`URL must start with ${expectedBaseUrl}, got: ${url.substring(0, 50)}...`);
+    }
+}
+//# sourceMappingURL=file-validator.js.map

package/build/utils/html-converter.js

@@ -0,0 +1,20 @@
+import TurndownService from "turndown";
+const turndownService = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+});
+export function convertHtmlToMarkdown(html) {
+    // Handle null/empty input
+    if (!html || html.trim().length === 0) {
+        return { markdown: "", html: "" };
+    }
+    try {
+        const markdown = turndownService.turndown(html);
+        return { markdown, html };
+    }
+    catch (error) {
+        // If conversion fails, fallback to raw HTML
+        return { markdown: html, html };
+    }
+}
+//# sourceMappingURL=html-converter.js.map

package/build/utils/logger.js

@@ -0,0 +1,69 @@
+let currentLevel = "INFO";
+const LEVEL_ORDER = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+};
+export function setLogLevel(level) {
+    currentLevel = level;
+}
+function redact(value) {
+    // JSON web tokens, wherever they appear
+    value = value.replace(/eyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]*)?/g, "eyJ...REDACTED");
+    // Redact Bearer tokens
+    value = value.replace(/Bearer\s+([A-Za-z0-9._~+/=-]{8})[A-Za-z0-9._~+/=-]*/g, "Bearer $1...REDACTED");
+    // Redact cookie: prefixed tokens
+    value = value.replace(/cookie:([^\s]{8})[^\s]*/g, "cookie:$1...REDACTED");
+    // JSON-serialized header fields: {"Authorization":"..."}, {"Cookie":"..."}
+    value = value.replace(/("(?:authorization|cookie|set-cookie)"\s*:\s*")[^"]*(")/gi, "$1...REDACTED$2");
+    // Credentials embedded in a URL: scheme://user:pass@host
+    value = value.replace(/(\b[a-z][a-z0-9+.-]*:\/\/)[^\s/:@]+:[^\s/@]+@/gi, "$1***:***@");
+    // Redact anything that looks like a long token (40+ chars of base64-like)
+    value = value.replace(/([A-Za-z0-9._~+/=-]{40,})/g, (match) => match.substring(0, 8) + "...REDACTED");
+    return value;
+}
+const MAX_ARG_LENGTH = 2000;
+function serializeArg(arg) {
+    if (arg instanceof Error) {
+        const frame = arg.stack?.split("\n").find((line) => line.trim().startsWith("at ")) ?? "";
+        return `${arg.name}: ${arg.message}${frame ? ` ${frame.trim()}` : ""}`;
+    }
+    if (typeof arg === "string")
+        return arg;
+    if (typeof arg === "object" && arg !== null) {
+        const seen = new WeakSet();
+        try {
+            const json = JSON.stringify(arg, (_key, value) => {
+                if (typeof value === "bigint")
+                    return value.toString();
+                if (typeof value === "object" && value !== null) {
+                    if (seen.has(value))
+                        return "[Circular]";
+                    seen.add(value);
+                }
+                return value;
+            });
+            return json.length > MAX_ARG_LENGTH ? `${json.slice(0, MAX_ARG_LENGTH)}...` : json;
+        }
+        catch {
+            return String(arg);
+        }
+    }
+    return String(arg);
+}
+export function log(level, message, ...args) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[currentLevel])
+        return;
+    const timestamp = new Date().toISOString();
+    const safeMessage = redact(message);
+    const safeArgs = args.map((arg) => redact(serializeArg(arg)));
+    console.error(`[${timestamp}] [${level}] ${safeMessage}`, ...safeArgs);
+}
+// Override console.log in production to prevent accidental stdout writes
+export function enableStdoutGuard() {
+    console.log = (...args) => {
+        console.error("[WARN] console.log intercepted (would corrupt stdio):", ...args);
+    };
+}
+//# sourceMappingURL=logger.js.map

package/build/utils/paths.js

@@ -0,0 +1,15 @@
+import * as os from "node:os";
+import * as path from "node:path";
+export const PACKAGE_NAME = "brightspace-d2l-mcp";
+export const SERVER_NAME = "brightspace";
+export const SETUP_COMMAND = `npx -y ${PACKAGE_NAME}@latest setup`;
+export const LOGIN_COMMAND = `npx -y ${PACKAGE_NAME}@latest login`;
+export function dataDir() {
+    return process.env.BRIGHTSPACE_MCP_HOME || path.join(os.homedir(), ".brightspace-d2l-mcp");
+}
+export const configPath = () => path.join(dataDir(), "config.json");
+export const sessionPath = () => path.join(dataDir(), "session.json");
+export const browserProfileDir = () => path.join(dataDir(), "browser-profile");
+export const savedCookiesPath = () => path.join(dataDir(), "browser-cookies.json");
+export const loginLockPath = () => path.join(dataDir(), "login.lock");
+//# sourceMappingURL=paths.js.map

package/build/utils/pdf-extractor.js

@@ -0,0 +1,18 @@
+import { extractText } from "unpdf";
+import { log } from "./logger.js";
+export async function extractPdfText(buffer) {
+    try {
+        const result = await extractText(new Uint8Array(buffer), {
+            mergePages: true,
+        });
+        return {
+            text: result.text,
+            totalPages: result.totalPages,
+        };
+    }
+    catch (error) {
+        log("ERROR", "Failed to extract text from PDF", error);
+        return null;
+    }
+}
+//# sourceMappingURL=pdf-extractor.js.map

package/build/utils/version.js

@@ -0,0 +1,18 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+let cached = null;
+export function packageVersion() {
+    if (cached)
+        return cached;
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        // build/utils/version.js -> package.json two levels up
+        cached = JSON.parse(readFileSync(resolve(here, "..", "..", "package.json"), "utf8")).version ?? "0.0.0";
+    }
+    catch {
+        cached = "0.0.0";
+    }
+    return cached;
+}
+//# sourceMappingURL=version.js.map

package/build/utils/zip-extract.js

@@ -0,0 +1,139 @@
+import { inflateRawSync } from "node:zlib";
+const EOCD_SIGNATURE = 0x06054b50;
+const CENTRAL_FILE_SIGNATURE = 0x02014b50;
+const EOCD_MIN_SIZE = 22;
+const EOCD_MAX_COMMENT = 0xffff;
+const ZIP64_MARKER = 0xffffffff;
+const METHOD_STORED = 0;
+const METHOD_DEFLATE = 8;
+function findEocd(buffer) {
+    const earliest = Math.max(0, buffer.length - EOCD_MIN_SIZE - EOCD_MAX_COMMENT);
+    for (let i = buffer.length - EOCD_MIN_SIZE; i >= earliest; i--) {
+        if (buffer.readUInt32LE(i) === EOCD_SIGNATURE)
+            return i;
+    }
+    return null;
+}
+function readCentralDirectory(buffer) {
+    const eocd = findEocd(buffer);
+    if (eocd === null)
+        return null;
+    const count = buffer.readUInt16LE(eocd + 10);
+    let offset = buffer.readUInt32LE(eocd + 16);
+    if (offset === ZIP64_MARKER)
+        return null; // ZIP64 is out of scope.
+    const entries = [];
+    for (let i = 0; i < count; i++) {
+        if (offset + 46 > buffer.length)
+            return null;
+        if (buffer.readUInt32LE(offset) !== CENTRAL_FILE_SIGNATURE)
+            return null;
+        const method = buffer.readUInt16LE(offset + 10);
+        const compressedSize = buffer.readUInt32LE(offset + 20);
+        const uncompressedSize = buffer.readUInt32LE(offset + 24);
+        const nameLength = buffer.readUInt16LE(offset + 28);
+        const extraLength = buffer.readUInt16LE(offset + 30);
+        const commentLength = buffer.readUInt16LE(offset + 32);
+        const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+        const nameStart = offset + 46;
+        if (nameStart + nameLength > buffer.length)
+            return null;
+        entries.push({
+            name: buffer.subarray(nameStart, nameStart + nameLength).toString("utf-8"),
+            method,
+            compressedSize,
+            uncompressedSize,
+            localHeaderOffset,
+        });
+        offset = nameStart + nameLength + extraLength + commentLength;
+    }
+    return entries;
+}
+function readEntryData(buffer, entry) {
+    const header = entry.localHeaderOffset;
+    if (header + 30 > buffer.length)
+        return null;
+    // The local header repeats the name and extra lengths, and its extra field
+    // can differ in length from the central one, so read them from here.
+    const nameLength = buffer.readUInt16LE(header + 26);
+    const extraLength = buffer.readUInt16LE(header + 28);
+    const start = header + 30 + nameLength + extraLength;
+    const end = start + entry.compressedSize;
+    if (end > buffer.length)
+        return null;
+    const raw = buffer.subarray(start, end);
+    if (entry.method === METHOD_STORED)
+        return Buffer.from(raw);
+    if (entry.method !== METHOD_DEFLATE)
+        return null;
+    try {
+        return inflateRawSync(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function extractZipEntry(buffer, entryName) {
+    try {
+        const entries = readCentralDirectory(buffer);
+        if (!entries)
+            return null;
+        const entry = entries.find((e) => e.name === entryName);
+        if (!entry)
+            return null;
+        return readEntryData(buffer, entry);
+    }
+    catch {
+        return null;
+    }
+}
+export function listZipEntries(buffer) {
+    try {
+        return readCentralDirectory(buffer)?.map((e) => e.name) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+const XML_ENTITIES = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&apos;": "'",
+    "&#39;": "'",
+};
+function xmlToText(xml) {
+    return xml
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&(?:amp|lt|gt|quot|apos|#39);/g, (m) => XML_ENTITIES[m] ?? m)
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function officeDocumentText(buffer) {
+    const names = listZipEntries(buffer);
+    if (!names)
+        return null;
+    const read = (name) => xmlToText(extractZipEntry(buffer, name)?.toString("utf-8") ?? "");
+    let text = "";
+    if (names.includes("word/document.xml")) {
+        text = read("word/document.xml");
+    }
+    else if (names.includes("xl/sharedStrings.xml")) {
+        text = read("xl/sharedStrings.xml");
+    }
+    else if (names.some((n) => n.startsWith("ppt/slides/slide"))) {
+        const slides = names
+            .filter((n) => /^ppt\/slides\/slide\d+\.xml$/.test(n))
+            .sort((a, b) => slideNumber(a) - slideNumber(b));
+        text = slides.map(read).filter(Boolean).join("\n\n");
+    }
+    else {
+        return null;
+    }
+    return text.length > 0 ? text : null;
+}
+function slideNumber(name) {
+    return Number(/slide(\d+)\.xml$/.exec(name)?.[1] ?? 0);
+}
+//# sourceMappingURL=zip-extract.js.map