single-file-core 1.6.9 → 1.6.10

package/core/index.js

@@ -460,6 +460,12 @@ class Processor {
 			frames: new Map()
 		};
 		this.fontTests = options.fontTests;
+		options.generatedDataURIs = new Set();
+	}
+
+	registerGeneratedDataURI(dataURI) {
+		this.options.generatedDataURIs.add(dataURI);
+		return dataURI;
 	}
 
 	initialize() {
@@ -492,6 +498,8 @@ class Processor {
 			pageContent = content.data || "";
 		}
 		this.doc = util.parseDocContent(pageContent, this.baseURI);
+		removeInsertedParagraphs(this.doc);
+		this.nestingPositions = getNestingPositions(this.doc);
 		util.fixInvalidNesting(this.doc);
 		if (this.options.saveRawPage) {
 			let charset;
@@ -600,6 +608,7 @@ class Processor {
 		if (this.options.displayStats) {
 			size = util.getContentSize(this.doc.documentElement.outerHTML);
 		}
+		restoreNestingPositions(this.nestingPositions);
 		if (this.doc.querySelector(`[${util.NESTING_TRACK_ID_ATTRIBUTE_NAME}]`)) {
 			const scriptElement = this.doc.createElement("script");
 			scriptElement.textContent = `(${util.getFixInvalidNestingSource()})(document, "${util.NESTING_TRACK_ID_ATTRIBUTE_NAME}");`;
@@ -799,7 +808,7 @@ class Processor {
 				if (attributeValue) {
 					const posterURL = this.options.posters[Number(attributeValue)];
 					if (!videoElement.getAttribute("poster") && posterURL && posterURL != EMPTY_RESOURCE) {
-						videoElement.setAttribute("poster", posterURL);
+						videoElement.setAttribute("poster", this.registerGeneratedDataURI(posterURL));
 					}
 				}
 			});
@@ -829,7 +838,7 @@ class Processor {
 					linkElement.style.setProperty("min-height", ICON_SIZE, "important");
 					linkElement.style.setProperty("max-width", ICON_SIZE, "important");
 					linkElement.style.setProperty("max-height", ICON_SIZE, "important");
-					imgElement.src = LINK_ICON;
+					imgElement.src = this.registerGeneratedDataURI(LINK_ICON);
 					imgElement.style.setProperty("width", ICON_SIZE, "important");
 					imgElement.style.setProperty("height", ICON_SIZE, "important");
 					imgElement.style.setProperty("min-width", ICON_SIZE, "important");
@@ -1081,7 +1090,7 @@ class Processor {
 							if (canvasData.backgroundColor) {
 								backgroundStyle["background-color"] = canvasData.backgroundColor;
 							}
-							this.processorHelper.setBackgroundImage(canvasElement, "url(" + canvasData.dataURI + ")", backgroundStyle);
+							this.processorHelper.setBackgroundImage(canvasElement, "url(" + this.registerGeneratedDataURI(canvasData.dataURI) + ")", backgroundStyle);
 							this.stats.add("processed", "canvas", 1);
 						} else if (!canvasData.blank) {
 							discardedCount++;
@@ -1242,17 +1251,17 @@ class Processor {
 								canvasElement.height = temporaryVideoElement.videoHeight || videoData.size.videoHeight;
 								context.drawImage(temporaryVideoElement, 0, 0, canvasElement.width, canvasElement.height);
 								try {
-									videoElement.poster = util.getPosterDataURI(canvasElement) || blankPosterURI;
+									videoElement.poster = this.registerGeneratedDataURI(util.getPosterDataURI(canvasElement) || blankPosterURI);
 									// eslint-disable-next-line no-unused-vars
 								} catch (error) {
-									videoElement.poster = blankPosterURI;
+									videoElement.poster = this.registerGeneratedDataURI(blankPosterURI);
 									// ignored
 								}
 								temporaryVideoElement.remove();
 								resolve();
 							};
 							temporaryVideoElement.onerror = () => {
-								videoElement.poster = blankPosterURI;
+								videoElement.poster = this.registerGeneratedDataURI(blankPosterURI);
 								temporaryVideoElement.remove();
 								resolve();
 							};
@@ -1342,7 +1351,9 @@ class Processor {
 			if (frameElement.tagName.toUpperCase() == "OBJECT") {
 				frameElement.setAttribute("data", "data:text/html,");
 			} else {
-				frameElement.removeAttribute("src");
+				if (frameElement.hasAttribute("src")) {
+					frameElement.setAttribute("src", "");
+				}
 				frameElement.removeAttribute("srcdoc");
 			}
 			Array.from(frameElement.childNodes).forEach(node => node.remove());
@@ -1745,6 +1756,7 @@ const FILE_URI_PREFIX = /^file:\/\//;
 const EMPTY_URL = /^https?:\/\/+\s*$/;
 const NOT_EMPTY_URL = /^(https?:\/\/|file:\/\/|blob:).+/;
 const SINGLE_FILE_VARIABLE_NAME_PREFIX = "--sf-img-";
+const PARAGRAPH_TAG_NAME = "P";
 
 function normalizeURL(url) {
 	if (!url || url.startsWith(DATA_URI_PREFIX)) {
@@ -1783,6 +1795,70 @@ function testIgnoredPath(resourceURL) {
 	return resourceURL && (resourceURL.startsWith(DATA_URI_PREFIX) || resourceURL == ABOUT_BLANK_URI);
 }
 
+function getNestingPositions(doc) {
+	return Array.from(doc.querySelectorAll(`[${util.NESTING_TRACK_ID_ATTRIBUTE_NAME}]`)).map(element => ({
+		element,
+		parentNode: element.parentNode,
+		nextSibling: element.nextSibling
+	}));
+}
+
+function restoreNestingPositions(positions) {
+	if (positions) {
+		positions.slice().reverse().forEach(({ element, parentNode, nextSibling }) => {
+			if (element.isConnected && parentNode && parentNode.isConnected) {
+				if (nextSibling && nextSibling.parentNode == parentNode) {
+					parentNode.insertBefore(element, nextSibling);
+				} else {
+					parentNode.appendChild(element);
+				}
+			}
+		});
+	}
+}
+
+function removeInsertedParagraphs(doc) {
+	const trackedElements = new Map();
+	doc.querySelectorAll(`[${util.NESTING_TRACK_ID_ATTRIBUTE_NAME}]`).forEach(element =>
+		trackedElements.set(element.getAttribute(util.NESTING_TRACK_ID_ATTRIBUTE_NAME), element));
+	const displacedElements = new Set();
+	trackedElements.forEach((element, trackId) => {
+		const parentTrackId = getParentTrackId(trackId);
+		const expectedParent = trackedElements.get(parentTrackId);
+		if (expectedParent && element.parentElement != expectedParent && !element.contains(expectedParent) &&
+			testParagraphExpectedAncestor(trackedElements, parentTrackId)) {
+			displacedElements.add(element);
+		}
+	});
+	const insertedParagraphs = new Set();
+	displacedElements.forEach(element => {
+		let sibling = element.nextSibling;
+		while (sibling && (sibling.nodeType != 1 || displacedElements.has(sibling))) {
+			sibling = sibling.nextSibling;
+		}
+		if (sibling && sibling.tagName == PARAGRAPH_TAG_NAME && !sibling.attributes.length && !sibling.childNodes.length) {
+			insertedParagraphs.add(sibling);
+		}
+	});
+	insertedParagraphs.forEach(paragraph => paragraph.remove());
+}
+
+function testParagraphExpectedAncestor(trackedElements, trackId) {
+	let element = trackedElements.get(trackId);
+	while (element) {
+		if (element.tagName == PARAGRAPH_TAG_NAME) {
+			return true;
+		}
+		trackId = getParentTrackId(trackId);
+		element = trackId ? trackedElements.get(trackId) : null;
+	}
+	return false;
+}
+
+function getParentTrackId(trackId) {
+	return trackId.split(".").slice(0, -1).join(".");
+}
+
 function testValidPath(resourceURL) {
 	return resourceURL && !resourceURL.match(EMPTY_URL);
 }

package/core/lib/processor-helper-common.js

@@ -232,7 +232,7 @@ class ProcessorHelperCommon {
 								// ignored
 							}
 							if (testValidURL(resourceURL)) {
-								return this.processImageSrcset(resourceURL, srcsetValue, resources, batchRequest);
+								return this.processImageSrcset(resourceURL, srcsetValue, resources, batchRequest, resourceElement);
 							} else {
 								return "";
 							}

package/core/lib/processor-helper-inline.js

@@ -51,6 +51,8 @@ const EMPTY_URL_SOURCE = /^url\(["']?data:[^,]*,?["']?\)/;
 const LOCAL_SOURCE = "local(";
 const FONT_MAX_LOAD_DELAY = 5000;
 const DUPLICATE_STYLESHEET_ATTRIBUTE_NAME = "data-sf-duplicate-stylesheet-ref";
+const LAYER_KEYWORD = "layer";
+const SUPPORTS_KEYWORD = "supports";
 const LINK_FETCH_ATTRIBUTE_NAMES = ["rel", "href", "type", "media", "as", "crossorigin", "integrity",
 	"referrerpolicy", "hreflang", "sizes", "imagesrcset", "imagesizes", "fetchpriority"];
 
@@ -219,25 +221,17 @@ function getProcessorHelperClass(utilInstance) {
 							if (content.data && content.data.match(/^<!doctype /i)) {
 								content.data = "";
 							}
+							const importedLayerName = getImportedLayerName(node);
+							if (importedLayerName !== null) {
+								content.data = this.wrapLayer(content.data, importedLayerName);
+							}
 							const mediaQueryListNode = cssTree.find(node, node => node.type == "MediaQueryList");
 							if (mediaQueryListNode) {
 								content.data = this.wrapMediaQuery(content.data, cssTree.generate(mediaQueryListNode));
 							}
-							const layerListNode = cssTree.find(node, node => node.type == "LayerList");
-							if (layerListNode) {
-								const layerNames = [];
-								layerListNode.children.forEach(child => {
-									if (child.type == "Identifier") {
-										layerNames.push(child.name);
-									}
-								});
-								if (layerNames.length == 1) {
-									content.data = this.wrapLayer(content.data, layerNames[0]);
-								}
-							}
-							const supportsNode = cssTree.find(node, node => node.type == "Supports");
-							if (supportsNode) {
-								content.data = "@supports " + cssTree.generate(supportsNode) + " { " + content.data + " }";
+							const importedSupportsCondition = getImportedSupportsCondition(node);
+							if (importedSupportsCondition) {
+								content.data = "@supports " + importedSupportsCondition + " { " + content.data + " }";
 							}
 							const importedStylesheet = cssTree.parse(content.data, { context: "stylesheet", parseCustomProperty: true });
 							const ancestorStyleSheets = new Set(importedStyleSheets);
@@ -302,7 +296,6 @@ function getProcessorHelperClass(utilInstance) {
 					frameElement.setAttribute("src", "data:text/html," + pageData.content.replace(/%/g, "%25").replace(/#/g, "%23"));
 				} else {
 					frameElement.setAttribute("srcdoc", pageData.content);
-					frameElement.removeAttribute("src");
 				}
 			}
 		}
@@ -520,11 +513,7 @@ function getProcessorHelperClass(utilInstance) {
 		}
 
 		wrapLayer(stylesheetContent, layerName) {
-			if (layerName) {
-				return "@layer " + layerName + " { " + stylesheetContent + " }";
-			} else {
-				return stylesheetContent;
-			}
+			return "@layer " + (layerName ? layerName + " " : "") + "{ " + stylesheetContent + " }";
 		}
 
 		getAdditionalPageData() {
@@ -770,6 +759,32 @@ function getProcessorHelperClass(utilInstance) {
 	};
 }
 
+function getImportedLayerName(importNode) {
+	const layerNode = cssTree.find(importNode, node => node.type == "Layer");
+	if (layerNode) {
+		return layerNode.name;
+	}
+	const prelude = importNode.prelude;
+	if (prelude && prelude.children) {
+		for (let child = prelude.children.head; child; child = child.next) {
+			if (child.data.type == "Identifier" && child.data.name.toLowerCase() == LAYER_KEYWORD) {
+				return "";
+			}
+		}
+	}
+	return null;
+}
+
+function getImportedSupportsCondition(importNode) {
+	const supportsNode = cssTree.find(importNode, node => node.type == "Function" && node.name.toLowerCase() == SUPPORTS_KEYWORD);
+	if (supportsNode && supportsNode.children && supportsNode.children.head) {
+		const conditionNode = supportsNode.children.head.data;
+		const condition = cssTree.generate(conditionNode);
+		return conditionNode.type == "Declaration" ? "(" + condition + ")" : condition;
+	}
+	return null;
+}
+
 function getFontFaces(cssRules, scope, fontFaces) {
 	for (let cssRule = cssRules.head; cssRule; cssRule = cssRule.next) {
 		const ruleData = cssRule.data;

package/core/lib/processor-helper.js

@@ -38,6 +38,9 @@ const LOCAL_SOURCE = "local(";
 const FONT_MAX_LOAD_DELAY = 5000;
 const SCRIPT_EXTENSION = ".js";
 const LINK_OWN_ATTRIBUTE_NAMES = ["rel", "type", "href", "media"];
+const CROSS_ORIGIN_ATTRIBUTE_NAME = "crossorigin";
+const SOURCE_TAG_NAME = "SOURCE";
+const MEDIA_TAG_NAMES = ["VIDEO", "AUDIO"];
 const SRCSET_ATTRIBUTE_NAME = "srcset";
 const IMAGE_ATTRIBUTE_NAMES = ["src", "href", "data", "poster", "background", "xlink:href", SRCSET_ATTRIBUTE_NAME];
 const IMAGE_ATTRIBUTE_SELECTOR = "[src], [href], [data], [poster], [background], [srcset], image, feImage";
@@ -74,6 +77,7 @@ function getProcessorHelperClass(utilInstance) {
 		async resolveStylesheets(element, stylesheetInfo, stylesheets, baseURI, options, workStyleElement, resources) {
 			if (element.tagName.toUpperCase() == "LINK") {
 				element.removeAttribute("integrity");
+				element.removeAttribute(CROSS_ORIGIN_ATTRIBUTE_NAME);
 				if (element.charset) {
 					options.charset = element.charset;
 				}
@@ -107,6 +111,7 @@ function getProcessorHelperClass(utilInstance) {
 			const linkElements = new Map();
 			const sharedStyleElements = new Map();
 			const emptyStylesheetRefIndexes = new Set();
+			const sharedStylesheetIndexes = new Set();
 			Array.from(new Set(options.inlineStylesheetsRefs.values())).forEach(stylesheetRefIndex => {
 				const { styleElement, content } = options.inlineStylesheets.get(stylesheetRefIndex);
 				const sharedEntry = entries.find(([key]) => key.element == styleElement);
@@ -121,6 +126,7 @@ function getProcessorHelperClass(utilInstance) {
 					linkElement.setAttribute("type", "text/css");
 					const name = "stylesheet_" + resources.stylesheets.size + ".css";
 					linkElement.setAttribute("href", name);
+					sharedStylesheetIndexes.add(resources.stylesheets.size);
 					resources.stylesheets.set(resources.stylesheets.size, { name, stylesheet });
 					linkElements.set(stylesheetRefIndex, linkElement);
 				}
@@ -138,7 +144,7 @@ function getProcessorHelperClass(utilInstance) {
 						} else {
 							key.urlNode.value = name;
 						}
-						resources.stylesheets.set(resources.stylesheets.size, { name, stylesheet: stylesheetInfo.stylesheet, url: stylesheetInfo.url });
+						resources.stylesheets.set(resources.stylesheets.size, { name, stylesheet: stylesheetInfo.stylesheet, url: stylesheetInfo.url, urlNode: key.urlNode });
 					}
 				} else if (key.element.tagName.toUpperCase() == "LINK") {
 					const linkElement = key.element;
@@ -173,11 +179,36 @@ function getProcessorHelperClass(utilInstance) {
 					}
 				}
 			}
-			for (const [, stylesheetResource] of resources.stylesheets) {
-				if (stylesheetResource.stylesheet) {
-					stylesheetResource.content = this.generateStylesheetContent(stylesheetResource.stylesheet, options);
-					stylesheetResource.stylesheet = null;
-				}
+			const stylesheetResources = Array.from(resources.stylesheets);
+			const canonicalNames = new Map();
+			const canonicalStylesheets = new Map();
+			stylesheetResources
+				.filter(([indexResource]) => !sharedStylesheetIndexes.has(indexResource))
+				.concat(stylesheetResources.filter(([indexResource]) => sharedStylesheetIndexes.has(indexResource)))
+				.forEach(([indexResource, stylesheetResource]) => {
+					if (stylesheetResource.stylesheet) {
+						const content = this.generateStylesheetContent(stylesheetResource.stylesheet, options);
+						stylesheetResource.stylesheet = null;
+						const canonicalName = canonicalStylesheets.get(content);
+						if (canonicalName === undefined) {
+							canonicalStylesheets.set(content, stylesheetResource.name);
+							stylesheetResource.content = content;
+						} else {
+							canonicalNames.set(stylesheetResource.name, canonicalName);
+							if (stylesheetResource.urlNode) {
+								replaceResourceName(stylesheetResource.urlNode, canonicalNames);
+							}
+							resources.stylesheets.delete(indexResource);
+						}
+					}
+				});
+			if (canonicalNames.size) {
+				doc.querySelectorAll("link[href]").forEach(linkElement => {
+					const href = linkElement.getAttribute("href");
+					if (canonicalNames.has(href)) {
+						linkElement.setAttribute("href", canonicalNames.get(href));
+					}
+				});
 			}
 		}
 
@@ -367,7 +398,7 @@ function getProcessorHelperClass(utilInstance) {
 				const originalResourceURL = urlNode.value;
 				if (!options.blockImages) {
 					const resourceURL = normalizeURL(originalResourceURL);
-					if (!testIgnoredPath(resourceURL) && testValidURL(resourceURL)) {
+					if ((!testIgnoredPath(resourceURL) && testValidURL(resourceURL)) || testGeneratedDataURI(resourceURL, options)) {
 						let { content, indexResource, contentType, extension } = await batchRequest.addURL(resourceURL,
 							{ asBinary: true, expectedType: "image" });
 						const name = "images/" + indexResource + extension;
@@ -394,17 +425,20 @@ function getProcessorHelperClass(utilInstance) {
 						resourceElement.setAttribute("data-sf-original-" + attributeName, resourceURL);
 					}
 					delete resourceElement.dataset.singleFileOriginURL;
+					const generatedDataURI = testGeneratedDataURI(resourceURL, options);
 					if (!expectedType || !options["block" + expectedType.charAt(0).toUpperCase() + expectedType.substring(1) + "s"]) {
-						if (!testIgnoredPath(resourceURL)) {
+						if (!testIgnoredPath(resourceURL) || generatedDataURI) {
 							this.setAttributeEmpty(resourceElement, attributeName, expectedType);
 							if (testValidPath(resourceURL)) {
-								try {
-									resourceURL = util.resolveURL(resourceURL, baseURI);
-									// eslint-disable-next-line no-unused-vars
-								} catch (error) {
-									// ignored
+								if (!generatedDataURI) {
+									try {
+										resourceURL = util.resolveURL(resourceURL, baseURI);
+										// eslint-disable-next-line no-unused-vars
+									} catch (error) {
+										// ignored
+									}
 								}
-								if (testValidURL(resourceURL)) {
+								if (testValidURL(resourceURL) || generatedDataURI) {
 									const declaredContentType = ["OBJECT", "EMBED"].includes(resourceElement.tagName.toUpperCase()) ? resourceElement.getAttribute("type") : "";
 									let { content, indexResource, extension, contentType, charset } = await batchRequest.addURL(resourceURL,
 										{ asBinary: true, expectedType, contentType: declaredContentType });
@@ -444,6 +478,7 @@ function getProcessorHelperClass(utilInstance) {
 									} else if (!this.testEmptyResource(content)) {
 										const name = "images/" + indexResource + extension;
 										resourceElement.setAttribute(attributeName, name);
+										removeCrossOriginAttribute(resourceElement);
 										resources.images.set(indexResource, { name, content, extension, contentType, url: resourceURL });
 									}
 								}
@@ -456,10 +491,11 @@ function getProcessorHelperClass(utilInstance) {
 			}));
 		}
 
-		async processImageSrcset(resourceURL, srcsetValue, resources, batchRequest) {
+		async processImageSrcset(resourceURL, srcsetValue, resources, batchRequest, resourceElement) {
 			const { content, indexResource, extension, contentType } = await batchRequest.addURL(resourceURL, { asBinary: true, expectedType: "image" });
 			const name = "images/" + indexResource + extension;
 			resources.images.set(indexResource, { name, content, extension, contentType, url: resourceURL });
+			resourceElement.removeAttribute(CROSS_ORIGIN_ATTRIBUTE_NAME);
 			return serializeSrcset([Object.assign({}, srcsetValue, { url: name })]);
 		}
 
@@ -526,6 +562,7 @@ function getProcessorHelperClass(utilInstance) {
 			// the browser refuses to execute. Stylesheets have always been named this way
 			const name = "scripts/" + indexResource + SCRIPT_EXTENSION;
 			element.setAttribute("src", name);
+			element.removeAttribute(CROSS_ORIGIN_ATTRIBUTE_NAME);
 			resources.scripts.set(indexResource, { name, content, extension, contentType, url: resourceURL });
 		}
 
@@ -659,6 +696,14 @@ function isEmptyStylesheet(stylesheet) {
 	return !stylesheet || !stylesheet.children || !stylesheet.children.size;
 }
 
+function removeCrossOriginAttribute(element) {
+	element.removeAttribute(CROSS_ORIGIN_ATTRIBUTE_NAME);
+	const parentElement = element.parentElement;
+	if (element.tagName.toUpperCase() == SOURCE_TAG_NAME && parentElement && MEDIA_TAG_NAMES.includes(parentElement.tagName.toUpperCase())) {
+		parentElement.removeAttribute(CROSS_ORIGIN_ATTRIBUTE_NAME);
+	}
+}
+
 function removeImportRule(parentStylesheet, importNode) {
 	let importItem, importList;
 	cssTree.walk(parentStylesheet, {
@@ -675,6 +720,10 @@ function removeImportRule(parentStylesheet, importNode) {
 	}
 }
 
+function testGeneratedDataURI(resourceURL, options) {
+	return Boolean(options.generatedDataURIs && options.generatedDataURIs.has(resourceURL));
+}
+
 function testSameContent(content, otherContent) {
 	if (content.length != otherContent.length) {
 		return false;

package/modules/css-identifier.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010-2022 Gildas Lormeau
+ * contact : gildas.lormeau <at> gmail.com
+ *
+ * This file is part of SingleFile.
+ *
+ *   The code in this file is free software: you can redistribute it and/or
+ *   modify it under the terms of the GNU Affero General Public License
+ *   (GNU AGPL) as published by the Free Software Foundation, either version 3
+ *   of the License, or (at your option) any later version.
+ *
+ *   The code in this file is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+ *   General Public License for more details.
+ *
+ *   As additional permission under GNU AGPL version 3 section 7, you may
+ *   distribute UNMODIFIED VERSIONS OF THIS file without the copy of the GNU
+ *   AGPL normally required by section 4, provided you include this license
+ *   notice and a URL through which recipients can access the Corresponding
+ *   Source.
+ */
+
+const ESCAPE_CHARACTER = "\\";
+const CSS_ESCAPE_TEST = /\\(?:([0-9a-fA-F]{1,6})(?:\r\n|[ \n\r\t\f])?|([^\n\r\f]))/g;
+const REPLACEMENT_CHARACTER = "�";
+const MAX_CODE_POINT = 0x10ffff;
+const SURROGATE_FIRST_CODE_POINT = 0xd800;
+const SURROGATE_LAST_CODE_POINT = 0xdfff;
+const HEXADECIMAL_RADIX = 16;
+
+export {
+	ESCAPE_CHARACTER,
+	decodeIdentifier,
+	decodeName
+};
+
+function decodeIdentifier(identifier) {
+	if (identifier.indexOf(ESCAPE_CHARACTER) === -1) {
+		return identifier;
+	}
+	return identifier.replace(CSS_ESCAPE_TEST, (match, hexadecimalDigits, character) => {
+		if (hexadecimalDigits === undefined) {
+			return character;
+		}
+		const codePoint = parseInt(hexadecimalDigits, HEXADECIMAL_RADIX);
+		return codePoint === 0 || codePoint > MAX_CODE_POINT || (codePoint >= SURROGATE_FIRST_CODE_POINT && codePoint <= SURROGATE_LAST_CODE_POINT)
+			? REPLACEMENT_CHARACTER
+			: String.fromCodePoint(codePoint);
+	});
+}
+
+function decodeName(name) {
+	return typeof name === "string" ? decodeIdentifier(name).toLowerCase() : name;
+}