typesditac 1.0.0

package/dist/preprocess/TypesDitacPreprocessor.js

@@ -0,0 +1,1262 @@
+/*
+ * Portions Copyright (c) 2017-2025 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 { existsSync, mkdirSync, rmSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { LanguageUtils } from "typesbcp47";
+import { TextNode, XMLAttribute, XMLWriter } from "typesxml";
+import { DitaElement } from "../dom/DitaElement.js";
+import { DitaUtils } from "../utils/DitaUtils.js";
+import { NodeLocation } from "../utils/NodeLocation.js";
+import { URIComponent } from "../utils/URIComponent.js";
+import { AttributeValues } from "./AttributeValues.js";
+import { CascadeMeta } from "./CascadeMeta.js";
+import { ChunkDocumentBuilder } from "./ChunkDocumentBuilder.js";
+import { ChunkEntryType } from "./ChunkEntry.js";
+import { Chunking } from "./Chunking.js";
+import { ChunkPlan } from "./ChunkPlan.js";
+import { CollectionLinkProcessor } from "./CollectionLinkProcessor.js";
+import { ConrefIncluder } from "./ConrefIncluder.js";
+import { ConrefPusher } from "./ConrefPusher.js";
+import { CopyMeta } from "./CopyMeta.js";
+import { EmbeddedLists } from "./EmbeddedLists.js";
+import { ExtractAsImage } from "./ExtractAsImage.js";
+import { Filter } from "./Filter.js";
+import { Filters } from "./Filters.js";
+import { FormalElementCounter } from "./FormalElementCounter.js";
+import { FrontBackMatter } from "./FrontBackMatter.js";
+import { KeyLoader } from "./KeyLoader.js";
+import { ListingProcessor } from "./ListingProcessor.js";
+import { ListsDocumentBuilder } from "./ListsDocumentBuilder.js";
+import { ListTargetCollector } from "./ListTargetCollector.js";
+import { LoadedDocumentType } from "./LoadedDocument.js";
+import { LoadedDocuments } from "./LoadedDocuments.js";
+import { MapLoader } from "./MapLoader.js";
+import { MapSimplifier } from "./MapSimplifier.js";
+import { ReltableProcessor } from "./ReltableProcessor.js";
+import { SimplifyTopicrefs } from "./SimplifyTopicrefs.js";
+import { UnifiedDocumentBuilder } from "./UnifiedDocumentBuilder.js";
+import { WrapTopicrefTitle } from "./WrapTopicrefTitle.js";
+export class TypesDitacPreprocessor {
+    static IMAGE_ELEMENTS = [
+        "topic/image",
+        "svg-d/svgref",
+        "mathml-d/mathmlref"
+    ];
+    static XREF_ELEMENTS = [
+        "topic/ph",
+        "topic/term",
+        "topic/keyword",
+        "topic/cite",
+        "topic/dt",
+        "glossentry/glossAlternateFor",
+        "topic/xref"
+    ];
+    documents;
+    conrefPusher;
+    keyLoader;
+    mapSimplifier;
+    mapLoader;
+    listTargetCollector;
+    unifiedDocumentBuilder;
+    reltableProcessor;
+    collectionLinkProcessor;
+    diagnostics;
+    chunkDocumentBuilder;
+    listsDocumentBuilder;
+    topicIdRegistry = new Map();
+    chunkPlan;
+    chunkDocuments = new Map();
+    listsDocument;
+    unifiedDocument;
+    externalAttributeValues;
+    defaultAttributeValues;
+    attributeValues = new AttributeValues();
+    filters;
+    lang;
+    extractAsImage = false;
+    rootName;
+    extension;
+    outDir = "";
+    extractAsImageSpecs = [];
+    frontMatter;
+    backMatter;
+    media = "print";
+    resourceHandler;
+    chunking = Chunking.NONE;
+    forceTitlePage = false;
+    partRestartsChapterNumber = false;
+    constructor(documents, diagnostics, mapLoader, listTargetCollector, unifiedDocumentBuilder, conrefPusher, keyLoader, mapSimplifier) {
+        this.documents = documents;
+        this.diagnostics = diagnostics;
+        this.conrefPusher = conrefPusher ?? new ConrefPusher(documents, diagnostics);
+        this.keyLoader = keyLoader ?? new KeyLoader(diagnostics, documents);
+        this.mapSimplifier = mapSimplifier ?? new MapSimplifier(documents, diagnostics);
+        this.mapLoader = mapLoader ?? new MapLoader(documents, diagnostics);
+        this.listTargetCollector = listTargetCollector === undefined
+            ? new ListTargetCollector(diagnostics)
+            : listTargetCollector;
+        this.unifiedDocumentBuilder = unifiedDocumentBuilder === undefined
+            ? new UnifiedDocumentBuilder(diagnostics.i18n)
+            : unifiedDocumentBuilder;
+        this.reltableProcessor = new ReltableProcessor(diagnostics);
+        this.collectionLinkProcessor = new CollectionLinkProcessor(diagnostics);
+        this.filters = new Filters(diagnostics, documents.loader);
+        this.chunkDocumentBuilder = new ChunkDocumentBuilder(this.filters);
+        this.listsDocumentBuilder = new ListsDocumentBuilder(diagnostics);
+    }
+    determineDocLang(mapRoot, mapPath) {
+        const candidates = [mapRoot?.getAttribute("xml:lang")?.getValue().trim(), this.lang?.trim()];
+        for (const candidate of candidates) {
+            if (candidate === undefined || candidate.length === 0) {
+                continue;
+            }
+            const normalized = LanguageUtils.normalizeCode(candidate);
+            if (normalized !== undefined) {
+                return normalized;
+            }
+            this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "invalidLanguageCode"), [candidate]), mapPath);
+        }
+        return undefined;
+    }
+    setLang(lang) {
+        this.lang = lang;
+    }
+    setAttributeValues(attributeValues) {
+        this.externalAttributeValues = attributeValues;
+    }
+    getAttributeValues() {
+        return this.externalAttributeValues;
+    }
+    setDefaultAttributeValues(attributeValues) {
+        this.defaultAttributeValues = attributeValues;
+    }
+    getDefaultAttributeValues() {
+        return this.defaultAttributeValues;
+    }
+    setExtendedToc(extendedToc) {
+        this.unifiedDocumentBuilder.setExtendedToc(extendedToc);
+    }
+    getLang() {
+        return this.lang;
+    }
+    addExtractAsImageSpec(spec) {
+        this.extractAsImageSpecs.push(spec);
+    }
+    setExtractAsImage(extract) {
+        this.extractAsImage = extract;
+    }
+    setResourceHandler(handler) {
+        this.resourceHandler = handler;
+        this.filters.setResourceHandler(handler);
+    }
+    getResourceHandler() {
+        return this.resourceHandler;
+    }
+    setFrontMatter(items) {
+        this.frontMatter = items === undefined || items.length === 0 ? undefined : items;
+    }
+    getFrontMatter() {
+        return this.frontMatter;
+    }
+    setBackMatter(items) {
+        this.backMatter = items === undefined || items.length === 0 ? undefined : items;
+    }
+    getBackMatter() {
+        return this.backMatter;
+    }
+    setMedia(media) {
+        this.media = media;
+    }
+    getMedia() {
+        return this.media;
+    }
+    setChunking(chunking) {
+        this.chunking = chunking;
+    }
+    getChunking() {
+        return this.chunking;
+    }
+    setForceTitlePage(force) {
+        this.forceTitlePage = force;
+    }
+    getForceTitlePage() {
+        return this.forceTitlePage;
+    }
+    setPartRestartsChapterNumber(restarts) {
+        this.partRestartsChapterNumber = restarts;
+    }
+    getPartRestartsChapterNumber() {
+        return this.partRestartsChapterNumber;
+    }
+    process(mapPath, outFile, externalFilter) {
+        const absoluteOutFile = resolve(outFile);
+        this.outDir = dirname(absoluteOutFile);
+        if (!existsSync(this.outDir) || !statSync(this.outDir).isDirectory()) {
+            const message = this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "noOutputDirectory"), [this.outDir]);
+            this.diagnostics.error(message, this.outDir);
+            throw new Error(message);
+        }
+        const baseName = basename(absoluteOutFile).trim();
+        if (baseName.length === 0) {
+            this.rootName = undefined;
+            this.extension = undefined;
+        }
+        else {
+            const dot = baseName.lastIndexOf(".");
+            const rootName = (dot > 0 ? baseName.slice(0, dot) : baseName).trim();
+            this.rootName = rootName.length === 0 || rootName === "_" || rootName === "*" ? undefined : rootName;
+            const extension = dot > 0 ? baseName.slice(dot + 1).trim() : undefined;
+            this.extension = extension === undefined || extension.length === 0 ? undefined : extension;
+        }
+        if (this.resourceHandler !== undefined) {
+            this.resourceHandler.setMedia(this.media);
+            this.resourceHandler.reset();
+        }
+        this.filters.setOutputDirectory(this.outDir);
+        this.attributeValues = new AttributeValues();
+        if (this.externalAttributeValues !== undefined) {
+            this.attributeValues.addValues(this.externalAttributeValues);
+        }
+        const loader = this.documents.loader;
+        const validating = this.documents.isValidating();
+        const loadedDocs = new LoadedDocuments(loader, this.diagnostics);
+        loadedDocs.setValidating(validating);
+        const map = loadedDocs.load(mapPath, false);
+        const mapDocument = map.document;
+        const mapRoot = DitaUtils.getRoot(mapDocument);
+        if (mapRoot === undefined) {
+            throw new Error(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("LoadedDocument", "documentHasNoRoot"), [map.path]));
+        }
+        const keyFilter = externalFilter === undefined ? new Filter() : Filter.copyOf(externalFilter);
+        keyFilter.addExcludeProps("print", this.media === "print" ? "no" : "printonly");
+        this.filters.setExternalFilter(keyFilter);
+        this.keyLoader.setFilters(this.filters);
+        const keySpaces = this.keyLoader.load(mapDocument, map.path, loadedDocs);
+        // Simplify the main map. This also processes it. Afterwards, attribute values are fully initialized.
+        this.mapSimplifier.simplify(mapDocument, map.path, keySpaces, this.attributeValues, this.defaultAttributeValues);
+        SimplifyTopicrefs.duplicateTopics(mapRoot, this.diagnostics.i18n);
+        if (externalFilter !== undefined) {
+            this.attributeValues.validate(externalFilter, this.diagnostics);
+        }
+        this.filters.setAttributeValues(this.attributeValues);
+        this.filters.validateLoadedFilters();
+        FrontBackMatter.add(mapRoot, this.frontMatter, this.backMatter);
+        this.prepareChunking(mapRoot);
+        keySpaces.mapTopicsToKeySpaces(mapRoot, loadedDocs, map.path);
+        // Topic copies must be created from unprocessed topics.
+        SimplifyTopicrefs.createTopicCopies(mapRoot, map.path, loadedDocs, this.diagnostics);
+        const loadedDocs2 = new LoadedDocuments(loader, this.diagnostics, keySpaces);
+        loadedDocs2.setValidating(validating);
+        for (const loadedDoc of [...loadedDocs.values()]) {
+            // The main map has already been processed by the map simplifier.
+            const put = loadedDocs2.put(loadedDoc.path, loadedDoc.document, loadedDoc.document !== mapDocument);
+            put.setProperty("syntheticDocument", loadedDoc.getProperty("syntheticDocument"));
+        }
+        this.documents = loadedDocs2;
+        const topics = this.mapLoader.load(mapPath, this.documents);
+        this.validateAttributeValues(this.attributeValues);
+        const topicDocuments = [...this.documents.values()].filter((document) => document.type === LoadedDocumentType.TOPIC || document.type === LoadedDocumentType.MULTI_TOPIC);
+        new ConrefIncluder(this.documents, this.diagnostics).process(topicDocuments);
+        for (const topic of topics) {
+            CascadeMeta.processTopic(topic.element);
+        }
+        this.applyMapFilter(mapRoot, map.path, externalFilter, true);
+        CopyMeta.processMap(mapRoot, this.documents);
+        this.applyTopicFilters(mapRoot, map.path, externalFilter);
+        this.conrefPusher.process(topicDocuments);
+        WrapTopicrefTitle.processMap(mapRoot, map.path, this.documents);
+        this.collectionLinkProcessor.process(mapRoot, this.documents, map.path);
+        this.reltableProcessor.process(mapRoot, this.documents, map.path);
+        this.chunkPlan = ChunkPlan.fromMap(mapRoot, this.documents, map.path, this.diagnostics, this.rootName, map.type === LoadedDocumentType.BOOKMAP, this.partRestartsChapterNumber);
+        this.processLinks(this.chunkPlan, map.path, topics, this.documents);
+        if (this.extractAsImage) {
+            this.extractImages(this.chunkPlan, this.outDir);
+        }
+        if (this.resourceHandler !== undefined) {
+            this.processResources(this.chunkPlan, mapRoot, map.path);
+        }
+        this.sortColspecs(this.chunkPlan);
+        this.numberEquations(this.chunkPlan);
+        this.numberListingLines(this.chunkPlan);
+        const chunkBaseName = (chunk) => this.chunkBaseName(chunk.getRootName() ?? "");
+        const collectedTargets = this.listTargetCollector.collect(this.chunkPlan, chunkBaseName, this.topicIdRegistry);
+        const lists = new EmbeddedLists();
+        lists.addAll(collectedTargets);
+        const docLang = this.determineDocLang(mapRoot, map.path);
+        lists.setIndexTerms(this.listTargetCollector.indexTerms.getSortedEntries(docLang ?? "en"));
+        const listsDocument = this.listsDocumentBuilder.build(this.chunkPlan, lists, mapRoot, docLang, this.forceTitlePage, chunkBaseName);
+        this.listsDocument = listsDocument;
+        this.chunkDocuments = this.chunkDocumentBuilder.build(this.chunkPlan, docLang);
+        const unifiedDocument = this.unifiedDocumentBuilder.merge(map, this.chunkDocuments, listsDocument);
+        this.unifiedDocument = unifiedDocument;
+        return unifiedDocument;
+    }
+    static DITAC_SUFFIX = ".ditac";
+    static DITAC_LISTS_BASENAME = "ditac_lists.ditac_lists";
+    static DITAC_SUBDIR_BASENAME = "ditac_files";
+    chunkBaseName(rootName) {
+        let buffer = DitaUtils.quotePathSegment(rootName);
+        if (this.extension !== undefined) {
+            buffer += "." + DitaUtils.quotePathSegment(this.extension);
+        }
+        return buffer;
+    }
+    getChunkDocuments() {
+        return this.chunkDocuments;
+    }
+    getListsDocument() {
+        return this.listsDocument;
+    }
+    getUnifiedDocument() {
+        return this.unifiedDocument;
+    }
+    getOutputDirectory() {
+        return this.outDir;
+    }
+    writeChunkOutput() {
+        const listsFile = join(this.outDir, TypesDitacPreprocessor.DITAC_LISTS_BASENAME);
+        if (this.listsDocument !== undefined) {
+            XMLWriter.writeDocument(this.listsDocument, listsFile);
+        }
+        const chunkFiles = [];
+        for (const [rootName, document] of this.chunkDocuments) {
+            const chunkFile = join(this.outDir, rootName + TypesDitacPreprocessor.DITAC_SUFFIX);
+            XMLWriter.writeDocument(document, chunkFile);
+            chunkFiles.push(chunkFile);
+        }
+        return { listsFile, chunkFiles };
+    }
+    extractImages(plan, outDir) {
+        const extractDir = join(outDir, TypesDitacPreprocessor.DITAC_SUBDIR_BASENAME);
+        try {
+            if (existsSync(extractDir)) {
+                rmSync(extractDir, { recursive: true, force: true });
+            }
+            mkdirSync(extractDir);
+        }
+        catch (error) {
+            this.diagnostics.error(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "cannotCreateDirectory"), [extractDir, error instanceof Error ? error.message : String(error)]), extractDir);
+            throw error;
+        }
+        const extractor = new ExtractAsImage(extractDir, this.diagnostics);
+        for (const spec of this.extractAsImageSpecs) {
+            extractor.addSpec(spec);
+        }
+        const processed = new Set();
+        for (const chunk of plan.chunks) {
+            for (const entry of chunk.getEntries()) {
+                const topic = entry.type === ChunkEntryType.TOPIC ? entry.loadedTopic : undefined;
+                if (topic === undefined || processed.has(topic)) {
+                    continue;
+                }
+                processed.add(topic);
+                extractor.process(topic.element, topic.getAncestorDocument().path);
+            }
+        }
+    }
+    processResources(plan, mapRoot, mapPath) {
+        const handler = this.resourceHandler;
+        if (handler === undefined) {
+            return;
+        }
+        if (mapRoot !== undefined) {
+            const title = DitaUtils.getChildByClass(mapRoot, "topic/title");
+            if (title !== undefined) {
+                this.processResourcesInElement(title, handler, mapPath);
+            }
+            const metadata = DitaUtils.getChildByClass(mapRoot, "map/topicmeta");
+            if (metadata !== undefined) {
+                this.processResourcesInElement(metadata, handler, mapPath);
+            }
+        }
+        const processed = new Set();
+        for (const chunk of plan.chunks) {
+            for (const entry of chunk.getEntries()) {
+                const topic = entry.type === ChunkEntryType.TOPIC ? entry.loadedTopic : undefined;
+                if (topic === undefined || processed.has(topic)) {
+                    continue;
+                }
+                processed.add(topic);
+                this.processResourcesInElement(topic.element, handler, topic.getAncestorDocument().path);
+            }
+        }
+    }
+    processResourcesInElement(element, handler, documentPath) {
+        for (const child of element.getChildren()) {
+            if (DitaUtils.hasClass(child, "topic/topic")) {
+                return;
+            }
+            if (DitaUtils.hasClass(child, "topic/image")) {
+                this.processResource(child, "href", true, handler, documentPath);
+            }
+            else if (DitaUtils.hasClass(child, "topic/object")) {
+                this.processObjectResources(child, handler, documentPath);
+            }
+            else {
+                this.processResourcesInElement(child, handler, documentPath);
+            }
+        }
+    }
+    processObjectResources(element, handler, documentPath) {
+        this.processResource(element, "classid", false, handler, documentPath);
+        this.processResource(element, "data", false, handler, documentPath);
+        this.processArchiveResources(element, handler, documentPath);
+        for (const parameter of element.getChildren().filter((child) => DitaUtils.hasClass(child, "topic/param"))) {
+            const name = DitaUtils.getNonEmptyAttribute(parameter, "name");
+            if (name === "source" || name === "track") {
+                this.processResource(parameter, "value", false, handler, documentPath);
+            }
+            else if (name === "poster") {
+                this.processResource(parameter, "value", true, handler, documentPath);
+            }
+        }
+        this.processResourcesInElement(element, handler, documentPath);
+    }
+    processResource(element, attributeName, isImage, handler, documentPath) {
+        const absoluteAttributeName = "ditac:absolute" + attributeName[0].toUpperCase() + attributeName.slice(1);
+        if (DitaUtils.getNonEmptyAttribute(element, absoluteAttributeName) !== undefined) {
+            element.removeAttribute(absoluteAttributeName);
+            return;
+        }
+        const href = DitaUtils.getNonEmptyAttribute(element, attributeName);
+        if (href === undefined) {
+            return;
+        }
+        const resolved = this.tryHandleResource(handler, href, isImage, element, documentPath);
+        if (resolved !== undefined && resolved !== href) {
+            element.setAttribute(new XMLAttribute(attributeName, resolved));
+        }
+    }
+    processArchiveResources(element, handler, documentPath) {
+        const absoluteAttributeName = "ditac:absoluteArchive";
+        const absoluteValue = DitaUtils.getNonEmptyAttribute(element, absoluteAttributeName);
+        element.removeAttribute(absoluteAttributeName);
+        const archive = DitaUtils.getNonEmptyAttribute(element, "archive");
+        if (archive === undefined || absoluteValue === undefined) {
+            return;
+        }
+        const absoluteFlags = absoluteValue.split(/\s+/);
+        const hrefs = archive.split(/\s+/);
+        const resolvedHrefs = [];
+        let changed = false;
+        for (let index = 0; index < hrefs.length; index++) {
+            if (absoluteFlags[index] === "true") {
+                resolvedHrefs.push(hrefs[index]);
+                continue;
+            }
+            const resolved = this.tryHandleResource(handler, hrefs[index], false, element, documentPath);
+            if (resolved !== undefined && resolved !== hrefs[index]) {
+                changed = true;
+                resolvedHrefs.push(resolved);
+            }
+            else {
+                resolvedHrefs.push(hrefs[index]);
+            }
+        }
+        if (changed) {
+            element.setAttribute(new XMLAttribute("archive", resolvedHrefs.join(" ")));
+        }
+    }
+    tryHandleResource(handler, href, isImage, element, documentPath) {
+        try {
+            return handler.handleResource(href, isImage, this.outDir);
+        }
+        catch (error) {
+            const message = this.diagnostics.i18n.format(this.diagnostics.i18n.getString("Filter", "cannotProcessResource"), [href, error instanceof Error ? error.message : String(error)]);
+            this.diagnostics.error(message, NodeLocation.of(documentPath, element));
+            return undefined;
+        }
+    }
+    sortColspecs(plan) {
+        const processed = new Set();
+        for (const chunk of plan.chunks) {
+            for (const entry of chunk.getEntries()) {
+                const topic = entry.type === ChunkEntryType.TOPIC ? entry.loadedTopic : undefined;
+                if (topic === undefined || processed.has(topic)) {
+                    continue;
+                }
+                processed.add(topic);
+                this.sortColspecsInElement(topic.element, topic.getAncestorDocument().path);
+            }
+        }
+    }
+    sortColspecsInElement(element, location) {
+        for (const child of element.getChildren()) {
+            if (DitaUtils.hasClass(child, "topic/topic")) {
+                return;
+            }
+            if (DitaUtils.hasClass(child, "topic/tgroup")) {
+                this.sortColspecsInGroup(child, location);
+            }
+            else {
+                this.sortColspecsInElement(child, location);
+            }
+        }
+    }
+    sortColspecsInGroup(tgroup, location) {
+        const colspecs = DitaUtils.findChildrenByClass(tgroup, "topic/colspec");
+        if (colspecs.length <= 1) {
+            return;
+        }
+        const hasColnums = colspecs.some((colspec) => this.getColnum(colspec, location, false) >= 1);
+        if (!hasColnums) {
+            return;
+        }
+        let prevColnum = 0;
+        for (const colspec of colspecs) {
+            let colnum = this.getColnum(colspec, location, true);
+            if (colnum >= 1) {
+                if (colnum <= prevColnum) {
+                    this.diagnostics.error(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "unsortedColnum"), [colnum.toString(), prevColnum.toString()]), location);
+                }
+            }
+            else {
+                colnum = prevColnum + 1;
+                colspec.setAttribute(new XMLAttribute("colnum", colnum.toString()));
+            }
+            prevColnum = colnum;
+        }
+        const sorted = colspecs.slice().sort((a, b) => this.getColnum(a, location, false) - this.getColnum(b, location, false));
+        const content = tgroup.getContent();
+        const lastIndex = content.lastIndexOf(colspecs[colspecs.length - 1]);
+        const anchor = content[lastIndex + 1];
+        const remaining = content.filter((node) => !colspecs.includes(node));
+        const insertIndex = anchor === undefined ? remaining.length : remaining.indexOf(anchor);
+        remaining.splice(insertIndex, 0, ...sorted);
+        tgroup.setContent(remaining);
+    }
+    getColnum(colspec, location, reportError) {
+        const value = DitaUtils.getNonEmptyAttribute(colspec, "colnum");
+        if (value === undefined) {
+            return -1;
+        }
+        const normalized = value.trim();
+        const decimalPattern = /^[+-]?(?:(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?|Infinity|NaN)[fFdD]?$/;
+        const hexadecimalPattern = /^[+-]?0[xX](?:[0-9a-fA-F]+(?:\.[0-9a-fA-F]*)?|\.[0-9a-fA-F]+)[pP][+-]?[0-9]+[fFdD]?$/;
+        const parsesAsDouble = decimalPattern.test(normalized) || hexadecimalPattern.test(normalized);
+        if (!parsesAsDouble) {
+            if (reportError) {
+                this.diagnostics.error(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "invalidColnum"), [value]), location);
+            }
+            return -1;
+        }
+        const suffix = normalized.slice(-1).toLowerCase();
+        const numericValue = suffix === "f" || suffix === "d"
+            ? normalized.slice(0, -1)
+            : normalized;
+        let parsed;
+        if (hexadecimalPattern.test(normalized)) {
+            const sign = numericValue.startsWith("-") ? -1 : 1;
+            const unsigned = numericValue.replace(/^[+-]/, "");
+            const parts = unsigned.slice(2).split(/[pP]/);
+            const significandParts = parts[0].split(".");
+            const fraction = significandParts.length === 1 ? "" : significandParts[1];
+            const significand = Number.parseInt(significandParts[0] + fraction, 16);
+            const exponent = Number.parseInt(parts[1], 10);
+            parsed = sign * significand * Math.pow(16, exponent - fraction.length * 4);
+        }
+        else {
+            parsed = Number(numericValue);
+        }
+        let colnum;
+        if (Number.isNaN(parsed)) {
+            colnum = 0;
+        }
+        else if (parsed >= 2147483647) {
+            colnum = 2147483647;
+        }
+        else if (parsed <= -2147483648) {
+            colnum = -2147483648;
+        }
+        else {
+            colnum = Math.trunc(parsed);
+        }
+        return colnum >= 1 ? colnum : -1;
+    }
+    numberEquations(plan) {
+        const equationCounter = new FormalElementCounter("equation");
+        const processed = new Set();
+        for (const chunk of plan.chunks) {
+            for (const entry of chunk.getEntries()) {
+                const topic = entry.type === ChunkEntryType.TOPIC ? entry.loadedTopic : undefined;
+                if (topic === undefined || processed.has(topic)) {
+                    continue;
+                }
+                processed.add(topic);
+                equationCounter.traversing(entry);
+                this.numberEquationsInElement(topic.element, equationCounter);
+            }
+        }
+    }
+    numberEquationsInElement(element, counter) {
+        for (const child of element.getChildren()) {
+            if (DitaUtils.hasClass(child, "topic/topic")) {
+                return;
+            }
+            if (DitaUtils.hasClass(child, "equation-d/equation-block")) {
+                const numbers = DitaUtils.findChildrenByClass(child, "equation-d/equation-number");
+                if (numbers.length > 0) {
+                    counter.increment();
+                    const value = counter.format();
+                    for (const number of numbers) {
+                        if (!DitaUtils.hasContent(number)) {
+                            number.addString(value);
+                            number.setAttribute(new XMLAttribute("ditac:filled", "true"));
+                        }
+                    }
+                }
+            }
+            else {
+                this.numberEquationsInElement(child, counter);
+            }
+        }
+    }
+    numberListingLines(plan) {
+        const processed = new Set();
+        for (const chunk of plan.chunks) {
+            for (const entry of chunk.getEntries()) {
+                const topic = entry.type === ChunkEntryType.TOPIC ? entry.loadedTopic : undefined;
+                if (topic === undefined || processed.has(topic)) {
+                    continue;
+                }
+                processed.add(topic);
+                ListingProcessor.processTopic(topic.element, topic.getAncestorDocument().path, this.diagnostics);
+            }
+        }
+    }
+    applyMapFilter(mapRoot, mapPath, externalFilter, excludeResourceOnly) {
+        const filterCopy = externalFilter === undefined ? new Filter() : Filter.copyOf(externalFilter);
+        if (excludeResourceOnly) {
+            filterCopy.addExcludeProps("processing-role", "resource-only");
+        }
+        filterCopy.addExcludeProps("print", this.media === "print" ? "no" : "printonly");
+        this.filters.setExternalFilter(filterCopy);
+        this.filters.filterMap(mapRoot, mapPath);
+    }
+    applyTopicFilters(mapRoot, mapPath, externalFilter) {
+        if (mapRoot === undefined) {
+            return;
+        }
+        if (externalFilter === undefined && !DitaUtils.containsDitavalrefs(mapRoot)) {
+            return;
+        }
+        this.filters.setExternalFilter(externalFilter);
+        this.filters.filterTopics(mapRoot, mapPath, this.documents);
+    }
+    validateAttributeValues(values) {
+        if (!values.hasAttributes()) {
+            return;
+        }
+        for (const document of this.documents.values()) {
+            if (document.type !== LoadedDocumentType.TOPIC && document.type !== LoadedDocumentType.MULTI_TOPIC) {
+                continue;
+            }
+            const root = DitaUtils.getRoot(document.document);
+            if (root !== undefined) {
+                values.validate(root, document.path, this.diagnostics);
+            }
+        }
+    }
+    prepareChunking(mapRoot) {
+        let chunkMode = this.chunking;
+        if (chunkMode === Chunking.AUTO && this.media === "print") {
+            chunkMode = Chunking.NONE;
+        }
+        if (chunkMode !== Chunking.AUTO) {
+            this.discardChunk(mapRoot, chunkMode === Chunking.SINGLE);
+            mapRoot.setAttribute(new XMLAttribute("chunk", "to-content"));
+        }
+    }
+    discardChunk(element, keepSelect) {
+        for (const child of element.getChildren()) {
+            if (keepSelect) {
+                const value = child.getAttribute("chunk")?.getValue();
+                if (value !== undefined && value.length > 0) {
+                    const tokens = value.trim().split(/\s+/);
+                    const select = tokens.find((token) => token.startsWith("select-"));
+                    if (select === undefined) {
+                        child.removeAttribute("chunk");
+                    }
+                    else {
+                        child.setAttribute(new XMLAttribute("chunk", select));
+                    }
+                }
+            }
+            else {
+                child.removeAttribute("chunk");
+            }
+            this.discardChunk(child, keepSelect);
+        }
+    }
+    processLinks(plan, mapPath, topics, loadedDocuments) {
+        const targets = this.indexTopics(plan, mapPath, topics);
+        this.normalizeTopicIds(plan);
+        const glossEntries = new Set();
+        const processed = new Set();
+        for (const chunk of plan.chunks) {
+            for (const entry of chunk.getEntries()) {
+                const topic = entry.type === ChunkEntryType.TOPIC ? entry.loadedTopic : undefined;
+                if (topic === undefined || processed.has(topic.element)) {
+                    continue;
+                }
+                processed.add(topic.element);
+                this.rewriteTopic(topic.element, topic, chunk, plan, targets, mapPath, glossEntries, loadedDocuments);
+            }
+        }
+    }
+    normalizeTopicIds(plan) {
+        const used = this.topicIdRegistry;
+        const processed = new Set();
+        for (const chunk of plan.chunks) {
+            for (const entry of chunk.getEntries()) {
+                const topic = entry.type === ChunkEntryType.TOPIC ? entry.loadedTopic : undefined;
+                if (topic === undefined || processed.has(topic.element)) {
+                    continue;
+                }
+                processed.add(topic.element);
+                const originalTopicId = topic.element.getAttribute("id")?.getValue().trim() || topic.topicId;
+                const topicId = DitaUtils.makeUniqueId(originalTopicId, used, topic.element);
+                topic.element.setAttribute(new XMLAttribute("id", topicId));
+                this.processIds(topic.element, topicId, used, topic.getAncestorDocument().path);
+            }
+        }
+    }
+    processIds(element, topicId, used, documentPath) {
+        for (const child of element.getChildren()) {
+            if (DitaUtils.hasClass(child, "topic/topic")) {
+                return;
+            }
+            if (!DitaUtils.hasDITANamespace(child)) {
+                continue;
+            }
+            const originalId = DitaUtils.getNonEmptyAttribute(child, "id");
+            if (originalId !== undefined) {
+                if (DitaUtils.hasClass(child, "topic/resourceid")) {
+                    used.set(originalId, child);
+                }
+                else {
+                    const candidate = topicId + "__" + originalId;
+                    if (used.has(candidate)) {
+                        this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "duplicateId"), [originalId, "???"]), documentPath);
+                    }
+                    const flattenedId = DitaUtils.makeUniqueId(candidate, used, child);
+                    child.setAttribute(new XMLAttribute("id", flattenedId));
+                }
+            }
+            this.processIds(child, topicId, used, documentPath);
+        }
+    }
+    indexTopics(plan, mapPath, topics) {
+        const targets = new Map();
+        const indexedTopics = new Set();
+        for (const chunk of plan.chunks) {
+            for (const entry of chunk.getEntries()) {
+                if (entry.type !== ChunkEntryType.TOPIC || entry.loadedTopic === undefined) {
+                    continue;
+                }
+                const topic = entry.loadedTopic;
+                if (indexedTopics.has(topic)) {
+                    continue;
+                }
+                indexedTopics.add(topic);
+                const target = { topic, chunk };
+                this.addTarget(targets, topic.getAncestorDocument().path + "#" + topic.topicId, target);
+                this.addTarget(targets, topic.getHref(), target);
+                const sourceHref = topic.getSourceHref();
+                if (sourceHref !== undefined) {
+                    this.addTarget(targets, sourceHref, target);
+                    this.addTarget(targets, this.normalizeTarget(sourceHref, mapPath), target);
+                }
+                if (topic === topic.getAncestorDocument().getFirstTopic()) {
+                    const documentPath = topic.getAncestorDocument().path;
+                    this.addTarget(targets, documentPath, target);
+                    this.addTarget(targets, this.normalizePath(documentPath, mapPath), target);
+                }
+            }
+        }
+        for (const topic of topics) {
+            if (indexedTopics.has(topic)) {
+                continue;
+            }
+            const target = { topic, chunk: plan.getChunk(topic) };
+            const sourceHref = topic.getSourceHref();
+            if (sourceHref !== undefined) {
+                this.addTarget(targets, sourceHref, target);
+                this.addTarget(targets, this.normalizeTarget(sourceHref, mapPath), target);
+            }
+            const documentPath = topic.getAncestorDocument().path;
+            this.addTarget(targets, documentPath + "#" + topic.topicId, target);
+            this.addTarget(targets, topic.getHref(), target);
+        }
+        return targets;
+    }
+    addTarget(targets, href, target) {
+        targets.set(href, target);
+    }
+    rewriteTopic(element, currentTopic, currentChunk, plan, targets, mapPath, glossEntries, loadedDocuments) {
+        for (const child of element.getChildren()) {
+            if (DitaUtils.hasClass(child, "topic/topic")) {
+                return;
+            }
+            let deeper = true;
+            if (TypesDitacPreprocessor.IMAGE_ELEMENTS.some((cls) => DitaUtils.hasClass(child, cls))) {
+                this.checkImageHref(child, currentTopic.getAncestorDocument().path);
+            }
+            else {
+                const href = child.getAttribute("href");
+                if (href !== undefined &&
+                    this.isLocalDitaHref(child, href.getValue(), currentTopic.getAncestorDocument().path)) {
+                    const target = this.targetURLToChunkRef(href.getValue(), currentTopic, targets, currentTopic.getAncestorDocument().path, loadedDocuments);
+                    if ("error" in target) {
+                        if (target.error === "invalidAttribute") {
+                            this.diagnostics.error(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("Filter", "invalidAttribute"), [href.getValue(), "href"]), currentTopic.getAncestorDocument().path + ": href=\"" + href.getValue() + "\"");
+                        }
+                        else {
+                            this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("LinkGenerator", "pointsOutsidePreprocessedTopics"), [href.getValue()]), currentTopic.getAncestorDocument().path + ": href=\"" + href.getValue() + "\"");
+                        }
+                    }
+                    else if (!this.rewriteResolvedLink(child, target.target, currentChunk, plan)) {
+                        this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("LinkGenerator", "pointsOutsidePreprocessedTopics"), [href.getValue()]), currentTopic.getAncestorDocument().path + ": href=\"" + href.getValue() + "\"");
+                    }
+                    else {
+                        const targetElement = this.resolveTargetElement(target.target);
+                        if (targetElement === undefined) {
+                            this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "noHrefTarget"), [target.target.topic.getHref()]), currentTopic.getAncestorDocument().path + ": href=\"" + href.getValue() + "\"");
+                        }
+                        else {
+                            const done = this.fillLinkContent(child, targetElement, glossEntries, currentTopic.getAncestorDocument().path);
+                            if (!done) {
+                                this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "noLinkText"), [child.getName(), targetElement.getName(), targetElement.getAttribute("id")?.getValue() ?? ""]), currentTopic.getAncestorDocument().path + ": href=\"" + href.getValue() + "\"");
+                            }
+                            deeper = child.getAttribute("ditac:filled") === undefined;
+                        }
+                    }
+                }
+            }
+            if (deeper) {
+                this.rewriteTopic(child, currentTopic, currentChunk, plan, targets, mapPath, glossEntries, loadedDocuments);
+            }
+        }
+    }
+    rewriteResolvedLink(element, target, currentChunk, plan) {
+        const targetChunk = target.chunk ?? plan.getChunk(target.topic);
+        if (targetChunk === undefined) {
+            return false;
+        }
+        const targetName = targetChunk.getRootName();
+        if (targetName === undefined) {
+            return false;
+        }
+        const targetId = this.targetId(target);
+        const prefix = targetChunk === currentChunk ? "" : this.chunkBaseName(targetName);
+        element.setAttribute(new XMLAttribute("href", prefix + "#" + URIComponent.quoteFragment(targetId)));
+        return true;
+    }
+    targetURLToChunkRef(href, currentTopic, targets, mapPath, loadedDocuments) {
+        if (href.startsWith("#")) {
+            const fragment = href.slice(1);
+            const slash = fragment.lastIndexOf("/");
+            const topicPart = slash >= 0 ? fragment.slice(0, slash) : fragment;
+            const elementPart = slash >= 0 ? fragment.slice(slash + 1) : undefined;
+            const topicId = URIComponent.decode(topicPart.trim());
+            const elementId = elementPart === undefined || elementPart.trim().length === 0
+                ? undefined
+                : URIComponent.decode(elementPart.trim());
+            if (topicId.length === 0) {
+                return { error: "invalidAttribute" };
+            }
+            const documentPath = currentTopic === undefined
+                ? undefined
+                : currentTopic.getAncestorDocument().path;
+            const target = documentPath === undefined
+                ? undefined
+                : targets.get(documentPath + "#" + topicId);
+            return target === undefined
+                ? { error: "pointsOutsidePreprocessedTopics" }
+                : { target: { ...target, elementId } };
+        }
+        const parts = href.split("#", 2);
+        const base = parts[0];
+        const normalizedBase = this.normalizePath(base, mapPath);
+        const normalizedTarget = this.normalizeTarget(href, mapPath);
+        if (parts.length === 1) {
+            const existingTarget = targets.get(base) ?? targets.get(normalizedBase);
+            if (existingTarget !== undefined) {
+                return { target: existingTarget };
+            }
+            const loadedTarget = this.loadTarget(normalizedBase, undefined, loadedDocuments, targets);
+            if (loadedTarget === undefined) {
+                return { error: "pointsOutsidePreprocessedTopics" };
+            }
+            return { target: { topic: loadedTarget } };
+        }
+        const fragment = parts[1];
+        const slash = fragment.lastIndexOf("/");
+        const topicPart = slash >= 0 ? fragment.slice(0, slash) : fragment;
+        const elementPart = slash >= 0 ? fragment.slice(slash + 1) : undefined;
+        const topicId = URIComponent.decode(topicPart.trim());
+        const elementId = elementPart === undefined || elementPart.trim().length === 0
+            ? undefined
+            : URIComponent.decode(elementPart.trim());
+        if (topicId.length === 0) {
+            return { error: "invalidAttribute" };
+        }
+        const candidates = [
+            base + "#" + topicPart,
+            base + "#" + topicId,
+            normalizedTarget,
+            normalizedBase + "#" + topicPart,
+            normalizedBase + "#" + topicId
+        ];
+        for (const candidate of candidates) {
+            const target = targets.get(candidate);
+            if (target !== undefined) {
+                return { target: { ...target, elementId } };
+            }
+        }
+        for (const target of new Set(targets.values())) {
+            if (target.topic.getAncestorDocument().path === normalizedBase && target.topic.topicId === topicId) {
+                return { target: { ...target, elementId } };
+            }
+            const sourceHref = target.topic.getSourceHref();
+            if (sourceHref !== undefined) {
+                const sourceParts = sourceHref.split("#", 2);
+                const sourceTopicId = sourceParts.length === 2
+                    ? URIComponent.decode(sourceParts[1].split("/", 1)[0])
+                    : undefined;
+                if (sourceTopicId === topicId && this.normalizePath(sourceParts[0], mapPath) === normalizedBase) {
+                    return { target: { ...target, elementId } };
+                }
+            }
+        }
+        const loadedTarget = this.loadTarget(normalizedBase, topicId, loadedDocuments, targets);
+        if (loadedTarget !== undefined) {
+            return { target: { topic: loadedTarget, elementId } };
+        }
+        return { error: "pointsOutsidePreprocessedTopics" };
+    }
+    loadTarget(documentPath, topicId, loadedDocuments, targets) {
+        try {
+            const document = loadedDocuments.load(documentPath);
+            const topic = topicId === undefined
+                ? document.getFirstTopic()
+                : document.findTopicById(topicId);
+            if (topic !== undefined) {
+                this.addTarget(targets, topicId === undefined ? documentPath : documentPath + "#" + topicId, { topic });
+                return topic;
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    resolveTarget(target) {
+        const topicId = target.topic.element.getAttribute("id")?.getValue() ?? target.topic.topicId;
+        if (target.elementId === undefined) {
+            return { id: topicId, element: target.topic.element };
+        }
+        const wantedId = topicId + "__" + target.elementId;
+        for (const element of this.ownDescendants(target.topic.element)) {
+            if (element.getAttribute("id")?.getValue() === wantedId) {
+                return { id: wantedId, element };
+            }
+        }
+        return { id: wantedId };
+    }
+    ownDescendants(element) {
+        const result = [];
+        for (const child of element.getChildren()) {
+            if (DitaUtils.hasClass(child, "topic/topic")) {
+                return result;
+            }
+            result.push(child);
+            result.push(...this.ownDescendants(child));
+        }
+        return result;
+    }
+    targetId(target) {
+        return this.resolveTarget(target).id;
+    }
+    resolveTargetElement(target) {
+        return this.resolveTarget(target).element;
+    }
+    normalizePath(href, mapPath) {
+        const queryIndex = href.indexOf("?");
+        const base = queryIndex < 0 ? href : href.slice(0, queryIndex);
+        if (base.startsWith("file:")) {
+            try {
+                return fileURLToPath(new URL(base));
+            }
+            catch {
+                return base;
+            }
+        }
+        return base.length === 0 ? mapPath : DitaUtils.resolveDocumentPath(mapPath, base);
+    }
+    normalizeTarget(href, mapPath) {
+        const hashIndex = href.indexOf("#");
+        if (hashIndex < 0) {
+            return this.normalizePath(href, mapPath);
+        }
+        const base = href.slice(0, hashIndex);
+        return this.normalizePath(base, mapPath) + href.slice(hashIndex);
+    }
+    isLocalDitaHref(element, href, documentPath) {
+        const scope = DitaUtils.getScope(element, href);
+        if (scope !== "local") {
+            return false;
+        }
+        const format = DitaUtils.getFormat(element, href, scope);
+        if (format === undefined) {
+            this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("DITAUtil", "missingAttribute"), ["format"]), documentPath + ": href=\"" + href + "\"");
+            return false;
+        }
+        return format === "dita";
+    }
+    checkImageHref(element, documentPath) {
+        const href = DitaUtils.getNonEmptyAttribute(element, "href");
+        if (href === undefined) {
+            this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("Filter", "missingAttribute"), ["href"]), documentPath);
+            return;
+        }
+        if (href.startsWith("data:")) {
+            return;
+        }
+        if (/^https?:\/\//i.test(href)) {
+            try {
+                new URL(href);
+            }
+            catch {
+                this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("Filter", "invalidAttribute"), [href, "href"]), documentPath + ": href=\"" + href + "\"");
+                return;
+            }
+            if (!DitaUtils.urlExists(href.split("#", 1)[0])) {
+                this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "noSuchFile"), [href]), documentPath + ": href=\"" + href + "\"");
+            }
+            return;
+        }
+        let filePath;
+        if (href.startsWith("file:")) {
+            try {
+                filePath = fileURLToPath(href);
+            }
+            catch {
+                this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("Filter", "invalidAttribute"), [href, "href"]), documentPath + ": href=\"" + href + "\"");
+                return;
+            }
+        }
+        else {
+            filePath = href.split("#", 1)[0];
+        }
+        if (!existsSync(filePath)) {
+            this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "noSuchFile"), [filePath]), documentPath + ": href=\"" + href + "\"");
+        }
+    }
+    fillLinkContent(element, target, glossEntries, documentPath) {
+        if (DitaUtils.hasClass(element, "topic/link")) {
+            return this.addLinkText(element, target);
+        }
+        if (DitaUtils.hasClass(element, "abbrev-d/abbreviated-form")) {
+            return this.addAbbrev(element, target, glossEntries, documentPath);
+        }
+        if (TypesDitacPreprocessor.XREF_ELEMENTS.some((cls) => DitaUtils.hasClass(element, cls))) {
+            return this.addXrefText(element, target, documentPath);
+        }
+        return true;
+    }
+    addLinkText(link, target) {
+        let linktext = DitaUtils.getChildByClass(link, "topic/linktext");
+        if (linktext !== undefined && DitaUtils.collapseWhitespace(DitaUtils.getTextContent(linktext)).length === 0) {
+            link.removeChild(linktext);
+            linktext = undefined;
+        }
+        let desc = DitaUtils.getChildByClass(link, "topic/desc");
+        if (desc !== undefined && DitaUtils.collapseWhitespace(DitaUtils.getTextContent(desc)).length === 0) {
+            link.removeChild(desc);
+            desc = undefined;
+        }
+        let done = false;
+        if (linktext !== undefined) {
+            done = true;
+        }
+        else {
+            const title = DitaUtils.hasClass(target, "topic/title") ? target : this.getTitleFromChild(target, true);
+            if (title !== undefined) {
+                const newLinktext = new DitaElement("linktext");
+                newLinktext.setAttribute(new XMLAttribute("class", "- topic/linktext "));
+                this.insertBefore(link, newLinktext, desc);
+                this.copyChildren(title, newLinktext);
+                done = true;
+                link.setAttribute(new XMLAttribute("ditac:filled", "true"));
+            }
+        }
+        if (desc === undefined) {
+            let shortdesc = DitaUtils.getChildByClass(target, "topic/shortdesc");
+            if (shortdesc === undefined && DitaUtils.hasClass(target, "topic/topic")) {
+                const container = DitaUtils.getChildByClass(target, "topic/abstract");
+                if (container !== undefined) {
+                    shortdesc = DitaUtils.getChildByClass(container, "topic/shortdesc");
+                }
+            }
+            if (shortdesc !== undefined) {
+                const newDesc = new DitaElement("desc");
+                newDesc.setAttribute(new XMLAttribute("class", "- topic/desc "));
+                link.addElement(newDesc);
+                this.copyChildren(shortdesc, newDesc);
+            }
+        }
+        return done;
+    }
+    addAbbrev(abbrev, target, glossEntries, documentPath) {
+        const useLongForm = !glossEntries.has(target);
+        if (useLongForm) {
+            glossEntries.add(target);
+        }
+        const longForm = DitaUtils.getDescendantByClass(target, 0, ["glossentry/glossSurfaceForm"]);
+        const shortForm = DitaUtils.getDescendantByClass(target, 0, ["glossentry/glossAcronym", "glossentry/glossAbbreviation", "glossentry/glossShortForm"]);
+        let done;
+        if (useLongForm) {
+            if (longForm === undefined) {
+                done = this.addXrefText(abbrev, target, documentPath);
+            }
+            else {
+                this.fillXref(abbrev, longForm);
+                done = true;
+            }
+        }
+        else if (shortForm === undefined) {
+            done = this.addXrefText(abbrev, target, documentPath);
+        }
+        else {
+            this.fillXref(abbrev, shortForm);
+            done = true;
+            const title = longForm === undefined ? "" : DitaUtils.collapseWhitespace(DitaUtils.getTextContent(longForm));
+            if (title.length > 0) {
+                abbrev.setAttribute(new XMLAttribute("ditac:title", title));
+            }
+        }
+        return done;
+    }
+    addXrefText(xref, target, documentPath) {
+        if (DitaUtils.hasContent(xref)) {
+            return true;
+        }
+        const isXref = DitaUtils.hasClass(xref, "topic/xref");
+        const xrefType = xref.getAttribute("type")?.getValue().trim();
+        if (isXref && xrefType === "fn") {
+            return true;
+        }
+        if (DitaUtils.hasClass(target, "topic/fn") && isXref && xrefType === undefined) {
+            if (!this.isLwDITA(xref)) {
+                this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("PreProcessor", "missingAttribute2"), ["type", "fn"]), documentPath + ": " + xref.getName());
+            }
+            xref.setAttribute(new XMLAttribute("type", "fn"));
+            return true;
+        }
+        if (DitaUtils.hasClass(target, "topic/li")) {
+            const parent = target.getParent();
+            if (parent !== undefined && DitaUtils.hasClass(parent, "topic/ol")) {
+                const number = this.listItemIndex(parent, target);
+                if (number > 0) {
+                    xref.addTextNode(new TextNode(number.toString()));
+                    xref.setAttribute(new XMLAttribute("ditac:filled", "true"));
+                    return true;
+                }
+            }
+        }
+        if (DitaUtils.hasClass(target, "topic/dlentry")) {
+            const term = DitaUtils.getChildByClass(target, "topic/dt");
+            if (term !== undefined) {
+                this.fillXref(xref, term);
+                return true;
+            }
+        }
+        const title = DitaUtils.hasClass(target, "topic/title") ? target : this.getTitleFromChild(target, true);
+        if (title === undefined) {
+            return false;
+        }
+        this.fillXref(xref, title);
+        return true;
+    }
+    fillXref(xref, title) {
+        this.copyChildren(title, xref);
+        xref.setAttribute(new XMLAttribute("ditac:filled", "true"));
+    }
+    isLwDITA(element) {
+        const domains = DitaUtils.lookupAncestorAttribute(element, "domains");
+        if (domains === undefined) {
+            return false;
+        }
+        const collapsed = DitaUtils.collapseWhitespace(domains);
+        return collapsed.length > 0 && collapsed.indexOf(" xdita-c)") > 0;
+    }
+    getTitleFromChild(element, preferNavtitle) {
+        let titleElement;
+        if (preferNavtitle && DitaUtils.hasClass(element, "topic/topic")) {
+            const titlealts = DitaUtils.getChildByClass(element, "topic/titlealts");
+            if (titlealts !== undefined) {
+                const navtitle = DitaUtils.getChildByClass(titlealts, "topic/navtitle");
+                if (navtitle !== undefined) {
+                    titleElement = this.checkTitleChild(navtitle);
+                }
+            }
+        }
+        if (titleElement === undefined) {
+            const title = DitaUtils.getChildByClass(element, "topic/title");
+            if (title !== undefined) {
+                titleElement = this.checkTitleChild(title);
+            }
+        }
+        return titleElement;
+    }
+    checkTitleChild(element) {
+        return DitaUtils.collapseWhitespace(DitaUtils.getTextContent(element)).length > 0 ? element : undefined;
+    }
+    listItemIndex(parent, element) {
+        let index = 1;
+        for (const child of parent.getChildren()) {
+            if (child === element) {
+                return index;
+            }
+            if (child.getName() === element.getName()) {
+                index++;
+            }
+        }
+        return -1;
+    }
+    insertBefore(parent, newChild, before) {
+        if (before === undefined) {
+            parent.addElement(newChild);
+            return;
+        }
+        const content = parent.getContent();
+        const index = content.indexOf(before);
+        if (index < 0) {
+            parent.addElement(newChild);
+            return;
+        }
+        content.splice(index, 0, newChild);
+        parent.setContent(content);
+    }
+    copyChildren(source, target) {
+        const content = target.getContent();
+        for (const node of source.getContent()) {
+            content.push(node instanceof DitaElement ? DitaUtils.cloneElement(node) : node);
+        }
+        target.setContent(content);
+    }
+}
+//# sourceMappingURL=TypesDitacPreprocessor.js.map