the editable site (validation-lab)
deploy / build-and-publish (push) Successful in 1m37s

This commit is contained in:
2026-11-21 08:03:55 +01:00
commit 3ac81d5a52
13454 changed files with 2227005 additions and 0 deletions
+10
View File
@@ -0,0 +1,10 @@
/**
* The smallest way to encode a character.
*
* @param {number} code
* Code point.
* @returns {string}
* Hexadecimal reference.
*/
export function formatBasic(code: number): string;
//# sourceMappingURL=format-basic.d.ts.map
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"format-basic.d.ts","sourceRoot":"","sources":["format-basic.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,kCALW,MAAM,GAEJ,MAAM,CAKlB"}
+11
View File
@@ -0,0 +1,11 @@
/**
* The smallest way to encode a character.
*
* @param {number} code
* Code point.
* @returns {string}
* Hexadecimal reference.
*/
export function formatBasic(code) {
return '&#x' + code.toString(16).toUpperCase() + ';'
}
+46
View File
@@ -0,0 +1,46 @@
/**
* Configurable ways to encode a character yielding pretty or small results.
*
* @param {number} code
* Code point.
* @param {number} next
* Code point of the next character (or `NaN`).
* @param {FormatSmartOptions} options
* Configuration.
* @returns {string}
* Character reference.
*/
export function formatSmart(code: number, next: number, options: FormatSmartOptions): string;
/**
* Configuration for `stringifyEntities` that is not in `LightOptions`.
*/
export type FormatSmartOptions = {
/**
* Create character references which don’t fail in attributes
* (default: `false`);
* only applies when operating dangerously with
* `omitOptionalSemicolons: true`.
*/
attribute?: boolean | null | undefined;
/**
* Whether to omit semicolons when possible (default: `false`);
* this creates what HTML calls “parse errors” but is otherwise still valid
* HTML,
* so don’t use this except when building a minifier;
* omitting semicolons is possible for certain named and numeric references in
* some cases.
*/
omitOptionalSemicolons?: boolean | null | undefined;
/**
* Prefer named character references (`&`) where possible
* (default: `false`).
*/
useNamedReferences?: boolean | null | undefined;
/**
* Prefer the shortest possible reference,
* if that results in less bytes (default: `false`);
* `useNamedReferences` can be omitted when using `useShortestReferences`.
*/
useShortestReferences?: boolean | null | undefined;
};
//# sourceMappingURL=format-smart.d.ts.map
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"format-smart.d.ts","sourceRoot":"","sources":["format-smart.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;GAWG;AACH,kCATW,MAAM,QAEN,MAAM,WAEN,kBAAkB,GAEhB,MAAM,CAsClB;;;;;;;;;;;gBAxEa,OAAO,GAAG,IAAI,GAAG,SAAS;;;;;;;;;6BAK1B,OAAO,GAAG,IAAI,GAAG,SAAS;;;;;yBAO1B,OAAO,GAAG,IAAI,GAAG,SAAS;;;;;;4BAG1B,OAAO,GAAG,IAAI,GAAG,SAAS"}
+76
View File
@@ -0,0 +1,76 @@
/**
* @typedef FormatSmartOptions
* Configuration for `stringifyEntities` that is not in `LightOptions`.
* @property {boolean | null | undefined} [attribute=false]
* Create character references which don’t fail in attributes
* (default: `false`);
* only applies when operating dangerously with
* `omitOptionalSemicolons: true`.
* @property {boolean | null | undefined} [omitOptionalSemicolons=false]
* Whether to omit semicolons when possible (default: `false`);
* this creates what HTML calls “parse errors” but is otherwise still valid
* HTML,
* so don’t use this except when building a minifier;
* omitting semicolons is possible for certain named and numeric references in
* some cases.
* @property {boolean | null | undefined} [useNamedReferences=false]
* Prefer named character references (`&`) where possible
* (default: `false`).
* @property {boolean | null | undefined} [useShortestReferences=false]
* Prefer the shortest possible reference,
* if that results in less bytes (default: `false`);
* `useNamedReferences` can be omitted when using `useShortestReferences`.
*/
import {toHexadecimal} from './to-hexadecimal.js'
import {toDecimal} from './to-decimal.js'
import {toNamed} from './to-named.js'
/**
* Configurable ways to encode a character yielding pretty or small results.
*
* @param {number} code
* Code point.
* @param {number} next
* Code point of the next character (or `NaN`).
* @param {FormatSmartOptions} options
* Configuration.
* @returns {string}
* Character reference.
*/
export function formatSmart(code, next, options) {
const omit = options.omitOptionalSemicolons && next !== 59 /* `;` */
let numeric = toHexadecimal(code, next, omit)
/** @type {string | undefined} */
let named
if (options.useNamedReferences || options.useShortestReferences) {
named = toNamed(code, next, omit, options.attribute)
}
// Use the shortest numeric reference when requested.
// A simple algorithm would use decimal for all code points under 100, as
// those are shorter than hexadecimal:
//
// * `c` vs `c` (decimal shorter)
// * `d` vs `d` (equal)
//
// However, because we take `next` into consideration when `omit` is used,
// And it would be possible that decimals are shorter on bigger values as
// well if `next` is hexadecimal but not decimal, we instead compare both.
if (
(options.useShortestReferences || !named) &&
options.useShortestReferences
) {
const decimal = toDecimal(code, next, omit)
if (decimal.length < numeric.length) {
numeric = decimal
}
}
return named &&
(!options.useShortestReferences || named.length < numeric.length)
? named
: numeric
}
+14
View File
@@ -0,0 +1,14 @@
/**
* Configurable ways to encode characters as decimal references.
*
* @param {number} code
* Code point.
* @param {number} next
* Code point of the next character (or `NaN`).
* @param {boolean | null | undefined} omit
* Whether to omit the semicolon when possible.
* @returns {string}
* Decimal reference.
*/
export function toDecimal(code: number, next: number, omit: boolean | null | undefined): string;
//# sourceMappingURL=to-decimal.d.ts.map
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"to-decimal.d.ts","sourceRoot":"","sources":["to-decimal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,gCATW,MAAM,QAEN,MAAM,QAEN,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,MAAM,CAQlB"}
+20
View File
@@ -0,0 +1,20 @@
const decimalRegex = /\d/
/**
* Configurable ways to encode characters as decimal references.
*
* @param {number} code
* Code point.
* @param {number} next
* Code point of the next character (or `NaN`).
* @param {boolean | null | undefined} omit
* Whether to omit the semicolon when possible.
* @returns {string}
* Decimal reference.
*/
export function toDecimal(code, next, omit) {
const value = '&#' + String(code)
return omit && next && !decimalRegex.test(String.fromCharCode(next))
? value
: value + ';'
}
+14
View File
@@ -0,0 +1,14 @@
/**
* Configurable ways to encode characters as hexadecimal references.
*
* @param {number} code
* Code point.
* @param {number} next
* Code point of the next character (or `NaN`).
* @param {boolean | null | undefined} omit
* Whether to omit the semicolon when possible.
* @returns {string}
* Hexadecimal reference.
*/
export function toHexadecimal(code: number, next: number, omit: boolean | null | undefined): string;
//# sourceMappingURL=to-hexadecimal.d.ts.map
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"to-hexadecimal.d.ts","sourceRoot":"","sources":["to-hexadecimal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,oCATW,MAAM,QAEN,MAAM,QAEN,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,MAAM,CAQlB"}
+20
View File
@@ -0,0 +1,20 @@
const hexadecimalRegex = /[\dA-Fa-f]/
/**
* Configurable ways to encode characters as hexadecimal references.
*
* @param {number} code
* Code point.
* @param {number} next
* Code point of the next character (or `NaN`).
* @param {boolean | null | undefined} omit
* Whether to omit the semicolon when possible.
* @returns {string}
* Hexadecimal reference.
*/
export function toHexadecimal(code, next, omit) {
const value = '&#x' + code.toString(16).toUpperCase()
return omit && next && !hexadecimalRegex.test(String.fromCharCode(next))
? value
: value + ';'
}
+16
View File
@@ -0,0 +1,16 @@
/**
* Configurable ways to encode characters as named references.
*
* @param {number} code
* Code point.
* @param {number} next
* Code point of the next character (or `NaN`).
* @param {boolean | null | undefined} omit
* Whether to omit the semicolon when possible.
* @param {boolean | null | undefined} attribute
* Whether the reference is in an attribute.
* @returns {string}
* Named reference, or empty string if there is no name.
*/
export function toNamed(code: number, next: number, omit: boolean | null | undefined, attribute: boolean | null | undefined): string;
//# sourceMappingURL=to-named.d.ts.map
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"to-named.d.ts","sourceRoot":"","sources":["to-named.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;GAaG;AACH,8BAXW,MAAM,QAEN,MAAM,QAEN,OAAO,GAAG,IAAI,GAAG,SAAS,aAE1B,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,MAAM,CA0BlB"}
+62
View File
@@ -0,0 +1,62 @@
import {characterEntitiesLegacy} from 'character-entities-legacy'
import {characterEntitiesHtml4} from 'character-entities-html4'
import {dangerous} from '../constant/dangerous.js'
const own = {}.hasOwnProperty
/**
* `characterEntitiesHtml4` but inverted.
*
* @type {Record<string, string>}
*/
const characters = {}
/** @type {string} */
let key
for (key in characterEntitiesHtml4) {
if (own.call(characterEntitiesHtml4, key)) {
characters[characterEntitiesHtml4[key]] = key
}
}
const notAlphanumericRegex = /[^\dA-Za-z]/
/**
* Configurable ways to encode characters as named references.
*
* @param {number} code
* Code point.
* @param {number} next
* Code point of the next character (or `NaN`).
* @param {boolean | null | undefined} omit
* Whether to omit the semicolon when possible.
* @param {boolean | null | undefined} attribute
* Whether the reference is in an attribute.
* @returns {string}
* Named reference, or empty string if there is no name.
*/
export function toNamed(code, next, omit, attribute) {
const character = String.fromCharCode(code)
if (own.call(characters, character)) {
const name = characters[character]
const value = '&' + name
if (
omit &&
characterEntitiesLegacy.includes(name) &&
!dangerous.includes(name) &&
(!attribute ||
(next &&
next !== 61 /* `=` */ &&
notAlphanumericRegex.test(String.fromCharCode(next))))
) {
return value
}
return value + ';'
}
return ''
}