typesditac 1.0.0

package/dist/preprocess/LoadedDocuments.js

@@ -0,0 +1,851 @@
+/*
+ * 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 { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ProcessingInstruction, XMLAttribute } 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 { CascadeMeta } from "./CascadeMeta.js";
+import { LoadedDocument, LoadedDocumentType } from "./LoadedDocument.js";
+export class LoadedDocuments {
+    static SUPPORTED_DITA_VERSIONS = ["1.0", "1.1", "1.2", "1.3"];
+    loader;
+    diagnostics;
+    documents = new Map();
+    preloadedDocuments = new Map();
+    keySpaces;
+    validate = false;
+    cascadingAttributes;
+    constructor(loader, diagnostics, keySpaces) {
+        this.loader = loader;
+        this.diagnostics = diagnostics;
+        this.keySpaces = keySpaces;
+    }
+    setValidating(validate) {
+        this.validate = validate;
+    }
+    isValidating() {
+        return this.validate;
+    }
+    preload(filePath) {
+        const canonicalPath = this.canonicalize(filePath);
+        const existing = this.documents.get(canonicalPath);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const preloaded = this.preloadedDocuments.get(canonicalPath);
+        if (preloaded !== undefined) {
+            return preloaded;
+        }
+        const document = this.createLoadedDocument(canonicalPath, this.loadDocument(canonicalPath, this.validate));
+        document.getTopics(this.diagnostics);
+        this.preloadedDocuments.set(canonicalPath, document);
+        return document;
+    }
+    loadDocument(filePath, validate) {
+        return this.loader.load(filePath, validate);
+    }
+    load(filePath, process = true) {
+        const canonicalPath = this.canonicalize(filePath);
+        const existing = this.documents.get(canonicalPath);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const document = this.preload(canonicalPath);
+        this.preloadedDocuments.delete(canonicalPath);
+        this.documents.set(document.path, document);
+        if (process) {
+            this.processLoadedDocument(document);
+        }
+        // Not a fatal error.
+        this.checkDITAVersion(document);
+        return document;
+    }
+    createLoadedDocument(filePath, document) {
+        return new LoadedDocument(filePath, document, this.diagnostics.i18n);
+    }
+    checkDITAVersion(document) {
+        const root = DitaUtils.getRoot(document.document);
+        if (root === undefined) {
+            return false;
+        }
+        let checked = true;
+        if (document.type === LoadedDocumentType.MULTI_TOPIC) {
+            for (const child of root.getChildren()) {
+                if (!this.checkDITAVersionElement(child, document.path)) {
+                    checked = false;
+                }
+            }
+        }
+        else if (document.type !== LoadedDocumentType.DITAVAL) {
+            checked = this.checkDITAVersionElement(root, document.path);
+        }
+        return checked;
+    }
+    checkDITAVersionElement(element, documentPath) {
+        const version = DitaUtils.getNonEmptyAttribute(element, "ditaarch:DITAArchVersion");
+        if (version === undefined) {
+            this.diagnostics.error(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("Filter", "missingAttribute"), ["ditaarch:DITAArchVersion"]), NodeLocation.of(documentPath, element));
+            return false;
+        }
+        if (!LoadedDocuments.SUPPORTED_DITA_VERSIONS.includes(version)) {
+            this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("LoadedDocuments", "unsupportedDITAVersion"), [version, LoadedDocuments.SUPPORTED_DITA_VERSIONS.join(", ")]), NodeLocation.of(documentPath, element));
+        }
+        return true;
+    }
+    put(filePath, document, process = true) {
+        const canonicalPath = this.canonicalize(filePath);
+        const loadedDocument = this.createLoadedDocument(canonicalPath, document);
+        loadedDocument.getTopics(this.diagnostics);
+        this.documents.set(canonicalPath, loadedDocument);
+        this.preloadedDocuments.delete(canonicalPath);
+        if (process) {
+            this.processLoadedDocument(loadedDocument);
+        }
+        return loadedDocument;
+    }
+    processLoadedDocument(document) {
+        const root = DitaUtils.getRoot(document.document);
+        if (root === undefined) {
+            return;
+        }
+        const keySpaces = this.keySpaces;
+        if (keySpaces === undefined || document.type === LoadedDocumentType.DITAVAL || document.type === LoadedDocumentType.SUBJECT_SCHEME) {
+            this.process(root, document.path);
+        }
+        else if (document.type === LoadedDocumentType.TOPIC || document.type === LoadedDocumentType.MULTI_TOPIC) {
+            for (const topic of document.getTopics()) {
+                this.process(topic.element, document.path, keySpaces, keySpaces.getTopicKeySpace(topic.getHref()));
+            }
+        }
+        else {
+            this.process(root, document.path, keySpaces);
+        }
+    }
+    get(filePath) {
+        return this.documents.get(this.canonicalize(filePath));
+    }
+    remove(filePath) {
+        const canonicalPath = this.canonicalize(filePath);
+        const document = this.documents.get(canonicalPath);
+        this.documents.delete(canonicalPath);
+        this.preloadedDocuments.delete(canonicalPath);
+        return document;
+    }
+    has(filePath) {
+        return this.documents.has(this.canonicalize(filePath));
+    }
+    size() {
+        return this.documents.size;
+    }
+    values() {
+        return this.documents.values();
+    }
+    iterator() {
+        return this.documents.values();
+    }
+    ensureHasValidId(element, documentPath) {
+        const id = DitaUtils.getNonEmptyAttribute(element, "id");
+        if (id !== undefined && DitaUtils.isValidId(id)) {
+            return id;
+        }
+        if (id !== undefined) {
+            this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("Filter", "invalidAttribute"), [id, "id"]), NodeLocation.of(documentPath, element));
+        }
+        const generated = DitaUtils.generateId("I", element);
+        element.setAttribute(new XMLAttribute("id", generated));
+        return generated;
+    }
+    needsId(element) {
+        return DitaUtils.hasClass(element, "topic/topic") ||
+            DitaUtils.hasClass(element, "topic/section") ||
+            DitaUtils.hasClass(element, "topic/table") ||
+            DitaUtils.hasClass(element, "topic/fig") ||
+            DitaUtils.hasClass(element, "topic/example") ||
+            DitaUtils.hasClass(element, "topic/indexterm");
+    }
+    process(element, documentPath, keySpaces, topicKeySpace) {
+        if (this.needsId(element)) {
+            this.ensureHasValidId(element, documentPath);
+        }
+        let currentKeySpace = topicKeySpace;
+        if (DitaUtils.hasClass(element, "topic/topic")) {
+            const topicId = DitaUtils.getNonEmptyAttribute(element, "id");
+            if (keySpaces !== undefined && topicKeySpace !== undefined && topicId !== undefined) {
+                currentKeySpace = keySpaces.getTopicKeySpace(URIComponent.setFragment(documentPath, topicId));
+            }
+        }
+        if (keySpaces !== undefined && currentKeySpace !== undefined) {
+            keySpaces.mapElementToKeySpace(element, currentKeySpace);
+        }
+        for (const attributeName of ["conref", "conrefend", "href"]) {
+            this.resolveHref(element, attributeName, documentPath);
+        }
+        if (keySpaces !== undefined) {
+            this.resolveElement(element, keySpaces, documentPath, currentKeySpace);
+        }
+        if (DitaUtils.hasClass(element, "topic/object")) {
+            this.resolveObjectElement(element, keySpaces, documentPath);
+        }
+        let child = element.getContent()[0];
+        while (child !== undefined) {
+            const content = element.getContent();
+            const childIndex = content.indexOf(child);
+            const nextChild = childIndex >= 0 && childIndex + 1 < content.length
+                ? content[childIndex + 1]
+                : undefined;
+            if (child instanceof DitaElement) {
+                if (DitaUtils.hasDITANamespace(child)) {
+                    this.process(child, documentPath, keySpaces, currentKeySpace);
+                }
+            }
+            else if (child instanceof ProcessingInstruction && child.getTarget() === "onclick") {
+                this.ensureHasValidId(element, documentPath);
+            }
+            child = nextChild;
+        }
+    }
+    resolveHref(element, attributeName, documentPath) {
+        const value = DitaUtils.getNonEmptyAttribute(element, attributeName);
+        if (value === undefined) {
+            return;
+        }
+        let href = value;
+        if (value.startsWith("#")) {
+            href = this.getDocumentUrl(documentPath) + this.resolveFragment(value, element, documentPath);
+        }
+        else {
+            let resolveRelative = true;
+            if (value.startsWith("data:")) {
+                resolveRelative = false;
+                this.markAbsoluteHref(element, attributeName);
+            }
+            else {
+                const absolute = this.resolveAbsoluteUri(value);
+                if (absolute !== undefined) {
+                    href = absolute;
+                    resolveRelative = false;
+                    this.markAbsoluteHref(element, attributeName);
+                }
+            }
+            if (resolveRelative && attributeName === "href" && !DitaUtils.hasClass(element, "topic/image")) {
+                // Do not resolve an href pointing to a peer or external resource.
+                const scope = DitaUtils.inheritAttribute(element, "scope");
+                if (scope !== undefined && scope !== "local") {
+                    resolveRelative = false;
+                }
+            }
+            if (resolveRelative) {
+                href = this.createUrl(documentPath, value);
+            }
+        }
+        element.setAttribute(new XMLAttribute(attributeName, href));
+    }
+    markAbsoluteHref(element, attributeName) {
+        if (attributeName === "href") {
+            element.setAttribute(new XMLAttribute("ditac:absoluteHref", "true"));
+        }
+    }
+    resolveFragment(fragment, link, documentPath) {
+        if (fragment === "#." || fragment.startsWith("#./")) {
+            const topic = DitaUtils.findAncestorByClass(link, "topic/topic");
+            if (topic !== undefined) {
+                const topicId = this.ensureHasValidId(topic, documentPath);
+                return "#" + URIComponent.quoteFragment(topicId) + fragment.slice(2);
+            }
+        }
+        return fragment;
+    }
+    getDocumentUrl(documentPath) {
+        return /^https?:\/\//i.test(documentPath) ? documentPath : DitaUtils.toFileUrl(documentPath);
+    }
+    createUrl(baseLocation, spec) {
+        if (DitaUtils.hasURIScheme(spec)) {
+            return spec;
+        }
+        if (/^(https?|file):/i.test(baseLocation)) {
+            return new URL(spec, baseLocation).toString().replace(/^file:\/\/\//, "file:/");
+        }
+        const hashIndex = spec.indexOf("#");
+        const fragment = hashIndex < 0 ? "" : spec.slice(hashIndex);
+        const withoutFragment = hashIndex < 0 ? spec : spec.slice(0, hashIndex);
+        const queryIndex = withoutFragment.indexOf("?");
+        const sourcePath = queryIndex < 0 ? withoutFragment : withoutFragment.slice(0, queryIndex);
+        const query = queryIndex < 0 ? "" : withoutFragment.slice(queryIndex);
+        const target = sourcePath.length === 0
+            ? baseLocation
+            : resolve(baseLocation, "..", URIComponent.decode(sourcePath));
+        return DitaUtils.toFileUrl(target) + query + fragment;
+    }
+    resolveAbsoluteUri(value) {
+        if (!DitaUtils.hasURIScheme(value)) {
+            return undefined;
+        }
+        const catalogUrl = this.resolveCatalogURL(value);
+        if (catalogUrl !== undefined) {
+            return catalogUrl;
+        }
+        try {
+            return new URL(value).toString();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    resolveUri(location, documentPath) {
+        return this.resolveAbsoluteUri(location) ?? this.createUrl(documentPath, location);
+    }
+    resolveCatalogURL(value) {
+        const catalogMatches = [
+            this.loader.catalog.matchSystem(value),
+            this.loader.catalog.matchURI(value),
+            this.loader.catalog.matchPublic(value)
+        ];
+        for (const match of catalogMatches) {
+            if (match === undefined) {
+                continue;
+            }
+            if (DitaUtils.hasURIScheme(match)) {
+                try {
+                    return new URL(match).toString();
+                }
+                catch {
+                    continue;
+                }
+            }
+            return DitaUtils.toFileUrl(resolve(match));
+        }
+        return undefined;
+    }
+    resolveElement(element, keySpaces, documentPath, topicKeySpace) {
+        let resolved = false;
+        const conkeyref = DitaUtils.getNonEmptyAttribute(element, "conkeyref");
+        if (conkeyref !== undefined && this.resolveConkeyref(element, conkeyref, keySpaces, documentPath, topicKeySpace)) {
+            resolved = true;
+        }
+        const keyref = DitaUtils.getNonEmptyAttribute(element, "keyref");
+        if (keyref !== undefined && this.resolveKeyref(element, keyref, keySpaces, documentPath, topicKeySpace)) {
+            resolved = true;
+        }
+        return resolved;
+    }
+    lookupDefinition(keySpaces, key, element, topicKeySpace) {
+        return keySpaces.lookupKeyDefinition(topicKeySpace ?? keySpaces.getElementKeySpace(element), key);
+    }
+    resolveConkeyref(element, value, keySpaces, documentPath, topicKeySpace) {
+        element.removeAttribute("conkeyref");
+        const split = this.splitKeyref("conkeyref", value, element, documentPath);
+        if (split === undefined) {
+            return false;
+        }
+        const href = this.lookupDefinition(keySpaces, split.key, element, topicKeySpace)?.getHref();
+        if (href === undefined) {
+            this.keyrefWarning(element, "conkeyref", value, "conref", documentPath);
+            return false;
+        }
+        element.setAttribute(new XMLAttribute("conref", this.addIdToHref(href, split.id)));
+        return true;
+    }
+    resolveKeyref(element, value, keySpaces, documentPath, topicKeySpace) {
+        element.removeAttribute("keyref");
+        const split = this.splitKeyref("keyref", value, element, documentPath);
+        if (split === undefined) {
+            return false;
+        }
+        const definition = this.lookupDefinition(keySpaces, split.key, element, topicKeySpace);
+        if (definition === undefined) {
+            this.keyrefWarning(element, "keyref", value, "href", documentPath);
+            return false;
+        }
+        const href = this.processKeyref(definition, split.id, element);
+        // Remove void elements.
+        if (href === undefined && !DitaUtils.hasContent(element)) {
+            element.getParent()?.removeChild(element);
+        }
+        return true;
+    }
+    splitKeyref(attributeName, value, element, documentPath) {
+        const separator = value.indexOf("/");
+        const key = separator < 0 ? value : value.slice(0, separator);
+        const id = separator < 0 ? undefined : value.slice(separator + 1);
+        if (!DitaUtils.isValidKey(key) || (id !== undefined && !DitaUtils.isValidId(id))) {
+            this.diagnostics.error(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("Filter", "invalidAttribute"), [value, attributeName]), NodeLocation.of(documentPath, element));
+            return undefined;
+        }
+        return id === undefined ? { key } : { key, id };
+    }
+    keyrefWarning(element, attributeName, keyref, fallbackAttributeName, documentPath) {
+        const key = DitaUtils.getNonEmptyAttribute(element, fallbackAttributeName) === undefined
+            ? "cannotResolveKeyref2"
+            : "cannotResolveKeyref";
+        this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("LoadedDocuments", key), [attributeName, keyref, fallbackAttributeName]), NodeLocation.of(documentPath, element));
+    }
+    addIdToHref(href, id) {
+        if (id === undefined) {
+            return href;
+        }
+        const quotedId = URIComponent.quoteFragment(id);
+        return href.includes("#") ? href + "/" + quotedId : href + "#" + quotedId;
+    }
+    static LINKING_ATTRIBUTES = ["href", "scope", "format", "ditac:absoluteHref", "ditac:copyOf"];
+    processKeyref(definition, id, element) {
+        let href = definition.getHref();
+        if (href !== undefined && definition.getAttribute("linking") === "none" &&
+            !DitaUtils.hasClass(element, "abbrev-d/abbreviated-form")) {
+            // Not conforming, but an empty abbreviated-form needs content from the glossentry.
+            href = undefined;
+        }
+        if (href !== undefined) {
+            href = this.addIdToHref(href, id);
+            for (const name of LoadedDocuments.LINKING_ATTRIBUTES) {
+                const value = name === "href" ? href : definition.getAttribute(name);
+                if (value === undefined) {
+                    element.removeAttribute(name);
+                }
+                else {
+                    element.setAttribute(new XMLAttribute(name, value));
+                }
+            }
+        }
+        else {
+            for (const name of LoadedDocuments.LINKING_ATTRIBUTES) {
+                element.removeAttribute(name);
+            }
+        }
+        if (DitaUtils.hasClass(element, "map/topicref")) {
+            this.addMetadata(definition, element);
+        }
+        else {
+            this.addContent(definition, element);
+        }
+        return href;
+    }
+    resolveObjectElement(element, keySpaces, documentPath) {
+        let codebase;
+        const codebaseLocation = DitaUtils.getNonEmptyAttribute(element, "codebase");
+        if (codebaseLocation !== undefined) {
+            // No longer useful.
+            element.removeAttribute("codebase");
+            codebase = this.resolveUri(codebaseLocation, documentPath);
+        }
+        if (keySpaces !== undefined) {
+            const keyref = DitaUtils.getNonEmptyAttribute(element, "codebasekeyref");
+            if (keyref !== undefined) {
+                element.removeAttribute("codebasekeyref");
+                const resolved = this.resolveObjectKeyrefTarget(element, "codebasekeyref", keyref, "codebase", true, keySpaces, documentPath);
+                if (resolved !== undefined) {
+                    codebase = resolved.url;
+                }
+            }
+        }
+        const classid = DitaUtils.getNonEmptyAttribute(element, "classid");
+        if (classid !== undefined) {
+            if (classid.startsWith("clsid:")) {
+                element.setAttribute(new XMLAttribute("ditac:absoluteClassid", "true"));
+            }
+            else {
+                this.resolveObjectAttributeUrl(element, "classid", classid, codebase, documentPath);
+            }
+        }
+        if (keySpaces !== undefined) {
+            this.resolveObjectKeyref(element, "classidkeyref", "classid", keySpaces, documentPath);
+        }
+        const data = DitaUtils.getNonEmptyAttribute(element, "data");
+        if (data !== undefined) {
+            this.resolveObjectAttributeUrl(element, "data", data, codebase, documentPath);
+        }
+        if (keySpaces !== undefined) {
+            this.resolveObjectType(element, "datakeyref", keySpaces);
+            this.resolveObjectKeyref(element, "datakeyref", "data", keySpaces, documentPath);
+        }
+        const archive = DitaUtils.getNonEmptyAttribute(element, "archive");
+        if (archive !== undefined) {
+            this.resolveObjectAttributeUrls(element, "archive", archive, codebase, documentPath);
+        }
+        if (keySpaces !== undefined) {
+            this.resolveObjectKeyrefs(element, "archivekeyrefs", "archive", keySpaces, documentPath);
+        }
+        for (const param of DitaUtils.findChildrenByClass(element, "topic/param")) {
+            this.resolveObjectParam(element, param, keySpaces, documentPath);
+        }
+    }
+    resolveObjectParam(element, param, keySpaces, documentPath) {
+        let valuetype = DitaUtils.getNonEmptyAttribute(param, "valuetype");
+        if (DitaUtils.getNonEmptyAttribute(param, "keyref") !== undefined) {
+            if (valuetype === undefined) {
+                valuetype = "ref";
+            }
+            else if (valuetype !== "ref") {
+                this.diagnostics.warning(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("LoadedDocuments", "ignoringAttribute"), ["keyref"]), NodeLocation.of(documentPath, param));
+                param.removeAttribute("keyref");
+            }
+        }
+        const name = DitaUtils.getNonEmptyAttribute(param, "name");
+        if (valuetype === "ref" || ((name === "source" || name === "track" || name === "poster") && valuetype === undefined)) {
+            // Explicit or implicit valuetype=ref.
+            param.setAttribute(new XMLAttribute("valuetype", "ref"));
+            const location = DitaUtils.getNonEmptyAttribute(param, "value");
+            if (location !== undefined) {
+                this.resolveObjectAttributeUrl(param, "value", location, undefined, documentPath);
+            }
+            if (keySpaces !== undefined) {
+                this.resolveObjectType(param, "keyref", keySpaces);
+                this.resolveObjectKeyref(param, "keyref", "value", keySpaces, documentPath);
+            }
+        }
+        else if (name === "movie" && valuetype === undefined) {
+            // Implicit valuetype=ref depending on the object type.
+            const type = DitaUtils.getNonEmptyAttribute(element, "type");
+            const location = DitaUtils.getNonEmptyAttribute(param, "value");
+            const isRef = type?.toLowerCase() === "application/x-shockwave-flash" ||
+                (location !== undefined && location.toLowerCase().endsWith(".swf"));
+            if (isRef) {
+                param.setAttribute(new XMLAttribute("valuetype", "ref"));
+                param.setAttribute(new XMLAttribute("type", "application/x-shockwave-flash"));
+                if (location !== undefined) {
+                    this.resolveObjectAttributeUrl(param, "value", location, undefined, documentPath);
+                }
+                if (keySpaces !== undefined) {
+                    this.resolveObjectKeyref(param, "keyref", "value", keySpaces, documentPath);
+                }
+            }
+        }
+    }
+    resolveObjectType(element, attributeName, keySpaces) {
+        if (DitaUtils.getNonEmptyAttribute(element, "type") !== undefined) {
+            return;
+        }
+        const keyref = DitaUtils.getNonEmptyAttribute(element, attributeName);
+        if (keyref === undefined) {
+            return;
+        }
+        const type = keySpaces.get(keyref, element)?.getAttribute("type");
+        if (type !== undefined) {
+            element.setAttribute(new XMLAttribute("type", type));
+        }
+    }
+    resolveObjectKeyref(element, attributeName, fallbackAttributeName, keySpaces, documentPath) {
+        const keyref = DitaUtils.getNonEmptyAttribute(element, attributeName);
+        if (keyref === undefined) {
+            return;
+        }
+        // No longer useful.
+        element.removeAttribute(attributeName);
+        const resolved = this.resolveObjectKeyrefTarget(element, attributeName, keyref, fallbackAttributeName, true, keySpaces, documentPath);
+        if (resolved === undefined) {
+            return;
+        }
+        element.setAttribute(new XMLAttribute(fallbackAttributeName, resolved.url));
+        const absoluteName = "ditac:absolute" + this.capitalize(fallbackAttributeName);
+        if (resolved.absolute) {
+            element.setAttribute(new XMLAttribute(absoluteName, "true"));
+        }
+        else {
+            element.removeAttribute(absoluteName);
+        }
+    }
+    resolveObjectKeyrefs(element, attributeName, fallbackAttributeName, keySpaces, documentPath) {
+        const value = DitaUtils.getNonEmptyAttribute(element, attributeName);
+        if (value === undefined) {
+            return;
+        }
+        // No longer useful.
+        element.removeAttribute(attributeName);
+        const urls = [];
+        const absoluteFlags = [];
+        for (const keyref of value.split(/\s+/).filter((item) => item.length > 0)) {
+            const resolved = this.resolveObjectKeyrefTarget(element, attributeName, keyref, fallbackAttributeName, false, keySpaces, documentPath);
+            if (resolved !== undefined) {
+                urls.push(resolved.url);
+                absoluteFlags.push(resolved.absolute ? "true" : "false");
+            }
+        }
+        if (urls.length === 0) {
+            this.keyrefWarning(element, attributeName, value, fallbackAttributeName, documentPath);
+            return;
+        }
+        element.setAttribute(new XMLAttribute(fallbackAttributeName, urls.join(" ")));
+        element.setAttribute(new XMLAttribute("ditac:absolute" + this.capitalize(fallbackAttributeName), absoluteFlags.join(" ")));
+    }
+    resolveObjectKeyrefTarget(element, attributeName, keyref, fallbackAttributeName, warn, keySpaces, documentPath) {
+        let target;
+        const definition = keySpaces.get(keyref, element);
+        if (definition !== undefined) {
+            const href = definition.getHref();
+            const url = href === undefined ? undefined : this.resolveAbsoluteUri(href);
+            if (url !== undefined) {
+                target = { url, absolute: definition.getAttribute("ditac:absoluteHref") === "true" };
+            }
+        }
+        if (target === undefined && warn) {
+            this.keyrefWarning(element, attributeName, keyref, fallbackAttributeName, documentPath);
+        }
+        return target;
+    }
+    resolveObjectAttributeUrls(element, attributeName, value, codebase, documentPath) {
+        const hrefs = [];
+        const absoluteFlags = [];
+        for (const item of value.split(/\s+/).filter((part) => part.length > 0)) {
+            const joined = this.joinObjectUrl(codebase, item);
+            if (joined.startsWith("#")) {
+                hrefs.push(this.getDocumentUrl(documentPath) + joined);
+                absoluteFlags.push("false");
+                continue;
+            }
+            const absolute = this.resolveAbsoluteUri(joined);
+            if (absolute === undefined) {
+                hrefs.push(this.createUrl(documentPath, joined));
+                absoluteFlags.push("false");
+            }
+            else {
+                hrefs.push(absolute);
+                absoluteFlags.push("true");
+            }
+        }
+        element.setAttribute(new XMLAttribute(attributeName, hrefs.join(" ")));
+        element.setAttribute(new XMLAttribute("ditac:absolute" + this.capitalize(attributeName), absoluteFlags.join(" ")));
+    }
+    resolveObjectAttributeUrl(element, attributeName, value, codebase, documentPath) {
+        const joined = this.joinObjectUrl(codebase, value);
+        let href = joined;
+        if (joined.startsWith("#")) {
+            href = this.getDocumentUrl(documentPath) + joined;
+        }
+        else {
+            const absolute = this.resolveAbsoluteUri(joined);
+            if (absolute === undefined) {
+                href = this.createUrl(documentPath, joined);
+            }
+            else {
+                href = absolute;
+                element.setAttribute(new XMLAttribute("ditac:absolute" + this.capitalize(attributeName), "true"));
+            }
+        }
+        element.setAttribute(new XMLAttribute(attributeName, href));
+    }
+    joinObjectUrl(codebase, path) {
+        if (codebase === undefined) {
+            return path;
+        }
+        try {
+            return new URL(path, codebase).toString().replace(/^file:\/\/\//, "file:/");
+        }
+        catch {
+            return path;
+        }
+    }
+    capitalize(name) {
+        return name.charAt(0).toUpperCase() + name.slice(1);
+    }
+    static VARIABLE_ELEMENTS = [
+        "topic/dt", "topic/cite", "topic/term", "topic/keyword", "topic/ph"
+    ];
+    isVariableElement(element) {
+        return LoadedDocuments.VARIABLE_ELEMENTS.some((className) => DitaUtils.hasClass(element, className));
+    }
+    addContent(definition, element) {
+        // Get rid of the empty linktext and desc children created by some editors.
+        const isLink = DitaUtils.hasClass(element, "topic/link");
+        if (isLink) {
+            const linktext = DitaUtils.getChildByClass(element, "topic/linktext");
+            if (linktext !== undefined && !DitaUtils.hasContent(linktext)) {
+                element.removeChild(linktext);
+            }
+            const desc = DitaUtils.getChildByClass(element, "topic/desc");
+            if (desc !== undefined && !DitaUtils.hasContent(desc)) {
+                element.removeChild(desc);
+            }
+        }
+        const meta = definition.getMeta();
+        if (meta === undefined) {
+            return;
+        }
+        if (!DitaUtils.hasContent(element)) {
+            if (isLink) {
+                const linktext = DitaUtils.getChildByClass(meta, "map/linktext");
+                if (linktext !== undefined) {
+                    element.addElement(this.copyElement(linktext, "linktext", "topic/linktext"));
+                }
+            }
+            else if (DitaUtils.hasClass(element, "topic/xref")) {
+                const linktext = DitaUtils.getChildByClass(meta, "map/linktext");
+                if (linktext !== undefined) {
+                    this.copyChildren(linktext, element);
+                }
+            }
+            else if (this.isVariableElement(element)) {
+                let container;
+                const keywords = DitaUtils.getChildByClass(meta, "topic/keywords");
+                if (keywords !== undefined) {
+                    container = DitaUtils.getChildByClass(keywords, "topic/keyword");
+                }
+                if (container === undefined) {
+                    container = DitaUtils.getChildByClass(meta, "map/linktext");
+                }
+                if (container !== undefined) {
+                    this.copyChildren(container, element);
+                }
+            }
+        }
+        if ((DitaUtils.hasClass(element, "topic/xref") || DitaUtils.hasClass(element, "topic/link")) &&
+            DitaUtils.getChildByClass(element, "topic/desc") === undefined) {
+            const shortdesc = DitaUtils.getChildByClass(meta, "map/shortdesc");
+            if (shortdesc !== undefined) {
+                element.addElement(this.copyElement(shortdesc, "desc", "topic/desc"));
+            }
+        }
+        else if (DitaUtils.hasClass(element, "topic/image") &&
+            DitaUtils.getNonEmptyAttribute(element, "alt") === undefined &&
+            DitaUtils.getChildByClass(element, "topic/alt") === undefined) {
+            const container = DitaUtils.getChildByClass(meta, "map/linktext") ??
+                DitaUtils.getChildByClass(meta, "map/shortdesc");
+            if (container !== undefined) {
+                element.addElement(this.copyElement(container, "alt", "topic/alt"));
+            }
+        }
+        else if (this.isVariableElement(element)) {
+            const shortdesc = DitaUtils.getChildByClass(meta, "map/shortdesc");
+            if (shortdesc !== undefined) {
+                // May be used as a tooltip.
+                const title = DitaUtils.collapseWhitespace(DitaUtils.getTextContent(shortdesc));
+                if (title.length > 0) {
+                    element.setAttribute(new XMLAttribute("ditac:title", title));
+                }
+            }
+        }
+    }
+    copyElement(from, name, className) {
+        const source = DitaUtils.cloneElement(from);
+        const copy = new DitaElement(name);
+        copy.setAttributes(source.getAttributes());
+        copy.setAttribute(new XMLAttribute("class", "- " + className + " "));
+        copy.setContent(source.getContent());
+        return copy;
+    }
+    copyChildren(from, to) {
+        const source = DitaUtils.cloneElement(from);
+        to.setContent([...to.getContent(), ...source.getContent()]);
+    }
+    static BASE_CASCADING_ATTRIBUTES = [
+        "linking", "toc", "print", "search", "type", "translate", "processing-role", "cascade", "rev",
+        "audience", "platform", "product", "otherprops", "props", "deliveryTarget"
+    ];
+    static FIRST_ADDITIVE_INDEX = 9;
+    getCascadingAttributes(topicref) {
+        if (this.cascadingAttributes === undefined) {
+            const attributes = [...LoadedDocuments.BASE_CASCADING_ATTRIBUTES];
+            const map = DitaUtils.findAncestorByClass(topicref, "map/map");
+            if (map !== undefined) {
+                for (const name of DitaUtils.getFilterAttributes(map)) {
+                    if (!attributes.includes(name)) {
+                        attributes.push(name);
+                    }
+                }
+            }
+            this.cascadingAttributes = attributes;
+        }
+        return this.cascadingAttributes;
+    }
+    addMetadata(definition, topicref) {
+        const sourceMeta = definition.getMeta();
+        if (sourceMeta !== undefined && DitaUtils.getNonEmptyAttribute(sourceMeta, "lockmeta") === "no") {
+            return;
+        }
+        const cascade = DitaUtils.getNonEmptyAttribute(topicref, "cascade") ?? definition.getAttribute("cascade");
+        const nomerge = cascade === "nomerge";
+        const cascadingAttributes = this.getCascadingAttributes(topicref);
+        for (let index = 0; index < cascadingAttributes.length; index++) {
+            const name = cascadingAttributes[index];
+            const cascadedValue = definition.getAttribute(name);
+            if (cascadedValue === undefined) {
+                continue;
+            }
+            const localValue = DitaUtils.getNonEmptyAttribute(topicref, name);
+            let newValue;
+            if (localValue === undefined) {
+                newValue = cascadedValue;
+            }
+            else if (index >= LoadedDocuments.FIRST_ADDITIVE_INDEX) {
+                newValue = nomerge ? localValue : this.mergeValues(localValue, cascadedValue);
+            }
+            else {
+                newValue = localValue;
+            }
+            if (newValue !== localValue) {
+                topicref.setAttribute(new XMLAttribute(name, newValue));
+            }
+        }
+        if (sourceMeta === undefined) {
+            return;
+        }
+        let targetMeta = DitaUtils.getChildByClass(topicref, "map/topicmeta");
+        if (targetMeta === undefined) {
+            targetMeta = new DitaElement("topicmeta");
+            targetMeta.setAttribute(new XMLAttribute("class", "- map/topicmeta "));
+            topicref.setContent([targetMeta, ...topicref.getContent()]);
+        }
+        for (const child of sourceMeta.getChildren()) {
+            const className = CascadeMeta.CASCADED_ELEMENTS.find((name) => DitaUtils.hasClass(child, name));
+            if (className === undefined) {
+                continue;
+            }
+            const single = CascadeMeta.SINGLE_ELEMENTS.has(className);
+            if (single && DitaUtils.getChildByClass(targetMeta, className) !== undefined) {
+                continue;
+            }
+            const before = DitaUtils.findChildByClassFrom(targetMeta, CascadeMeta.TOPICMETA_ELEMENTS.indexOf(className), CascadeMeta.TOPICMETA_ELEMENTS);
+            const content = targetMeta.getContent();
+            const insertionIndex = before === undefined ? content.length : content.indexOf(before);
+            content.splice(insertionIndex, 0, DitaUtils.cloneElement(child));
+            targetMeta.setContent(content);
+        }
+    }
+    mergeValues(first, second) {
+        const values = first.split(/\s+/).filter((value) => value.length > 0);
+        for (const value of second.split(/\s+/)) {
+            if (value.length > 0 && !values.includes(value)) {
+                values.push(value);
+            }
+        }
+        return values.join(" ");
+    }
+    canonicalize(filePath) {
+        if (filePath instanceof URL) {
+            if (filePath.protocol === "file:") {
+                filePath = fileURLToPath(filePath);
+            }
+            else if (filePath.protocol === "http:" || filePath.protocol === "https:") {
+                const url = new URL(filePath.toString());
+                url.hash = "";
+                return url.toString();
+            }
+            else {
+                throw new Error(this.diagnostics.i18n.format(this.diagnostics.i18n.getString("LoadedDocuments", "unsupportedURL"), [filePath.toString()]));
+            }
+        }
+        if (/^file:/i.test(filePath)) {
+            filePath = fileURLToPath(new URL(filePath));
+        }
+        if (/^https?:\/\//i.test(filePath)) {
+            const url = new URL(filePath);
+            url.hash = "";
+            return url.toString();
+        }
+        const withoutFragment = filePath.split("#", 1)[0];
+        return resolve(withoutFragment.split("?", 1)[0]);
+    }
+}
+//# sourceMappingURL=LoadedDocuments.js.map