extension PureXML.XSLT.Transformer { /// Compares strings case-insensitively, with `caseOrder` breaking ties among /// strings that differ only in case (the XSLT `case-order` semantics). static func caseInsensitiveCompare(_ left: String, _ right: String, _ caseOrder: PureXML.XSLT.CaseOrder) -> Int { let leftLower = left.lowercased() let rightLower = right.lowercased() if leftLower != rightLower { return leftLower < rightLower ? -1 : 1 } if left == right { return 0 } // Equal apart from case: codepoint order puts uppercase first. let upperFirst = left < right let leftFirst = caseOrder == .upperFirst ? upperFirst : !upperFirst return leftFirst ? -1 : 1 } /// Rewrites a literal name in an `xsl:namespace-alias`ed stylesheet namespace /// to its result namespace, keeping the literal prefix; other names pass /// through unchanged. func aliased(_ name: PureXML.Model.QualifiedName) -> PureXML.Model.QualifiedName { guard let alias = stylesheet.namespaceAliases[name.namespaceURI ?? ""] else { return name } // The literal prefix is kept and only its namespace URI is remapped (XSLT // 1.0 7.1.1: the result namespace node keeps the stylesheet prefix); the // result-prefix only selects the replacement namespace, it is not adopted. return PureXML.Model.QualifiedName(prefix: name.prefix, localName: name.localName, namespaceURI: alias.uri) } /// The attributes with duplicates by name removed, keeping the last (so a /// later attribute overrides one from an attribute set or an earlier source). static func deduplicated(_ attributes: [PureXML.Model.Attribute]) -> [PureXML.Model.Attribute] { var indexByName: [String: Int] = [:] var result: [PureXML.Model.Attribute] = [] for attribute in attributes { if let index = indexByName[attribute.name.description] { result[index] = attribute } else { indexByName[attribute.name.description] = result.count result.append(attribute) } } return result } /// The expanded name an xsl:element/xsl:attribute creates (7.1.2/7.1.3): /// an explicit namespace attribute wins; otherwise a prefixed name /// resolves against the instruction's in-scope stylesheet declarations /// (an unprefixed attribute name stays in no namespace). func createdName( _ nameTemplate: PureXML.XSLT.ValueTemplate, _ namespaceTemplate: PureXML.XSLT.ValueTemplate?, _ namespaces: [String: String], _ context: PureXML.XSLT.XSLTContext, isAttribute: Bool, ) -> PureXML.Model.QualifiedName { let raw = avt(nameTemplate, context) var name = PureXML.Model.QualifiedName(raw) if let namespaceTemplate { let uri = avt(namespaceTemplate, context) if !uri.isEmpty { return PureXML.Model.QualifiedName(prefix: name.prefix, localName: name.localName, namespaceURI: uri) } return PureXML.Model.QualifiedName(prefix: nil, localName: name.localName, namespaceURI: nil) } if let prefix = name.prefix { if prefix == "xml" { name = PureXML.Model.QualifiedName(prefix: prefix, localName: name.localName, namespaceURI: "http://www.w3.org/XML/1998/namespace") } else if let uri = namespaces[prefix] { name = PureXML.Model.QualifiedName(prefix: prefix, localName: name.localName, namespaceURI: uri) } } else if !isAttribute, let defaultURI = namespaces[""], !defaultURI.isEmpty { name = PureXML.Model.QualifiedName(prefix: nil, localName: name.localName, namespaceURI: defaultURI) } return name } } extension PureXML.XSLT.Transformer { /// The concatenated value of only the text and CDATA node items, ignoring an /// element (or other) node together with its content. xsl:comment and /// xsl:processing-instruction may contain only text (XSLT 1.0 7.4, 7.6); the /// recovery for a created non-text node is to ignore it and its content, /// which is not the same as taking the string-value of everything. static func textNodesOnly(of items: [PureXML.XSLT.ResultItem]) -> String { items.reduce(into: "") { result, item in guard case let .node(node) = item else { return } switch node { case let .text(value), let .cdata(value): result += value default: break } } } /// The text-node content of `items` as the string value of an attribute, /// comment, or processing-instruction node, with disable-output-escaping /// ignored (XSLT 1.0 16.4: disabling escaping for a value used as something /// other than a text node is an error; the recovery is to ignore it). The /// raw markers are only stripped when the stylesheet uses the feature, so a /// private-use character in ordinary data is never removed. func escapedTextValue(of items: [PureXML.XSLT.ResultItem]) -> String { let text = Self.textNodesOnly(of: items) return stylesheet.usesRawText ? PureXML.XSLT.RawText.stripped(text) : text } /// The source element's in-scope namespace declarations as literal /// xmlns attributes (xsl:copy copies namespace nodes, 7.5); the fixup /// pass drops the ones already in scope in the result. static func namespaceDeclarations(inScopeAt node: PureXML.Model.TreeNode) -> [PureXML.XSLT.LiteralAttribute] { var bindings: [String: String] = [:] var current: PureXML.Model.TreeNode? = node while let candidate = current { for attribute in candidate.attributes { if attribute.name.prefix == "xmlns", bindings[attribute.name.localName] == nil { bindings[attribute.name.localName] = attribute.value } else if attribute.name.prefix == nil, attribute.name.localName == "xmlns", bindings[""] == nil { bindings[""] = attribute.value } } current = candidate.parent } return bindings.sorted(by: { $0.key < $1.key }).compactMap { prefix, uri in if prefix.isEmpty, uri.isEmpty { return nil } let name = prefix.isEmpty ? "xmlns" : "xmlns:" + prefix return PureXML.XSLT.LiteralAttribute(name: PureXML.Model.QualifiedName(name), value: [.literal(uri)]) } } /// A copied tree node for `xsl:copy-of`. For an element it carries the /// element's full set of in-scope namespace nodes (XSLT 1.0 11.3: copying a /// node copies its namespace nodes), so a declaration inherited from an /// ancestor of the copied element is added alongside the element's own; the /// serializer's namespace fixup later drops any already in the result scope. static func withInScopeNamespaces(_ tree: PureXML.Model.TreeNode) -> PureXML.Model.Node { guard case let .element(element) = tree.node else { return tree.node } let declared = Set(element.attributes .filter { $0.name.prefix == "xmlns" || ($0.name.prefix == nil && $0.name.localName == "xmlns") } .map(\.name.description)) let inherited = namespaceDeclarations(inScopeAt: tree).compactMap { decl -> PureXML.Model.Attribute? in guard !declared.contains(decl.name.description), case let .literal(uri) = decl.value.first else { return nil } return PureXML.Model.Attribute(name: decl.name, value: uri) } return .element(.init(name: element.name, attributes: element.attributes + inherited, children: element.children)) } /// The topmost ancestor of `node` (its document node). static func documentRoot(of node: PureXML.Model.TreeNode) -> PureXML.Model.TreeNode { var current = node while let parent = current.parent { current = parent } return current } /// `xsl:number`: an explicit `value` expression rounds per the XSLT 1.0 /// rules; otherwise the level/count/from machinery numbers the context /// node, with patterns matched through the transform's match cache. func numberInstruction(_ instruction: PureXML.XSLT.Instruction, _ context: XSLTContext) -> String { guard case let .number(spec) = instruction else { return "" } let format = avt(spec.format, context) let grouping = spec.groupingSeparator.flatMap { separator in spec.groupingSize.map { (separator: separator, size: $0) } } if let valueExpression = spec.value { let number = value(valueExpression, context)?.number ?? .nan // Outside [1, Int.max] the number renders as a plain XPath // number (below one there is nothing to format; above, the Int // conversion would trap; the bound is platform-correct, so // wasm32's 32-bit Int is honored too). guard number.isFinite, number.rounded() >= 1, number.rounded() <= Double(Int.max) else { return PureXML.XPath.Value.format(number) } return XSLTNumbering.format([Int(number.rounded())], format, grouping) } let numbers = XSLTNumbering.numbers( of: context.node, level: spec.level, count: spec.count, from: spec.from, siblingCache: numberingCache, ) { node, pattern in matches(node, pattern) } return XSLTNumbering.format(numbers, format, grouping) } }