claude-coach 0.0.1

package/dist/viewer/lib/export/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Training Plan Export
+ *
+ * Unified export interface for generating workout files client-side.
+ * Supports:
+ * - ZWO (Zwift workouts) - bike/run only
+ * - FIT (Garmin workouts) - all sports
+ * - MRC (ERG/MRC) - bike only, for indoor trainers
+ * - ICS (iCalendar) - full plan calendar events
+ */
+import type { Workout, TrainingPlan, Sport } from "../../../schema/training-plan.js";
+import type { Settings } from "../../stores/settings.js";
+export type ExportFormat = "zwo" | "fit" | "mrc" | "ics";
+export interface ExportResult {
+    success: boolean;
+    filename: string;
+    error?: string;
+}
+/**
+ * Trigger a file download in the browser
+ */
+export declare function downloadFile(content: string | Uint8Array, filename: string, mimeType: string): void;
+/**
+ * Sanitize filename to be safe across platforms
+ */
+export declare function sanitizeFilename(name: string): string;
+/**
+ * Get available export formats for a workout based on its sport
+ */
+export declare function getAvailableFormats(sport: Sport): ExportFormat[];
+/**
+ * Export a single workout to the specified format
+ */
+export declare function exportWorkout(workout: Workout, format: ExportFormat, settings: Settings): Promise<ExportResult>;
+/**
+ * Export the full training plan to iCalendar format
+ */
+export declare function exportPlanToCalendar(plan: TrainingPlan): ExportResult;
+/**
+ * Export all workouts in the plan to a single ZIP file
+ * Contains ZWO/FIT/MRC files based on the selected format
+ */
+export declare function exportAllWorkouts(plan: TrainingPlan, format: "zwo" | "fit" | "mrc", settings: Settings): Promise<{
+    exported: number;
+    skipped: number;
+    errors: string[];
+}>;
+export { isZwoSupported } from "./zwo.js";
+export { isFitSupported, isFitSdkAvailable } from "./fit.js";
+export { isErgSupported } from "./erg.js";

package/dist/viewer/lib/export/index.js

@@ -0,0 +1,229 @@
+/**
+ * Training Plan Export
+ *
+ * Unified export interface for generating workout files client-side.
+ * Supports:
+ * - ZWO (Zwift workouts) - bike/run only
+ * - FIT (Garmin workouts) - all sports
+ * - MRC (ERG/MRC) - bike only, for indoor trainers
+ * - ICS (iCalendar) - full plan calendar events
+ */
+import { generateZwo, isZwoSupported } from "./zwo.js";
+import { generateFit, isFitSupported } from "./fit.js";
+import { generateMrc, isErgSupported } from "./erg.js";
+import { generateIcs } from "./ics.js";
+import JSZip from "jszip";
+/**
+ * Trigger a file download in the browser
+ */
+export function downloadFile(content, filename, mimeType) {
+    const blob = content instanceof Uint8Array
+        ? new Blob([new Uint8Array(content)], { type: mimeType })
+        : new Blob([content], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+}
+/**
+ * Sanitize filename to be safe across platforms
+ */
+export function sanitizeFilename(name) {
+    return name
+        .replace(/[<>:"/\\|?*]/g, "") // Remove invalid chars
+        .replace(/\s+/g, "_") // Replace spaces with underscores
+        .substring(0, 100); // Limit length
+}
+/**
+ * Get available export formats for a workout based on its sport
+ */
+export function getAvailableFormats(sport) {
+    const formats = [];
+    if (isZwoSupported(sport)) {
+        formats.push("zwo");
+    }
+    if (isFitSupported(sport)) {
+        formats.push("fit");
+    }
+    if (isErgSupported(sport)) {
+        formats.push("mrc");
+    }
+    return formats;
+}
+/**
+ * Export a single workout to the specified format
+ */
+export async function exportWorkout(workout, format, settings) {
+    const safeName = sanitizeFilename(workout.name);
+    try {
+        switch (format) {
+            case "zwo": {
+                if (!isZwoSupported(workout.sport)) {
+                    return {
+                        success: false,
+                        filename: "",
+                        error: `Zwift export only supports bike and run workouts`,
+                    };
+                }
+                const zwoContent = generateZwo(workout, settings);
+                const filename = `${safeName}.zwo`;
+                downloadFile(zwoContent, filename, "application/xml");
+                return { success: true, filename };
+            }
+            case "fit": {
+                if (!isFitSupported(workout.sport)) {
+                    return {
+                        success: false,
+                        filename: "",
+                        error: `FIT export not supported for ${workout.sport} workouts`,
+                    };
+                }
+                const fitContent = await generateFit(workout, settings);
+                const filename = `${safeName}.fit`;
+                downloadFile(fitContent, filename, "application/vnd.ant.fit");
+                return { success: true, filename };
+            }
+            case "mrc": {
+                if (!isErgSupported(workout.sport)) {
+                    return {
+                        success: false,
+                        filename: "",
+                        error: `MRC export only supports bike workouts`,
+                    };
+                }
+                const mrcContent = generateMrc(workout, settings);
+                const filename = `${safeName}.mrc`;
+                downloadFile(mrcContent, filename, "text/plain");
+                return { success: true, filename };
+            }
+            default:
+                return {
+                    success: false,
+                    filename: "",
+                    error: `Unknown format: ${format}`,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            filename: "",
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+/**
+ * Export the full training plan to iCalendar format
+ */
+export function exportPlanToCalendar(plan) {
+    try {
+        const icsContent = generateIcs(plan);
+        const safeName = sanitizeFilename(plan.meta.event);
+        const filename = `${safeName}_training_plan.ics`;
+        downloadFile(icsContent, filename, "text/calendar");
+        return { success: true, filename };
+    }
+    catch (error) {
+        return {
+            success: false,
+            filename: "",
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+/**
+ * Generate workout file content without triggering a download
+ */
+async function generateWorkoutContent(workout, format, settings) {
+    const safeName = sanitizeFilename(workout.name);
+    try {
+        switch (format) {
+            case "zwo": {
+                if (!isZwoSupported(workout.sport))
+                    return null;
+                const content = generateZwo(workout, settings);
+                return { content, filename: `${safeName}.zwo` };
+            }
+            case "fit": {
+                if (!isFitSupported(workout.sport))
+                    return null;
+                const content = await generateFit(workout, settings);
+                return { content, filename: `${safeName}.fit` };
+            }
+            case "mrc": {
+                if (!isErgSupported(workout.sport))
+                    return null;
+                const content = generateMrc(workout, settings);
+                return { content, filename: `${safeName}.mrc` };
+            }
+            default:
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Export all workouts in the plan to a single ZIP file
+ * Contains ZWO/FIT/MRC files based on the selected format
+ */
+export async function exportAllWorkouts(plan, format, settings) {
+    const errors = [];
+    let exported = 0;
+    let skipped = 0;
+    const zip = new JSZip();
+    for (const week of plan.weeks) {
+        for (const day of week.days) {
+            for (const workout of day.workouts) {
+                // Skip rest days
+                if (workout.sport === "rest") {
+                    skipped++;
+                    continue;
+                }
+                // Check format support
+                if (format === "zwo" && !isZwoSupported(workout.sport)) {
+                    skipped++;
+                    continue;
+                }
+                if (format === "fit" && !isFitSupported(workout.sport)) {
+                    skipped++;
+                    continue;
+                }
+                if (format === "mrc" && !isErgSupported(workout.sport)) {
+                    skipped++;
+                    continue;
+                }
+                try {
+                    const result = await generateWorkoutContent(workout, format, settings);
+                    if (result) {
+                        zip.file(result.filename, result.content);
+                        exported++;
+                    }
+                    else {
+                        skipped++;
+                    }
+                }
+                catch (error) {
+                    errors.push(`${workout.name}: ${error instanceof Error ? error.message : "Unknown error"}`);
+                }
+            }
+        }
+    }
+    // Only create and download the ZIP if there are files to export
+    if (exported > 0) {
+        const zipContent = await zip.generateAsync({ type: "uint8array" });
+        const planName = sanitizeFilename(plan.meta.event);
+        const zipFilename = `${planName}_workouts_${format}.zip`;
+        downloadFile(zipContent, zipFilename, "application/zip");
+    }
+    return { exported, skipped, errors };
+}
+// Re-export format-specific helpers
+export { isZwoSupported } from "./zwo.js";
+export { isFitSupported, isFitSdkAvailable } from "./fit.js";
+export { isErgSupported } from "./erg.js";

package/dist/viewer/lib/export/zwo.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ZWO (Zwift Workout) Export
+ *
+ * Generates Zwift workout files in XML format.
+ * Only supports bike and run workouts.
+ *
+ * How to import to Zwift:
+ * - Desktop: Save to Documents/Zwift/Workouts/[userID]/
+ * - iOS/iPad: Open Zwift on desktop first (syncs to cloud), then iOS downloads it
+ * - Alternative: Save to iCloud at Documents/Zwift/Workouts/[userID]/
+ */
+import type { Workout, Sport } from "../../../schema/training-plan.js";
+import type { Settings } from "../../stores/settings.js";
+/**
+ * Check if a sport is supported by Zwift export
+ */
+export declare function isZwoSupported(sport: Sport): boolean;
+/**
+ * Generate a complete ZWO file for a workout
+ */
+export declare function generateZwo(workout: Workout, _settings: Settings): string;

package/dist/viewer/lib/export/zwo.js

@@ -0,0 +1,230 @@
+/**
+ * ZWO (Zwift Workout) Export
+ *
+ * Generates Zwift workout files in XML format.
+ * Only supports bike and run workouts.
+ *
+ * How to import to Zwift:
+ * - Desktop: Save to Documents/Zwift/Workouts/[userID]/
+ * - iOS/iPad: Open Zwift on desktop first (syncs to cloud), then iOS downloads it
+ * - Alternative: Save to iCloud at Documents/Zwift/Workouts/[userID]/
+ */
+/**
+ * Check if a sport is supported by Zwift export
+ */
+export function isZwoSupported(sport) {
+    return sport === "bike" || sport === "run";
+}
+/**
+ * Escape XML special characters
+ */
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Convert intensity percentage to Zwift decimal format
+ * (e.g., 75% FTP -> 0.75)
+ */
+function intensityToDecimal(intensity) {
+    // Intensity is stored as percentage (e.g., 75 for 75%)
+    // Zwift expects decimal (0.75)
+    return intensity / 100;
+}
+/**
+ * Convert duration to seconds
+ */
+function durationToSeconds(value, unit) {
+    switch (unit) {
+        case "seconds":
+            return value;
+        case "minutes":
+            return value * 60;
+        case "hours":
+            return value * 3600;
+        default:
+            // For distance-based durations, estimate using typical speeds
+            // This is a rough approximation
+            return value; // Return as-is if not time-based
+    }
+}
+/**
+ * Get workout type for ZWO (bike or run)
+ */
+function getZwoSportType(sport) {
+    return sport === "run" ? "run" : "bike";
+}
+/**
+ * Generate a warmup segment
+ */
+function generateWarmup(step) {
+    const duration = durationToSeconds(step.duration.value, step.duration.unit);
+    const startPower = intensityToDecimal(step.intensity.valueLow || step.intensity.value * 0.6);
+    const endPower = intensityToDecimal(step.intensity.valueHigh || step.intensity.value);
+    return `    <Warmup Duration="${duration}" PowerLow="${startPower.toFixed(2)}" PowerHigh="${endPower.toFixed(2)}"/>`;
+}
+/**
+ * Generate a cooldown segment
+ */
+function generateCooldown(step) {
+    const duration = durationToSeconds(step.duration.value, step.duration.unit);
+    const startPower = intensityToDecimal(step.intensity.valueHigh || step.intensity.value);
+    const endPower = intensityToDecimal(step.intensity.valueLow || step.intensity.value * 0.5);
+    return `    <Cooldown Duration="${duration}" PowerLow="${endPower.toFixed(2)}" PowerHigh="${startPower.toFixed(2)}"/>`;
+}
+/**
+ * Generate a steady state segment
+ */
+function generateSteadyState(step, isRamp = false) {
+    const duration = durationToSeconds(step.duration.value, step.duration.unit);
+    const power = intensityToDecimal(step.intensity.value);
+    let cadenceAttr = "";
+    if (step.cadence) {
+        cadenceAttr = ` Cadence="${step.cadence.low}"`;
+        if (step.cadence.high !== step.cadence.low) {
+            cadenceAttr = ` CadenceLow="${step.cadence.low}" CadenceHigh="${step.cadence.high}"`;
+        }
+    }
+    if (isRamp && step.intensity.valueLow !== undefined && step.intensity.valueHigh !== undefined) {
+        const powerLow = intensityToDecimal(step.intensity.valueLow);
+        const powerHigh = intensityToDecimal(step.intensity.valueHigh);
+        return `    <Ramp Duration="${duration}" PowerLow="${powerLow.toFixed(2)}" PowerHigh="${powerHigh.toFixed(2)}"${cadenceAttr}/>`;
+    }
+    return `    <SteadyState Duration="${duration}" Power="${power.toFixed(2)}"${cadenceAttr}/>`;
+}
+/**
+ * Generate an interval set (IntervalsT in ZWO)
+ */
+function generateIntervalSet(intervalSet) {
+    // Find work and recovery steps
+    const workStep = intervalSet.steps.find((s) => s.type === "work");
+    const recoveryStep = intervalSet.steps.find((s) => s.type === "recovery" || s.type === "rest");
+    if (!workStep) {
+        // Just generate steady states if no work step found
+        return intervalSet.steps.map((s) => generateSteadyState(s)).join("\n");
+    }
+    const onDuration = durationToSeconds(workStep.duration.value, workStep.duration.unit);
+    const onPower = intensityToDecimal(workStep.intensity.value);
+    const offDuration = recoveryStep
+        ? durationToSeconds(recoveryStep.duration.value, recoveryStep.duration.unit)
+        : 60; // Default 60s recovery
+    const offPower = recoveryStep ? intensityToDecimal(recoveryStep.intensity.value) : 0.5; // Default 50% recovery
+    let cadenceAttr = "";
+    if (workStep.cadence) {
+        cadenceAttr = ` Cadence="${workStep.cadence.low}"`;
+    }
+    return `    <IntervalsT Repeat="${intervalSet.repeats}" OnDuration="${onDuration}" OffDuration="${offDuration}" OnPower="${onPower.toFixed(2)}" OffPower="${offPower.toFixed(2)}"${cadenceAttr}/>`;
+}
+/**
+ * Generate workout segments from structured workout
+ */
+function generateSegmentsFromStructure(structure) {
+    const segments = [];
+    // Warmup
+    if (structure.warmup && structure.warmup.length > 0) {
+        for (const step of structure.warmup) {
+            if (step.type === "warmup") {
+                segments.push(generateWarmup(step));
+            }
+            else {
+                segments.push(generateSteadyState(step));
+            }
+        }
+    }
+    // Main set
+    for (const item of structure.main) {
+        if ("repeats" in item) {
+            // Interval set
+            segments.push(generateIntervalSet(item));
+        }
+        else {
+            // Single step
+            const step = item;
+            segments.push(generateSteadyState(step));
+        }
+    }
+    // Cooldown
+    if (structure.cooldown && structure.cooldown.length > 0) {
+        for (const step of structure.cooldown) {
+            if (step.type === "cooldown") {
+                segments.push(generateCooldown(step));
+            }
+            else {
+                segments.push(generateSteadyState(step));
+            }
+        }
+    }
+    return segments;
+}
+/**
+ * Generate a simple workout when no structure is provided
+ * Creates warmup -> main -> cooldown based on duration
+ */
+function generateSimpleWorkout(workout) {
+    const segments = [];
+    const totalMinutes = workout.durationMinutes || 60;
+    // 10% warmup (min 5 min, max 15 min)
+    const warmupMinutes = Math.min(15, Math.max(5, Math.round(totalMinutes * 0.1)));
+    segments.push(`    <Warmup Duration="${warmupMinutes * 60}" PowerLow="0.40" PowerHigh="0.65"/>`);
+    // Main set based on workout type
+    let mainPower = 0.65; // Default endurance
+    switch (workout.type) {
+        case "recovery":
+            mainPower = 0.55;
+            break;
+        case "endurance":
+            mainPower = 0.65;
+            break;
+        case "tempo":
+            mainPower = 0.8;
+            break;
+        case "threshold":
+            mainPower = 0.95;
+            break;
+        case "vo2max":
+            mainPower = 1.1;
+            break;
+        case "intervals":
+            mainPower = 0.85;
+            break;
+        case "long":
+            mainPower = 0.65;
+            break;
+    }
+    // 10% cooldown (min 5 min, max 10 min)
+    const cooldownMinutes = Math.min(10, Math.max(5, Math.round(totalMinutes * 0.1)));
+    const mainMinutes = totalMinutes - warmupMinutes - cooldownMinutes;
+    segments.push(`    <SteadyState Duration="${mainMinutes * 60}" Power="${mainPower.toFixed(2)}"/>`);
+    segments.push(`    <Cooldown Duration="${cooldownMinutes * 60}" PowerLow="0.40" PowerHigh="0.60"/>`);
+    return segments;
+}
+/**
+ * Generate a complete ZWO file for a workout
+ */
+export function generateZwo(workout, _settings) {
+    if (!isZwoSupported(workout.sport)) {
+        throw new Error(`ZWO export not supported for ${workout.sport} workouts`);
+    }
+    const sportType = getZwoSportType(workout.sport);
+    const segments = workout.structure
+        ? generateSegmentsFromStructure(workout.structure)
+        : generateSimpleWorkout(workout);
+    // Clean up description for XML
+    const description = escapeXml((workout.description || "") +
+        (workout.humanReadable ? `\n\n${workout.humanReadable.replace(/\\n/g, "\n")}` : ""));
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<workout_file>
+  <author>Claude Coach</author>
+  <name>${escapeXml(workout.name)}</name>
+  <description>${description}</description>
+  <sportType>${sportType}</sportType>
+  <workout>
+${segments.join("\n")}
+  </workout>
+</workout_file>`;
+    return xml;
+}

package/dist/viewer/lib/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Settings } from "../stores/settings.js";
+import type { Sport } from "../../schema/training-plan.js";
+export declare function formatDuration(minutes: number | undefined): string;
+export declare function formatDistance(meters: number | undefined, sport: Sport, settings: Settings): string;
+export declare function formatDate(dateStr: string): string;
+export declare function formatEventDate(dateStr: string): string;
+export declare function getZoneInfo(sport: Sport, zoneStr: string | undefined, settings: Settings): string;
+export declare function getDaysToEvent(eventDate: string): number;
+export declare function getOrderedDays(firstDayOfWeek: "monday" | "sunday"): string[];
+export declare function getTodayISO(): string;
+export declare function formatDateISO(date: Date): string;
+export declare function parseDate(dateStr: string): Date;
+export declare function getSportColor(sport: Sport): string;
+export declare function getSportIcon(sport: Sport): string;

package/dist/viewer/lib/utils.js

@@ -0,0 +1,118 @@
+const METERS_PER_YARD = 0.9144;
+const KM_PER_MILE = 1.60934;
+export function formatDuration(minutes) {
+    if (!minutes)
+        return "";
+    const h = Math.floor(minutes / 60);
+    const m = minutes % 60;
+    if (h > 0) {
+        return m > 0 ? `${h}h ${m}m` : `${h}h`;
+    }
+    return `${m}m`;
+}
+export function formatDistance(meters, sport, settings) {
+    if (!meters)
+        return "";
+    if (sport === "swim") {
+        if (settings.units.swim === "yards") {
+            const yards = meters / METERS_PER_YARD;
+            return `${Math.round(yards)}yd`;
+        }
+        return `${Math.round(meters)}m`;
+    }
+    if (sport === "bike" || sport === "run") {
+        const unit = settings.units[sport];
+        if (unit === "miles") {
+            const miles = meters / 1000 / KM_PER_MILE;
+            return miles >= 10 ? `${Math.round(miles)}mi` : `${miles.toFixed(1)}mi`;
+        }
+        const km = meters / 1000;
+        return km >= 10 ? `${Math.round(km)}km` : `${km.toFixed(1)}km`;
+    }
+    return `${Math.round(meters)}m`;
+}
+export function formatDate(dateStr) {
+    const date = new Date(dateStr);
+    return date.toLocaleDateString("en-US", {
+        weekday: "long",
+        month: "short",
+        day: "numeric",
+    });
+}
+export function formatEventDate(dateStr) {
+    const date = new Date(dateStr);
+    return date.toLocaleDateString("en-US", {
+        weekday: "long",
+        month: "long",
+        day: "numeric",
+        year: "numeric",
+    });
+}
+export function getZoneInfo(sport, zoneStr, settings) {
+    if (!zoneStr)
+        return "";
+    const match = zoneStr.match(/(?:Zone\s*)?(\d)(?:\s*-\s*(\d))?/i);
+    if (!match)
+        return zoneStr;
+    const z1 = parseInt(match[1]);
+    const z2 = match[2] ? parseInt(match[2]) : z1;
+    let info = zoneStr;
+    if (sport === "run" || sport === "bike") {
+        const hrZones = settings[sport]?.hrZones;
+        if (hrZones && hrZones[z1 - 1]) {
+            const low = hrZones[z1 - 1].low;
+            const high = z2 !== z1 && hrZones[z2 - 1] ? hrZones[z2 - 1].high : hrZones[z1 - 1].high;
+            info += ` (${low}-${high} bpm)`;
+        }
+    }
+    return info;
+}
+export function getDaysToEvent(eventDate) {
+    const daysLeft = Math.ceil((new Date(eventDate).getTime() - new Date().getTime()) / (1000 * 60 * 60 * 24));
+    return Math.max(0, daysLeft);
+}
+export function getOrderedDays(firstDayOfWeek) {
+    if (firstDayOfWeek === "monday") {
+        return ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+    }
+    return ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+}
+export function getTodayISO() {
+    return formatDateISO(new Date());
+}
+// Format date as YYYY-MM-DD without timezone conversion
+export function formatDateISO(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+// Parse ISO date string to Date object (at midnight local time)
+export function parseDate(dateStr) {
+    const [year, month, day] = dateStr.split("-").map(Number);
+    return new Date(year, month - 1, day);
+}
+export function getSportColor(sport) {
+    const colors = {
+        swim: "var(--swim)",
+        bike: "var(--bike)",
+        run: "var(--run)",
+        strength: "var(--strength)",
+        brick: "var(--brick)",
+        race: "var(--race)",
+        rest: "var(--rest)",
+    };
+    return colors[sport] || "var(--text-muted)";
+}
+export function getSportIcon(sport) {
+    const icons = {
+        swim: "\u{1F3CA}",
+        bike: "\u{1F6B4}",
+        run: "\u{1F3C3}",
+        strength: "\u{1F4AA}",
+        brick: "\u{1F525}",
+        race: "\u{1F3C6}",
+        rest: "\u{1F6CC}",
+    };
+    return icons[sport] || "";
+}

package/dist/viewer/main.d.ts

@@ -0,0 +1,5 @@
+declare const app: {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<Record<string, any>>): void;
+} & Record<string, any>;
+export default app;

package/dist/viewer/main.js

@@ -0,0 +1,6 @@
+import App from "./App.svelte";
+import { mount } from "svelte";
+const app = mount(App, {
+    target: document.getElementById("app"),
+});
+export default app;