typesditac 1.0.0

package/dist/utils/DitaUtils.js

@@ -0,0 +1,783 @@
+/*
+ * 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 { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Constants, FileReader, ProcessingInstruction, TextNode, XMLAttribute, XMLUtils } from "typesxml";
+import { DitaElement } from "../dom/DitaElement.js";
+import { URIComponent } from "./URIComponent.js";
+export class DitaUtils {
+    static generatedIds = new WeakMap();
+    static nextGeneratedId = 0;
+    static radicalIdCounter = 0;
+    static ABSOLUTE_SCHEMES = ["http://", "https://", "ftp://", "mailto:"];
+    static HTML_EXTENSIONS = ["html", "htm", "shtml", "xhtml", "xhtm", "xht"];
+    static MARKDOWN_EXTENSIONS = ["md", "markdown", "mdown", "mkdn", "mdwn", "mkd", "rmd"];
+    static DITA_ALIAS_FORMATS = ["mdita", "markdown", "hdita", "html"];
+    static quotePathSegment(segment) {
+        return URIComponent.encode(URIComponent.quotePath(segment));
+    }
+    static hasURIScheme(value) {
+        return /^[A-Za-z][A-Za-z0-9+.-]+:/.test(value);
+    }
+    static toFileUrl(absolutePath) {
+        return pathToFileURL(absolutePath).href.replace(/^file:\/\/\//, "file:/");
+    }
+    static resolveDocumentPath(basePath, relativePath) {
+        if (/^https?:\/\//i.test(relativePath)) {
+            return relativePath;
+        }
+        if (/^https?:\/\//i.test(basePath)) {
+            return new URL(relativePath, basePath).toString();
+        }
+        const localBasePath = /^file:/i.test(basePath)
+            ? fileURLToPath(new URL(basePath))
+            : basePath;
+        const localRelativePath = /^file:/i.test(relativePath)
+            ? fileURLToPath(new URL(relativePath))
+            : URIComponent.decode(relativePath);
+        return resolve(localBasePath, "..", localRelativePath);
+    }
+    static readText(filePath, encoding) {
+        const reader = new FileReader(filePath, encoding);
+        let text = "";
+        try {
+            while (reader.dataAvailable()) {
+                text += reader.read();
+            }
+        }
+        finally {
+            reader.closeFile();
+        }
+        return text;
+    }
+    static retrieve(url, i18n) {
+        return DitaUtils.retrieveBytes(url, i18n).toString("utf8");
+    }
+    static retrieveBytes(url, i18n) {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            throw new Error(i18n.format(i18n.getString("DITAUtil", "onlyHttpRetrievable"), [url]));
+        }
+        const fetchScript = fileURLToPath(new URL("./Fetch.js", import.meta.url));
+        const result = spawnSync(process.execPath, [fetchScript, url], {
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024
+        });
+        if (result.error !== undefined) {
+            throw new Error(i18n.format(i18n.getString("DITAUtil", "cannotRetrieve"), [url, result.error.message]));
+        }
+        if (result.status !== 0) {
+            const detail = result.stderr.trim();
+            throw new Error(detail.length === 0
+                ? i18n.format(i18n.getString("DITAUtil", "cannotRetrieveNoDetail"), [url])
+                : i18n.format(i18n.getString("DITAUtil", "cannotRetrieve"), [url, detail]));
+        }
+        return Buffer.from(result.stdout.trim(), "base64");
+    }
+    static urlExists(url) {
+        const checkScript = fileURLToPath(new URL("./CheckURL.js", import.meta.url));
+        const result = spawnSync(process.execPath, [checkScript, url], {
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024
+        });
+        if (result.error !== undefined || result.status !== 0) {
+            return false;
+        }
+        return result.stdout.trim() === "true";
+    }
+    static getRoot(document) {
+        // TypesXML types getRoot() as XMLElement; every root built in this port is a DitaElement.
+        return document.getRoot();
+    }
+    static hasDITANamespace(element) {
+        const name = element.getName();
+        return !name.includes(":") || name.startsWith("ditac:");
+    }
+    static hasContent(element) {
+        let content = element.getContent();
+        for (const node of content) {
+            if (node.getNodeType() === Constants.TEXT_NODE) {
+                const text = node.getValue().trim();
+                if (text.length > 0) {
+                    return true;
+                }
+            }
+            if (node.getNodeType() === Constants.ELEMENT_NODE) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static getNonEmptyAttribute(element, name) {
+        const attribute = element.getAttribute(name);
+        if (attribute === undefined) {
+            return undefined;
+        }
+        const value = DitaUtils.trimControlAndSpace(attribute.getValue());
+        return value.length === 0 || value === "???" ? undefined : value;
+    }
+    static trimControlAndSpace(value) {
+        let start = 0;
+        let end = value.length;
+        while (start < end && value.charCodeAt(start) <= 0x20) {
+            start++;
+        }
+        while (end > start && value.charCodeAt(end - 1) <= 0x20) {
+            end--;
+        }
+        return value.substring(start, end);
+    }
+    static getScope(element, href) {
+        const scope = DitaUtils.getNonEmptyAttribute(element, "scope");
+        if (scope !== undefined) {
+            return scope;
+        }
+        if (href !== undefined &&
+            DitaUtils.ABSOLUTE_SCHEMES.some((scheme) => href.startsWith(scheme)) &&
+            DitaUtils.getNonEmptyAttribute(element, "ditac:absoluteHref") === "true") {
+            return "external";
+        }
+        return "local";
+    }
+    static getFormat(element, href, scope) {
+        return DitaUtils.resolveFormat(DitaUtils.getNonEmptyAttribute(element, "format"), href, scope);
+    }
+    static resolveFormat(format, href, scope) {
+        let resolved = format;
+        if (resolved !== undefined) {
+            const semicolon = resolved.indexOf(";");
+            if (semicolon >= 0) {
+                resolved = resolved.slice(0, semicolon).trim();
+            }
+            resolved = resolved.length === 0 ? undefined : resolved.toLowerCase();
+        }
+        if (resolved === undefined && href !== undefined) {
+            resolved = DitaUtils.formatFromExtension(href);
+        }
+        if (resolved !== undefined && (scope === undefined || scope === "local") &&
+            DitaUtils.DITA_ALIAS_FORMATS.includes(resolved)) {
+            resolved = "dita";
+        }
+        return resolved;
+    }
+    static formatFromExtension(href) {
+        const path = href.split("#", 1)[0].split("?", 1)[0];
+        if (path.length === 0) {
+            return undefined;
+        }
+        const dotIndex = path.lastIndexOf(".");
+        const slashIndex = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+        let ext = dotIndex > slashIndex ? path.slice(dotIndex + 1).trim().toLowerCase() : undefined;
+        if (ext !== undefined && ext.length === 0) {
+            ext = undefined;
+        }
+        if (ext !== undefined) {
+            if (ext === "xml") {
+                return "dita";
+            }
+            if (DitaUtils.HTML_EXTENSIONS.includes(ext)) {
+                return "html";
+            }
+            if (DitaUtils.MARKDOWN_EXTENSIONS.includes(ext)) {
+                return "markdown";
+            }
+            return ext;
+        }
+        if (path.startsWith("http://") || path.startsWith("https://")) {
+            return "html";
+        }
+        if (path.endsWith("/")) {
+            return "x-directory";
+        }
+        return undefined;
+    }
+    static FILTER_ATTRIBUTES = [
+        "rev", "deliveryTarget", "audience", "platform", "product", "otherprops", "props"
+    ];
+    static OTHER_META_ATTRIBUTES = [
+        "xml:lang", "translate", "dir", "outputclass", "importance", "status", "base"
+    ];
+    static filterAttributeIsSingle(index) {
+        return index === 0;
+    }
+    static otherMetaAttributeIsSingle(index) {
+        return index < DitaUtils.OTHER_META_ATTRIBUTES.length - 1;
+    }
+    static getFilterAttributes(element) {
+        const domains = DitaUtils.lookupAncestorAttribute(element, "domains");
+        return DitaUtils.getMetaAttributes(domains, DitaUtils.FILTER_ATTRIBUTES, "a(props");
+    }
+    static getOtherMetaAttributes(element) {
+        const domains = DitaUtils.lookupAncestorAttribute(element, "domains");
+        return DitaUtils.getMetaAttributes(domains, DitaUtils.OTHER_META_ATTRIBUTES, "a(base");
+    }
+    static getMetaAttributes(domains, attrNames, specializationPrefix) {
+        let allAttrNames = attrNames;
+        if (domains !== undefined) {
+            let pos = 0; // fixed offset past prefix + space
+            for (;;) {
+                pos = domains.indexOf(specializationPrefix, pos);
+                if (pos < 0) {
+                    break;
+                }
+                pos += 7;
+                const start = pos;
+                pos = domains.indexOf(")", pos);
+                if (pos < 0) {
+                    break;
+                }
+                const end = pos;
+                pos++;
+                const names = domains.slice(start, end).trim().split(/\s+/).filter((name) => name.length > 0);
+                for (const name of names) {
+                    if (!allAttrNames.includes(name)) {
+                        allAttrNames = [...allAttrNames, name];
+                    }
+                }
+            }
+        }
+        return allAttrNames;
+    }
+    static findChildByClassFrom(element, fromIndex, classNames) {
+        for (const child of element.getChildren()) {
+            for (let index = fromIndex; index < classNames.length; index++) {
+                if (DitaUtils.hasClass(child, classNames[index])) {
+                    return child;
+                }
+            }
+        }
+        return undefined;
+    }
+    static lookupAncestorAttribute(target, name) {
+        let current = target;
+        while (current !== undefined) {
+            const value = DitaUtils.getNonEmptyAttribute(current, name);
+            if (value !== undefined) {
+                return value;
+            }
+            current = current.getParent();
+        }
+        return undefined;
+    }
+    static lookupAncestorAttributeRaw(target, name) {
+        let current = target;
+        while (current !== undefined) {
+            const value = current.getAttribute(name)?.getValue();
+            if (value !== undefined && value.length > 0) {
+                return value;
+            }
+            current = current.getParent();
+        }
+        return undefined;
+    }
+    static getRawAttribute(element, name) {
+        const attribute = element.getAttribute(name);
+        if (attribute === undefined) {
+            return undefined;
+        }
+        const value = attribute.getValue();
+        return value.length === 0 ? undefined : value;
+    }
+    static inheritAttribute(target, name) {
+        let cellIndex = -1;
+        let current = target;
+        while (current !== undefined) {
+            if (cellIndex >= 0 && DitaUtils.hasClass(current, "map/reltable")) {
+                const header = DitaUtils.getChildByClass(current, "map/relheader");
+                const colspec = header?.getChildren()[cellIndex];
+                const columnValue = colspec === undefined
+                    ? undefined
+                    : DitaUtils.getRawAttribute(colspec, name);
+                if (columnValue !== undefined) {
+                    return columnValue;
+                }
+            }
+            const value = DitaUtils.getRawAttribute(current, name);
+            if (value !== undefined) {
+                return value;
+            }
+            const parent = current.getParent();
+            if (DitaUtils.hasClass(current, "map/relcell") && parent !== undefined) {
+                cellIndex = parent.getChildren().indexOf(current);
+            }
+            current = parent;
+        }
+        return undefined;
+    }
+    static inheritFormat(target, href, scope) {
+        return DitaUtils.resolveFormat(DitaUtils.inheritAttribute(target, "format"), href, scope);
+    }
+    static isValidKey(value) {
+        if (value === undefined || value.length === 0) {
+            return false;
+        }
+        for (let index = 0; index < value.length; index++) {
+            const c = value.charAt(index);
+            if ("-_.!~*'()".includes(c)) {
+                continue;
+            }
+            if (!/[\p{L}\p{Nd}]/u.test(c)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static getTextContent(element) {
+        let text = "";
+        for (const node of element.getContent()) {
+            if (node instanceof TextNode) {
+                text += node.getValue();
+            }
+            else if (node instanceof DitaElement &&
+                !DitaUtils.hasClass(node, "topic/draft-comment") &&
+                !DitaUtils.hasClass(node, "topic/required-cleanup")) {
+                text += DitaUtils.getTextContent(node);
+            }
+        }
+        return text;
+    }
+    static getTitleTextFromChild(element, preferNavtitle) {
+        if (preferNavtitle && DitaUtils.hasClass(element, "topic/topic")) {
+            const titlealts = DitaUtils.getChildByClass(element, "topic/titlealts");
+            const navtitle = titlealts === undefined
+                ? undefined
+                : DitaUtils.getChildByClass(titlealts, "topic/navtitle");
+            if (navtitle !== undefined) {
+                const text = DitaUtils.collapseWhitespace(DitaUtils.getTextContent(navtitle));
+                if (text.length > 0) {
+                    return text;
+                }
+            }
+        }
+        const title = DitaUtils.getChildByClass(element, "topic/title");
+        if (title !== undefined) {
+            const text = DitaUtils.collapseWhitespace(DitaUtils.getTextContent(title));
+            if (text.length > 0) {
+                return text;
+            }
+        }
+        return undefined;
+    }
+    static hasClass(element, className) {
+        const classAttribute = element.getAttribute("class");
+        if (classAttribute === undefined) {
+            return false;
+        }
+        const classTokens = classAttribute.getValue().trim().split(/\s+/);
+        for (const token of classTokens) {
+            if (token === className || token.endsWith("/" + className)) {
+                return true;
+            }
+            if (className.startsWith("*/") && token.endsWith(className.slice(1)) && token.length > className.length - 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static getChildByClass(element, className) {
+        const children = element.getChildren();
+        for (const child of children) {
+            if (DitaUtils.hasClass(child, className)) {
+                return child;
+            }
+        }
+        return undefined;
+    }
+    static findAncestorByClass(element, className) {
+        let current = element;
+        while (current !== undefined) {
+            if (DitaUtils.hasClass(current, className)) {
+                return current;
+            }
+            current = current.getParent();
+        }
+        return undefined;
+    }
+    static findChildrenByClass(element, className) {
+        return element.getChildren().filter((child) => DitaUtils.hasClass(child, className));
+    }
+    static getDescendantByClass(element, fromIndex, classNames) {
+        for (const child of element.getChildren()) {
+            for (let index = fromIndex; index < classNames.length; index++) {
+                if (DitaUtils.hasClass(child, classNames[index])) {
+                    return child;
+                }
+            }
+            const found = DitaUtils.getDescendantByClass(child, fromIndex, classNames);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    static collapseWhitespace(value) {
+        let result = value.replace(/[ \t\r\n]+/g, " ");
+        if (result.endsWith(" ")) {
+            result = result.substring(0, result.length - 1);
+        }
+        if (result.startsWith(" ")) {
+            result = result.substring(1);
+        }
+        return result;
+    }
+    static getSubRole(role) {
+        const subRoles = new Map([
+            ["part", "chapter"],
+            ["chapter", "section1"],
+            ["section1", "section2"],
+            ["section2", "section3"],
+            ["section3", "section4"],
+            ["section4", "section5"],
+            ["section5", "section6"],
+            ["section6", "section7"],
+            ["section7", "section8"],
+            ["section8", "section9"],
+            ["section9", "section9"],
+            ["appendices", "appendix"]
+        ]);
+        return role === undefined ? "section1" : subRoles.get(role) ?? "section1";
+    }
+    static isValidId(value) {
+        return XMLUtils.isValidNMTOKEN(value);
+    }
+    static makeUniqueId(candidate, used, element) {
+        let id = candidate;
+        let counter = 2;
+        let existing = used.get(id);
+        while (existing !== undefined && existing !== element) {
+            if (counter >= 100) {
+                do {
+                    id = candidate + "-" + (++DitaUtils.radicalIdCounter).toString(36);
+                    existing = used.get(id);
+                } while (existing !== undefined && existing !== element);
+                break;
+            }
+            id = candidate + "-" + counter.toString();
+            counter++;
+            existing = used.get(id);
+        }
+        if (element !== undefined) {
+            used.set(id, element);
+        }
+        return id;
+    }
+    static ROOT_ROLES = [
+        "bookmap/toc",
+        "bookmap/figurelist",
+        "bookmap/tablelist",
+        "bookmap/examplelist",
+        "bookmap/equationlist",
+        "bookmap/abbrevlist",
+        "bookmap/trademarklist",
+        "bookmap/bibliolist",
+        "bookmap/glossarylist",
+        "bookmap/indexlist",
+        "bookmap/booklist", // Must be after the other *lists.
+        "bookmap/notices",
+        "bookmap/dedication",
+        "bookmap/colophon",
+        "bookmap/bookabstract",
+        "bookmap/draftintro",
+        "bookmap/preface",
+        "bookmap/part",
+        "bookmap/chapter",
+        "bookmap/appendices",
+        "bookmap/appendix",
+        "bookmap/amendments"
+    ];
+    static getTopicrefHref(element) {
+        return DitaUtils.getNonEmptyAttribute(element, "href");
+    }
+    static getTopicrefParent(element) {
+        const parent = element.getParent();
+        return parent !== undefined && DitaUtils.hasClass(parent, "map/topicref") ? parent : undefined;
+    }
+    static getTopicrefChildren(element) {
+        return element.getChildren().filter((child) => DitaUtils.hasClass(child, "map/topicref"));
+    }
+    static getTopicrefRawNavtitle(element) {
+        const topicmeta = DitaUtils.getChildByClass(element, "map/topicmeta");
+        const navtitle = topicmeta === undefined
+            ? undefined
+            : DitaUtils.getChildByClass(topicmeta, "topic/navtitle");
+        if (navtitle !== undefined) {
+            const text = DitaUtils.collapseWhitespace(DitaUtils.getTextContent(navtitle));
+            if (text.length > 0) {
+                return text;
+            }
+        }
+        const attribute = DitaUtils.getNonEmptyAttribute(element, "navtitle");
+        if (attribute !== undefined) {
+            const text = DitaUtils.collapseWhitespace(attribute);
+            if (text.length > 0) {
+                return text;
+            }
+        }
+        return undefined;
+    }
+    static getTopicrefNavtitle(element) {
+        const title = DitaUtils.getTopicrefRawNavtitle(element);
+        return title !== undefined && DitaUtils.getNonEmptyAttribute(element, "locktitle") === "yes" ? title : undefined;
+    }
+    static getTopicrefRole(element) {
+        for (const cls of DitaUtils.ROOT_ROLES) {
+            if (DitaUtils.hasClass(element, cls)) {
+                return cls.slice(cls.lastIndexOf("/") + 1);
+            }
+        }
+        if (DitaUtils.isTopicrefFrontmatterSection(element, "bookmap/frontmatter")) {
+            // A plain topicref contained in frontmatter. Not a normal section1.
+            return "frontmattersection";
+        }
+        if (DitaUtils.isTopicrefFrontmatterSection(element, "bookmap/backmatter")) {
+            // A plain topicref contained in backmatter. Not a normal section1.
+            return "backmattersection";
+        }
+        return "section1";
+    }
+    static isTopicrefFrontmatterSection(element, frontmatterClass) {
+        const parent = DitaUtils.getTopicrefParent(element);
+        if (parent !== undefined && DitaUtils.hasClass(parent, frontmatterClass)) {
+            return true;
+        }
+        const grandparent = parent === undefined ? undefined : DitaUtils.getTopicrefParent(parent);
+        if (parent !== undefined && grandparent !== undefined &&
+            DitaUtils.hasClass(grandparent, frontmatterClass) &&
+            DitaUtils.getNonEmptyAttribute(parent, "href") === undefined &&
+            DitaUtils.getTopicrefRawNavtitle(parent) === undefined) {
+            // topicref is contained in a dummy topicgroup (no href, no
+            // navtitle) itself contained in frontmatter/backmatter.
+            return true;
+        }
+        return false;
+    }
+    static getDescendants(element) {
+        const result = [];
+        const children = element.getChildren();
+        for (const child of children) {
+            result.push(child);
+            result.push(...DitaUtils.getDescendants(child));
+        }
+        return result;
+    }
+    static findById(root, id, includeSelf = true) {
+        if (includeSelf) {
+            const rootId = root.getAttribute("id");
+            if (rootId !== undefined && rootId.getValue().length > 0 && rootId.getValue().trim() === id) {
+                return root;
+            }
+        }
+        for (const element of DitaUtils.getDescendants(root)) {
+            const elementId = element.getAttribute("id");
+            if (elementId !== undefined && elementId.getValue().length > 0 && elementId.getValue().trim() === id) {
+                return element;
+            }
+        }
+        return undefined;
+    }
+    static cloneElement(element) {
+        const clone = new DitaElement(element.getName());
+        const attributes = element.getAttributes();
+        const clonedAttributes = [];
+        for (const attribute of attributes) {
+            clonedAttributes.push(new XMLAttribute(attribute.getName(), attribute.getValue()));
+        }
+        clone.setAttributes(clonedAttributes);
+        const content = element.getContent();
+        const clonedContent = [];
+        for (const node of content) {
+            if (node instanceof DitaElement) {
+                clonedContent.push(DitaUtils.cloneElement(node));
+            }
+            else if (node instanceof ProcessingInstruction) {
+                clonedContent.push(new ProcessingInstruction(node.getTarget(), node.getData()));
+            }
+            else if (node instanceof TextNode) {
+                clonedContent.push(new TextNode(node.getValue()));
+            }
+            else {
+                clonedContent.push(node);
+            }
+        }
+        clone.setContent(clonedContent);
+        return clone;
+    }
+    static checkDomainsFlag;
+    static checkDomains(superset, subset) {
+        if (DitaUtils.checkDomainsFlag === undefined) {
+            const prop = process.env.DITAC_CHECK_DOMAINS;
+            DitaUtils.checkDomainsFlag = (prop !== undefined && prop.length > 0);
+        }
+        if (DitaUtils.checkDomainsFlag) {
+            return DitaUtils.doCheckDomains(superset, subset);
+        }
+        return true;
+    }
+    static doCheckDomains(superset, subset) {
+        const collapsedSuperset = DitaUtils.collapseWhitespace(superset);
+        const collapsedSubset = DitaUtils.collapseWhitespace(subset);
+        if (collapsedSuperset === collapsedSubset || collapsedSuperset.includes(collapsedSubset)) {
+            return true;
+        }
+        const supersetList = DitaUtils.splitDomains(collapsedSuperset);
+        const subsetList = DitaUtils.splitDomains(collapsedSubset);
+        for (const domain1 of subsetList) {
+            const domain2 = DitaUtils.findDomain(supersetList, domain1);
+            if (domain2 === undefined || !DitaUtils.domainIsLessConstrainedThan(domain2, domain1)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static splitDomains(domains) {
+        const list = [];
+        const count = domains.length;
+        let start = -1;
+        for (let i = 0; i < count; ++i) {
+            const c = domains.charAt(i);
+            switch (c) {
+                case "(":
+                    if (i === 0 || domains.charAt(i - 1) !== "a") {
+                        start = i;
+                    }
+                    break;
+                case ")":
+                    if (start >= 0) {
+                        if (i - start > 1) {
+                            list.push(domains.substring(start, i + 1));
+                        }
+                        start = -1;
+                    }
+                    break;
+            }
+        }
+        return list;
+    }
+    static findDomain(list, domain) {
+        for (const item of list) {
+            if (item === domain) {
+                return item;
+            }
+        }
+        const domainParts = DitaUtils.splitDomain(domain);
+        for (const item of list) {
+            const itemParts = DitaUtils.splitDomain(item);
+            let foundDomainParts = true;
+            for (const domainPart of domainParts) {
+                if (!domainPart.endsWith("-c")) {
+                    let foundDomainPart = false;
+                    for (const itemPart of itemParts) {
+                        if (itemPart === domainPart) {
+                            foundDomainPart = true;
+                            break;
+                        }
+                    }
+                    if (!foundDomainPart) {
+                        foundDomainParts = false;
+                        break;
+                    }
+                }
+            }
+            if (foundDomainParts) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+    static splitDomain(domain) {
+        return domain.substring(1, domain.length - 1).trim().split(/\s+/);
+    }
+    static domainIsLessConstrainedThan(less, more) {
+        if (!less.includes("-c")) {
+            return true;
+        }
+        const lessParts = DitaUtils.splitDomain(less);
+        const moreParts = DitaUtils.splitDomain(more);
+        for (const lessPart of lessParts) {
+            if (lessPart.endsWith("-c")) {
+                let foundLessPart = false;
+                for (const morePart of moreParts) {
+                    if (morePart === lessPart) {
+                        foundLessPart = true;
+                        break;
+                    }
+                }
+                if (!foundLessPart) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    static getLocalTopicURL(topicref, i18n) {
+        try {
+            return DitaUtils.doGetLocalTopicURL(topicref, i18n);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static doGetLocalTopicURL(topicref, i18n) {
+        const href = DitaUtils.getNonEmptyAttribute(topicref, "href");
+        if (href === undefined) {
+            return undefined;
+        }
+        const scope = DitaUtils.getScope(topicref, href);
+        if (scope !== "local") {
+            return undefined;
+        }
+        const format = DitaUtils.getFormat(topicref, href, scope);
+        if (format === undefined) {
+            throw new Error(i18n.format(i18n.getString("Filter", "missingAttribute"), ["format"]));
+        }
+        if (format !== "dita") {
+            return undefined;
+        }
+        try {
+            new URL(href);
+        }
+        catch {
+            throw new Error(i18n.format(i18n.getString("Filter", "invalidAttribute"), [href, "href"]));
+        }
+        return href;
+    }
+    static generateId(prefix, element) {
+        const existing = DitaUtils.generatedIds.get(element);
+        if (existing !== undefined) {
+            return existing;
+        }
+        // Stable per-element counter; only needs to be unique and deterministic, not identity-hash-like.
+        DitaUtils.nextGeneratedId++;
+        const generated = prefix + "_" + DitaUtils.nextGeneratedId.toString(36) + "_";
+        DitaUtils.generatedIds.set(element, generated);
+        return generated;
+    }
+    static findDitavalrefs(element) {
+        const result = [];
+        for (const child of element.getChildren()) {
+            if (DitaUtils.isDitavalref(child)) {
+                result.push(child);
+            }
+        }
+        return result;
+    }
+    static isDitavalref(element) {
+        return DitaUtils.hasClass(element, "ditavalref-d/ditavalref");
+    }
+    static containsDitavalrefs(element) {
+        return DitaUtils.getDescendantByClass(element, 0, ["ditavalref-d/ditavalref"]) !== undefined;
+    }
+}
+//# sourceMappingURL=DitaUtils.js.map