@projektemacher/storymapjs 0.10.6 → 0.10.8

package/src/dom/Dom.ts

@@ -0,0 +1,31 @@
+/*	Dom
+	Utilities for working with the DOM
+================================================= */
+
+export default class Dom {
+    static get(id: string | HTMLElement): HTMLElement | null {
+        return typeof id === "string" ? document.getElementById(id) : id;
+    }
+
+    static create(tagName: string, className: string, container?: HTMLElement): HTMLElement {
+        const el = document.createElement(tagName);
+        el.className = className;
+        if (container) {
+            container.appendChild(el);
+        }
+        return el;
+    }
+
+    static getPosition(el: HTMLElement | null): { x: number; y: number } {
+        const pos = {
+            x: 0,
+            y: 0,
+        };
+        while (el && !isNaN(el.offsetLeft) && !isNaN(el.offsetTop)) {
+            pos.x += el.offsetLeft;
+            pos.y += el.offsetTop;
+            el = el.offsetParent as HTMLElement | null;
+        }
+        return pos;
+    }
+}

package/src/dom/DomEvent.ts

@@ -0,0 +1,80 @@
+import { stamp } from "../core/Util";
+
+/*	DomEvent
+	Inspired by Leaflet
+	DomEvent contains functions for working with DOM events.
+================================================== */
+
+/** Elements/objects DomEvent listeners can be attached to. */
+type DomEventTarget = HTMLElement | Window | Document;
+
+/** Legacy drag handlers historically mixed mouse and touch event surfaces. */
+export type LegacyEvent = Event & {
+    originalEvent?: TouchEvent;
+    targetTouches?: TouchList;
+    pageX?: number;
+    pageY?: number;
+};
+
+/**
+ * The wrapper is remembered on the target so `removeListener` can find it
+ * again. Keyed by a per-registration counter rather than only by the stamped
+ * function: registering the same function twice for the same event used to
+ * overwrite the key, leaving the first listener permanently unremovable.
+ */
+const registrationCounts = new WeakMap<object, number>();
+
+function handlerKey(obj: DomEventTarget, type: string, fn: (e: Event) => void): string {
+    const target = obj as object;
+    const next = (registrationCounts.get(target) ?? 0) + 1;
+    registrationCounts.set(target, next);
+    return "_vco_" + type + stamp(fn) + "_" + next;
+}
+
+const DomEvent = {
+    addListener: function (
+        obj: DomEventTarget,
+        type: string,
+        fn: (e: Event) => void,
+        context?: unknown,
+    ): void {
+        const handler = function (e: Event) {
+            return (fn as (this: unknown, e: Event) => void).call(context || obj, e);
+        };
+
+        obj.addEventListener(type, handler, false);
+        (obj as unknown as Record<string, unknown>)[handlerKey(obj, type, fn)] = handler;
+    },
+
+    removeListener: function (
+        obj: DomEventTarget,
+        type: string,
+        fn: (e: Event) => void,
+        context?: unknown,
+    ): void {
+        // The most recent registration for this (type, fn) pair is the one the
+        // caller means; walk the counter back to find it.
+        const target = obj as unknown as Record<string, unknown>;
+        for (let n = registrationCounts.get(obj as object) ?? 0; n > 0; n--) {
+            const key = "_vco_" + type + stamp(fn) + "_" + n;
+            const handler = target[key];
+            if (!handler) {
+                continue;
+            }
+            obj.removeEventListener(type, handler as EventListener, false);
+            target[key] = null;
+            return;
+        }
+    },
+
+    preventDefault: function (e: Event): void {
+        if (e.preventDefault) {
+            e.preventDefault();
+        } else {
+            e.returnValue = false;
+        }
+    },
+};
+
+export { DomEvent };
+export type { DomEventTarget };

package/src/globals.d.ts

@@ -0,0 +1,24 @@
+// Externally loaded script globals (YouTube/SoundCloud player APIs).
+// Everything the library or the test harness touches on window is typed
+// at its usage site instead.
+
+declare global {
+    // Externally loaded script globals
+    const YT: {
+        Player: new (el: HTMLElement | string, opts: unknown) => unknown;
+        PlayerState: Record<string, number>;
+    };
+    const SC: {
+        Widget: (el: HTMLElement) => { pause(): void };
+    };
+
+    /**
+     * The library version, substituted from package.json by the Vite lib build
+     * (see the `define` in vite.config.ts). Hard-coded here only so the
+     * source type-checks; a dev-server run without the define falls back to
+     * "unknown" at runtime via the typeof guard in StoryMap.
+     */
+    const __STORYMAP_VERSION__: string;
+}
+
+export {};

package/src/language/Language.ts

@@ -0,0 +1,281 @@
+/**
+ * UI strings for the active locale.
+ *
+ * English is the fallback for every missing key (see `getLanguage`), so
+ * `messages` and `buttons` are guaranteed to be fully populated once a
+ * language has been set — they are typed as required here rather than as
+ * `Record<string, string> | undefined` so call sites do not need a null
+ * check on every one of the ~30 `Language.messages.*` reads.
+ *
+ * The locale JSON files themselves are *not* complete: only `en.json` defines
+ * every key, and 28 of the 29 bundled locales are missing 8-10 of them
+ * (the per-service consent strings and the fullscreen button labels). The
+ * runtime falls back to English per key, so this is a translation gap rather
+ * than a defect — `npm run check:locales` reports it.
+ */
+export interface LanguageEntry {
+    /** Display name of the language, e.g. "Deutsch". */
+    name?: string;
+    /** BCP 47 code, e.g. "de". */
+    lang?: string;
+    /** Writing direction; drives the `vco-rtl` layout. */
+    direction?: "ltr" | "rtl";
+    messages: Record<string, string>;
+    buttons: Record<string, string>;
+    [key: string]: unknown;
+}
+
+// The locales are imported statically rather than through `import.meta.glob`
+// on purpose. The viewer reads `Language.messages.*` while it is being
+// constructed — the consent dialog, the RTL class, the swipe hint icon and
+// every button label are all decided synchronously inside `new StoryMap()` —
+// so a locale that has not finished fetching yet would silently render in
+// English. The saving from splitting them is ~6 kB gzip, which is not worth
+// making the language load order-dependent.
+//
+// English remains the fallback for every key a translation is missing (see
+// `getLanguage`), and `npm run check:locales` reports those gaps.
+import be from "./locale/be.json";
+import bg from "./locale/bg.json";
+import cs from "./locale/cs.json";
+import de from "./locale/de.json";
+import el from "./locale/el.json";
+import en from "./locale/en.json";
+import es from "./locale/es.json";
+import et from "./locale/et.json";
+import fr from "./locale/fr.json";
+import he from "./locale/he.json";
+import hu from "./locale/hu.json";
+import isLocale from "./locale/is.json";
+import it from "./locale/it.json";
+import jp from "./locale/jp.json";
+import ko from "./locale/ko.json";
+import nl from "./locale/nl.json";
+import nn from "./locale/nn.json";
+import no from "./locale/no.json";
+import pl from "./locale/pl.json";
+import pt from "./locale/pt.json";
+import ru from "./locale/ru.json";
+import sk from "./locale/sk.json";
+import sr from "./locale/sr.json";
+import sv from "./locale/sv.json";
+import tr from "./locale/tr.json";
+import uk from "./locale/uk.json";
+import ur from "./locale/ur.json";
+import zhCn from "./locale/zh-cn.json";
+import zhTw from "./locale/zh-tw.json";
+
+const localeModules: Record<string, { default?: unknown }> = {
+    "./locale/be.json": { default: be },
+    "./locale/bg.json": { default: bg },
+    "./locale/cs.json": { default: cs },
+    "./locale/de.json": { default: de },
+    "./locale/el.json": { default: el },
+    "./locale/en.json": { default: en },
+    "./locale/es.json": { default: es },
+    "./locale/et.json": { default: et },
+    "./locale/fr.json": { default: fr },
+    "./locale/he.json": { default: he },
+    "./locale/hu.json": { default: hu },
+    "./locale/is.json": { default: isLocale },
+    "./locale/it.json": { default: it },
+    "./locale/jp.json": { default: jp },
+    "./locale/ko.json": { default: ko },
+    "./locale/nl.json": { default: nl },
+    "./locale/nn.json": { default: nn },
+    "./locale/no.json": { default: no },
+    "./locale/pl.json": { default: pl },
+    "./locale/pt.json": { default: pt },
+    "./locale/ru.json": { default: ru },
+    "./locale/sk.json": { default: sk },
+    "./locale/sr.json": { default: sr },
+    "./locale/sv.json": { default: sv },
+    "./locale/tr.json": { default: tr },
+    "./locale/uk.json": { default: uk },
+    "./locale/ur.json": { default: ur },
+    "./locale/zh-cn.json": { default: zhCn },
+    "./locale/zh-tw.json": { default: zhTw },
+};
+
+/** The locale every other language falls back to, per key. */
+const EN: Record<string, unknown> =
+    (localeModules["./locale/en.json"]?.default as Record<string, unknown> | undefined) || {};
+
+/** The strings the viewer reads before (or without) a `setLanguage` call. */
+const FALLBACK: LanguageEntry = {
+    name: "English",
+    lang: "en",
+    direction: "ltr",
+    messages: (EN.messages as Record<string, string>) ?? {},
+    buttons: (EN.buttons as Record<string, string>) ?? {},
+};
+
+let Language: LanguageEntry = FALLBACK;
+
+/**
+ * The locale code last passed to `setLanguage`, defaulting to the fallback.
+ *
+ * Deliberately not derived from `Language.lang`: every bundled locale's `lang`
+ * happens to equal its file name today, but a locale like `pt-BR` would make
+ * the claim comparison below judge two different identifiers for one locale.
+ * Tracking what the caller passed keeps every comparison on one vocabulary.
+ */
+let activeLanguageCode = "en";
+
+/**
+ * Which live viewer owns the page-wide locale.
+ *
+ * `Language` above is a single module-level binding, and every label read in
+ * the viewer goes through it (MenuBar, Message, StorySlider, Consent, Media,
+ * ...). That is deliberate — the strings are read synchronously while a viewer
+ * is constructed — but it means two viewers on one page cannot show different
+ * languages: whichever called `setLanguage` last would win, and the other
+ * would silently keep repainting its chrome in the wrong language.
+ *
+ * Rather than thread a resolved entry down the options chain, the viewer
+ * claims the locale it needs and we fail loudly on a conflict. The claim is
+ * refcounted, so tearing down one of two viewers set in the same language
+ * does not release the page.
+ */
+const languageHolders = new Map<symbol, string>();
+
+/** Why a claim was rejected, for the thrown error. */
+function languageConflict(claimed: string, requested: string): Error {
+    const err = new Error(
+        `StoryMapJS: two viewers on this page asked for different languages ` +
+            `("${claimed}" and "${requested}"), but the UI strings are a single ` +
+            `page-wide setting — the last one set would win and the other viewer ` +
+            `would keep rendering its chrome in the wrong language. Pass the same ` +
+            `language to every viewer on the page, or call refreshLanguage() on ` +
+            `the surviving viewer. See docs/DEVELOPMENT.md, ` +
+            `"Multiple instances on one page".`,
+    );
+    // the data may carry its own `language`, and a URL-loaded document claims
+    // asynchronously, where the constructor cannot throw — the name lets the
+    // async load path report the real cause instead of "could not load data"
+    err.name = "StoryMapLanguageConflict";
+    return err;
+}
+
+/** True for the error {@link claimLanguage} throws on a conflicting locale. */
+function isLanguageConflict(err: unknown): boolean {
+    return err instanceof Error && err.name === "StoryMapLanguageConflict";
+}
+
+/**
+ * Claim the page-wide locale for a viewer.
+ *
+ * @param code - The locale code the viewer is about to render.
+ * @param holder - Per-viewer identity; pass the same one to `releaseLanguage`.
+ * @throws If a live holder already claimed a different locale.
+ */
+function claimLanguage(code: string, holder: symbol): void {
+    for (const [existingHolder, existingCode] of languageHolders) {
+        if (existingHolder !== holder && existingCode !== code) {
+            throw languageConflict(existingCode, code);
+        }
+    }
+    languageHolders.set(holder, code);
+}
+
+/**
+ * Release a viewer's claim. The page-wide locale is only released once the
+ * last holder is gone, so a disposed viewer does not free the locale a
+ * sibling is still rendering in.
+ *
+ * @param holder - The identity passed to `claimLanguage`.
+ */
+function releaseLanguage(holder: symbol): void {
+    languageHolders.delete(holder);
+}
+
+/** The locale currently claimed by a live viewer, or null if there is none. */
+function claimedLanguage(): string | null {
+    const codes = new Set(languageHolders.values());
+    return codes.size > 0 ? [...codes][0] : null;
+}
+
+function getLanguage(code: string): Record<string, unknown> {
+    const lang: Record<string, unknown> = {};
+    // start from a deep copy of the English defaults, then layer this locale
+    // on top: a key the translation is missing keeps its English value
+    for (const k in EN) {
+        lang[k] = structuredClone(EN[k]);
+    }
+    const entry = (localeModules[`./locale/${code}.json`]?.default ?? {}) as Record<
+        string,
+        unknown
+    >;
+    applyLanguage(lang, entry);
+    return lang;
+}
+
+/** Merge `entry` over `target`, per key, never mutating the English defaults. */
+function applyLanguage(target: Record<string, unknown>, entry: Record<string, unknown>): void {
+    for (const k in entry) {
+        if (!entry[k]) {
+            continue;
+        }
+        if (typeof EN[k] === "object" && EN[k] !== null && typeof entry[k] === "object") {
+            // fresh object: never mutate the shared English default,
+            // otherwise one setLanguage() call would poison every later
+            // lookup (and every other language falling back to English)
+            target[k] = Object.assign({}, EN[k] as object, entry[k] as object);
+        } else {
+            target[k] = structuredClone(entry[k]);
+        }
+    }
+}
+
+/**
+ * Switch the active UI language. Synchronous: the viewer resolves its labels
+ * while it is being constructed.
+ *
+ * @param code - A locale code for which a locale file exists (e.g. `"en"`).
+ * @returns The language entry that is now active.
+ */
+function setLanguage(code: string): LanguageEntry {
+    // recorded before the merge, and unconditionally: a rejected *claim* never
+    // reaches here, so a throw cannot leave the page locale half-switched
+    activeLanguageCode = code;
+    const merged = getLanguage(code);
+    Language = {
+        ...(merged as Omit<LanguageEntry, "messages" | "buttons">),
+        messages: (merged.messages as Record<string, string>) ?? FALLBACK.messages,
+        buttons: (merged.buttons as Record<string, string>) ?? FALLBACK.buttons,
+    };
+    return Language;
+}
+
+/**
+ * The locale code the page is currently set to.
+ *
+ * A viewer that was not given a `language` adopts this instead of claiming the
+ * hardcoded `"en"` default, so a host that called `setLanguage("de")` and then
+ * constructed a viewer gets German rather than a conflict with a sibling.
+ */
+function currentLanguageCode(): string {
+    return activeLanguageCode;
+}
+
+/** The active locale's BCP 47 code, for `Intl` formatting. */
+function currentLocale(): string {
+    return typeof Language.lang === "string" && Language.lang !== "" ? Language.lang : "en";
+}
+
+/** True when the active language is written right-to-left. */
+function isRtl(): boolean {
+    return Language.direction === "rtl";
+}
+
+export {
+    setLanguage,
+    Language,
+    currentLocale,
+    isRtl,
+    currentLanguageCode,
+    claimLanguage,
+    releaseLanguage,
+    claimedLanguage,
+    isLanguageConflict,
+};

package/src/language/locale/.expected-gaps.json

@@ -0,0 +1,86 @@
+{
+    "be": ["messages.consent_service_narration"],
+    "bg": ["messages.consent_service_narration"],
+    "cs": ["messages.consent_service_narration"],
+    "de": ["messages.consent_service_narration"],
+    "el": ["messages.consent_service_narration"],
+    "es": ["messages.consent_service_narration"],
+    "et": [
+        "buttons.exit_fullscreen",
+        "buttons.fullscreen",
+        "messages.consent_allow",
+        "messages.consent_blocked",
+        "messages.consent_deny",
+        "messages.consent_message",
+        "messages.consent_service_fonts",
+        "messages.consent_service_narration",
+        "messages.consent_service_tiles",
+        "messages.error"
+    ],
+    "fr": ["messages.consent_service_narration"],
+    "he": ["messages.consent_service_narration"],
+    "hu": ["messages.consent_service_narration"],
+    "is": [
+        "buttons.exit_fullscreen",
+        "buttons.fullscreen",
+        "messages.consent_allow",
+        "messages.consent_blocked",
+        "messages.consent_deny",
+        "messages.consent_message",
+        "messages.consent_service_fonts",
+        "messages.consent_service_narration",
+        "messages.consent_service_tiles",
+        "messages.error"
+    ],
+    "it": ["messages.consent_service_narration"],
+    "jp": ["messages.consent_service_narration"],
+    "ko": ["messages.consent_service_narration"],
+    "nl": ["messages.consent_service_narration"],
+    "nn": [
+        "buttons.exit_fullscreen",
+        "buttons.fullscreen",
+        "messages.consent_allow",
+        "messages.consent_blocked",
+        "messages.consent_deny",
+        "messages.consent_message",
+        "messages.consent_service_fonts",
+        "messages.consent_service_narration",
+        "messages.consent_service_tiles",
+        "messages.error"
+    ],
+    "no": ["messages.consent_service_narration"],
+    "pl": ["messages.consent_service_narration"],
+    "pt": ["messages.consent_service_narration"],
+    "ru": ["messages.consent_service_narration"],
+    "sk": ["messages.consent_service_narration"],
+    "sr": [
+        "buttons.exit_fullscreen",
+        "buttons.fullscreen",
+        "buttons.overview",
+        "messages.consent_allow",
+        "messages.consent_blocked",
+        "messages.consent_deny",
+        "messages.consent_message",
+        "messages.consent_service_fonts",
+        "messages.consent_service_narration",
+        "messages.consent_service_tiles",
+        "messages.error"
+    ],
+    "sv": ["messages.consent_service_narration"],
+    "tr": ["messages.consent_service_narration"],
+    "uk": ["messages.consent_service_narration"],
+    "ur": [
+        "buttons.exit_fullscreen",
+        "buttons.fullscreen",
+        "messages.consent_allow",
+        "messages.consent_blocked",
+        "messages.consent_deny",
+        "messages.consent_message",
+        "messages.consent_service_fonts",
+        "messages.consent_service_narration",
+        "messages.consent_service_tiles",
+        "messages.error"
+    ],
+    "zh-cn": ["messages.consent_service_narration"],
+    "zh-tw": ["messages.consent_service_narration"]
+}

package/src/language/locale/be.json

@@ -0,0 +1,31 @@
+{
+    "name": "Беларуская",
+    "lang": "be",
+    "messages": {
+        "loading": "Загрузка",
+        "wikipedia": "Вікіпедыя",
+        "start": "Start Exploring",
+        "error": "Памылка загрузкі",
+        "consent_start_title": "Знешні кантэнт",
+        "consent_start_message": "Гэтая гісторыя загружае кантэнт з знешніх сэрвісаў. Выберыце, якія дазволены.",
+        "consent_allow_all": "Дазволіць усе",
+        "consent_decline_all": "Адхіліць усе",
+        "consent_message": "Загрузіць змесціва з {service}?",
+        "consent_allow": "Дазволіць",
+        "consent_deny": "Адмовіць",
+        "consent_blocked": "Змесціва з {service} заблакіравана.",
+        "consent_service_tiles": "тайлаў карты",
+        "consent_service_fonts": "веб-шрыфтаў"
+    },
+    "buttons": {
+        "map_overview": "Прагляд мапы",
+        "overview": "Прагляд",
+        "backtostart": "Вярнуцца ў пачатак",
+        "collapse_toggle": "Схаваць мапу",
+        "uncollapse_toggle": "Паказаць мапу",
+        "swipe_to_navigate": "Swipe to Navigate<br><span class='vco-button'>OK</span>",
+        "fullscreen": "Поўны экран",
+        "exit_fullscreen": "Выхад з поўнаэкранага рэжыму"
+    },
+    "direction": "ltr"
+}

package/src/language/locale/bg.json

@@ -0,0 +1,31 @@
+{
+    "name": "Български",
+    "lang": "bg",
+    "messages": {
+        "loading": "Зареждане",
+        "wikipedia": "От Уикипедия, свободната енциклопедия",
+        "start": "Започнете да разглеждате",
+        "error": "Грешка при зареждане",
+        "consent_start_title": "Външно съдържание",
+        "consent_start_message": "Тази история зарежда съдържание от външни услуги. Изберете кои са разрешени.",
+        "consent_allow_all": "Разреши всички",
+        "consent_decline_all": "Отхвърли всички",
+        "consent_message": "Да се зареди съдържание от {service}?",
+        "consent_allow": "Разреши",
+        "consent_deny": "Откажи",
+        "consent_blocked": "Съдържанието от {service} е блокирано.",
+        "consent_service_tiles": "тайли на картата",
+        "consent_service_fonts": "уеб шрифтове"
+    },
+    "buttons": {
+        "map_overview": "Преглед на картата",
+        "overview": "Преглед",
+        "backtostart": "Към началото",
+        "collapse_toggle": "Скриване на картата",
+        "uncollapse_toggle": "Показване на картата",
+        "swipe_to_navigate": "Swipe to Navigate<br><span class='vco-button'>OK</span>",
+        "fullscreen": "Цял екран",
+        "exit_fullscreen": "Изход от цял екран"
+    },
+    "direction": "ltr"
+}

package/src/language/locale/cs.json

@@ -0,0 +1,31 @@
+{
+    "name": "Čeština",
+    "lang": "cs",
+    "messages": {
+        "loading": "Nahrávání",
+        "wikipedia": "Z Wikipedie, svobodné encyklopedie",
+        "start": "Prozkoumat",
+        "error": "Chyba při načítání",
+        "consent_start_title": "Externí obsah",
+        "consent_start_message": "Tento příběh načítá obsah z externích služeb. Zvolte, které jsou povoleny.",
+        "consent_allow_all": "Povolit vše",
+        "consent_decline_all": "Odmítnout vše",
+        "consent_message": "Načíst obsah z {service}?",
+        "consent_allow": "Povolit",
+        "consent_deny": "Odmítnout",
+        "consent_blocked": "Obsah z {service} je zablokován.",
+        "consent_service_tiles": "mapových dlaždic",
+        "consent_service_fonts": "webových písem"
+    },
+    "buttons": {
+        "map_overview": "Přehledová mapa",
+        "overview": "Přehled",
+        "backtostart": "Zpět na začátek",
+        "collapse_toggle": "Skrýt mapu",
+        "uncollapse_toggle": "Zobrazit mapu",
+        "swipe_to_navigate": "Swipe to Navigate<br><span class='vco-button'>OK</span>",
+        "fullscreen": "Celá obrazovka",
+        "exit_fullscreen": "Ukončit celou obrazovku"
+    },
+    "direction": "ltr"
+}

package/src/language/locale/de.json

@@ -0,0 +1,31 @@
+{
+    "name": "Deutsch",
+    "lang": "de",
+    "messages": {
+        "loading": "Daten werden geladen",
+        "wikipedia": "von Wikipedia, der freien Enzyklopädie",
+        "start": "Explore",
+        "consent_start_title": "Externe Inhalte",
+        "consent_start_message": "Diese Story lädt Inhalte von externen Diensten. Wählen Sie, welche erlaubt sind.",
+        "consent_allow_all": "Alle erlauben",
+        "consent_decline_all": "Alle ablehnen",
+        "error": "Fehler beim Laden",
+        "consent_message": "Inhalte von {service} laden?",
+        "consent_allow": "Erlauben",
+        "consent_deny": "Ablehnen",
+        "consent_blocked": "Inhalte von {service} sind blockiert.",
+        "consent_service_tiles": "Kartenkacheln",
+        "consent_service_fonts": "Web-Schriften"
+    },
+    "buttons": {
+        "map_overview": "Kartenübersicht",
+        "overview": "Kartenübersicht",
+        "backtostart": "Zurück zum Anfang",
+        "collapse_toggle": "Karte ausblenden",
+        "uncollapse_toggle": "Karte anzeigen",
+        "swipe_to_navigate": "Swipe to Navigate<br><span class='vco-button'>OK</span>",
+        "fullscreen": "Vollbild",
+        "exit_fullscreen": "Vollbild beenden"
+    },
+    "direction": "ltr"
+}

package/src/language/locale/el.json

@@ -0,0 +1,31 @@
+{
+    "name": "Ελληνικά",
+    "lang": "el",
+    "messages": {
+        "loading": "Φόρτωση",
+        "wikipedia": "Από την Wikipedia, την ελεύθερη εγκυκλοπαίδεια",
+        "start": "Έναρξη περιήγησης",
+        "error": "Σφάλμα φόρτωσης",
+        "consent_start_title": "Εξωτερικό περιεχόμενο",
+        "consent_start_message": "Αυτή η ιστορία φορτώνει περιεχόμενο από εξωτερικές υπηρεσίες. Επιλέξτε ποιες επιτρέπονται.",
+        "consent_allow_all": "Να επιτρέπονται όλα",
+        "consent_decline_all": "Να απορρίπτονται όλα",
+        "consent_message": "Φόρτωση περιεχομένου από {service};",
+        "consent_allow": "Επίτρεψη",
+        "consent_deny": "Απόρριψη",
+        "consent_blocked": "Το περιεχόμενο από {service} είναι αποκλεισμένο.",
+        "consent_service_tiles": "πλακίδια χάρτη",
+        "consent_service_fonts": "διαδικτυακές γραμματοσειρές"
+    },
+    "buttons": {
+        "map_overview": "Επισκόπηση χάρτη",
+        "overview": "Επισκόπηση",
+        "backtostart": "Επιστροφή στην αρχή",
+        "collapse_toggle": "Απόκρυψη χάρτη",
+        "uncollapse_toggle": "Εμφάνιση χάρτη",
+        "swipe_to_navigate": "Κτυπήστε ελαφρά για περιήγηση<br><span class='vco-button'>OK</span>",
+        "fullscreen": "Πλήρης οθόνη",
+        "exit_fullscreen": "Έξοδος από πλήρη οθόνη"
+    },
+    "direction": "ltr"
+}