typesditac 1.0.0

package/dist/load/hdita/HDITAConverter.js

@@ -0,0 +1,817 @@
+/*
+ * Portions Copyright (c) 2018-2026 XMLmind Software. All rights reserved.
+ * Author: Hussein Shafie
+ *
+ * Portions Copyright (c) 2026 Maxprograms SAS.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * This Source Code Form is "Incompatible With Secondary Licenses", as
+ * defined by the Mozilla Public License, v. 2.0.
+ */
+import { HtmlSupport } from "./HtmlSupport.js";
+import { DitaBuilder } from "./DitaBuilder.js";
+import { HDITATableConverter } from "./HDITATableConverter.js";
+const DIV_WRAPPED_ELEMENTS = [
+    "address", "aside", "article", "section", "nav", "h1", "h2", "h3", "h4", "h5", "h6"
+];
+const PH_WRAPPED_ELEMENTS = ["bdi", "bdo", "mark", "big", "small", "time"];
+const FLOW_CONTAINER_DESCENDANTS = [
+    "h1", "h2", "h3", "h4", "h5", "h6", "div", "section", "nav", "aside", "header", "footer",
+    "blockquote", "address", "hr", "p", "pre", "ul", "ol", "dl", "table", "figure", "fieldset",
+    "form", "details", "dialog", "script", "template"
+];
+const FOOTNOTE_HOST_PARENTS = [
+    "pre", "dd", "div", "td", "th", "figure", "li", "blockquote", "p", "span", "section"
+];
+const NO_IMAGE_PH_PARENTS = [
+    "em", "strong", "dfn", "abbr", "acronym", "code", "var", "kdb", "samp",
+    "cite", "b", "i", "q", "sub", "sup", "tt", "u", "s", "strike"
+];
+const META_NAMES_IN_PROLOG = [
+    "description", "author", "source", "publisher", "dcterms.publisher", "created", "dcterms.created",
+    "revised", "dcterms.modified", "permissions", "audience", "category", "keyword", "resourceid"
+];
+const ADMONITION_TYPES = [
+    "note", "attention", "caution", "danger", "fastpath", "important",
+    "notice", "remember", "restriction", "tip", "trouble", "warning"
+];
+export class HDITAConverter {
+    constructor() { }
+    static checkId(text) {
+        const collapsed = HtmlSupport.normalizeSpace(text);
+        const base = collapsed.length === 0 ? "_" : collapsed;
+        const extras = String.fromCharCode(0x00B7, 0x203F, 0x2040);
+        const pattern = new RegExp("[^\\p{L}\\p{N}\\p{M}_.:" + extras + "-]+", "gu");
+        const sanitized = base.replace(pattern, "_");
+        return /^[\p{L}_:]/u.test(sanitized) ? sanitized : "_" + sanitized;
+    }
+    static processCommonAttributes0(source, target) {
+        DitaBuilder.setAttr(target, "xml:lang", HtmlSupport.nonEmptyAttribute(source, "lang"));
+        const translate = HtmlSupport.attribute(source, "translate");
+        if (translate === "" || translate === "no" || translate === "yes") {
+            DitaBuilder.setAttr(target, "translate", translate === "" ? "yes" : translate);
+        }
+        const dir = HtmlSupport.attribute(source, "dir");
+        if (dir === "rtl" || dir === "ltr") {
+            DitaBuilder.setAttr(target, "dir", dir);
+        }
+        DitaBuilder.setAttr(target, "props", HtmlSupport.nonEmptyAttribute(source, "data-props"));
+        DitaBuilder.setAttr(target, "conref", HtmlSupport.nonEmptyAttribute(source, "data-conref"));
+    }
+    static processCommonAttributes1(source, target) {
+        DitaBuilder.setAttr(target, "id", HtmlSupport.nonEmptyAttribute(source, "id"));
+        HDITAConverter.processCommonAttributes0(source, target);
+    }
+    static processCommonAttributes(source, target, ctx, addRole = false) {
+        HDITAConverter.processCommonAttributes1(source, target);
+        const rawClass = HtmlSupport.attribute(source, "class") ?? "";
+        let effectiveClass = rawClass;
+        const parent = HtmlSupport.parentElement(ctx.documentRoot, source);
+        const grandparent = parent === undefined
+            ? undefined
+            : HtmlSupport.parentElement(ctx.documentRoot, parent);
+        if (source.tagName === "h1" && parent?.tagName === "article" && grandparent?.tagName === "body") {
+            effectiveClass = rawClass.replace(/(^|\s+)(map|topic|concept|task|reference)(\s+|$)/, " ").trim();
+        }
+        else if (source.tagName === "h2" && parent?.tagName === "article" && grandparent?.tagName === "body") {
+            effectiveClass = rawClass.replace(/(^|\s+)(section|example)(\s+|$)/, " ").trim();
+        }
+        if (effectiveClass !== "" || addRole) {
+            const outputclass = addRole
+                ? HtmlSupport.normalizeSpace(effectiveClass + " role-" + source.tagName)
+                : effectiveClass;
+            DitaBuilder.setAttr(target, "outputclass", outputclass);
+        }
+    }
+    static processLinkAttributes(source, target) {
+        DitaBuilder.setAttr(target, "format", HtmlSupport.nonEmptyAttribute(source, "type"));
+        DitaBuilder.setAttr(target, "scope", HtmlSupport.nonEmptyAttribute(source, "rel"));
+    }
+    static processKeyrefAttribute(source, target) {
+        DitaBuilder.setAttr(target, "keyref", HtmlSupport.nonEmptyAttribute(source, "data-keyref"));
+    }
+    static inheritedLang(source, ctx) {
+        let current = HtmlSupport.parentElement(ctx.documentRoot, source);
+        const chain = [];
+        while (current !== undefined) {
+            chain.push(current);
+            current = HtmlSupport.parentElement(ctx.documentRoot, current);
+        }
+        for (let index = chain.length - 1; index >= 0; index--) {
+            const lang = HtmlSupport.nonEmptyAttribute(chain[index], "lang");
+            if (lang !== undefined) {
+                return lang;
+            }
+        }
+        return undefined;
+    }
+    static processTopicArticle(article, ctx) {
+        const h1 = HtmlSupport.firstChildElement(article)?.tagName === "h1"
+            ? HtmlSupport.firstChildElement(article)
+            : undefined;
+        const h1Classes = h1 === undefined ? [] : HtmlSupport.classTokens(h1);
+        const isConcept = HtmlSupport.attribute(article, "data-class") === "concept" || h1Classes.includes("concept");
+        const topicName = isConcept ? "concept" : "topic";
+        const bodyName = isConcept ? "conbody" : "body";
+        const root = DitaBuilder.createElement(topicName);
+        HDITAConverter.processCommonAttributes(article, root, ctx);
+        if (HtmlSupport.attribute(article, "lang") === undefined) {
+            DitaBuilder.setAttr(root, "xml:lang", HDITAConverter.inheritedLang(article, ctx));
+        }
+        const idAttr = HtmlSupport.attribute(article, "id");
+        if (idAttr === undefined || idAttr === "???") {
+            DitaBuilder.setAttr(root, "id", HtmlSupport.normalizeSpace(ctx.rootName) !== ""
+                ? HDITAConverter.checkId(ctx.rootName)
+                : topicName);
+        }
+        const kids = HtmlSupport.childElements(article);
+        if (h1 !== undefined) {
+            root.addElement(HDITAConverter.processTitle(h1, ctx));
+            const second = kids[1];
+            const p = second?.tagName === "p" ? second : undefined;
+            const shortdesc = HDITAConverter.processDescription(p, ctx);
+            if (shortdesc !== undefined) {
+                root.addElement(shortdesc);
+            }
+            const meta = HDITAConverter.processMeta(ctx);
+            if (meta !== undefined) {
+                root.addElement(meta);
+            }
+            root.addElement(HDITAConverter.processTopicBody(article, bodyName, p !== undefined ? 2 : 1, ctx));
+        }
+        else {
+            const html = HtmlSupport.firstElementNamed(ctx.documentNodes, "html");
+            const head = HtmlSupport.firstElementNamed(HtmlSupport.children(html), "head");
+            const title = HtmlSupport.firstElementNamed(HtmlSupport.children(head), "title");
+            if (title !== undefined) {
+                const titleElement = DitaBuilder.createElement("title");
+                DitaBuilder.addText(titleElement, HtmlSupport.textContent(title));
+                root.addElement(titleElement);
+            }
+            const first = kids[0];
+            const p = first?.tagName === "p" ? first : undefined;
+            const shortdesc = HDITAConverter.processDescription(p, ctx);
+            if (shortdesc !== undefined) {
+                root.addElement(shortdesc);
+            }
+            const meta = HDITAConverter.processMeta(ctx);
+            if (meta !== undefined) {
+                root.addElement(meta);
+            }
+            root.addElement(HDITAConverter.processTopicBody(article, bodyName, p !== undefined ? 1 : 0, ctx));
+        }
+        return root;
+    }
+    static processTitle(element, ctx) {
+        const title = DitaBuilder.createElement("title");
+        HDITAConverter.processCommonAttributes(element, title, ctx);
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(element), title, ctx);
+        return title;
+    }
+    static processDescription(firstP, ctx) {
+        if (firstP !== undefined) {
+            if (HtmlSupport.children(firstP).length === 0) {
+                return undefined;
+            }
+            return HDITAConverter.processShortdesc(firstP, ctx);
+        }
+        const description = HDITAConverter.firstMeta(ctx, ["description"]);
+        if (description === undefined) {
+            return undefined;
+        }
+        const shortdesc = DitaBuilder.createElement("shortdesc");
+        DitaBuilder.addText(shortdesc, HtmlSupport.attribute(description, "content") ?? "");
+        return shortdesc;
+    }
+    static processShortdesc(element, ctx) {
+        const shortdesc = DitaBuilder.createElement("shortdesc");
+        HDITAConverter.processCommonAttributes(element, shortdesc, ctx);
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(element), shortdesc, ctx);
+        return shortdesc;
+    }
+    static allMetas(ctx) {
+        const head = HtmlSupport.firstElementNamed(ctx.documentNodes, "head");
+        return HtmlSupport.childElements(head).filter((element) => element.tagName === "meta" && HtmlSupport.attribute(element, "name") !== undefined);
+    }
+    static metasNamed(ctx, names) {
+        return HDITAConverter.allMetas(ctx).filter((meta) => names.includes(HtmlSupport.attribute(meta, "name") ?? ""));
+    }
+    static firstMeta(ctx, names) {
+        return HDITAConverter.metasNamed(ctx, names)[0];
+    }
+    static processMeta(ctx) {
+        const prolog = DitaBuilder.createElement("prolog");
+        HDITAConverter.appendMetaContent(prolog, ctx);
+        return prolog.getChildren().length === 0 ? undefined : prolog;
+    }
+    static appendMetaContent(prolog, ctx) {
+        for (const meta of HDITAConverter.metasNamed(ctx, ["author"])) {
+            prolog.addElement(HDITAConverter.convertMeta(meta));
+        }
+        const source = HDITAConverter.firstMeta(ctx, ["source"]);
+        if (source !== undefined) {
+            prolog.addElement(HDITAConverter.convertMeta(source));
+        }
+        const publisher = HDITAConverter.firstMeta(ctx, ["publisher", "dcterms.publisher"]);
+        if (publisher !== undefined) {
+            prolog.addElement(HDITAConverter.convertMeta(publisher));
+        }
+        if (HDITAConverter.metasNamed(ctx, ["created", "dcterms.created", "revised", "dcterms.modified"]).length > 0) {
+            const critdates = DitaBuilder.createElement("critdates");
+            const created = HDITAConverter.firstMeta(ctx, ["created", "dcterms.created"]);
+            if (created !== undefined) {
+                critdates.addElement(HDITAConverter.convertMeta(created));
+            }
+            for (const revised of HDITAConverter.metasNamed(ctx, ["revised", "dcterms.modified"])) {
+                critdates.addElement(HDITAConverter.convertMeta(revised));
+            }
+            prolog.addElement(critdates);
+        }
+        const permissions = HDITAConverter.firstMeta(ctx, ["permissions"]);
+        if (permissions !== undefined) {
+            prolog.addElement(HDITAConverter.convertMeta(permissions));
+        }
+        if (HDITAConverter.metasNamed(ctx, ["audience", "category", "keyword"]).length > 0) {
+            const metadata = DitaBuilder.createElement("metadata");
+            for (const audience of HDITAConverter.metasNamed(ctx, ["audience"])) {
+                metadata.addElement(HDITAConverter.convertMeta(audience));
+            }
+            for (const category of HDITAConverter.metasNamed(ctx, ["category"])) {
+                metadata.addElement(HDITAConverter.convertMeta(category));
+            }
+            const keywordMetas = HDITAConverter.metasNamed(ctx, ["keyword"]);
+            if (keywordMetas.length > 0) {
+                const keywords = DitaBuilder.createElement("keywords");
+                for (const keyword of keywordMetas) {
+                    keywords.addElement(HDITAConverter.convertMeta(keyword));
+                }
+                metadata.addElement(keywords);
+            }
+            prolog.addElement(metadata);
+        }
+        for (const resourceid of HDITAConverter.metasNamed(ctx, ["resourceid"])) {
+            prolog.addElement(HDITAConverter.convertMeta(resourceid));
+        }
+        for (const other of HDITAConverter.allMetas(ctx).filter((meta) => !META_NAMES_IN_PROLOG.includes(HtmlSupport.attribute(meta, "name") ?? ""))) {
+            prolog.addElement(HDITAConverter.convertMeta(other));
+        }
+    }
+    static convertMeta(meta) {
+        const name = HtmlSupport.attribute(meta, "name") ?? "";
+        const content = HtmlSupport.normalizeSpace(HtmlSupport.attribute(meta, "content") ?? "");
+        if (name === "author" || name === "source" || name === "category" || name === "keyword") {
+            const element = DitaBuilder.createElement(name);
+            DitaBuilder.addText(element, content);
+            return element;
+        }
+        if (name === "publisher" || name === "dcterms.publisher") {
+            const element = DitaBuilder.createElement("publisher");
+            DitaBuilder.addText(element, content);
+            return element;
+        }
+        if (name === "created" || name === "dcterms.created") {
+            const element = DitaBuilder.createElement("created");
+            DitaBuilder.setAttr(element, "date", content);
+            return element;
+        }
+        if (name === "revised" || name === "dcterms.modified") {
+            const element = DitaBuilder.createElement("revised");
+            DitaBuilder.setAttr(element, "modified", content);
+            return element;
+        }
+        if (name === "permissions") {
+            const element = DitaBuilder.createElement("permissions");
+            DitaBuilder.setAttr(element, "view", content);
+            return element;
+        }
+        if (name === "audience") {
+            const element = DitaBuilder.createElement("audience");
+            DitaBuilder.setAttr(element, "type", content);
+            return element;
+        }
+        if (name === "resourceid") {
+            const element = DitaBuilder.createElement("resourceid");
+            DitaBuilder.setAttr(element, "appid", content);
+            return element;
+        }
+        const data = DitaBuilder.createElement("data");
+        DitaBuilder.setAttr(data, "name", name);
+        DitaBuilder.setAttr(data, "value", content);
+        return data;
+    }
+    static processTopicBody(article, bodyName, after, ctx) {
+        const body = DitaBuilder.createElement(bodyName);
+        const rest = HtmlSupport.childElements(article).slice(after);
+        const firstH2Index = rest.findIndex((element) => element.tagName === "h2");
+        if (firstH2Index < 0) {
+            HDITAConverter.applyTemplatesInto(rest, body, ctx);
+            return body;
+        }
+        HDITAConverter.applyTemplatesInto(rest.slice(0, firstH2Index), body, ctx);
+        let index = firstH2Index;
+        while (index < rest.length) {
+            const heading = rest[index];
+            let end = index + 1;
+            while (end < rest.length && rest[end].tagName !== "h2") {
+                end++;
+            }
+            const sectionName = HtmlSupport.hasClassToken(heading, "example") ? "example" : "section";
+            const section = DitaBuilder.createElement(sectionName);
+            section.addElement(HDITAConverter.processTitle(heading, ctx));
+            HDITAConverter.applyTemplatesInto(rest.slice(index + 1, end), section, ctx);
+            body.addElement(section);
+            index = end;
+        }
+        return body;
+    }
+    static processTopLevelSection(section, ctx) {
+        const sectionName = HtmlSupport.attribute(section, "data-class") === "example" ? "example" : "section";
+        const result = DitaBuilder.createElement(sectionName);
+        HDITAConverter.processCommonAttributes(section, result, ctx);
+        const kids = HtmlSupport.childElements(section);
+        const heading = kids[0] !== undefined && /^h[1-6]$/.test(kids[0].tagName)
+            ? kids[0]
+            : undefined;
+        if (heading !== undefined) {
+            result.addElement(HDITAConverter.processTitle(heading, ctx));
+            HDITAConverter.applyTemplatesInto(kids.slice(1), result, ctx);
+        }
+        else {
+            HDITAConverter.applyTemplatesInto(HtmlSupport.children(section), result, ctx);
+        }
+        return result;
+    }
+    static processDefinitionList(dl, ctx) {
+        const result = DitaBuilder.createElement("dl");
+        HDITAConverter.processCommonAttributes(dl, result, ctx);
+        const terms = HtmlSupport.childElements(dl).filter((el) => el.tagName === "dt" || el.tagName === "dd");
+        let groupStart = 0;
+        for (let index = 1; index <= terms.length; index++) {
+            const isBoundary = index === terms.length ||
+                (terms[index].tagName === "dt" && terms[index - 1].tagName === "dd");
+            if (isBoundary) {
+                const entry = DitaBuilder.createElement("dlentry");
+                HDITAConverter.applyTemplatesInto(terms.slice(groupStart, index), entry, ctx);
+                result.addElement(entry);
+                groupStart = index;
+            }
+        }
+        return result;
+    }
+    static processOrderedList(ol, ctx) {
+        const result = DitaBuilder.createElement("ol");
+        HDITAConverter.processCommonAttributes(ol, result, ctx);
+        const type = HtmlSupport.attribute(ol, "type");
+        const start = HtmlSupport.attribute(ol, "start");
+        if (type !== undefined || start !== undefined) {
+            let piece = "";
+            if (type !== undefined) {
+                piece = type === "a" ? "lower-alpha"
+                    : type === "A" ? "upper-alpha"
+                        : type === "i" ? "lower-roman"
+                            : type === "I" ? "upper-roman"
+                                : "decimal";
+            }
+            piece += " ";
+            if (start !== undefined && Number(start) >= 0) {
+                piece += "start(" + start + ")";
+            }
+            DitaBuilder.setAttr(result, "outputclass", HtmlSupport.normalizeSpace((HtmlSupport.attribute(ol, "class") ?? "") + " " + piece));
+        }
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(ol), result, ctx);
+        return result;
+    }
+    static processFigure(figure, ctx) {
+        const fig = DitaBuilder.createElement("fig");
+        HDITAConverter.processCommonAttributes(figure, fig, ctx);
+        const caption = HtmlSupport.childElements(figure).find((el) => el.tagName === "figcaption");
+        if (caption !== undefined) {
+            fig.addElement(HDITAConverter.processTitle(caption, ctx));
+        }
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(figure).filter((node) => node !== caption), fig, ctx);
+        return fig;
+    }
+    static processNote(div, ctx) {
+        const note = DitaBuilder.createElement("note");
+        const type = HtmlSupport.attribute(div, "data-type");
+        if (type !== undefined && ADMONITION_TYPES.includes(type)) {
+            DitaBuilder.setAttr(note, "type", type);
+        }
+        HDITAConverter.processCommonAttributes(div, note, ctx);
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(div), note, ctx);
+        return note;
+    }
+    static processBlockquote(blockquote, ctx) {
+        const lq = DitaBuilder.createElement("lq");
+        HDITAConverter.processCommonAttributes(blockquote, lq, ctx);
+        HDITAConverter.processKeyrefAttribute(blockquote, lq);
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(blockquote), lq, ctx);
+        return lq;
+    }
+    static processPre(pre, ctx) {
+        const code = HtmlSupport.firstElementNamed(HtmlSupport.children(pre), "code");
+        if (code !== undefined && HtmlSupport.children(pre).length === 1) {
+            const codeblock = DitaBuilder.createElement("codeblock");
+            HDITAConverter.processCommonAttributes(pre, codeblock, ctx);
+            HDITAConverter.applyTemplatesInto(HtmlSupport.children(code), codeblock, ctx);
+            return codeblock;
+        }
+        const preElement = DitaBuilder.createElement("pre");
+        HDITAConverter.processCommonAttributes(pre, preElement, ctx);
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(pre), preElement, ctx);
+        return preElement;
+    }
+    static processFootnoteDiv(div, ctx) {
+        const parent = HtmlSupport.parentElement(ctx.documentRoot, div);
+        const fn = HDITAConverter.processFootnote(div, ctx);
+        if (parent !== undefined && FOOTNOTE_HOST_PARENTS.includes(parent.tagName)) {
+            return fn;
+        }
+        const wrapper = DitaBuilder.createElement("div");
+        wrapper.addElement(fn);
+        return wrapper;
+    }
+    static processFootnoteSpan(span, ctx) {
+        const parent = HtmlSupport.parentElement(ctx.documentRoot, span);
+        const fn = HDITAConverter.processFootnote(span, ctx);
+        if (parent !== undefined && FOOTNOTE_HOST_PARENTS.includes(parent.tagName)) {
+            return fn;
+        }
+        const wrapper = DitaBuilder.createElement("ph");
+        wrapper.addElement(fn);
+        return wrapper;
+    }
+    static processFootnote(element, ctx) {
+        const fn = DitaBuilder.createElement("fn");
+        HDITAConverter.processCommonAttributes0(element, fn);
+        const id = HtmlSupport.attribute(element, "id");
+        if (id !== undefined) {
+            const pattern = new RegExp("^(?:[^/]+/)?" + id + "$");
+            const hasMatchingLink = HDITAConverter.descendantsInDocument(ctx, "a").some((a) => {
+                const href = HtmlSupport.attribute(a, "href") ?? "";
+                return pattern.test(href.startsWith("#") ? href.slice(1) : href);
+            });
+            if (hasMatchingLink) {
+                DitaBuilder.setAttr(fn, "id", id);
+            }
+        }
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(element), fn, ctx);
+        return fn;
+    }
+    static descendantsInDocument(ctx, tagName) {
+        const results = [];
+        for (const node of ctx.documentNodes) {
+            if (HtmlSupport.isElement(node)) {
+                if (node.tagName === tagName) {
+                    results.push(node);
+                }
+                results.push(...HtmlSupport.descendantsNamed(node, tagName));
+            }
+        }
+        return results;
+    }
+    static findById(ctx, id) {
+        for (const node of ctx.documentNodes) {
+            if (HtmlSupport.isElement(node)) {
+                if (HtmlSupport.attribute(node, "id") === id) {
+                    return node;
+                }
+                const found = HDITAConverter.findByIdIn(node, id);
+                if (found !== undefined) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
+    static findByIdIn(element, id) {
+        for (const child of HtmlSupport.childElements(element)) {
+            if (HtmlSupport.attribute(child, "id") === id) {
+                return child;
+            }
+            const found = HDITAConverter.findByIdIn(child, id);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    static processAnchor(a, ctx) {
+        const href = HtmlSupport.attribute(a, "href");
+        if (href === undefined) {
+            const ph = DitaBuilder.createElement("ph");
+            HDITAConverter.processCommonAttributes(a, ph, ctx);
+            HDITAConverter.processKeyrefAttribute(a, ph);
+            HDITAConverter.applyTemplatesInto(HtmlSupport.children(a), ph, ctx);
+            return ph;
+        }
+        const xref = DitaBuilder.createElement("xref");
+        const dataKeyref = HtmlSupport.nonEmptyAttribute(a, "data-keyref");
+        const isMDITAKeyRef = dataKeyref !== undefined && href === "#" &&
+            HtmlSupport.normalizeSpace(HtmlSupport.textContent(a)) === dataKeyref;
+        const normalizedHref = href.startsWith("#")
+            ? (href.includes("/") ? href : "#./" + href.slice(1))
+            : href;
+        if (!isMDITAKeyRef) {
+            DitaBuilder.setAttr(xref, "href", normalizedHref);
+        }
+        HDITAConverter.processCommonAttributes(a, xref, ctx);
+        HDITAConverter.processLinkAttributes(a, xref);
+        HDITAConverter.processKeyrefAttribute(a, xref);
+        let type = "";
+        if (normalizedHref.startsWith("#")) {
+            const ref = normalizedHref.includes("/")
+                ? normalizedHref.slice(normalizedHref.indexOf("/") + 1)
+                : normalizedHref.slice(1);
+            const target = HDITAConverter.findById(ctx, ref);
+            if (target !== undefined && HtmlSupport.attribute(target, "data-class") === "fn" &&
+                (target.tagName === "span" || target.tagName === "div")) {
+                type = "fn";
+            }
+        }
+        if (type !== "") {
+            DitaBuilder.setAttr(xref, "type", type);
+        }
+        else if (!isMDITAKeyRef) {
+            HDITAConverter.applyTemplatesInto(HtmlSupport.children(a), xref, ctx);
+        }
+        return xref;
+    }
+    static processObject(object, ctx) {
+        const result = DitaBuilder.createElement("object");
+        HDITAConverter.processCommonAttributes(object, result, ctx);
+        for (const name of ["data", "type", "name", "tabindex"]) {
+            DitaBuilder.setAttr(result, name, HtmlSupport.attribute(object, name));
+        }
+        HDITAConverter.processMediaContent0(object, result);
+        HDITAConverter.applyTemplatesInto(HtmlSupport.childElements(object).filter((el) => el.tagName === "param"), result, ctx);
+        return result;
+    }
+    static processMediaContent0(source, target) {
+        for (const name of ["width", "height"]) {
+            const value = HtmlSupport.attribute(source, name);
+            if (value !== undefined && Number(value) > 0) {
+                DitaBuilder.setAttr(target, name, value);
+            }
+        }
+        const title = HtmlSupport.nonEmptyAttribute(source, "title");
+        if (title !== undefined) {
+            const desc = DitaBuilder.createElement("desc");
+            DitaBuilder.addText(desc, title);
+            target.addElement(desc);
+        }
+    }
+    static processParam(param) {
+        if (HtmlSupport.attribute(param, "name") === undefined) {
+            return undefined;
+        }
+        const result = DitaBuilder.createElement("param");
+        HDITAConverter.processCommonAttributes1(param, result);
+        DitaBuilder.setAttr(result, "name", HtmlSupport.attribute(param, "name"));
+        DitaBuilder.setAttr(result, "value", HtmlSupport.attribute(param, "value"));
+        return result;
+    }
+    static mediaSourceElement(name, value) {
+        const el = DitaBuilder.createElement("media-source", "+ topic/param media-d/media-source ");
+        DitaBuilder.setAttr(el, "name", name);
+        DitaBuilder.setAttr(el, "value", value);
+        return el;
+    }
+    static mediaTrackElement(element) {
+        const el = DitaBuilder.createElement("media-track", "+ topic/param media-d/media-track ");
+        DitaBuilder.setAttr(el, "name", "track");
+        DitaBuilder.setAttr(el, "value", HtmlSupport.attribute(element, "src"));
+        DitaBuilder.setAttr(el, "type", HtmlSupport.nonEmptyAttribute(element, "kind"));
+        return el;
+    }
+    static processMediaContent(source, target) {
+        HDITAConverter.processMediaContent0(source, target);
+        const poster = HtmlSupport.nonEmptyAttribute(source, "poster");
+        if (poster !== undefined) {
+            const el = DitaBuilder.createElement("video-poster", "+ topic/param media-d/video-poster ");
+            DitaBuilder.setAttr(el, "name", "poster");
+            DitaBuilder.setAttr(el, "value", poster);
+            target.addElement(el);
+        }
+        for (const [attr, name, className] of [
+            ["controls", "media-controls", "+ topic/param media-d/media-controls "],
+            ["autoplay", "media-autoplay", "+ topic/param media-d/media-autoplay "],
+            ["loop", "media-loop", "+ topic/param media-d/media-loop "],
+            ["muted", "media-muted", "+ topic/param media-d/media-muted "]
+        ]) {
+            if (HtmlSupport.attribute(source, attr) !== undefined) {
+                const el = DitaBuilder.createElement(name, className);
+                DitaBuilder.setAttr(el, "name", attr);
+                DitaBuilder.setAttr(el, "value", "true");
+                target.addElement(el);
+            }
+        }
+        const src = HtmlSupport.nonEmptyAttribute(source, "src");
+        if (src !== undefined) {
+            target.addElement(HDITAConverter.mediaSourceElement("source", src));
+        }
+        for (const sourceEl of HtmlSupport.childElements(source).filter((el) => el.tagName === "source" && HtmlSupport.attribute(el, "src") !== undefined)) {
+            target.addElement(HDITAConverter.mediaSourceElement("source", HtmlSupport.attribute(sourceEl, "src")));
+        }
+        for (const trackEl of HtmlSupport.childElements(source).filter((el) => el.tagName === "track" && HtmlSupport.attribute(el, "src") !== undefined)) {
+            target.addElement(HDITAConverter.mediaTrackElement(trackEl));
+        }
+    }
+    static processAudio(audio, ctx) {
+        const result = DitaBuilder.createElement("audio", "+ topic/object media-d/audio ");
+        HDITAConverter.processCommonAttributes(audio, result, ctx);
+        HDITAConverter.processMediaContent(audio, result);
+        return result;
+    }
+    static processVideo(video, ctx) {
+        const result = DitaBuilder.createElement("video", "+ topic/object media-d/video ");
+        HDITAConverter.processCommonAttributes(video, result, ctx);
+        HDITAConverter.processMediaContent(video, result);
+        return result;
+    }
+    static processImage(img, ctx, placement = "") {
+        const image = DitaBuilder.createElement("image");
+        HDITAConverter.processCommonAttributes(img, image, ctx);
+        HDITAConverter.processKeyrefAttribute(img, image);
+        const dataKeyref = HtmlSupport.nonEmptyAttribute(img, "data-keyref");
+        const alt = HtmlSupport.attribute(img, "alt");
+        const isMDITAKeyRef = dataKeyref !== undefined && HtmlSupport.attribute(img, "src") === "#" &&
+            HtmlSupport.normalizeSpace(alt ?? "") === dataKeyref;
+        if (!isMDITAKeyRef) {
+            DitaBuilder.setAttr(image, "href", HtmlSupport.attribute(img, "src"));
+        }
+        for (const name of ["width", "height"]) {
+            const value = HtmlSupport.attribute(img, name);
+            if (value !== undefined && Number(value) > 0) {
+                DitaBuilder.setAttr(image, name, value);
+            }
+        }
+        const parent = HtmlSupport.parentElement(ctx.documentRoot, img);
+        const placement2 = placement !== "" ? placement : (parent?.tagName === "figure" ? "break" : "");
+        if (placement2 !== "") {
+            DitaBuilder.setAttr(image, "placement", placement2);
+        }
+        if (alt !== undefined && alt !== "" && !isMDITAKeyRef) {
+            const altElement = DitaBuilder.createElement("alt");
+            DitaBuilder.addText(altElement, alt);
+            image.addElement(altElement);
+        }
+        return image;
+    }
+    static processImgElement(img, ctx) {
+        const parent = HtmlSupport.parentElement(ctx.documentRoot, img);
+        if (parent !== undefined && NO_IMAGE_PH_PARENTS.includes(parent.tagName)) {
+            const ph = DitaBuilder.createElement("ph");
+            ph.addElement(HDITAConverter.processImage(img, ctx));
+            return ph;
+        }
+        return HDITAConverter.processImage(img, ctx);
+    }
+    static processImageParagraph(p, ctx) {
+        const img = HtmlSupport.firstElementNamed(HtmlSupport.children(p), "img");
+        const title = HtmlSupport.normalizeSpace(HtmlSupport.attribute(img, "title") ?? "");
+        if (title !== "") {
+            const fig = DitaBuilder.createElement("fig");
+            const titleElement = DitaBuilder.createElement("title");
+            DitaBuilder.addText(titleElement, title);
+            fig.addElement(titleElement);
+            fig.addElement(HDITAConverter.processImage(img, ctx, "break"));
+            return fig;
+        }
+        return HDITAConverter.processImage(img, ctx, "break");
+    }
+    static isImageOnlyParagraph(p) {
+        const nodes = HtmlSupport.children(p);
+        return nodes.length === 1 && HtmlSupport.isElement(nodes[0]) && nodes[0].tagName === "img" && p.attrs.length === 0;
+    }
+    static wrapGeneric(name, source, ctx, addRole = false) {
+        const result = DitaBuilder.createElement(name);
+        HDITAConverter.processCommonAttributes(source, result, ctx, addRole);
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(source), result, ctx);
+        return result;
+    }
+    static wrapGenericWithKeyref(name, source, ctx) {
+        const result = DitaBuilder.createElement(name);
+        HDITAConverter.processCommonAttributes(source, result, ctx);
+        HDITAConverter.processKeyrefAttribute(source, result);
+        HDITAConverter.applyTemplatesInto(HtmlSupport.children(source), result, ctx);
+        return result;
+    }
+    static applyTemplate(node, ctx) {
+        if (HtmlSupport.isTextNode(node)) {
+            return node.value;
+        }
+        if (!HtmlSupport.isElement(node)) {
+            return undefined;
+        }
+        const element = node;
+        const name = element.tagName;
+        if (name === "p" && HDITAConverter.isImageOnlyParagraph(element)) {
+            return HDITAConverter.processImageParagraph(element, ctx);
+        }
+        if (name === "table") {
+            const parent = HtmlSupport.parentElement(ctx.documentRoot, element);
+            const table = HDITATableConverter.processTable(element, ctx);
+            if (parent !== undefined && (parent.tagName === "td" || parent.tagName === "th" || parent.tagName === "figure" ||
+                (parent.tagName === "div" && HtmlSupport.attribute(parent, "data-class") === "fn"))) {
+                const p = DitaBuilder.createElement("p");
+                p.addElement(table);
+                return p;
+            }
+            return table;
+        }
+        switch (name) {
+            case "dl": return HDITAConverter.processDefinitionList(element, ctx);
+            case "ol": return HDITAConverter.processOrderedList(element, ctx);
+            case "figure": return HDITAConverter.processFigure(element, ctx);
+            case "blockquote": return HDITAConverter.processBlockquote(element, ctx);
+            case "pre": return HDITAConverter.processPre(element, ctx);
+            case "a": return HDITAConverter.processAnchor(element, ctx);
+            case "object": return HDITAConverter.processObject(element, ctx);
+            case "param": return HDITAConverter.processParam(element);
+            case "audio": return HDITAConverter.processAudio(element, ctx);
+            case "video": return HDITAConverter.processVideo(element, ctx);
+            case "img": return HDITAConverter.processImgElement(element, ctx);
+            case "source":
+                return HtmlSupport.attribute(element, "src") !== undefined
+                    ? HDITAConverter.mediaSourceElement("source", HtmlSupport.attribute(element, "src"))
+                    : undefined;
+            case "track":
+                return HtmlSupport.attribute(element, "src") !== undefined ? HDITAConverter.mediaTrackElement(element) : undefined;
+            case "strong":
+            case "b": return HDITAConverter.wrapGeneric("b", element, ctx);
+            case "em":
+            case "i": return HDITAConverter.wrapGeneric("i", element, ctx);
+            case "span":
+                if (HtmlSupport.attribute(element, "data-class") === "fn") {
+                    return HDITAConverter.processFootnoteSpan(element, ctx);
+                }
+                return HDITAConverter.wrapGenericWithKeyref("ph", element, ctx);
+            case "s":
+            case "strike": return HDITAConverter.wrapGeneric("line-through", element, ctx);
+            case "dfn": return HDITAConverter.wrapGenericWithKeyref("term", element, ctx);
+            case "abbr":
+            case "acronym": return HDITAConverter.wrapGenericWithKeyref("keyword", element, ctx);
+            case "code": return HDITAConverter.wrapGenericWithKeyref("codeph", element, ctx);
+            case "var": return HDITAConverter.wrapGenericWithKeyref("varname", element, ctx);
+            case "kbd": return HDITAConverter.wrapGenericWithKeyref("userinput", element, ctx);
+            case "samp": return HDITAConverter.wrapGenericWithKeyref("systemoutput", element, ctx);
+            case "cite": return HDITAConverter.wrapGenericWithKeyref("cite", element, ctx);
+            case "dt": return HDITAConverter.wrapGenericWithKeyref("dt", element, ctx);
+            case "dd": return HDITAConverter.wrapGeneric("dd", element, ctx);
+            case "li": return HDITAConverter.wrapGeneric("li", element, ctx);
+            case "div":
+                if (HtmlSupport.attribute(element, "data-class") === "note") {
+                    return HDITAConverter.processNote(element, ctx);
+                }
+                if (HtmlSupport.attribute(element, "data-class") === "fn") {
+                    return HDITAConverter.processFootnoteDiv(element, ctx);
+                }
+                return HDITAConverter.wrapGeneric("div", element, ctx);
+            case "p": return HDITAConverter.wrapGeneric("p", element, ctx);
+            case "ul": return HDITAConverter.wrapGeneric("ul", element, ctx);
+            case "sub": return HDITAConverter.wrapGeneric("sub", element, ctx);
+            case "sup": return HDITAConverter.wrapGeneric("sup", element, ctx);
+            case "u": return HDITAConverter.wrapGeneric("u", element, ctx);
+            case "q": return HDITAConverter.wrapGeneric("q", element, ctx);
+            case "tt": return HDITAConverter.wrapGeneric("tt", element, ctx);
+            case "del":
+            case "ins": {
+                const containerName = FLOW_CONTAINER_DESCENDANTS.some((tag) => HtmlSupport.findDescendant(HtmlSupport.children(element), tag) !== undefined) ? "div" : "ph";
+                return HDITAConverter.wrapGeneric(containerName, element, ctx, true);
+            }
+            default: break;
+        }
+        if (DIV_WRAPPED_ELEMENTS.includes(name)) {
+            return HDITAConverter.wrapGeneric("div", element, ctx, true);
+        }
+        if (PH_WRAPPED_ELEMENTS.includes(name)) {
+            return HDITAConverter.wrapGeneric("ph", element, ctx, true);
+        }
+        HDITAConverter.warnIgnoredElement(element, ctx);
+        return undefined;
+    }
+    static warnIgnoredElement(element, ctx) {
+        ctx.diagnostics.warning(ctx.diagnostics.i18n.format(ctx.diagnostics.i18n.getString("HDITAConverter", "ignoringElement"), [element.tagName]), ctx.documentPath);
+    }
+    static applyTemplatesInto(nodes, target, ctx) {
+        for (const node of nodes) {
+            if (HtmlSupport.isElement(node) && node.tagName === "section" &&
+                HtmlSupport.parentElement(ctx.documentRoot, node)?.tagName === "article") {
+                target.addElement(HDITAConverter.processTopLevelSection(node, ctx));
+                continue;
+            }
+            const converted = HDITAConverter.applyTemplate(node, ctx);
+            if (typeof converted === "string") {
+                DitaBuilder.addText(target, converted);
+            }
+            else if (converted !== undefined) {
+                target.addElement(converted);
+            }
+        }
+    }
+}
+//# sourceMappingURL=HDITAConverter.js.map