@codename/deck 0.1.0 → 0.1.1

package/dist/types/blocks.d.ts

@@ -0,0 +1,25 @@
+export type Where = {
+    base: string;
+    root: HTMLElement;
+    versions?: {
+        echarts?: string;
+        pele?: string;
+    };
+};
+/**
+ * A library's file: from a CDN's npm mirror, at its version (`https://…/npm/name@1.2.3/file`), or from a
+ * node_modules folder, which holds one version (`…/node_modules/name/file`).
+ * @param {string} base @param {string} name @param {string} version @param {string} file
+ */
+export declare const libraryAt: (base: string, name: string, version: string, file: string) => string;
+/** @param {Where} where */
+export declare function defaultBlocks({ base, root, versions }: Where): {
+    /** @param {HTMLElement} box @param {string} source */
+    echarts(box: HTMLElement, source: string): Promise<void>;
+    /**
+     * A diagram written in Mermaid's language, drawn by Pele (Obsidian's, MIT): every kind Mermaid
+     * 12.1 has, no DOM needed, an SVG with no script or HTML in it. Shown as a picture, its colours
+     * the deck's, set as Pele's variables inside it. @param {HTMLElement} box @param {string} source
+     */
+    mermaid(box: HTMLElement, source: string): Promise<void>;
+};

package/dist/types/deck.d.ts

@@ -0,0 +1,42 @@
+export type Deck = import('./parse.js').Deck;
+export type Options = {
+    source: string;
+    lang?: string;
+    dir?: string;
+    kit?: Record<string, any>;
+    scheme?: 'light' | 'dark' | 'auto';
+    blocks?: Record<string, import('./render.js').Drawer>;
+    resolve?: (src: string) => string | null;
+    strings?: Record<string, string>;
+    headings?: 'real' | 'aria';
+    editable?: boolean;
+    lex?: (markdown: string) => any[];
+    onChange?: (source: string) => void;
+    onSave?: (source: string) => void;
+    onExport?: (deck: DeckView) => void;
+};
+export type DeckView = ReturnType<typeof createDeck>;
+/** @typedef {ReturnType<typeof createDeck>} DeckView */
+/** @param {HTMLElement} root @param {Options} options */
+export declare function createDeck(root: HTMLElement, options: Options): {
+    root: HTMLElement;
+    stage: HTMLElement;
+    readonly source: string;
+    readonly deck: import("./parse.js").Deck;
+    readonly at: number;
+    readonly scheme: "dark" | "light";
+    readonly kit: import("./kit.js").Kit;
+    readonly kitProblems: string[];
+    lang: string;
+    dir: string;
+    slides: () => HTMLElement[];
+    setSource: (text: string) => void;
+    go: (to: number, toStep?: number) => void;
+    toggle: (mode: string) => void;
+    present: () => void;
+    fitAll: () => void;
+    setScheme: (/** @type {'light' | 'dark'} */ value: 'light' | 'dark') => void;
+    destroy: () => void;
+};
+/** The Markdown of words changed in place: bold, italics, code and links kept as Markdown writes them. @param {Node} node @returns {string} */
+export declare function markdownOf(node: Node): string;

package/dist/types/file.d.ts

@@ -0,0 +1,38 @@
+export declare const OPEN = "<script type=\"text/markdown\" id=\"deck\">";
+/** @param {string} markdown */
+export declare const escape: (markdown: string) => string;
+/** @param {string} text */
+export declare const unescape: (text: string) => string;
+/**
+ * Code held whole in the file: `</script`, `<script` and `<!--`, which only a string or a regular
+ * expression of a bundle holds, written with `\x3C` for their `<`, which reads the same there.
+ * @param {string} code
+ */
+export declare function inlineCode(code: string): string;
+/**
+ * A deck's Markdown, from a file's text, or null when it holds none.
+ * @param {string} html @returns {string | null}
+ */
+export declare function readDeckFile(html: string): string | null;
+/** Where a linked file finds its renderer: this version of the package, on jsDelivr's npm mirror. @param {string} [version] */
+export declare const rendererUrl: (version?: string) => string;
+/**
+ * A deck file around its Markdown: its title, language and direction in the page's head for
+ * whatever reads it before the renderer does, then the Markdown, in the body (the head is never shown), readable as it is when no
+ * renderer comes, then the renderer: linked by default, to this version's address, or held whole;
+ * `base` tells it where to load the libraries a slide needs (a CDN's npm mirror, or a node_modules).
+ * @param {string} markdown
+ * @param {{ title?: string, lang?: string, dir?: string, renderer?: { src: string } | { code: string }, base?: string, generator?: string }} [options]
+ */
+export declare function writeDeckFile(markdown: string, { title, lang, dir, renderer, base, generator }?: {
+    title?: string;
+    lang?: string;
+    dir?: string;
+    renderer?: {
+        src: string;
+    } | {
+        code: string;
+    };
+    base?: string;
+    generator?: string;
+}): string;

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+export { createDeck, markdownOf } from './deck.js';
+export { parseDeck } from './parse.js';
+export { renderSlide } from './render.js';
+export { STANDARD, mergeKits, layoutOf, inferLayout, labelOf, tokensFrom } from './kit.js';
+export { tokensOf, schemeOf, LOOKS, readable, contrast } from './look.js';
+export { readDeckFile, writeDeckFile, rendererUrl, escape, unescape } from './file.js';
+export { toPptx } from './pptx.js';
+export { defaultBlocks, libraryAt } from './blocks.js';
+export { inlinePictures } from './pictures.js';
+export { deckIn } from './repair.js';
+export { VERSION } from './version.js';

package/dist/types/kit.d.ts

@@ -0,0 +1,73 @@
+export type Budget = {
+    required?: boolean;
+    max_words?: number;
+    max_chars?: number;
+    items?: [number, number];
+    item_max_words?: number;
+    heading_max_words?: number;
+    kind?: string;
+};
+export type Layout = {
+    label?: Record<string, string> | string;
+    intent?: string;
+    use_when?: string;
+    avoid_when?: string;
+    slots: string[];
+    budgets: Record<string, Budget>;
+    areas: string[][];
+    columns: string[];
+    rows: string[];
+    align: 'start' | 'center' | 'end';
+    justify: 'start' | 'center' | 'end';
+    paper: 'paper' | 'fill' | 'ink' | 'soft';
+    title: 'normal' | 'large' | 'huge';
+    pptx: string;
+    numbered: boolean;
+};
+export type Kit = {
+    name?: string;
+    tokens: Record<string, any>;
+    layouts: Record<string, Layout>;
+};
+/** The names brains give the usual layouts, for the ones deck has. */
+export declare const ALIASES: Record<string, string>;
+/** deck's own kit: the usual layouts, the ones Slidev names and the ones PowerPoint has, as data. */
+export declare const STANDARD: Kit;
+/**
+ * A layout as given, checked: its slots, areas and tracks in the grammar, its words' place, paper
+ * and size among their names. @param {any} given @returns {{ layout: Layout | null, problems: string[] }}
+ */
+export declare function layoutOf(given: any): {
+    layout: Layout | null;
+    problems: string[];
+};
+/**
+ * Design tokens as the W3C's Design Tokens format (DTCG 2025.10) writes them, read into a kit's:
+ * `color.light` and `color.dark` groups (bg, surface, fg, muted, accent) or flat colours, `font.sans`
+ * and the like; each `$value` a hex string or a colour object with its `hex`. Tokens already flat
+ * pass through. @param {any} given @returns {Record<string, any>}
+ */
+export declare function tokensFrom(given: any): Record<string, any>;
+/**
+ * Kits merged, the later over the earlier: their tokens, and their layouts by name, each checked.
+ * @param {...any} kits @returns {{ kit: Kit, problems: string[] }}
+ */
+export declare function mergeKits(...kits: any[]): {
+    kit: Kit;
+    problems: string[];
+};
+/** A layout's name in a language, else its own name. @param {Layout} layout @param {string} name @param {string} lang */
+export declare function labelOf(layout: Layout, name: string, lang: string): string;
+/**
+ * The layout a slide that names none is given, from what it holds, as Pandoc's PowerPoint writer
+ * chooses: the first slide is the cover; a heading alone, a section; slots beyond the first, the
+ * layout of two (or three) columns that has them; a number alone as its heading, a fact; a quote
+ * alone, a quote; else the default. @param {{ index: number, slots: { name: string, text: string }[] }} slide
+ */
+export declare function inferLayout(slide: {
+    index: number;
+    slots: {
+        name: string;
+        text: string;
+    }[];
+}): "cover" | "default" | "fact" | "quote" | "section" | "three-cols" | "two-cols" | "two-cols-header";

package/dist/types/look.d.ts

@@ -0,0 +1,55 @@
+export type Tokens = {
+    paper: string;
+    ink: string;
+    primary: string;
+    voice: string;
+    radius: number;
+    muted?: string;
+    soft?: string;
+    dark?: Record<string, string>;
+    fonts?: {
+        heading: string[];
+        body: string[];
+    };
+};
+export type Scheme = {
+    paper: string;
+    ink: string;
+    muted: string;
+    line: string;
+    primary: string;
+    onPrimary: string;
+    soft: string;
+    series: string[];
+};
+/** @typedef {{ paper: string, ink: string, primary: string, voice: string, radius: number, muted?: string, soft?: string, dark?: Record<string, string>, fonts?: { heading: string[], body: string[] } }} Tokens */
+/** @typedef {{ paper: string, ink: string, muted: string, line: string, primary: string, onPrimary: string, soft: string, series: string[] }} Scheme */
+/** Looks a deck can name (`theme:`), each a handful of tokens. */
+export declare const LOOKS: Record<string, Tokens>;
+/** Type for each voice: the device's faces, so a deck needs nothing to download to look right. */
+export declare const VOICES: Record<string, {
+    heading: string;
+    body: string;
+}>;
+/**
+ * The tokens a deck's settings give, over the project's look and a named one.
+ * @param {Record<string, any>} settings @param {Partial<Tokens>} [project]
+ * @returns {Tokens}
+ */
+export declare function tokensOf(settings: Record<string, any>, project?: Partial<Tokens>): Tokens;
+/**
+ * Light or dark, worked out from the tokens: dark swaps paper and ink and lifts the primary.
+ * @param {Tokens} tokens @param {'light' | 'dark'} scheme @returns {Scheme}
+ */
+export declare function schemeOf(tokens: Tokens, scheme: 'light' | 'dark'): Scheme;
+/** @param {string} value @returns {[number, number, number] | null} */
+export declare function hex(value: string): [number, number, number] | null;
+/** @param {number[]} rgb */
+export declare const css: (rgb: number[]) => string;
+/** WCAG's contrast ratio. @param {number[]} a @param {number[]} b */
+export declare function contrast(a: number[], b: number[]): number;
+/**
+ * The colour, its hue kept, deepened or lightened toward black or white until it reads at the
+ * ratio on the paper. @param {number[]} colour @param {number[]} paper @param {number} ratio
+ */
+export declare function readable(colour: number[], paper: number[], ratio: number): [number, number, number];

package/dist/types/parse.d.ts

@@ -0,0 +1,20 @@
+export type Slot = {
+    name: string;
+    text: string;
+    start: number;
+};
+export type Slide = {
+    index: number;
+    start: number;
+    end: number;
+    settings: Record<string, any>;
+    slots: Slot[];
+    notes: string;
+    title: string;
+};
+export type Deck = {
+    settings: Record<string, any>;
+    slides: Slide[];
+};
+/** @param {string} source @returns {Deck} */
+export declare function parseDeck(source: string): Deck;

package/dist/types/pictures.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The deck with its pictures inside it.
+ * @param {string} source
+ * @param {(place: string) => Promise<{ type: string, bytes: Uint8Array } | null>} read
+ * @param {{ web?: boolean, largest?: number }} [options] `web`: pictures on the web too; `largest`: bytes past which a picture stays a link
+ * @returns {Promise<{ source: string, inlined: string[], missing: string[], kept: string[] }>}
+ */
+export declare function inlinePictures(source: string, read: (place: string) => Promise<{
+    type: string;
+    bytes: Uint8Array;
+} | null>, { web: fromWeb, largest }?: {
+    web?: boolean;
+    largest?: number;
+}): Promise<{
+    source: string;
+    inlined: string[];
+    missing: string[];
+    kept: string[];
+}>;

package/dist/types/pptx.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {import('./deck.js').DeckView} view
+ * @param {{ PptxGenJS: any, JSZip: any }} libraries
+ * @returns {Promise<{ blob: Blob, report: { slides: number, charts: number, pictures: number, tables: number, placeholders: number } }>}
+ */
+export declare function toPptx(view: import('./deck.js').DeckView, { PptxGenJS, JSZip }: {
+    PptxGenJS: any;
+    JSZip: any;
+}): Promise<{
+    blob: Blob;
+    report: {
+        slides: number;
+        charts: number;
+        pictures: number;
+        tables: number;
+        placeholders: number;
+    };
+}>;

package/dist/types/render.d.ts

@@ -0,0 +1,34 @@
+export type Slide = import('./parse.js').Slide;
+export type Slot = import('./parse.js').Slot;
+export type Drawer = (element: HTMLElement, source: string) => void | Promise<void>;
+export type Context = {
+    blocks: Record<string, Drawer>;
+    resolve: (src: string) => string | null;
+    headings: 'real' | 'aria';
+    number: (n: number) => string;
+    total: number;
+    kit: import('./kit.js').Kit;
+    lex: (markdown: string) => any[];
+    slide: string;
+};
+/** @typedef {import('./parse.js').Slide} Slide */
+/** @typedef {import('./parse.js').Slot} Slot */
+/** @typedef {(element: HTMLElement, source: string) => void | Promise<void>} Drawer */
+/** @typedef {{ blocks: Record<string, Drawer>, resolve: (src: string) => string | null, headings: 'real' | 'aria', number: (n: number) => string, total: number, kit: import('./kit.js').Kit, lex: (markdown: string) => any[], slide: string }} Context */
+/**
+ * @param {string} tag @param {Record<string, string | number | boolean | undefined>} [attributes]
+ * @param {(Node | string | null | undefined | false)[]} [children]
+ */
+export declare function h(tag: string, attributes?: Record<string, string | number | boolean | undefined>, children?: (Node | string | null | undefined | false)[]): HTMLElement;
+/** An address a slide may show: the web's, a picture held in the file, or one beside it. @param {string} href */
+export declare function safeUrl(href: string): string | null;
+/**
+ * A slide, laid out by its layout, with its slots, steps and number.
+ * @param {Slide} slide @param {Context} context @returns {{ element: HTMLElement, steps: number }}
+ */
+export declare function renderSlide(slide: Slide, context: Context): {
+    element: HTMLElement;
+    steps: number;
+};
+/** @param {any[]} tokens @param {Context} context @returns {Node[]} */
+export declare function inline(tokens: any[] | undefined, context: Context): Node[];

package/dist/types/repair.d.ts

@@ -0,0 +1,5 @@
+/** The deck an answer holds, or null. @param {string} answer @returns {{ source: string, mended: string[] } | null} */
+export declare function deckIn(answer: string): {
+    source: string;
+    mended: string[];
+} | null;

package/dist/types/strings.d.ts

@@ -0,0 +1,2 @@
+/** @param {string} lang */
+export declare const stringsFor: (lang: string) => Record<string, string>;

package/dist/types/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.1.1";

package/dist/types/yaml.d.ts

@@ -0,0 +1,2 @@
+/** @param {string} text @returns {Record<string, any>} */
+export declare function parseYaml(text: string): Record<string, any>;

package/docs/host.md

@@ -14,7 +14,8 @@ const view = createDeck(document.querySelector('#deck'), {
   scheme: 'auto',               // 'light', 'dark' or 'auto', over the deck's colorSchema
   blocks: { echarts, mermaid }, // drawers for fenced blocks: (box, source) => void | Promise<void>
   resolve: (src) => url,        // a picture's address as the page can load it, or null
-  strings,                      // the bar's words, else deck's own (en, fr, ar, ja)
+  strings,                      // the bar's words, and `slide` and `carousel` for screen readers, else deck's own (en, fr, ar, ja)
+  lex: (markdown) => tokens,    // how a slide's Markdown is read: the host's own marked, its extensions too; else marked's GFM
   headings: 'aria',             // 'real' (h1–h6) or 'aria' (role=heading), for a deck inside a page
   editable: true,
   onChange: (source) => {},     // after each change, by the Markdown or on a slide

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@codename/deck",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Slide decks as one web page: Markdown in Slidev's form inside a .deck.html file any browser presents, a renderer that runs anywhere, kits of layouts and looks, and an editable PowerPoint out",
   "license": "MIT",
   "type": "module",
   "exports": {
-    ".": "./dist/deck.mjs",
-    "./bundle": "./dist/deck.bundle.mjs",
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/deck.mjs"
+    },
+    "./bundle": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/deck.bundle.mjs"
+    },
     "./file": "./dist/deck.js",
     "./css": "./dist/deck.css",
     "./src/*": "./src/*"
@@ -27,8 +33,8 @@
     "pptx"
   ],
   "scripts": {
-    "build": "node build.mjs",
-    "examples": "node build.mjs && node examples/make.mjs",
+    "build": "node build.mjs && tsc -p tsconfig.types.json",
+    "examples": "npm run build && node examples/make.mjs",
     "test": "node --test test/*.test.js",
     "test:browsers": "npm run examples && node test/browser.mjs && node test/kit-browser.mjs",
     "typecheck": "tsc --noEmit",
@@ -39,7 +45,7 @@
     "prepublishOnly": "npm run build && npm test"
   },
   "peerDependencies": {
-    "marked": "^18.1.1"
+    "marked": "^18.0.14"
   },
   "devDependencies": {
     "echarts": "6.1.0",

package/src/deck.js

@@ -4,19 +4,21 @@
 // the presenter's view (this slide, the next, the notes, the time) and all slides at once; light
 // or dark; changed as Markdown beside the slides, or in place on a slide, live. Host-agnostic:
 // the host gives the drawers of ```echarts and ```mermaid, how a picture's address resolves, its
-// words, and what to do when the deck changes or is saved.
+// words, how a slide's Markdown is read (its own marked, with its extensions), and what to do when
+// the deck changes or is saved.
 import { parseDeck } from './parse.js'
 import { renderSlide, h } from './render.js'
 import { tokensOf, schemeOf, VOICES } from './look.js'
 import { mergeKits } from './kit.js'
 import { stringsFor } from './strings.js'
+import { Lexer } from 'marked'
 
 /** @typedef {import('./parse.js').Deck} Deck */
 /**
  * @typedef {{
  *   source: string, lang?: string, dir?: string, kit?: Record<string, any>, scheme?: 'light' | 'dark' | 'auto',
  *   blocks?: Record<string, import('./render.js').Drawer>, resolve?: (src: string) => string | null,
- *   strings?: Record<string, string>, headings?: 'real' | 'aria', editable?: boolean,
+ *   strings?: Record<string, string>, headings?: 'real' | 'aria', editable?: boolean, lex?: (markdown: string) => any[],
  *   onChange?: (source: string) => void, onSave?: (source: string) => void, onExport?: (deck: DeckView) => void,
  * }} Options
  */
@@ -60,7 +62,7 @@ export function createDeck(root, options) {
   root.classList.add('deck')
   root.lang = lang
   root.dir = dir
-  const stage = h('div', { class: 'deck-stage', tabindex: 0, role: 'region', 'aria-roledescription': 'carousel', 'aria-label': words.deck })
+  const stage = h('div', { class: 'deck-stage', tabindex: 0, role: 'region', 'aria-roledescription': words.carousel, 'aria-label': words.deck })
   const where = h('span', { class: 'deck-where', 'aria-live': 'polite' })
   const button = (/** @type {string} */ name, /** @type {string} */ label, /** @type {() => void} */ act) => {
     const b = h('button', { type: 'button', 'aria-label': label, 'data-act': name }, [icon(name)])
@@ -115,6 +117,7 @@ export function createDeck(root, options) {
   /** @type {import('./render.js').Context} */
   const context = {
     blocks: options.blocks ?? {}, resolve: options.resolve ?? ((src) => src), headings: options.headings ?? 'real', number: (n) => number(n), total: 0, kit: mergeKits().kit,
+    lex: options.lex ?? ((markdown) => new Lexer({ gfm: true }).lex(markdown)), slide: words.slide,
   }
 
   function draw() {

package/src/render.js

@@ -4,13 +4,12 @@
 // source (data-edit, offsets), so an edit made on the slide goes back into the Markdown. HTML a
 // deck holds is not drawn: Slidev's <v-click> and <v-clicks> become steps, <br> a line break, and
 // any other tag gives up its words alone. ```echarts and ```mermaid go to the host's drawers.
-import { Lexer } from 'marked'
 import { STANDARD, inferLayout, ALIASES } from './kit.js'
 
 /** @typedef {import('./parse.js').Slide} Slide */
 /** @typedef {import('./parse.js').Slot} Slot */
 /** @typedef {(element: HTMLElement, source: string) => void | Promise<void>} Drawer */
-/** @typedef {{ blocks: Record<string, Drawer>, resolve: (src: string) => string | null, headings: 'real' | 'aria', number: (n: number) => string, total: number, kit: import('./kit.js').Kit }} Context */
+/** @typedef {{ blocks: Record<string, Drawer>, resolve: (src: string) => string | null, headings: 'real' | 'aria', number: (n: number) => string, total: number, kit: import('./kit.js').Kit, lex: (markdown: string) => any[], slide: string }} Context */
 
 /**
  * @param {string} tag @param {Record<string, string | number | boolean | undefined>} [attributes]
@@ -47,7 +46,7 @@ export function renderSlide(slide, context) {
   const section = h('section', {
     class: ['deck-slide', `deck-layout-${layout}`, ...classes.map((name) => `deck-class-${name}`)].join(' '),
     'data-index': slide.index, 'data-layout': layout, 'data-paper': definition.paper, 'data-align': definition.align, 'data-justify': definition.justify, 'data-title': definition.title,
-    'aria-roledescription': 'slide', role: 'group',
+    'aria-roledescription': context.slide, role: 'group',
   })
   // Its grid, from the layout's definition, through the CSSOM: areas named s-<slot>, as `default` is no name CSS allows.
   const canvas = h('div', { class: 'deck-canvas' })
@@ -79,7 +78,7 @@ export function renderSlide(slide, context) {
 
 /** @param {Slot} slot @param {Context} context @param {{ step: number }} counter @returns {Node[]} */
 function blocks(slot, context, counter) {
-  const tokens = new Lexer({ gfm: true }).lex(slot.text)
+  const tokens = context.lex(slot.text)
   /** @type {Node[]} */
   const out = []
   let at = slot.start, mode = /** @type {'' | 'click' | 'clicks'} */ ('')

package/src/strings.js

@@ -1,9 +1,9 @@
 // The deck's own words, for a deck opened on its own; a host gives its own instead (options.strings).
 const STRINGS = /** @type {Record<string, Record<string, string>>} */ ({
-  en: { deck: 'Slides', previous: 'Previous', next: 'Next', present: 'Present full screen', presenter: 'Presenter view', overview: 'All slides', edit: 'Change', scheme: 'Light or dark', export: 'Save as PowerPoint', source: 'The deck as text', notes: 'Notes', noNotes: 'No notes for this slide.', upNext: 'Next', last: 'Last slide', where: 'Slide {n} of {count}', saved: 'Saved' },
-  fr: { deck: 'Diapositives', previous: 'Précédente', next: 'Suivante', present: 'Présenter en plein écran', presenter: 'Vue présentateur', overview: 'Toutes les diapositives', edit: 'Modifier', scheme: 'Clair ou sombre', export: 'Enregistrer en PowerPoint', source: 'La présentation en texte', notes: 'Notes', noNotes: 'Pas de notes pour cette diapositive.', upNext: 'Ensuite', last: 'Dernière diapositive', where: 'Diapositive {n} sur {count}', saved: 'Enregistré' },
-  ar: { deck: 'الشرائح', previous: 'السابقة', next: 'التالية', present: 'العرض بملء الشاشة', presenter: 'عرض المقدّم', overview: 'كل الشرائح', edit: 'تعديل', scheme: 'فاتح أو داكن', export: 'الحفظ بصيغة PowerPoint', source: 'العرض كنص', notes: 'الملاحظات', noNotes: 'لا ملاحظات لهذه الشريحة.', upNext: 'التالية', last: 'الشريحة الأخيرة', where: 'الشريحة {n} من {count}', saved: 'تم الحفظ' },
-  ja: { deck: 'スライド', previous: '前へ', next: '次へ', present: '全画面で発表', presenter: '発表者ビュー', overview: 'すべてのスライド', edit: '編集', scheme: 'ライトまたはダーク', export: 'PowerPoint で保存', source: 'テキストとしてのスライド', notes: 'メモ', noNotes: 'このスライドにメモはありません。', upNext: '次', last: '最後のスライド', where: 'スライド {n} / {count}', saved: '保存しました' },
+  en: { deck: 'Slides', slide: 'slide', carousel: 'carousel', previous: 'Previous', next: 'Next', present: 'Present full screen', presenter: 'Presenter view', overview: 'All slides', edit: 'Change', scheme: 'Light or dark', export: 'Save as PowerPoint', source: 'The deck as text', notes: 'Notes', noNotes: 'No notes for this slide.', upNext: 'Next', last: 'Last slide', where: 'Slide {n} of {count}', saved: 'Saved' },
+  fr: { deck: 'Diapositives', slide: 'diapositive', carousel: 'carrousel', previous: 'Précédente', next: 'Suivante', present: 'Présenter en plein écran', presenter: 'Vue présentateur', overview: 'Toutes les diapositives', edit: 'Modifier', scheme: 'Clair ou sombre', export: 'Enregistrer en PowerPoint', source: 'La présentation en texte', notes: 'Notes', noNotes: 'Pas de notes pour cette diapositive.', upNext: 'Ensuite', last: 'Dernière diapositive', where: 'Diapositive {n} sur {count}', saved: 'Enregistré' },
+  ar: { deck: 'الشرائح', slide: 'شريحة', carousel: 'عرض شرائح', previous: 'السابقة', next: 'التالية', present: 'العرض بملء الشاشة', presenter: 'عرض المقدّم', overview: 'كل الشرائح', edit: 'تعديل', scheme: 'فاتح أو داكن', export: 'الحفظ بصيغة PowerPoint', source: 'العرض كنص', notes: 'الملاحظات', noNotes: 'لا ملاحظات لهذه الشريحة.', upNext: 'التالية', last: 'الشريحة الأخيرة', where: 'الشريحة {n} من {count}', saved: 'تم الحفظ' },
+  ja: { deck: 'スライド', slide: 'スライド', carousel: 'カルーセル', previous: '前へ', next: '次へ', present: '全画面で発表', presenter: '発表者ビュー', overview: 'すべてのスライド', edit: '編集', scheme: 'ライトまたはダーク', export: 'PowerPoint で保存', source: 'テキストとしてのスライド', notes: 'メモ', noNotes: 'このスライドにメモはありません。', upNext: '次', last: '最後のスライド', where: 'スライド {n} / {count}', saved: '保存しました' },
 })
 
 /** @param {string} lang */

package/src/version.js

@@ -1,2 +1,2 @@
 // deck's version, which a linked file names in its renderer's address. Kept equal to package.json's by a test.
-export const VERSION = '0.1.0'
+export const VERSION = '0.1.1'