@nice2dev/game-engine 0.1.0

package/dist/types/tutorials/TutorialBranching.d.ts

@@ -0,0 +1,132 @@
+import { EventBus } from '../core/EventBus';
+import type { TutorialProgress } from './TutorialEngine';
+import type { Locale } from '../i18n/I18n';
+export type BranchConditionType = 'quiz-correct' | 'quiz-incorrect' | 'quiz-answer' | 'code-valid' | 'code-invalid' | 'always';
+export interface BranchCondition {
+    type: BranchConditionType;
+    /** For 'quiz-answer': the specific answer ID that triggers this branch. */
+    answerId?: string;
+}
+export interface BranchRule {
+    /** Condition that triggers this branch. */
+    condition: BranchCondition;
+    /** Step ID to jump to if condition is met. */
+    targetStepId: string;
+}
+export interface BranchingStep {
+    /** The step ID this branching config applies to. */
+    stepId: string;
+    /** Ordered list of branching rules. First matching rule wins. */
+    rules: BranchRule[];
+    /** Fallback step ID if no rules match (defaults to next sequential step). */
+    fallbackStepId?: string;
+}
+export interface BranchingConfig {
+    /** Tutorial ID this branching config belongs to. */
+    tutorialId: string;
+    /** Map of step ID → branching rules. */
+    branches: BranchingStep[];
+}
+export declare class BranchingEngine {
+    private configs;
+    /** Register branching configuration for a tutorial. */
+    register(config: BranchingConfig): void;
+    /** Unregister branching for a tutorial. */
+    unregister(tutorialId: string): void;
+    /** Check if a step has branching rules. */
+    hasBranching(tutorialId: string, stepId: string): boolean;
+    /**
+     * Resolve the next step ID based on branching rules and context.
+     * Returns null if no branching is defined (use default sequential advance).
+     */
+    resolveNextStep(tutorialId: string, currentStepId: string, context: BranchContext): string | null;
+    private evaluateCondition;
+}
+export interface BranchContext {
+    /** Whether the quiz answer was correct (for quiz steps). */
+    quizCorrect?: boolean;
+    /** The specific quiz answer ID chosen. */
+    quizAnswerId?: string;
+    /** Whether the code validation passed (for code steps). */
+    codeValid?: boolean;
+}
+export type AchievementTier = 'bronze' | 'silver' | 'gold' | 'platinum' | 'diamond';
+export interface AchievementCondition {
+    type: 'tutorial-complete' | 'tutorials-count' | 'category-complete' | 'streak' | 'quiz-perfect' | 'custom';
+    /** For tutorial-complete: tutorial ID. */
+    tutorialId?: string;
+    /** For tutorials-count: minimum number. */
+    count?: number;
+    /** For category-complete: tutorial category. */
+    category?: string;
+    /** For streak: consecutive days. */
+    streakDays?: number;
+    /** For custom: custom condition ID evaluated externally. */
+    customId?: string;
+}
+export interface AchievementDefinition {
+    id: string;
+    /** Localized title. */
+    title: Record<string, string>;
+    /** Localized description. */
+    description: Record<string, string>;
+    /** Emoji icon. */
+    icon: string;
+    /** Tier (visual style). */
+    tier: AchievementTier;
+    /** XP points awarded. */
+    xp: number;
+    /** Condition to unlock. */
+    condition: AchievementCondition;
+    /** Whether this is hidden until unlocked. */
+    hidden?: boolean;
+}
+export interface AchievementProgress {
+    achievementId: string;
+    unlocked: boolean;
+    unlockedAt?: number;
+    /** Progress toward the goal (0-1). */
+    progress: number;
+}
+export declare class AchievementEngine {
+    private readonly persistToStorage;
+    readonly events: EventBus;
+    private definitions;
+    private playerProgress;
+    private customEvaluators;
+    private readonly storageKey;
+    constructor(persistToStorage?: boolean);
+    /** Register an achievement definition. */
+    registerAchievement(def: AchievementDefinition): void;
+    /** Register multiple achievements. */
+    registerAchievements(defs: AchievementDefinition[]): void;
+    /** Register a custom evaluator for custom conditions. */
+    registerCustomEvaluator(customId: string, evaluator: () => {
+        met: boolean;
+        progress: number;
+    }): void;
+    /**
+     * Evaluate all achievements against current tutorial progress.
+     * Returns newly unlocked achievement IDs.
+     */
+    evaluate(tutorialProgress: Map<string, TutorialProgress>, streakDays?: number): string[];
+    private evaluateCondition;
+    /** Get all achievement definitions. */
+    getAllAchievements(): AchievementDefinition[];
+    /** Get unlocked achievements. */
+    getUnlocked(): AchievementDefinition[];
+    /** Get progress for a specific achievement. */
+    getProgress(achievementId: string): AchievementProgress | undefined;
+    /** Total XP from unlocked achievements. */
+    getTotalXP(): number;
+    /** Get visible achievements (not hidden, or hidden but unlocked). */
+    getVisible(locale?: Locale): Array<AchievementDefinition & {
+        unlocked: boolean;
+        progress: number;
+    }>;
+    /** Reset all progress. */
+    reset(): void;
+    private save;
+    private load;
+}
+export declare const BUILT_IN_ACHIEVEMENTS: AchievementDefinition[];

package/dist/types/tutorials/TutorialEditor.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { TutorialStepType, TutorialDefinition } from './TutorialEngine';
+export interface TutorialEditorStep {
+    id: string;
+    type: TutorialStepType;
+    title: string;
+    content: string;
+    highlight?: string;
+    code?: string;
+    codeLanguage?: string;
+    quizOptions?: {
+        text: string;
+        correct: boolean;
+    }[];
+    validationHint?: string;
+    videoUrl?: string;
+    duration?: number;
+}
+export interface TutorialEditorState {
+    definition: Partial<TutorialDefinition>;
+    steps: TutorialEditorStep[];
+    selectedStepIndex: number;
+    previewMode: boolean;
+    dirty: boolean;
+}
+export interface TutorialEditorProps {
+    initial?: TutorialDefinition;
+    onSave?: (definition: TutorialDefinition) => void;
+    onExport?: (json: string) => void;
+}
+export declare function useTutorialEditor(initial?: TutorialDefinition): {
+    state: TutorialEditorState;
+    addStep: (type: TutorialStepType) => void;
+    removeStep: (index: number) => void;
+    moveStep: (fromIndex: number, toIndex: number) => void;
+    updateStep: (index: number, updates: Partial<TutorialEditorStep>) => void;
+    updateDefinition: (updates: Partial<TutorialDefinition>) => void;
+    selectStep: (index: number) => void;
+    togglePreview: () => void;
+    exportJSON: () => string;
+    importJSON: (json: string) => void;
+};
+export declare const NiceTutorialEditor: React.FC<TutorialEditorProps>;

package/dist/types/tutorials/TutorialEngine.d.ts

@@ -0,0 +1,237 @@
+import { EventBus } from '../core/EventBus';
+import type { Locale, InterpolationValues } from '../i18n/I18n';
+import { I18nManager } from '../i18n/I18n';
+/** Step types in a tutorial */
+export type TutorialStepType = 'text' | 'code' | 'highlight' | 'interactive' | 'quiz' | 'checkpoint' | 'video';
+/** Difficulty levels */
+export type TutorialDifficulty = 'beginner' | 'intermediate' | 'advanced' | 'expert';
+/** Category of tutorial */
+export type TutorialCategory = 'game-basics' | 'game-advanced' | 'ui-controls' | 'art-design' | 'multiplayer' | 'scripting' | 'editor' | 'quick-start';
+/** Quiz answer — supports both localized and simple flat format */
+export interface QuizOption {
+    id?: string;
+    text: string | Partial<Record<Locale, string>>;
+    correct?: boolean;
+}
+/** Code validation result */
+export interface CodeValidation {
+    pattern?: string;
+    containsAll?: string[];
+    containsAny?: string[];
+    maxLines?: number;
+    customValidator?: string;
+}
+/** A single step in a tutorial */
+export interface TutorialStep {
+    id: string;
+    type: TutorialStepType;
+    /** Localized title */
+    title: Record<string, string>;
+    /** Localized content/instruction */
+    content: Record<string, string>;
+    /** For 'code' steps: starting code template */
+    codeTemplate?: string;
+    /** For 'code' steps: expected solution (for hints) */
+    codeSolution?: string;
+    /** For 'code' steps: validation rules */
+    codeValidation?: CodeValidation;
+    /** Alias for codeTemplate */
+    code?: string;
+    /** Code language hint */
+    codeLanguage?: string;
+    /** Validation hint text */
+    validationHint?: string;
+    /** For 'highlight' steps: CSS selector or element ID to highlight */
+    highlightTarget?: string;
+    /** Alias for highlightTarget */
+    highlight?: string;
+    /** For 'interactive' steps: action the user must perform */
+    requiredAction?: string;
+    /** For 'quiz' steps: multiple-choice options */
+    quizOptions?: QuizOption[];
+    /** For 'quiz' steps: correct answer ID */
+    quizCorrectId?: string;
+    /** For 'video' steps: video URL */
+    videoUrl?: string;
+    /** Hint text (localized) shown on demand */
+    hint?: Record<string, string>;
+    /** Auto-advance after N milliseconds (0 = manual) */
+    autoAdvanceMs?: number;
+    /** Optional interpolation values for the content */
+    interpolation?: InterpolationValues;
+    /** Optional: position of tooltip (top/bottom/left/right) */
+    tooltipPosition?: 'top' | 'bottom' | 'left' | 'right' | 'center';
+    /** Whether to allow skipping this step */
+    skippable?: boolean;
+}
+/** A complete tutorial definition */
+export interface TutorialDefinition {
+    id: string;
+    /** Localized tutorial title */
+    title: Record<string, string>;
+    /** Localized description */
+    description: Record<string, string>;
+    /** Category */
+    category: TutorialCategory;
+    /** Difficulty level */
+    difficulty: TutorialDifficulty;
+    /** Estimated time in minutes */
+    estimatedMinutes: number;
+    /** Prerequisites — IDs of tutorials that should be completed first */
+    prerequisites?: string[];
+    /** Tags for search */
+    tags?: string[];
+    /** Kid-friendly version available? */
+    kidFriendly?: boolean;
+    /** Ordered steps */
+    steps: TutorialStep[];
+    /** Target age range (optional, for kid mode filtering) */
+    ageRange?: {
+        min: number;
+        max: number;
+    };
+}
+/** Progress for a single tutorial */
+export interface TutorialProgress {
+    tutorialId: string;
+    currentStepIndex: number;
+    completedSteps: string[];
+    startedAt: number;
+    lastAccessedAt: number;
+    completed: boolean;
+    completedAt?: number;
+    quizScores: Record<string, boolean>;
+    codeSubmissions: Record<string, string>;
+}
+/** Tutorial engine event types */
+export interface TutorialEvents {
+    'tutorial:started': {
+        tutorialId: string;
+    };
+    'tutorial:completed': {
+        tutorialId: string;
+        durationMs: number;
+    };
+    'tutorial:step:entered': {
+        tutorialId: string;
+        stepId: string;
+        stepIndex: number;
+    };
+    'tutorial:step:completed': {
+        tutorialId: string;
+        stepId: string;
+    };
+    'tutorial:quiz:answered': {
+        tutorialId: string;
+        stepId: string;
+        correct: boolean;
+    };
+    'tutorial:code:validated': {
+        tutorialId: string;
+        stepId: string;
+        valid: boolean;
+    };
+    'tutorial:hint:shown': {
+        tutorialId: string;
+        stepId: string;
+    };
+    'tutorial:progress:saved': {
+        tutorialId: string;
+    };
+}
+/** Custom code validator function signature */
+export type CodeValidatorFn = (code: string) => {
+    valid: boolean;
+    message?: string;
+};
+export declare class TutorialEngine {
+    private readonly i18n;
+    private readonly persistProgress;
+    private readonly tutorials;
+    private readonly progress;
+    private readonly validators;
+    private activeTutorialId;
+    private readonly storagePrefix;
+    readonly events: EventBus;
+    constructor(i18n: I18nManager, persistProgress?: boolean);
+    /** Register a tutorial definition */
+    registerTutorial(definition: TutorialDefinition): void;
+    /** Register multiple tutorials at once */
+    registerTutorials(definitions: TutorialDefinition[]): void;
+    /** Register a custom code validator */
+    registerValidator(name: string, fn: CodeValidatorFn): void;
+    /** Get all registered tutorials */
+    getAllTutorials(): TutorialDefinition[];
+    /** Get tutorials filtered by category */
+    getTutorialsByCategory(category: TutorialCategory): TutorialDefinition[];
+    /** Get tutorials filtered by difficulty */
+    getTutorialsByDifficulty(difficulty: TutorialDifficulty): TutorialDefinition[];
+    /** Get tutorials suitable for kids */
+    getKidFriendlyTutorials(): TutorialDefinition[];
+    /** Search tutorials by tag or title */
+    searchTutorials(query: string): TutorialDefinition[];
+    /** Start a tutorial */
+    startTutorial(tutorialId: string): TutorialStep | null;
+    /** Get the current step of the active tutorial */
+    getCurrentStep(): TutorialStep | null;
+    /** Advance to the next step */
+    nextStep(): TutorialStep | null;
+    /** Go to a previous step */
+    previousStep(): TutorialStep | null;
+    /** Jump to a specific step by index */
+    goToStep(index: number): TutorialStep | null;
+    /** Stop the current tutorial */
+    stopTutorial(): void;
+    /** Submit a quiz answer */
+    submitQuizAnswer(answerId: string): boolean;
+    /** Submit code for validation */
+    validateCode(code: string): {
+        valid: boolean;
+        message?: string;
+    };
+    /** Request a hint for the current step */
+    getHint(): string | null;
+    /** Get localized content for current step */
+    getStepContent(step: TutorialStep): {
+        title: string;
+        content: string;
+    };
+    /** Get progress for a tutorial */
+    getProgress(tutorialId: string): TutorialProgress | undefined;
+    /** Get progress percentage (0 to 1) */
+    getProgressPercent(tutorialId: string): number;
+    /** Check if a tutorial is completed */
+    isCompleted(tutorialId: string): boolean;
+    /** Get quiz score summary for a completed tutorial */
+    getQuizScore(tutorialId: string): {
+        correct: number;
+        total: number;
+        percentage: number;
+    };
+    /** Get all tutorials with their completion status */
+    getAllProgress(): Array<{
+        tutorial: TutorialDefinition;
+        progress?: TutorialProgress;
+        percent: number;
+    }>;
+    /** Reset progress for a tutorial */
+    resetProgress(tutorialId: string): void;
+    /** Reset all progress */
+    resetAllProgress(): void;
+    private saveProgress;
+    private loadAllProgress;
+    private removeStoredProgress;
+    getActiveTutorialId(): string | null;
+    getActiveTutorial(): TutorialDefinition | null;
+    getTotalSteps(): number;
+    getCurrentStepIndex(): number;
+    dispose(): void;
+}
+/** Tutorial: First Game — Bouncing Ball */
+export declare const TUTORIAL_FIRST_GAME: TutorialDefinition;
+/** Tutorial: Space Shooter */
+export declare const TUTORIAL_SPACE_SHOOTER: TutorialDefinition;
+/** Tutorial: NiceDataGrid basics (for nice2dev-ui) */
+export declare const TUTORIAL_DATAGRID_BASICS: TutorialDefinition;
+/** Get all built-in tutorials */
+export declare function getBuiltInTutorials(): TutorialDefinition[];

package/dist/types/tutorials/TutorialOverlay.d.ts

@@ -0,0 +1,79 @@
+import { EventBus } from '../core/EventBus';
+import type { TutorialDefinition } from './TutorialEngine';
+export interface OverlayConfig {
+    /** CSS z-index for the overlay layer (default: 10000). */
+    zIndex: number;
+    /** Spotlight padding around highlighted element in px (default: 8). */
+    spotlightPadding: number;
+    /** Spotlight border-radius (default: 8). */
+    spotlightBorderRadius: number;
+    /** Background opacity of the mask (default: 0.65). */
+    maskOpacity: number;
+    /** Whether to animate transitions (default: true). */
+    animate: boolean;
+    /** Animation duration in ms (default: 300). */
+    animationDuration: number;
+    /** Theme: 'light' or 'dark' (default: 'dark'). */
+    theme: 'light' | 'dark';
+    /** Custom CSS class prefix (default: 'n2d-tutorial'). */
+    classPrefix: string;
+    /** Whether tooltip closes when clicking outside (default: false). */
+    closeOnOutsideClick: boolean;
+    /** Whether to show the progress bar (default: true). */
+    showProgress: boolean;
+    /** Whether to show navigation buttons (default: true). */
+    showNavigation: boolean;
+    /** Locale for button labels. */
+    locale: string;
+}
+export interface TooltipPosition {
+    top: number;
+    left: number;
+    arrowDirection: 'top' | 'bottom' | 'left' | 'right';
+}
+export type OverlayAction = 'next' | 'back' | 'skip' | 'close' | 'quiz-answer';
+export declare class TutorialOverlay {
+    readonly events: EventBus;
+    private config;
+    private container;
+    private styleEl;
+    private maskEl;
+    private spotlightEl;
+    private tooltipEl;
+    private active;
+    private currentTutorial;
+    private currentStepIndex;
+    private selectedQuizAnswer;
+    private hintVisible;
+    constructor(config?: Partial<OverlayConfig>);
+    /** Whether the overlay is currently showing. */
+    get isActive(): boolean;
+    /** Current step index. */
+    get stepIndex(): number;
+    /** Total steps in current tutorial. */
+    get totalSteps(): number;
+    /** Show the overlay for a tutorial at a given step. */
+    show(tutorial: TutorialDefinition, stepIndex?: number): void;
+    /** Hide the overlay and clean up. */
+    hide(): void;
+    /** Go to a specific step. */
+    goToStep(index: number): void;
+    /** Advance to next step. */
+    next(): void;
+    /** Go to previous step. */
+    back(): void;
+    /** Update the locale for button labels. */
+    setLocale(locale: string): void;
+    private ensureDOM;
+    private removeDOM;
+    private renderStep;
+    private renderContent;
+    private renderQuizOptions;
+    private positionTooltip;
+    private calculatePosition;
+    private bindTooltipEvents;
+    private label;
+    private escapeHtml;
+    /** Dispose the overlay and all DOM elements. */
+    dispose(): void;
+}

package/dist/types/tutorials/VoiceNarration.d.ts

@@ -0,0 +1,75 @@
+export interface VoiceNarrationConfig {
+    /** Speech rate (0.1 to 10, default 1) */
+    rate: number;
+    /** Pitch (0 to 2, default 1) */
+    pitch: number;
+    /** Volume (0 to 1, default 0.8) */
+    volume: number;
+    /** Preferred voice name (auto-detected by locale if omitted) */
+    voiceName?: string;
+    /** BCP 47 locale (e.g. 'pl-PL', 'en-US') */
+    locale: string;
+    /** Enable narration (default true) */
+    enabled: boolean;
+}
+export interface NarrationEvent {
+    type: 'start' | 'end' | 'pause' | 'resume' | 'error' | 'boundary';
+    text?: string;
+    charIndex?: number;
+    error?: string;
+}
+export type NarrationCallback = (event: NarrationEvent) => void;
+export declare const DEFAULT_NARRATION_CONFIG: VoiceNarrationConfig;
+export declare class VoiceNarrator {
+    private config;
+    private synth;
+    private currentUtterance;
+    private listeners;
+    private _speaking;
+    private _paused;
+    constructor(config?: Partial<VoiceNarrationConfig>);
+    /** Check if TTS is available in the browser. */
+    get available(): boolean;
+    get speaking(): boolean;
+    get paused(): boolean;
+    /** Get available voices for the current locale. */
+    getVoices(): SpeechSynthesisVoice[];
+    /** Get all available voices. */
+    getAllVoices(): SpeechSynthesisVoice[];
+    /** Speak the given text. Stops any current speech first. */
+    speak(text: string, locale?: string): void;
+    /** Speak a tutorial step — extracts localized text. */
+    speakStep(step: {
+        title: string | Record<string, string>;
+        content: string | Record<string, string>;
+    }, locale?: string): void;
+    /** Pause speech. */
+    pause(): void;
+    /** Resume speech. */
+    resume(): void;
+    /** Stop speech. */
+    stop(): void;
+    /** Update configuration. */
+    setConfig(updates: Partial<VoiceNarrationConfig>): void;
+    /** Subscribe to narration events. */
+    on(callback: NarrationCallback): () => void;
+    /** Dispose — stop speech and clear listeners. */
+    dispose(): void;
+    private selectVoice;
+    private stripMarkdown;
+    private emit;
+}
+export declare function useVoiceNarration(config?: Partial<VoiceNarrationConfig>): {
+    speak: (text: string, locale?: string) => void;
+    speakStep: (step: {
+        title: string | Record<string, string>;
+        content: string | Record<string, string>;
+    }, locale?: string) => void;
+    pause: () => void | undefined;
+    resume: () => void | undefined;
+    stop: () => void | undefined;
+    speaking: boolean;
+    paused: boolean;
+    available: boolean;
+    voices: SpeechSynthesisVoice[];
+};

package/dist/types/tutorials/content/Tutorials_T04.d.ts

@@ -0,0 +1,3 @@
+import type { TutorialDefinition } from '../TutorialEngine';
+export declare const TUTORIAL_SOUNDS_AND_MUSIC: TutorialDefinition;
+export declare function getTutorial_T04(): TutorialDefinition[];

package/dist/types/tutorials/content/Tutorials_T05_T08.d.ts

@@ -0,0 +1,6 @@
+import type { TutorialDefinition } from '../TutorialEngine';
+export declare const TUTORIAL_ANIMATIONS: TutorialDefinition;
+export declare const TUTORIAL_TILEMAPS: TutorialDefinition;
+export declare const TUTORIAL_VISUAL_SCRIPTING: TutorialDefinition;
+export declare const TUTORIAL_LOCAL_MULTIPLAYER: TutorialDefinition;
+export declare function getTutorials_T05_T08(): TutorialDefinition[];

package/dist/types/tutorials/content/Tutorials_T09_T11.d.ts

@@ -0,0 +1,5 @@
+import type { TutorialDefinition } from '../TutorialEngine';
+export declare const TUTORIAL_MULTIPLAYER_ONLINE: TutorialDefinition;
+export declare const TUTORIAL_PROCEDURAL_WORLD: TutorialDefinition;
+export declare const TUTORIAL_PLATFORMER: TutorialDefinition;
+export declare function getTutorials_T09_T11(): TutorialDefinition[];

package/dist/types/tutorials/content/Tutorials_T12_T15.d.ts

@@ -0,0 +1,6 @@
+import type { TutorialDefinition } from '../TutorialEngine';
+export declare const TUTORIAL_RPG: TutorialDefinition;
+export declare const TUTORIAL_TOWER_DEFENSE: TutorialDefinition;
+export declare const TUTORIAL_3D_GAME: TutorialDefinition;
+export declare const TUTORIAL_PUBLISHING: TutorialDefinition;
+export declare function getTutorials_T12_T15(): TutorialDefinition[];

package/dist/types/tutorials/content/UITutorials.d.ts

@@ -0,0 +1,14 @@
+import type { TutorialDefinition } from '../TutorialEngine';
+export declare const TUTORIAL_UI_DATAGRID: TutorialDefinition;
+export declare const TUTORIAL_UI_FORM: TutorialDefinition;
+export declare const TUTORIAL_UI_CHART: TutorialDefinition;
+export declare const TUTORIAL_UI_TREEVIEW: TutorialDefinition;
+export declare const TUTORIAL_UI_SCHEDULER: TutorialDefinition;
+export declare const TUTORIAL_UI_GANTT: TutorialDefinition;
+export declare const TUTORIAL_UI_PIVOTGRID: TutorialDefinition;
+export declare const TUTORIAL_UI_HTMLEDITOR: TutorialDefinition;
+export declare const TUTORIAL_UI_NAVIGATION: TutorialDefinition;
+export declare const TUTORIAL_UI_OVERLAYS: TutorialDefinition;
+export declare const TUTORIAL_UI_THEMES: TutorialDefinition;
+export declare const TUTORIAL_UI_RESPONSIVE: TutorialDefinition;
+export declare function getAllUITutorials(): TutorialDefinition[];

package/dist/types/tutorials/content/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Tutorials_T04';
+export * from './Tutorials_T05_T08';
+export * from './Tutorials_T09_T11';
+export * from './Tutorials_T12_T15';
+export * from './UITutorials';

package/dist/types/tutorials/index.d.ts

@@ -0,0 +1,6 @@
+export * from './TutorialBranching';
+export * from './TutorialEditor';
+export * from './TutorialEngine';
+export * from './TutorialOverlay';
+export * from './VoiceNarration';
+export * from './content';