HUB text/PAO une syntaxe pour différentes cibles input et output (backends, targets ou writers), de manière à obtenir du HTML du LaTeX, page de man: pandoc

hexadécimal

Au départ si on a que du texte sans mise en forme, on peut écrire en hexadécimal comme dans ma jeunesse des années 70 (en ASCII ou étendue pour les caractères français par exemple). Il suffisait de connaitre par coeur la table ASCII de 128 correspondances qui est une norme informatique de codage de caractères des années 60. Et tout cela avec un clavier de 0-9 et A-F soit 16 touches (même pas une touche carriage return  car c'est le code #D ni même une touche espace car c'est #20)!
http://ascii.cl/
Et pour l'histoire:
https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange

C'était clair, il y avait celui qui tapait ses idées au kilomètre puis celui qui mettait en forme.

que du text mis en forme (et un peu de "PAO") et comparaison des softs

Si on a que text (par exemple ASCII ou UTF-8) c'est assez simple.
Avec du balisage léger et des transcodeurs, on a du Hub-text.
voir une liste partielle des output formats:
https://en.wikipedia.org/wiki/Lightweight_markup_language

https://en.wikipedia.org/wiki/Comparison_of_document_markup_languages

https://en.wikipedia.org/wiki/Comparison_of_documentation_generators
(and  programming languages).
example: ROBODoc is a documentation tool similar to Javadoc and licensed under the GPL. It is used to extract API documentation from source code. It can be used with any language that supports comments and works by extracting specially formatted headers. These are then reformatted into HTML, DocBook, TROFF, ASCII, LaTeX, PDF, or RTF.
It can be used to document any programming artifact, such as: classes, functions, tests, makefile entries, etc.
ROBODoc works with C, C++, Fortran, Perl, shell scripts, Assembler, DCL, DB/C, Tcl/Tk, Forth, Lisp, COBOL, Occam, Basic, HTML, Clarion, and any other language that supports comments.
https://en.wikipedia.org/wiki/ROBODoc

Une analyse que je partage

Comparaison des langages de balisage (markup) léger (lightweight) : Txt2tags, Pandoc, Docutils, AsciiDoc, Deplate, Stx2any, AFT, Markdown et Textile:
http://fgallaire.flext.net/comparaison-langage-balisage-markup-lightweight-leger-txt2tags-pandoc-docutils-asciidoc-deplate-stx2any-aft-markdown-textile/

La bureautique est la principale utilisation de l’informatique depuis sa création. Pourtant, les outils majoritairement utilisés dans ce domaine, les logiciels de traitement de texte WYSIWYG comme LibreOffice ou MS word, laissent la majorité des informaticiens et des ergonomes totalement désespérés.
Ces logiciels ont en effet un nombre de défauts très important : ils font se concentrer sur la forme et non sur le fond, leur résultat final ne correspond souvent pas à ce qui est affiché, ils sont incompatibles entre eux, ce sont d’énormes usines à gaz, ils ne fonctionnent qu’en mode graphique, etc.

Il a donc fallu penser à une manière de donner ces instructions de mise en forme au sein du fichier texte lui-même, et c’est ainsi que sont apparus les langages de balisage (markup), dont les plus connus sont HTML (inventé en 1991 par Tim Berners-Lee) et LaTeX (créé en 1985, et basé sur TeX, inventé par le grand Donald Knuth en 1977), et dont la première grande figure fut Roff, un programme Unix historique développé à partir de 1961, et dont la version GNU, Groff, est installée par défaut sur toutes les distributions GNU/Linux, puisqu’on l’utilise encore pour les pages de man des logiciels.

Ces langages représentent une nette amélioration, mais ont tous un gros problème : ils sont gênants ! On ne retrouve plus aussi facilement son contenu au milieu de toutes ces balises supplémentaires, sans parler du fait que les syntaxes complexes ouvrent la voie à de nombreuses erreurs de compilation.

C’est en 1995 que l’on trouva la solution de ce problème, avec la création du premier langage Wiki, dont le but principal était de permettre l’édition facile de pages web par tout un chacun, et dont l’utilisateur actuel le plus célèbre est l’encyclopédie libre Wikipédia. S’il y a presque autant de syntaxes différentes que de logiciels Wiki, elles ont toutes la caractéristique d’utiliser des caractères textuels simples et intuitifs pour donner les indications de formatage du texte.
http://www.wikicreole.org/wiki/Reasoning

https://www.mediawiki.org/wiki/Help:Formatting
https://fr.wikipedia.org/wiki/Aide:Syntaxe_(wikicode)
https://fr.wikipedia.org/wiki/Aide:Ins%C3%A9rer_un_tableau_(wikicode,_avanc%C3%A9)
https://fr.wikipedia.org/wiki/Mod%C3%A8le:BUtilisateur
https://www.mediawiki.org/wiki/MediaWiki/fr

J'ai toujours aimé le principe du "folding editor".
le premier fut STET  'STructured Editing Tool' de 1977
https://en.wikipedia.org/wiki/STET_(text_editor)
A folding editor is a text editor which supports text folding or code folding, a mechanism allowing the user to hide and reveal blocks of text—usually named. Typically this is done to allow the user to better picture the overall structure of a document or program.
Folding is provided by many modern text editors, and syntax-based or semantics-based folding is now a component of many software development environments...
https://en.wikipedia.org/wiki/Folding_editor


Mais pourquoi limiter ces langages de balisage léger à la seule génération de HTML ? Pourquoi ne pas utiliser la même syntaxe pour différentes cibles (appelées backends, targets ou writers selon les logiciels), de manière à obtenir aussi bien une page web en HTML, qu’un document en LaTeX pour l’impression, ou qu’une page de man pour un logiciel ? Ce sont les logiciels qui poursuivent ce but qui m’intéressent, ils constituent pour moi l’avenir de la bureautique informatique, et j’ai été amené à les comparer pour en choisir un dans lequel m’investir comme développeur.

Trois d’entre eux, Docutils, Deplate et Pandoc, ont un design évolué, avec une machine à états finis pour laquelle on peut écrire de nouveaux readers et writers de manière parfaitement propre. Cependant, malgré leurs grandes qualités, Deplate est un projet trop confidentiel (ainsi il n’est incompréhensiblement pas présent parmi les pourtant si nombreux paquets Debian), et je ne me sentais pas à la hauteur pour m’investir dans un projet comme Pandoc, totalement écrit en Haskell, qui est un langage de programmation complexe que j’aimerais beaucoup utiliser.
Je détaillerai Pandoc ci-dessous.

Txt2tags

J’ai rajouté dans ce comparatif Markdown et Textile, puisqu’ils ont chacun une implémentation en Python, mais ne générant que du HTML, ils ne m’intéressaient pas vraiment. AsciiDoc et Txt2tags ont un peu la même architecture, avec un gros fichier principal faisant tout le travail, que l’on peut configurer, respectivement avec un fichier .conf et deux dictionnaires Python (un pour les Tags et l’autre pour les Rules), pour créer de nouvelles cibles. AsciiDoc et Txt2tags sont donc plus aisés à prendre en main et à modifier rapidement que Docutils, qui est une très belle et très bien architecturée machine à états objet, mais aussi plus difficile à appréhender.
De plus, comme je désapprouvais totalement la politique de licence domaine publique de Docutils, il ne me restait plus qu’à faire mon choix entre Txt2tags et AsciiDoc. C’est principalement l’orientation très DocBook (un format ne m’intéressant personnellement pas du tout) d’AsciiDoc, et d’autres détails, comme la localisation en de nombreuses langues de Txt2tags et sa plus grande simplicité, qui m’ont finalement fait choisir Txt2tags.

Ce choix est confirmé par une étude plus avancée des différentes syntaxes. Ainsi alors que la syntaxe reST de Docutils ne dispose que de :

*italique* et **gras**

Txt2tags est beaucoup plus riche :

//italique// **gras** __souligné__ et --barré--

Le codage visuel est bien meilleur, et le compréhension instantanée avec la syntaxe de Txt2tags, puisque les slashs donnent l’impression penchée de l’italique, les étoiles imitent la surcharge du gras, les underscores donnent l’impression de soulignement, et les moins apparaissent comme une barre. De plus, l’utilisation généralisée des caractères de balisage en doubles, permet de lever à peu de frais un maximum d’ambiguïtés syntaxiques.

insertion d'une image est beaucoup plus simple Txt2tags
[[picture.png] http://fgallaire.flext.net]

Leur implémentation en Python permet à Txt2tags, reST (par Docutils) et AsciiDoc d’être utilisables à la fois comme logiciels de bureautique multiplateforme (Linux, Mac OS X, Windows et *BSD) et pour le web côté serveur. Depuis 2012, une implémentation de txt2tags en PHP est disponible, développée par Petko Yotov (le mainteneur et principal développeur de PmWiki) et sponsorisée par Eric Forgeot. Grâce aux nombreux efforts de ce dernier, il existe maintenant plusieurs implémentations de la syntaxe Txt2tags en JavaScript, avec une démo parfaitement fonctionnelle des possibilités de rendu côté client en temps réel. Et Matthew Pickering a quant à lui écrit un reader Txt2tags pour Pandoc.

En face, Markdown est représenté par une armada d’implémentations dans tous les langages utilisés sur le web côté serveur, et aussi en JavaScript côté client pour des prévisualisations efficaces sans Ajax, mais seul Pandoc, qui n’est pas si facile à compiler sur toutes les plateformes, propose autre chose qu’un rendu en HTML.

Je vais bien sûr continuer à travailler sur le logiciel Txt2tags, mais une implémentation de la syntaxe Txt2tags dans un parser Docutils, pour toucher directement toute la communauté des développeurs Python qui documentent leurs projets, et pouvoir bénéficier ensuite du sublime Sphinx, est un projet qui me motive de plus en plus.

Enfin, je suis toujours un peu nostalgique devant ce screenshot, parce que c’est en le voyant, avec en haut à gauche le fichier avec les balises, et en bas à droite celui avec le résultat texte brut, que j’ai pris conscience que Txt2tags faisait bien ce que j’espérais, et que comme en plus il était en Python, ce serait probablement le logiciel auquel j’allais contribuer !

Pandoc

Pandoc is a command-line tool. There is no graphic user interface. 

Pandoc is a Haskell library for converting from one markup format to another, and a command-line tool that uses this library. It can read Markdown, CommonMark, PHP Markdown Extra, GitHub-Flavored Markdown, MultiMarkdown, and (subsets of) Textile, reStructuredText, HTML, LaTeX, MediaWiki markup, TWiki markup, Haddock markup, OPML, Emacs Org mode, DocBook, Muse, txt2tags, Vimwiki, EPUB, ODT, and Word docx; and it can write plain text, Markdown, CommonMark, PHP Markdown Extra, GitHub-Flavored Markdown, MultiMarkdown, reStructuredText, XHTML, HTML5, LaTeX (including beamer slide shows), ConTeXt, RTF, OPML, DocBook, OpenDocument, ODT, Word docx, GNU Texinfo, MediaWiki markup, DokuWiki markup, ZimWiki markup, Haddock markup, EPUB (v2 or v3), FictionBook2, Textile, groff man, [groff ms], Emacs Org mode, AsciiDoc, InDesign ICML, TEI Simple, Muse and Slidy, Slideous, DZSlides, reveal.js or S5 HTML slide shows. It can also produce PDF output on systems where LaTeX, ConTeXt, pdfroff, or wkhtmltopdf is installed.

Pandoc's enhanced version of Markdown includes syntax for footnotes, tables, flexible ordered lists, definition lists, fenced code blocks, superscripts and subscripts, strikeout, metadata blocks, automatic tables of contents, embedded LaTeX math, citations, and [Markdown inside HTML block elements][Extension: markdown_in_html_blocks]. (These enhancements, described further under Pandoc's Markdown, can be disabled using the markdown_strict input or output format.)

In contrast to most existing tools for converting Markdown to HTML, which use regex substitutions, pandoc has a modular design: it consists of a set of readers, which parse text in a given format and produce a native representation of the document, and a set of writers, which convert this native representation into a target format. Thus, adding an input or output format requires only adding a reader or writer.

Because pandoc's intermediate representation of a document is less expressive than many of the formats it converts between, one should not expect perfect conversions between every format and every other. Pandoc attempts to preserve the structural elements of a document, but not formatting details such as margin size. And some document elements, such as complex tables, may not fit into pandoc's simple document model. While conversions from pandoc's Markdown to all formats aspire to be perfect, conversions from formats more expressive than pandoc's Markdown can be expected to be lossy.

This document is for people who are unfamiliar with command line tools. Command-line experts can go straight to the User’s Guide or the pandoc man page:

http://pandoc.org/getting-started.html

https://pandoc.org/MANUAL.html

Modules 

In contrast to most existing tools for converting Markdown to HTML, pandoc has a modular design: it consists of a set of readers, which parse text in a given format and produce a native representation of the document, and a set of writers, which convert this native representation into a target format. Thus, adding an input or output format requires only adding a reader or writer.

• Text
  • Text.Pandoc
    • Text.Pandoc.CSS
    • Text.Pandoc.Error
    • Text.Pandoc.MediaBag
    • Text.Pandoc.Options
    • Text.Pandoc.PDF
    • Text.Pandoc.Pretty
    • Text.Pandoc.Process
    • Readers
      • Text.Pandoc.Readers.CommonMark
      • Text.Pandoc.Readers.DocBook
      • Text.Pandoc.Readers.Docx
      • Text.Pandoc.Readers.EPUB
      • Text.Pandoc.Readers.HTML
      • Text.Pandoc.Readers.Haddock
      • Text.Pandoc.Readers.LaTeX
      • Text.Pandoc.Readers.Markdown
      • Text.Pandoc.Readers.MediaWiki
      • Text.Pandoc.Readers.Native
      • Text.Pandoc.Readers.OPML
      • Text.Pandoc.Readers.Odt
      • Text.Pandoc.Readers.Org
      • Text.Pandoc.Readers.RST
      • Text.Pandoc.Readers.TWiki
      • Text.Pandoc.Readers.TeXMath
      • Text.Pandoc.Readers.Textile
      • Text.Pandoc.Readers.Txt2Tags
    • Text.Pandoc.SelfContained
    • Text.Pandoc.Shared
    • Text.Pandoc.Templates
    • Text.Pandoc.UTF8
    • Writers
      • Text.Pandoc.Writers.AsciiDoc
      • Text.Pandoc.Writers.CommonMark
      • Text.Pandoc.Writers.ConTeXt
      • Text.Pandoc.Writers.Custom
      • Text.Pandoc.Writers.Docbook
      • Text.Pandoc.Writers.Docx
      • Text.Pandoc.Writers.DokuWiki
      • Text.Pandoc.Writers.EPUB
      • Text.Pandoc.Writers.FB2
      • Text.Pandoc.Writers.HTML
      • Text.Pandoc.Writers.Haddock
      • Text.Pandoc.Writers.ICML
      • Text.Pandoc.Writers.LaTeX
      • Text.Pandoc.Writers.Man
      • Text.Pandoc.Writers.Markdown
      • Text.Pandoc.Writers.MediaWiki
      • Text.Pandoc.Writers.Native
      • Text.Pandoc.Writers.ODT
      • Text.Pandoc.Writers.OPML
      • Text.Pandoc.Writers.OpenDocument
      • Text.Pandoc.Writers.Org
      • Text.Pandoc.Writers.RST
      • Text.Pandoc.Writers.RTF
      • Text.Pandoc.Writers.TEI
      • Text.Pandoc.Writers.Texinfo
      • Text.Pandoc.Writers.Textile
      • Text.Pandoc.Writers.ZimWiki
    • Text.Pandoc.XML

Ref.

https://hackage.haskell.org/package/pandoc

Pandoc’s enhanced version of Markdown 

Pandoc’s enhanced version of Markdown includes syntax for footnotes, tables, flexible ordered lists, definition lists, fenced code blocks, superscripts and subscripts, strikeout, metadata blocks, automatic tables of contents, embedded LaTeX math, citations, and Markdown inside HTML block elements. (These enhancements, described further under Pandoc’s Markdown, can be disabled using the markdown_strict input or output format.)

http://pandoc.org/MANUAL.html#pandocs-markdown

Tricks

you have a long markdown file in GitHub and want to have a TOC, you can use 

pandoc -t markdown_github --toc -o example-with-toc.md example.md

Using Markdown Templates

Math in Pure Markdown

https://github.com/jgm/pandoc/wiki/Pandoc-Tricks

Jupiter notebook project and nbconvert: web application that allows you to create and share documents that contain live code, equations, visualizations.

Open source, interactive data science and scientific computing across over 40 programming languages.

The Jupyter Notebook is a web application that allows you to create and share documents that contain live code, equations, visualizations and explanatory text. Uses include: data cleaning and transformation, numerical simulation, statistical modeling, machine learning and much more.

https://jupyter.org/
https://github.com/jupyter

https://github.com/jupyter/nbconvert
Notebooks can be shared with others using email, Dropbox, GitHub and the Jupyter Notebook Viewer.
http://nbviewer.jupyter.org/
This website does not host notebooks, it only renders notebooks available on other websites.

nbconvert: Convert Notebooks to other formats
https://nbconvert.readthedocs.io/en/latest/#

Using nbconvert enables:

• presentation of information in familiar formats, such as PDF.
• publishing of research using LaTeX and opens the door for embedding notebooks in papers.
• collaboration with others who may not use the notebook in their work.
• sharing contents with many people via the web using HTML.

Primarily, the nbconvert tool allows you to convert a Jupyter .ipynb notebook document file into another static format including HTML, LaTeX, PDF, Markdown, reStructuredText, and more. nbconvert can also add productivity to your workflow when used to execute notebooks programmatically.

some features

The Notebook has support for over 40 programming languages, including those popular in Data Science such as Python, R, Julia and Scala.

Code can produce rich output such as images, videos, LaTeX, and JavaScript. Interactive widgets can be used to manipulate and visualize data in realtime.

JATS Journal Archiving and Interchange Tag Library and tools convert from doc pdf, JATS editor

The Journal Article Tag Suite (JATS) is an XML format used to describe scientific literature published online.
It is a technical standard developed by the National Information Standards Organization (NISO) and approved by the American National Standards Institute with the code Z39.96-2012.

The NISO project was a continuation of the work done by NLM/NCBI, and popularized by the NLM's PubMed Central as an de facto standard for archiving and interchange of scientific open-access journals and its contents with XML.
With the NISO standardization the NLM initiative has gained a wider reach, and several other repositories, such as SciELO, adopted the XML formatting for scientific articles.
https://en.wikipedia.org/wiki/SciELO

The JATS provides a set of XML elements and attributes for describing the textual and graphical content of journal articles as well as some non-article material such as letters, editorials, and book and product reviews.JATS allows for descriptions of the full article content or just the article header metadata.
Ref:
https://en.wikipedia.org/wiki/Journal_Article_Tag_Suite

https://jats.nlm.nih.gov/publishing/

http://jats.nlm.nih.gov/archiving/tag-library/1.1/
Journal Archiving and Interchange Tag Library
NISO JATS Version 1.1 (ANSI/NISO Z39.96-2015)
December 2015
National Center for Biotechnology Information (NCBI)
National Library of Medicine (NLM)

As NISO JATS began the de facto and de juri standard for open access journals, the scientific community has adopted the JATS repositories as a kind of legal deposit, more valuable than the traditional digital libraries where only a PDF version is stored. 
Open knowledge need richer and structured formats as JATS: PDF and JATS must be certified as "same content", and the set "PDF+JATS" forming the unit of legal deposit.

List of JATS repositories and its contained:

PubMed Central: US PubMed Central: in 2016 ~3.8 million articles
SciELO: in 2016 ~0.6 million articles

So you want to adopt JATS. What decisions do you need to make?

ATS users must decide which model to use (Archiving, Publishing, Authoring), which table model to adopt, and how to handle math. In addition they should select a citation model and style, an approach to encoding contributor names and affiliations, an approach to multi-language names
http://jats4r.org/so-you-want-to-adopt-jats-what-decisions-do-you-need-to-make

An intimidating number of variations are available for JATS version 1.1[1]. Each of the following models is available in three grammars: DTD, XSD (W3C XML Schema), and RNG (RELAX NG):

• JATS Archiving with XHTML tables and MathML2
• JATS Archiving with XHTML tables and MathML3
• JATS Archiving with OASIS and XHTML tables and MathML2
• JATS Archiving with OASIS and XHTML tables and MathML3
• JATS Publishing with XHTML tables and MathML2
• JATS Publishing with XHTML tables and MathML3
• JATS Publishing with OASIS and XHTML tables and MathML2
• JATS Publishing with OASIS and XHTML tables and MathML3
• JATS Authoring with XHTML tables and MathML2
• JATS Authoring with XHTML tables and MathML3
• JATS Authoring with OASIS and XHTML tables and MathML2
• JATS Authoring with OASIS and XHTML tables and MathML3

The first question a new JATS user must answer is “What Color”, meaning which of the JATS tag sets to adopt. There are three JATS tag sets:

Journal Archiving and Interchange — usually called ‘Archiving’ and nicknamed: Green
Journal Publishing — usually called ‘Publishing’ and nicknamed: Blue
Article Authoring — usually called ‘Authoring’ and nicknamed: Pumpkin

And there is an associated tag set for books and book-like material:
Book Interchange Tag Set — usually called ‘BITS’ and nicknamed: Chocolate
(The nicknames are the colors of the documentation for each of the Tag Sets, and are used as shorthand for the names of the Tag Sets.)

Archiving

If existing documents, especially existing XML documents, are to be converted to JATS, Archiving is the most likely target. This is because Archiving is the most flexible, and it is likely to require less reorganization and regrouping of the existing content to convert it to XML according to Archiving than it would take to get the same material into the Publishing tag set. The archiving model even provides an element to record processing that may have been done in the pre-JATS XML (<x>), which may be useful to retain information from existing non-JATS XML documents. Archiving is intended for libraries and archives who must accept input from a wide variety of sources and convert that input to JATS (as expeditiously as possible).

Publishing

The Publishing tag set is a good choice for publishers converting content from non-XML source material, such as proprietary typesetting formats and word processing files. It enables the tagging of metadata that is created during the publishing process, such as publication date, journal, volume, issue, and page numbers, and is flexible enough to accommodate most publisher styles. Publishing is more restrictive than Archiving, which reduces the variation in the files, reduces the options available for tagging, and makes editing the XML files more comfortable.

If the user is going to use the JATS content to create new journal articles for search and display or for repurposing such as combining fragments of multiple documents into new documents, Publishing may be the best choice because the content will be in a more predictable and thus tractable form than if it were tagged using Archiving.

Authoring

A publisher soliciting new material from article authors in JATS probably wants to have them submit the Article Authoring tag set for incoming content. (Similarly, an author in some utopian future where XML tools are common on general purpose desktops, would use the Authoring tag set to create articles because it is not specific to any particular publisher or journal.) There are few other scenarios in which Authoring is appropriate.

The Authoring tag set was designed to allow as few tagging options as possible while enabling the expression of the full content of a journal article. Authoring does not provide tagging for metadata that will not be known at the time an article is authored, such as publication date, page number, history, or journal name.

Math

JATS provides several ways to encode mathematical expressions including: as a graphic, as text, as TeX or LaTeX, and in MathML2 or MathML3. It also allows the user to provide the same expression in two or more of these formats and identify them as alternative versions of the same expression.

Because the MathML2 and MathML3 models cannot coexist in the same tag set, users must choose one or the other, even if you have no math in your documents or plan not to use MathML to encode the math you have (perhaps choosing to use graphics or TeX or LaTeX instead of MathML).

Tools

There are a variety of tools for create, edit, convert and transform JATS. They range from simple forms to complete conversion automation.

DTD:
https://en.wikipedia.org/wiki/Document_type_definition

http://jatswiki.org/wiki/Tools

convert to JATS

Take as input a scientific document, and, with some human support, produce a JATS output.

OpenOffice (LibreOffice) and MS Word documents to JATS:

• eXtyles
  http://www.inera.com/extyles-products/extyles
  automates time-consuming aspects of document editing in Microsoft Word and exports to JATS XML (as well as many other DTDs).
• Article Authoring Add-in for Word (NLM JATS)
  As described at http://authoring.codeplex.com/ , "this add-in for Microsoft Word enables authors/editors to use Microsoft Office Word to create, edit, and save files in the National Library of Medicine's NLM DTD (article or book) format."
  Though released in 2012, it was developed many years ago.
• meTypeset
  https://github.com/MartinPaulEve/meTypeset
  "is a fork of the OxGarage stack" "to convert from Microsoft Word .docx format to NLM/JATS-XML". It is implemented as part of the PKP XML parsing stack.
• OxGarage can convert documents from various formats into "National Library of Medicine (NLM) DTD 3.0" (as well as various other formats)
  http://www.oucs.ox.ac.uk/oxgarage/
• Open Typesetting Stack (PKP XML Parsing Service)
  The Open Typesetting Stack (formerly the PKP XML Parsing Service: sourcecode, https://github.com/pkp/xmlps beta site with free SaaS conversion from .doc or .pdf (pdfs must have embedded text (i.e. created from an already-digital document); scanned PDFs must have been OCRed before being uploaded to our service)  http://pkp-udev.lib.sfu.ca/) converts Word/pdf documents to NLM DTD 3.0 XML, HTML, and PDF using meTypeset and other tools. As of April 2015, it's in beta, with metadata parsing disabled because of poor results. A plugin is being developed for Open Journal Systems (OJS) that will call this service.
  For more information, see a paper presented at JATS-Con 2015. https://www.ncbi.nlm.nih.gov/books/NBK279666/

   SaaS:

  The Migrate JATS service enables journal, academic and book publishers to automate the conversion of MS Word documents to the Journal Article Tag Suite (JATS) specification, in the cloud.

   http://www.stilo.com/migrate-jats/

PDF to JATS: 
this is a very difficult problem to solve. Success depends on how well structured your PDFs are and, for batch conversion, how consistently structured your PDFs are.

• Shabash Merops
• The Public Knowledge Project is developing a pipeline for converting PDF to JATS. It will include use of pdfx.

Markdown to JATS: pandoc's "pandoc-jats" plugin

Editors

• JATS Framework for oXygen XML Editor: users of oXygen XML Editor and oXygen XML Author can now install support for current versions of NISO JATS (and as a bonus, NLM BITS). Based on an identifier given in a DOCTYPE declaration, oXygen will detect that you are editing a JATS document and provide stylesheets and utilities.
• FontoXML for JATS: WYSIWYS editor for editing and reviewing JATS content
• PubRef "Pipeline": Browser-based realtime-preview JATS editor
• Annotum:[30] a WordPress theme that contains WYSIWYG authoring in JATS (Kipling subset), peer-review and editorial management, and publishing.
• JATS edition for web-based XML editor Xeditor.
• Texture Editor of the Substance Consortium

Preview

Tools that render JATS as HTML, usually on fly.

• JATS Preview Stylesheets: the JATS Preview Stylesheets are a series of .xsl, .xpl, .css, and .sch files that will create .html or .pdf versions of valid NISO Z39.96-2012 JATS 1.0 files. It is primarily intended for internal use by publishers and a basis for customization.
• PubReader – "The PubReader view is an alternative web presentation ... Designed particularly for enhancing readability on tablet and other small screen devices, PubReader can also be used on desktops and laptops and from multiple web browsers".

Customization

Jatsdoc produces documentation for any particular JATS customization. Jatsdoc is integrated with NCBI's DtdAnalyzer.

Ref:
https://en.wikipedia.org/wiki/Journal_Article_Tag_Suite
http://jats4r.org/so-you-want-to-adopt-jats-what-decisions-do-you-need-to-make

Conference JATS

JATS-Con 2015 Schedule with Abstracts

https://jats.nlm.nih.gov/jats-con/2015/schedule2015a.html
---
-
Automating Complex High-Volume Technical Paper and Journal Article Page Composition with NLM XML and InDesign
Becky Fadik, SAE International
Brian Trombley, Data Conversion Laboratory
SAE International is a global association of more than 138,000 engineers and related technical experts in the aerospace, automotive and commercial-vehicle industries. Annually, SAE organizes and manages an industry conference, its World Congress and Exhibition, where thousands of technical papers and journal articles are presented as part of the conference program. Leading up to the Word Congress, the technical papers and journal articles are reviewed for compliance to SAE publishing requirements and published for print and made available online in a very short time-frame. This paper describes how SAE evolved the production cycle from a less than efficient XSL-FO based process to a highly automated process leveraging NLM XML, XSLT and Adobe InDesign resulting in productivity gains and higher quality output. This paper will take you through the evolution of this project and talk to future enhancements aimed at driving additional benefits.
-
Full paper: https://www.ncbi.nlm.nih.gov/books/NBK279830/
Materials (powerpoint): https://jats.nlm.nih.gov/jats-con/2015/presentations/FADIK-TROMBLEY.ppsx
video: https://videocast.nih.gov/summary.asp?Live=16114&start=2140
---
The Public Knowledge Project XML Publishing Service and meTypeset: Don't call it "Yet Another Word to JATS conversion kit"
Alex Garnett, Simon Fraser University
Juan Pablo Alperin, Simon Fraser University
John Willinsky, Stanford University
The Public Knowledge Project's Open Journal Systems, which provides a robust workflow and interface for editing, publishing, and indexing scholarly journal content, has always been somewhat agnostic as to the format of the content itself. Most authors, unsurprisingly, use Microsoft Word for its familiarity and ubiquity during the actual writing process, and the act of getting content from Word format into something that can be easily consumed on the web after that has always been something of a mystery among publishers. Those who have the means will typically outsource or partially automate the markup of an article in XML or an XML-like format, and this XML can then be transformed into HTML on the fly for viewing (OJS does include some stylesheets for this purpose); others, including many smaller open source journals, convert directly to the printable PDF format as a path of least effort, leaving them with something that looks nice on a printed page but potentially not so nice and not too flexible otherwise. For the past two years, PKP has been working on a web service (which integrates into OJS' workflow via a provided plugin) to fully automate the conversion of Word/compatible documents into the National Library of Medicine's standard JATS XML format (the same format which underlies PubMed Central), using fuzzy parsing and machine learning heuristics, and transform documents from there into matching human-readable HTML and PDF. This development, broadly speaking, takes two parts: one, the core OpenOffice/Word 2007 "docx" XML to JATS XML conversion engine, called "meTypeset" developed jointly with Martin Eve of the Open Library of the Humanities, and two, the web service pipeline, which unites meTypeset and other open-source libraries (including LibreOffice, ParsCit, ExifTool, and others). This service provides citation parsing, XMP metadata, and other industry-standard features. Improvement of various parsing features and automated evaluation is ongoing.
-
Full paper: https://www.ncbi.nlm.nih.gov/books/NBK279666/
Materials (powerpoint): https://jats.nlm.nih.gov/jats-con/2015/presentations/JATS2015garnett.pdf
video: https://videocast.nih.gov/summary.asp?Live=16114&start=5130
---
All Aboard! Round-tripping JATS in an HTML-based online CMS and editing platform
Wendell Piez, Piez Consulting Services
In a project just starting up, we are endeavoring to convert JATS (or actually near-NLM-Book) data into HTML for an HTML-based CMS, where the documents (structured reference material in short articles) will be edited (in the usual sort of web-based HTML editor) -- and then must be siphoned back up into the JATS-like textbase, for further processing using JATS-based tools.
Going both ways presents many interesting theoretical and technical challenges. This paper will describe the design principles we are following, with our solutions and findings by next April.
-
Full paper: https://www.ncbi.nlm.nih.gov/books/NBK279900/
Materials (powerpoint): https://jats.nlm.nih.gov/jats-con/2015/presentations/Piez-JATSCon2015/jats-con-slides.html
video: https://videocast.nih.gov/summary.asp?Live=16114&start=7320
---
Improving the reusability of JATS
Jeff Beck, NCBI/NLM/NIH
John Chodacki, PLoS
Alf Eaton, PeerJ
Michael Evans, F1000
Rupert Gatti, Open Book Publishers
James Gilbert, eLife
Melissa Harrison, eLife
Christopher Maloney, NCBI/NLM/NIH
Daniel Mietchen, Museum für Naturkunde Berlin; NCBI/NLM/NIH
Tom Mowlam, Ubiquity Press
JATS4R Working Group,
Despite a fair degree of standardization, JATS is still not used consistently across publishers, which inhibits harvesting and reuse of JATS-tagged materials. To address these issues, a working group has been formed to evaluate existing flavours of JATS and to harmonize them by issuing recommendations on how reuse-relevant tags should be used and on how documentation and guidelines can be clarified. Besides establishing communication channels and working out procedures, the group has already tackled some specific tagging issues, most notably the machine readability of license statements and of mathematics in journal articles.
-
Full paper: https://www.ncbi.nlm.nih.gov/books/NBK279901/
Materials (powerpoint): https://jats.nlm.nih.gov/jats-con/2015/presentations/jats4r.ppsx
video: https://videocast.nih.gov/summary.asp?Live=16114&start=12775
---
The Long Road to JATS
Paul Donohoe, Macmillan Science and Scholarly
Jenny Sherman, Macmillan Science and Scholarly
Ashwin Mistry, Macmillan Science and Scholarly
Nature Publishing Group/Palgrave has over a million articles, 180 journals, three in-house DTDs, numerous workflows and production systems, as well as teams based across the world. The challenge: How do we move to using JATS as our single DTD, introduce a streamlined production process and increase the number of journals we publish? This paper describes our journey so far, the challenges we faced, the XML tools we have used, the decisions we made and the reasons for them, and the work still to be done.
-
Full paper: https://www.ncbi.nlm.nih.gov/books/NBK279831/
Materials (powerpoint): https://jats.nlm.nih.gov/jats-con/2015/presentations/The-long-road-to-JATS.ppsx
video: https://videocast.nih.gov/summary.asp?Live=16114&start=17465
---
Adapting JATS to support data citation
Daniel Mietchen, Museum für Naturkunde Berlin; NCBI/NLM/NIH
Johanna McEntyre, EBI
Jeff Beck, NCBI/NLM/NIH
Christopher Maloney, NCBI/NLM/NIH
Force11 Data Citation Implementation Group,
Data are often not cited in a consistent fashion. To address this, Force 11 have developed the Data Citation Principles. JATS 1.1d1 has provisions for citing articles and other sources, but does not offer straightforward ways of expressing some of the concepts needed for data citation. In order to facilitate the citation of data in JATS-tagged documents in a way that is compliant with the Data Citation Principles, the Force11 Data Citation Implementation Group held a meeting in June, at which several new elements, attributes and values for attributes have been suggested to be added to JATS. These have since been submitted to the JATS Standing Committee, which largely accepted them, so they are now included in JATS 1.1d2. This talk will explain the decision criteria behind the elements that were proposed, and how they were selected for JATS 1.1d2. It will in addition provide suggested examples for use of the new tags.
-
Full paper: https://www.ncbi.nlm.nih.gov/books/NBK280240/
Materials (powerpoint): http://en.wikipedia.org/wiki/User:Daniel_Mietchen/Talks/JATS-Con_2015
video: https://videocast.nih.gov/summary.asp?Live=16116&start=73
---
---

JATS-Con 2016 Schedule with Abstracts

https://jats.nlm.nih.gov/jats-con/2016/schedule2016a.html

no full paper, no materials, no video, only abstract.
---
A Quality Assurance Tool for JATS/BITS with Schematron and HTML reporting
Martin Kraetke, le-tex publishing services GmbH
Franziska Bühring, De Gruyter
De Gruyter adopted the JATS/BITS schema for journal content and established De Gruyter specific XML guidelines for creating XML metadata and full text data. Together with le-tex, De Gruyter developed a submission checker to validate the data quality of book and journal packages delivered from their service vendors. The tool is based on the Open Source software Talend and Transpect.
The submission checker verifies the consistency of metadata, validates against the JATS schema and De Gruyter's business rules, which are specified with Schematron. An HTML report provides a rendering of the source files with the error messages. The messages are displayed at the error location and are grouped by their severity. Content passing the check is forwarded for archiving and publication. It guarantees a technically correct rendering of the content on degruyter.com and facilitates the retrieval and processing for future purposes.
---
So You Want to Adopt JATS. What Decisions Do You Need To Make?
B. Tommie Usdin, Mulberry Technologies, Inc.
Newcomers to JATS need to make decisions about which tag set to use (Authoring, Publishing, or Archiving), which table model to adopt, and how to handle math. In addition, they should consider citation model and style, contributor names and affiliations, alternative languages and encodings, and adoption of tagging guidelines from PMC, JATS4R, and/or their publishing partners.
---
Collecting XML at article submission at eLife: Two steps forward, one step back?
Melissa Harrison, eLife
When eLife was launched in 2012, almost all article metadata was collected from what the corresponding author entered into the submission form. These data were converted to JATS XML at acceptance. We will describe the benefits and limitations of this approach, and how and why we have reverted to a more traditional method of using an author's Word file to generate elements of the XML metadata within the production process for the final full-text XML/HTML version of record. However, we also publish the accepted manuscript PDF for approximately 60% of accepted articles, and this process still relies on the metadata entered via the submission system to generate the HTML heading and metadata information online. We will discuss aspects of the peer-review process and submission system that affect the acquisition and conversion of article metadata for both accepted article PDFs and the final version of record, and the challenges we encountered in our efforts to streamline the production process and improve the end-to-end author experience. We will describe our new production process and the conversion of Word to HTML at the point of acceptance, and how we could extend this to the peer-review workflow to minimise duplication of effort in the process of metadata acquisition.
---
An implementation of BITS: The Cambridge University Press experience
Mike Eden, Cambridge University Press
Tom Cleghorn, Cambridge University Press
Cambridge University Press's history of using mark-up for academic book content resulted in a proprietary model, loosely based on NLM DTDs. With new requirements and new types of content, the DTD and related business rules were added to. These changes became frequent and unpredictable, creating pain-points in production workflows and resulting in a heavy burden, both internally, in keeping automated processes up-to-date, and externally, in maintaining suppliers' knowledge.
A decision was taken to review the situation. Outside consultants were engaged to perform the review. It became clear that the choice of model and its manner of use constituted only one part of the picture, and that a review of the entire process would be beneficial.
BITS was chosen as the DTD to use, rather than redefining proprietary DTDs. As an emerging industry standard, it is closely aligned with the Journals NISO standard (NISO Z39.96-2012), already in use at CUP. It was also felt that as the standard grew, benefits would arise from the input and requirements of other publishers.
During implementation, consideration was given to, among other aspects:

• control of use (sub-setting or Schematron)
• use of MathML and other similar standards
• schemes for persistent element identification
• approaches to metadata encoding
• output intentions and specifications

Workflows were amended from copy editorial through to final delivery, with an emphasis on control of mark-up throughout. This resulted in a considerably better-defined and predictable process for external providers and internal stakeholders, and has resulted in the creation of a robust foundation for book production into the future.
---
Wrangling Math from Microsoft Word into JATS XML Workflows
Caitlin Gebhard, Inera, Inc.
Bruce Rosenblum, Inera, Inc.
Mathematics is a fundamental building block of modern technology, research, and industry, and yet the technological means of communicating mathematics is still surprisingly primitive. As a result, anyone involved in producing, publishing, or reading mathematical equations electronically knows that it is not a simple process.
The majority of scholarly papers are authored today in Microsoft Word. Some of those papers include simple and/or complex math. Authors have multiple means at their disposal to insert equations in Word documents including several of Word's native equation editors and third-party applications like Design Science's MathType. Building workflows that smoothly and accurately transform all of these formats into the appropriate XML markup for use in multiple rendering environments has many challenges.
This paper will clarify the different forms of equations that can be encountered in Word documents, and discuss the issues and idiosyncrasies of converting these various forms to MathML, LaTeX, and/or images in the JATS XML model. It will also touch on workflow alternatives for handling of equations in various rendering environments and how those downstream requirements may affect the means of equation extraction from Word documents.
---
JATSKit: An oXygen framework for JATS, BITS, and kindred XML formats
Wendell Piez, Piez Consulting
JATSKit is the newly improved oXygen XML Editor framework supporting NISO JATS and now NLM/NCBI BITS XML. With support for conversions of JATS and BITS data into HTML, EPUB and PDF. In addition to one-button publication, new features in the oXygen Author user interface include fielded entry for structured data elements, Schematron validation and QuickFixes, collapsible display of structural elements, more button controls and more. Everything is customizable and extensible.
---

courte analyse du code "markdown odyssey.js" et ajout popup tooltip icon

http://cartodb.github.io/odyssey.js/

il y a des fonctionnalités "cachées" (c'est du leaflet.js):

pour avoir des tooltips (hover) et popup, on peut faire dans le markdown:
L.marker([40.7348, -73.9970],{title:"I am a tooltip"}).bindPopup("<b>Hello world!</b><br>I am a popup.").actions.addRemove(S.map)

et une fonction associée:
L.marker([40.7348, -73.9970]).on("click", function(e){alert("You clicked the map at " + e.latlng);}).actions.addTo(S.map)
Ici cela ouvre une fenêtre "alert" (avec un bouton "OK"):
          cartodb.github.io indique :
          You clicked the map at LatLng(40.7348, -73.997)

Ref: https://github.com/CartoDB/odyssey.js/issues/171

on a aussi :
ce que fait le bouton "add":
L.marker([37.7620, -122.4385]).actions.addRemove(S.map)
Creates an action that adds the marker instance to the specified map when the story enters in the action and removes when the story leaves it.
mais on a aussi:
L.marker([37.8250, -122.0430]).actions.addTo(S.map)

http://cartodb.github.io/odyssey.js/documentation/#leaflet-object
On peut donc mettre du html après L.marker dans le fichier markdown avec la structure leaflet.js.

pour de l'audio:
L.marker([44.7348, -67.5645],{title:"I am a tooltip", opacity: 0.5}).bindPopup('<b>Hello world</b><br>  <mark> blue </mark><span style="color:blue">blue</span>..............................................................................................<br><audio controls autoplay loop> <source src="http://www.zapsplat.com/wp-content/uploads/2015/sound-effects-blastwave-fx/Blastwave_FX_ChurchBells_BW.60957.mp3" type="audio/mpeg">Your browser does not support the audio tag.</audio>').actions.addRemove(S.map)

pour un lien vers une image:
L.marker([40.7348, -73.9970],{title:"I am a tooltip", opacity: 0.7}).bindPopup('<b>Hello world</b><br>
<span style="color:blue">blue</span>..........................................................................................<br>
<a href="http://farm6.staticflickr.com/5344/25373090639_4a33c061fe_h.jpg"><img src="http://farm6.staticflickr.com/5344/25373090639_4a33c061fe_n.jpg" alt="Icon"></a>').actions.addRemove(S.map)

pour les video youtube par exemple:
<iframe width="480" height="360"src="https://www.youtube.com/embed/AekYJ62Knno?autoplay=1"></iframe>
elle déborde en largeur car pour la fenêtre popup, par défaut
maxWidth= 300 Max width of the popup.
minWidth= 50 Min width of the popup.
maxHeight= null If set, creates a scrollable container of the given height inside a popup if its content exceeds it.
http://leafletjs.com/reference.html#popup


Si le media dépasse 340px de large, il faut passer à autre chose qu'un simple bindPopup("<b>Hello world!</b><br>") mais aller en plus dans les options du popup:
L.marker([44.7348,-69.96]).bindPopup(L.popup({maxWidth:500}).setContent(
'<b>video with width=480 and L.popup maxWidth:500 </b><mark>OK</mark><br><span style="color:blue">blue</span>...<br><iframe width="480" height="360" src="https://www.youtube.com/embed/AekYJ62Knno?autoplay=1"></iframe>'
)).actions.addRemove(S.map)

utiliser maxWidth: "auto"

pour une video
L.marker([44.7348,-68.96],{title:"I am a tooltip for video", opacity: 0.7}).bindPopup(L.popup({maxWidth:500}).setContent('<b>video with width=480 and L.popup maxWidth:500 </b><mark>OK</mark><br><span style="color:blue">blue</span>...........................................................................<br><iframe width="480" height="360" src="https://www.youtube.com/embed/QmES8eumLa8?autoplay=1"></iframe>')).actions.addRemove(S.map)

pour l'icône des marqueurs:
L.marker([44.7348, -67.5655], {icon:L.icon({iconUrl:'https://raw.githubusercontent.com/Concept211/Google-Maps-Markers/master/images/marker_blue7.png',iconSize: [22, 40], iconAnchor: [12, 39]})}).actions.addRemove(S.map)
```
L.marker([44.7348, -67.5655], {icon:L.icon({iconUrl:'https://raw.githubusercontent.com/Concept211/Google-Maps-Markers/master/images/marker_blue7.png',iconSize: [22, 40], iconAnchor: [12, 39]})}).actions.addRemove(S.map)


**from GitHub**
https://raw.githubusercontent.com/Concept211/Google-Maps-Markers/master/images/marker_blue7.png


**from your blogspot**
https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjVWF7sYMJQpYwjWXRtpJPXgwB-HSk7dsbWlwlJ_KROyrSKKY70rwi5X_IHO49XjA77L1gfTDMzfHNsXKxQH6vAE6u467Sm0e1-LajztXNlJ4KVvdRPD40zKnwydqONHXWN1Xq1vS4TO5bT/s1600/church-2.png

**random with Placeholder Images **
L.marker([44.7348, -67.5655], {icon:L.icon({iconUrl:'http://lorempixel.com/64/64/',})}).actions.addRemove(S.map)

Sandbox html: cartodb.github.io/odyssey.js/sandbox

Lorsque l'on arrive sur la page  "slides" "Your first odyssey.js story", nous avons sur une page html (avec CSS et javascript interne et externe) hébergé par GitHub que tout compte peut réaliser de type:
http://cartodb.github.io/odyssey.js/sandbox avec username.github.io puis sa repository.

Dans le head, le titre de cette page est <title>Odyssey.js Sandbox</title>

A/ La liste des librairies js utilisées dans le "head":

http://cartodb.github.io/odyssey.js/vendor/modernizr-2.6.2.min.js
    https://modernizr.com/
    Modernizr tells you what HTML, CSS and JavaScript features 
    the user’s browser has to offer.
   dec 2016=latest version:  3.3.1

B/dans les scripts:

http://d3js.org/queue.v1.min.js
       Data-Driven Documents= D3; https://d3js.org/
       D3.js has been extensively used for GIS map making, managing both GeoJSON 
       and Topojson files as input.   https://en.wikipedia.org/wiki/D3.js
http://cartodb.github.io/odyssey.js/dist/odyssey.js
http://cartodb.github.io/odyssey.js/vendor/d3.js
    version: "3.3.10";  dec 2016= the latest version (4.4.0)
http://cartodb.github.io/odyssey.js/vendor/codemirror/codemirror.js
http://cartodb.github.io/odyssey.js/vendor/codemirror-markdown.js
    // CodeMirror version 3.22
    // CodeMirror is the only global var we claim
   CodeMirror is a versatile text editor implemented in JavaScript for the browser. 
   It is specialized for editing code, and comes with a number of language modes
   (>100, also Markdown) and addons 
   that implement more advanced editing functionality.
   It is the editor used in the dev tools for both Firefox and Chrome
    https://codemirror.net/
  Cela permet d'avoir le code markdown en couleur...
http://cartodb.github.io/odyssey.js/vendor/jszip.js
    les fonctions .zip (bouton "download story" qui sauve en .zip
http://cartodb.github.io/odyssey.js/vendor/ZeroClipboard.min.js
    * The ZeroClipboard library provides an easy way to copy text to the clipboard 
       using an invisible Adobe Flash movie and a JavaScript interface.
     * http://zeroclipboard.org/
     * v1.3.5  (now dec 2016, Current config: v2.2.0)
http://cartodb.github.io/odyssey.js/dist/sandbox.js

../vendor/jquery-1.10.2.min.js; /vendor/jquery.imageload.js; ./vendor/jquery.spriteanim.js célèbre jquery librairie... Juste un mot sur ce odyssey.js/vendor/markdown.js (un fork) qui est de 2013/09: https://github.com/cadorn/markdown-js https://github.com/evilstreak/markdown-js/ C'est un analyseur markdown pour JavaScript.  Vous entrez du markdown et obtenez du HTML en out.  Quelques points de vue sur le code:  produire du HTML bien formé. Cela signifie que em et strong nesting est important, de même que la capacité de sortie en tant que HTML et XHTML  une représentation intermédiaire pour permettre le traitement des données analysées (nous avons en fait deux, à la fois JsonML: un arbre markdown et un arbre HTML ). http://www.jsonml.org/ JSON Markup Language (JsonML). Étant facilement extensible pour ajouter de nouveaux dialectes sans avoir à réécrire la mécanique d'analyse entière. il est bien documenté... https://github.com/CartoDB/odyssey.js/search?utf8=%E2%9C%93&q=markdown.toHTML a fonction fondamentale est "markdown.toHTML" Dans odyssey.js, il y est 5 fois: https://github.com/CartoDB/odyssey.js/blob/59e194e8cf18154d095f004e01f955b6af9348f9/dist/odyssey.js aux lignes 1071 : _slide.html = function() {     if (!html) {       html = markdown.toHTML(['markdown'].concat(md_tree));     }     return html;   }; 5389: /** * toHTMLTree( markdown, [dialect] ) -> JsonML * toHTMLTree( md_tree ) -> JsonML * - markdown (String): markdown string to parse * - dialect (String | Dialect): the dialect to use, defaults to gruber * - md_tree (Markdown.JsonML): parsed markdown tree * * Turn markdown into HTML, represented as a JsonML tree. If a string is given * to this function, it is first parsed into a markdown tree by calling * [[parse]]. **/ Markdown.toHTMLTree = function toHTMLTree( input, dialect , options ) { 5418: /** * toHTML( markdown, [dialect] ) -> String * toHTML( md_tree ) -> String * - markdown (String): markdown string to parse * - md_tree (Markdown.JsonML): parsed markdown tree * * Take markdown (either as a string or as a JsonML tree) and run it through * [[toHTMLTree]] then turn it into a well-formated HTML fragment. **/ Markdown.toHTML = function toHTML( source , dialect , options ) { 6724: expose.toHTML = Markdown.toHTML;   expose.toHTMLTree = Markdown.toHTMLTree; C/ un petit js de 10lignes  initAnim Dans le body un iframe qui renvoie sur un html pour l'initialisation http://cartodb.github.io/odyssey.js/sandbox/slides.html et 2 div dont le "share_dialog" d'inialisation ---- Si on inspecte les éléments DOM avec le CSS. Il y a 4 grandes structures. Dans la iframe "map" class="leaflet-container leaflet-fade-anim" div class="leaflet-map-pane" (carte "baseMap liée au début du fichier markdown) "slides_container" le cadre avec texte de l'histoire qui s'affiche qui contient 3 sous-cadres: "dots" pour aller d'une slide à l'autre "slides" la narration avec le texte+image+URL "navButtons" les flèches préc et suivante "credits": c'est la barre en bas avec "title et "author" (liés au début du fichier markdown) Après les scripts, on a un div "editor_modal".  Ce cadre/DOM contient 4 div: "header" (barre en haut) qui contient 2 choses un bouton "expandButton" qui étend ou réduit cette fenêtre un bouton "show_slide"qui renvoie sur la page de choix du template slides/scroll... "options" qui est la barre d'en bas qui contient 2 <ul> (<ul> tag defines an unordered (bulleted) list) qui ont des popups: "h_left" : bouton "?" qui renvoie sur l'URL documentation" et                 bouton qui renvoie sur "change map" "h_right" : avec les 3 boutons en bas à droite   qui renvoie  sur des events "toggle collapse mode", "download story" et "share story". "actions_bar"  (barre à gauche) il y a un ::before et ::after car c'est une zone qui se déroule. L'apparence y montre les boutons qui permettent 3 choix dont mettre un marqueur  sur la carte mais en fait ces boutons forment une classe "actionButton".  class="CodeMirror cm-s-default CodeMirror-wrap" il y a un ::before et ::after car c'est une zone qui se déroule. Elle contient des zones "collapsées" de la structure de codemirror, mais 3 structures y sont: "CodeMirror-vscrollbar" sur la droite "CodeMirror-scroll"  qui contient le texte  "actionButton" sur la gauche avec 3 choix dont mettre un marqueur  sur la carte En fait la liste des dépendances est plus importante: https://libraries.io/github/CartoDB/odyssey.js  package.json Requirements Latest Stable Latest Release Licenses browserify ^4.1.5 13.1.1 13.1.1 MIT d3 3.3.10 4.4.0 4.4.0 BSD-3-Clause hammerjs ~1.1.3 2.0.8 2.0.8 MIT phantomjs ~1.9.0 2.1.7 2.1.7 Apache-2.0 smash 0.0 0.0.15 0.0.15 BSD-3-Clause https://libraries.io/npm/hammerjs A javascript library for multi-touch gestures https://libraries.io/npm/phantomjs Headless WebKit with JS API https://libraries.io/npm/smash Concatenate files together using import statements. This project has been marked as deprecated and is not recommended for use anymore.