@amermathsoc/texml-to-html 15.0.0

package/lib/helpers/extractContribGroups.js

@@ -0,0 +1,94 @@
+/*!
+ *  Copyright (c) 2023 American Mathematical Society
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * 
+ * @param {node} contrib - contrib element node
+ * @returns {String}
+ */
+const extractContribName = (contrib) => {
+    let fullName = ''
+    // NAME
+    const maybeGivenNames = contrib.querySelector('name>given-names');
+    const maybeSurname = contrib.querySelector('name>surname');
+    const maybeSuffix = contrib.querySelector('name > suffix');
+    const maybeStringname = contrib.querySelector('string-name');
+    // NOTE we prefer stringname, cf. AmerMathSoc/texml#69
+    if (maybeStringname) {
+        fullName = maybeStringname.textContent;
+    }
+    else if (maybeSurname) { // NOTE: given-names are optional
+        fullName = `${maybeGivenNames ? maybeGivenNames?.textContent + '\u00A0' : ''}${maybeSurname.textContent}`;
+    }
+    if (maybeSuffix) fullName = fullName + (maybeSuffix.textContent[0] === ',' ? '' : '\u00A0') + maybeSuffix.textContent;
+    return fullName;
+}
+
+/**
+ * 
+ * @param {Node} articleMetaNode - a node with contrib-group descendants
+ * @returns {Object}
+ */
+export function extractContribGroups(articleMetaNode) {
+
+    // TODO: move out of scope // fix `this` 
+    const extractContribAffiliation = (contrib, xref) => {
+        const aff = contrib.ownerDocument.querySelector(`#${xref.getAttribute('rid')}`);
+        let prefix = '';
+        if (aff.getAttribute('specific-use') === 'current') prefix = '<span>Address at time of publication:</span> '; //NOTE: whitespace at end is intentional.
+        return prefix + this.passthroughIntoHTMLString(aff);
+    }
+    const extractContribAffiliations = (contrib) => {
+        return [...contrib
+            .querySelectorAll('xref[ref-type="aff"]')].map(extractContribAffiliation.bind(null, contrib))
+
+    }
+
+    const extractContrib = function (contributorsArray, contrib, index) {
+        const contributor = {};
+
+        contributor.name = extractContribName(contrib);
+        contributor.bio = this.passthroughIntoHTMLString(contrib.querySelector('bio'));
+
+        // AFFs
+        contributor.affiliations = extractContribAffiliations(contrib);
+        // EMAILS
+
+        const emailChildren = contrib.querySelectorAll(':scope>email');
+        // NOTE: specific-use="current" is not used downstream
+        contributor.emails = emailChildren.map(email => email.textContent);
+
+        contributor.mrauth = contrib.querySelector('contrib-id[contrib-id-type="mrauth"]')?.textContent;
+        contributor.orcid = contrib.querySelector('contrib-id[contrib-id-type="orcid"]')?.textContent;
+
+        contributor.uri = contrib.querySelector('uri')?.textContent;
+        // author-comment (NOTE: child of contrib-group but it's easier if we copy it to each contributor)
+        const authorComment = contrib.parentNode.querySelector('author-comment')?.textContent;
+        if (index === 0 && authorComment) contributor.byline = authorComment;
+        contributorsArray.push(contributor);
+    }
+
+    const extractContribGroup = function (contributors, contribGroup) {
+        contributors[contribGroup.getAttribute('content-type')] ??= []; // NOTE: jams410 has 2 contrib-groups with content-type=contributors (but different author-comments); cf. #408
+        contribGroup.querySelectorAll('contrib').forEach(extractContrib.bind(this, contributors[contribGroup.getAttribute('content-type')]));
+    };
+
+
+
+    let contributors = {};
+    articleMetaNode.querySelectorAll('contrib-group').forEach(extractContribGroup.bind(this, contributors));
+    return contributors;
+}

package/lib/helpers/generateByline.js

@@ -0,0 +1,35 @@
+/*!
+ *  Copyright (c) 2023 American Mathematical Society
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * Turn author metadata into parts of a sentence.
+ * @param {Object} contributors - contributors metadata object (from article- or section-metadata)
+ * @returns {String}
+ */
+
+const createPartialByline = (contributors) => {
+    const formatter = new Intl.ListFormat('en', { style: 'long', type: 'conjunction' });
+    return formatter.format(Object.values(contributors).map(contributor => `${contributor.byline ? contributor.byline + ' ' : ''}${contributor.name}`));
+}
+
+
+/**
+ * Generates Byline from contributor information. 
+ * NOTE: tested via article-metadata-json.js and sec-meta.js
+ * @param {Object} contributors 
+ * @returns {String}
+ */
+export const generateByline = (contributors) => Object.values(contributors).map(contributorGroup => createPartialByline(contributorGroup)).join(', ');

package/lib/helpers/getParentLevel.js

@@ -0,0 +1,24 @@
+/*!
+ *  Copyright (c) 2023 American Mathematical Society
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * Get parent level.
+ * @param {HTMLElement} htmlParentNode 
+ */
+const getParentLevel = htmlParentNode =>
+  parseInt(htmlParentNode.getAttribute('data-ams-doc-level'));
+
+export default getParentLevel;

package/lib/helpers/helpers-tex.js

@@ -0,0 +1,54 @@
+/*!
+ *  Copyright (c) 2023 American Mathematical Society
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * Re-escape active TeX characters inside text node (since we create TeX input for mathjax from <text> elements)
+ * @param {Text} textNode 
+ */
+const replaceTeXCharactersInNode = textNode => {
+    const regExp = /([#$_&])/g;
+    textNode.textContent = textNode.textContent.replace(regExp, '\\$1').replace('~','\\unicode{x7E}');
+}
+
+/**
+ * Runs replaceTeXCharactersInNode on all text node (direct) children
+ * @param {Node} xmlnode 
+ */
+export const replaceTeXCharactersInNodes = (xmlnode) => {
+    const textChildren = [...xmlnode.childNodes].filter(node => node.nodeType === 3);
+    textChildren.forEach(replaceTeXCharactersInNode)
+}
+
+
+/**
+ * Common pattern for handling most xml nodes when inside tex-math:
+ * - create provided TeX macro
+ * - maybe replaces active characters in xmlnode
+ * - maybe wraps in $...$
+ * - runs pass through
+ * @param {HTMLElement} htmlParentNode - html container for resulting output
+ * @param {Node} xmlnode - an xml node inside tex-math
+ * @param {String} macroName - name of TeX macro
+ * @param {Boolean} needsEscaping - decide if active TeX characters need escaping
+ * @param {Boolean} needsDollars - decide if active TeX characters need escaping
+ */
+export function node2macro(htmlParentNode, xmlnode, macroName, needsEscaping, needsDollars) {
+    const maybeDollar = needsDollars ? '$' : '';
+    htmlParentNode.insertAdjacentText('beforeend', `${maybeDollar}\\${macroName}{`);
+    if (needsEscaping) replaceTeXCharactersInNodes(xmlnode);
+    this.passThrough(htmlParentNode, xmlnode);
+    htmlParentNode.insertAdjacentText('beforeend', `}${maybeDollar}`);
+}

package/lib/helpers/mapAttributes.js

@@ -0,0 +1,54 @@
+/*!
+ *  Copyright (c) 2023 American Mathematical Society
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+const attributeDictionary = {
+  class: 'class', // NOTE should only appear on table elements
+  id: 'id',
+  rowspan: 'rowspan',
+  colspan: 'colspan',
+  'content-type': 'data-ams-content-type',
+  'has-qed-box': 'data-ams-qed-box',
+  hidden: 'hidden',
+  style: 'data-ams-style',
+  'specific-use': 'data-ams-specific-use' // NOTE generic fallback; elementProcessors who do something different should remove the attribute from the xmlnode before calling mapAttributes
+};
+
+/**
+ * Map attribute from XML to HTML element.
+ * @param {HTMLElement} htmlParentNode 
+ * @param {Element} xmlnode 
+ * @param {String} attributeName 
+ * @returns {undefined}
+ */
+const mapAttribute = (htmlNode, xmlNode, attributeName) => {
+  const attributeValue = xmlNode.getAttribute(attributeName);
+  if (!attributeValue) return;
+  htmlNode.setAttribute(attributeDictionary[attributeName], attributeValue);
+};
+
+/**
+ * Map admissible attributes from XML to HTML element.
+ * @param {HTMLElement} htmlNode 
+ * @param {Element} xmlNode 
+ * @returns {undefined}
+ */
+const mapAttributes = (htmlNode, xmlNode) => {
+  Object.keys(attributeDictionary).forEach(
+    mapAttribute.bind(null, htmlNode, xmlNode)
+  );
+};
+
+export default mapAttributes;

package/lib/helpers/mapColorAttributes.js

@@ -0,0 +1,36 @@
+/*!
+ *  Copyright (c) 2023 American Mathematical Society
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * Maps color attributes on XML element to (combined) style declaration on HTML element
+ * @param {HTMLElement} htmlParentNode 
+ * @param {Element} xmlnode 
+ */
+export const mapColorAttributes = (htmlnode, xmlnode) => {
+    const colors = [];
+    if (xmlnode.hasAttribute('text-color')) colors.push(`color:${xmlnode.getAttribute('text-color')};`);
+    if (xmlnode.hasAttribute('background-color')) colors.push(`background-color:${xmlnode.getAttribute('background-color')};`);
+    if (xmlnode.hasAttribute('border-color')) {
+        colors.push(`border-color:${xmlnode.getAttribute('border-color')};`);
+    }
+    if (xmlnode.hasAttribute('border-width')) {
+        colors.push(`border-width:${xmlnode.getAttribute('border-width')};`);
+    }
+    if (xmlnode.hasAttribute('border-style')) {
+        colors.push(`border-style:${xmlnode.getAttribute('border-style')};`);
+    }
+    if (colors.length) htmlnode.setAttribute('data-ams-style-color', colors.join(''));
+}

package/lib/helpers/unnest.js

@@ -0,0 +1,34 @@
+/*!
+ *  Copyright (c) 2023 American Mathematical Society
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * moves links into subsequent span
+ * @param {Function} recurseTheDom 
+ * @param {Function} createNode 
+ * @param {Node} xmlnode  XML DOM node
+ * @param {Node} htmlnode HTML Dom Node
+ * @param {Node} linkChild XML Dom Node, child of xmlnode
+ * @returns {Boolean} 
+ */
+export const unnestLinks = (recurseTheDom, createNode, xmlnode, htmlnode, linkChild) => {
+    const siblings = [...xmlnode.childNodes];
+    const precedingSiblings = siblings.slice(0, siblings.indexOf(linkChild));
+    const followingSiblings = siblings.slice(siblings.indexOf(linkChild));
+    const span = createNode('span');
+    htmlnode.insertAdjacentElement('afterend', span);
+    precedingSiblings.forEach(recurseTheDom.bind(null, htmlnode));
+    followingSiblings.forEach(recurseTheDom.bind(null, span));
+}

package/lib/transformer.js

@@ -0,0 +1,311 @@
+/*!
+ *  Copyright (c) 2023 American Mathematical Society
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+import Front from './elements/front.js';
+import Preface from './elements/preface.js';
+import BookMeta from './elements/book-meta.js';
+import BookTitle from './elements/book-title.js';
+import Subtitle from './elements/subtitle.js';
+import Email from './elements/email.js';
+import Xref from './elements/xref.js';
+import X from './elements/x.js';
+import RefList from './elements/ref-list.js';
+import Ref from './elements/ref.js';
+import MixedCitation from './elements/mixed-citation.js';
+import Label from './elements/label.js';
+import StringName from './elements/string-name.js';
+import Article from './elements/article.js';
+import ArticleTitle from './elements/article-title.js';
+import KwdGroup from './elements/kwd-group.js';
+import Kwd from './elements/kwd.js';
+import CompoundKwd from './elements/compound-kwd.js';
+import FundingGroup from './elements/funding-group.js';
+import MetaName from './elements/meta-name.js';
+import MetaValue from './elements/meta-value.js';
+import Notes from './elements/notes.js';
+import Abstract from './elements/abstract.js';
+import Sec from './elements/sec.js';
+import StyledContent from './elements/styled-content.js';
+import Italic from './elements/italic.js';
+import Bold from './elements/bold.js';
+import DispQuote from './elements/disp-quote.js';
+import Attrib from './elements/attrib.js';
+import Fn from './elements/fn.js';
+import P from './elements/p.js';
+import DefList from './elements/def-list.js';
+import DefItem from './elements/def-item.js';
+import Term from './elements/term.js';
+import Def from './elements/def.js';
+import App from './elements/app.js';
+import Statement from './elements/statement.js';
+import SecHeading from './elements/secheading.js';
+import SecMeta from './elements/sec-meta.js';
+import Graphic from './elements/graphic.js';
+import Img from './elements/img.js';
+import Fig from './elements/fig.js';
+import Caption from './elements/caption.js';
+import Toc from './elements/toc.js';
+import TocEntry from './elements/toc-entry.js';
+import Formula from './elements/formula.js';
+import Text from './elements/text.js';
+import ExtLink from './elements/ext-link.js';
+import Break from './elements/break.js';
+import Target from './elements/target.js';
+import BoxedText from './elements/boxed-text.js';
+import Table from './elements/table.js';
+import Underline from './elements/underline.js';
+import DispFormulaGroup from './elements/disp-formula-group.js';
+import SimpleTabbing from './elements/simpletabbing.js';
+import Line from './elements/line.js';
+import SubjGroup from './elements/subj-group.js';
+import Subject from './elements/subject.js';
+import Monospace from './elements/monospace.js';
+import Roman from './elements/roman.js';
+import SansSerif from './elements/sans-serif.js';
+import Sc from './elements/sc.js';
+import * as algorithm from './elements/algorithm.js';
+import Tag from './elements/tag.js';
+import Xrefgroup from './elements/xref-group.js';
+import TexMath from './elements/tex-math.js';
+
+import copyElement from './helpers/copyElement.js';
+import { extractContribGroups } from './helpers/extractContribGroups.js';
+
+/**
+ * The Transformer class
+ */
+export class Transformer {
+    /**
+     * 
+     * @param {Document} htmldoc - HTML document
+     * @param {Object} imageAltDictionary - Key value store with file names and alt text strings
+     * @param {Boolean} isBook - Boolean to indicate if we are transforming a book
+     */
+    constructor(htmldoc, imageAltDictionary, isBook) {
+        // the HTML document
+        this.htmldoc = htmldoc;
+
+        // the image alt lookup table
+        this.imageAltDictionary = imageAltDictionary;
+
+        // book check
+        this.isBook = isBook;
+
+        // helper mapping elements to existing methods
+        const mapTag = (func, newtag) => (this[newtag] = func);
+
+        // sec-like elements
+        ['ack', 'front-matter-part', 'dedication', 'book-app-group', 'book-app'].forEach(
+            mapTag.bind(null, this['sec'])
+        );
+        // fig-like elements
+        ['fig-group', 'verse-group', 'table-wrap', 'table-wrap-group'].forEach(
+            mapTag.bind(null, this['fig'])
+        );
+        // copyable elements
+        [
+            'sup',
+            'sub',
+            'tbody',
+            'thead',
+            'th',
+            'tr',
+            'td',
+            'pre',
+            'hr',
+        ].forEach(mapTag.bind(null, this.copyElement));
+        // passThrough elements
+        [
+            'book',
+            'front-matter',
+            'book-body',
+            'book-back',
+            'book-part',
+            'named-book-part-body',
+            'book-part-meta',
+            'body',
+            'description',
+            'custom-meta-group',
+            'custom-meta',
+            'permissions',
+            'back',
+            'alternatives',
+            'title-group',
+            'cite-group',
+            'app-group',
+            'book-title-group',
+            'private-char',
+        ].forEach(mapTag.bind(null, this.passThrough));
+    }
+
+    /**
+     * 
+     * @param {String} tagname - a tag name to create node with
+     * @param {String} content  - content added to the tag's innerHTML
+     * @param {Object} properties  - Object of attribute / value keys
+     * @returns {HTMLElement} - node with tagname, content and attributes
+     */
+    createNode = (tagname, content, properties = {}) => {
+        const node = this.htmldoc.createElement(tagname);
+        if (content) node.innerHTML = content;
+        for (let prop of Object.keys(properties))
+            node.setAttribute(prop, properties[prop]);
+        return node;
+    };
+    /**
+     * Main (recursive) step - adds cloned text node or recurses into children
+     * @param {Node} htmlParentNode - HTML "parent" for xmlnode content
+     * @param {Node} xmlnode - XML node (to possibly recurse into)
+     * @returns {undefined}
+     */
+    recurseTheDom = (htmlParentNode, xmlnode) => {
+        if (!xmlnode) return;
+        if (xmlnode.nodeType === 3)
+            htmlParentNode.appendChild(this.htmldoc.importNode(xmlnode, false));
+        if (xmlnode.nodeType !== 1) return;
+        if (this[xmlnode.tagName]) this[xmlnode.tagName](htmlParentNode, xmlnode);
+        // else we drop/ignore the node
+    };
+
+    /**
+     * Pass-through function (for xmlnode that are we "unwrap")
+     * @param {Node} htmlParentNode - HTML "parent" for xmlnode content
+     * @param {Node} xmlnode - XML node to unwrap
+     * @returns {undefined}
+     */
+    passThrough = (htmlParentNode, xmlnode) => {
+        if (!xmlnode) return;
+        xmlnode.childNodes.forEach(this.recurseTheDom.bind(null, htmlParentNode));
+    };
+
+    /**
+     * Pass through hack for metadata generation
+     * @param {Node} xmlnode
+     * @returns {String}
+     */
+    passthroughIntoHTMLString = xmlnode => {
+        const span = this.createNode('span');
+        this.passThrough(span, xmlnode);
+        return span.innerHTML.trim();
+    }
+    
+    // extract contrib-groups into json data
+    extractContribGroups = extractContribGroups.bind(this);
+
+    // copy elements helper
+    copyElement = copyElement.bind(this)
+
+    // imported elements
+    front = Front.bind(this)
+    preface = Preface.bind(this)
+    'book-meta' = BookMeta.bind(this)
+    'book-title' = BookTitle.bind(this)
+    subtitle = Subtitle.bind(this)
+    email = Email.bind(this)
+    xref = Xref.bind(this)
+    x = X.bind(this)
+    'ref-list' = RefList.bind(this)
+    ref = Ref.bind(this)
+    'mixed-citation' = MixedCitation.bind(this)
+    label = Label.bind(this)
+    'string-name' = StringName.bind(this)
+    article = Article.bind(this)
+    'article-title' = ArticleTitle.bind(this)
+    'kwd-group' = KwdGroup.bind(this)
+    kwd = Kwd.bind(this)
+    'compound-kwd' = CompoundKwd.bind(this)
+    'funding-group' = FundingGroup.bind(this)
+    'meta-name' = MetaName.bind(this)
+    'meta-value' = MetaValue.bind(this)
+    notes = Notes.bind(this)
+    abstract = Abstract.bind(this)
+    sec = Sec.bind(this)
+    'styled-content' = StyledContent.bind(this)
+    italic = Italic.bind(this)
+    bold = Bold.bind(this)
+    'disp-quote' = DispQuote.bind(this)
+    attrib = Attrib.bind(this)
+    fn = Fn.bind(this)
+    p = P.bind(this)
+    'def-list' = DefList.bind(this)
+    'def-item' = DefItem.bind(this)
+    term = Term.bind(this)
+    def = Def.bind(this)
+    app = App.bind(this)
+    statement = Statement.bind(this)
+    secheading = SecHeading.bind(this)
+    'sec-meta' = SecMeta.bind(this)
+    graphic = Graphic.bind(this)
+    img = Img.bind(this)
+    fig = Fig.bind(this)
+    caption = Caption.bind(this)
+    toc = Toc.bind(this)
+    'toc-entry' = TocEntry.bind(this)
+    'inline-formula' = Formula.bind(this)
+    text = Text.bind(this)
+    'ext-link' = ExtLink.bind(this)
+    break = Break.bind(this)
+    target = Target.bind(this)
+    'boxed-text' = BoxedText.bind(this)
+    table = Table.bind(this)
+    underline = Underline.bind(this)
+    'disp-formula-group' = DispFormulaGroup.bind(this)
+    simpletabbing = SimpleTabbing.bind(this)
+    line = Line.bind(this)
+    'subj-group' = SubjGroup.bind(this)
+    subject = Subject.bind(this)
+    monospace = Monospace.bind(this)
+    roman = Roman.bind(this)
+    'sans-serif' = SansSerif.bind(this)
+    sc = Sc.bind(this)
+    tag = Tag.bind(this)
+    'xref-group' = Xrefgroup.bind(this)
+    'tex-math' = TexMath.bind(this)
+
+    // one-off reuse of imported elements
+    // NOTE if RHS gets re-used more than once, use mapTag in the constructor
+    'funding-statement' = this['p']
+    'inline-graphic' = this['graphic']
+    'disp-formula' = this['inline-formula']
+    title = this['label']
+
+    // algorithm layout
+    'alg:algorithm' = algorithm.alg;
+    'alg:line' = algorithm.algLine;
+    'alg:block' = algorithm.algBlock;
+    'alg:statement' = algorithm.algStatement;
+    'alg:comment' = algorithm.algComment;
+    // remapped alg:* elements
+    'alg:require' = algorithm.algStatement;
+    'alg:ensure' = algorithm.algStatement;
+    'alg:globals' = algorithm.algStatement;
+    // pass-through alg:* elements
+    'alg:body' = this.passThrough; // NOTE no test (case)
+    'alg:outputs' = this.passThrough; // NOTE no test (case)
+    'alg:inputs' = this.passThrough; // NOTE no test (case)
+    'alg:condition' = this.passThrough;
+    'alg:if' = this.passThrough;
+    'alg:elsif' = this.passThrough; // NOTE no test (case)
+    'alg:else' = this.passThrough;
+    'alg:for' = this.passThrough;
+    'alg:forall' = this.passThrough; // NOTE no test (case)
+    'alg:while' = this.passThrough; // NOTE no test (case)
+    'alg:repeat' = this.passThrough; // NOTE no test (case)
+    'alg:until' = this.passThrough; // NOTE no test (case)
+    'alg:loop' = this.passThrough; // NOTE no test (case)
+    'alg:function' = this.passThrough;
+    'alg:procedure' = this.passThrough;
+}