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
+8
View File
@@ -0,0 +1,8 @@
/**
* List of legacy (that don’t need a trailing `;`) named references which could,
* depending on what follows them, turn into a different meaning
*
* @type {Array<string>}
*/
export const dangerous: Array<string>;
//# sourceMappingURL=dangerous.d.ts.map
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"dangerous.d.ts","sourceRoot":"","sources":["dangerous.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAFU,KAAK,CAAC,MAAM,CAAC,CAWtB"}
+16
View File
@@ -0,0 +1,16 @@
/**
* List of legacy (that don’t need a trailing `;`) named references which could,
* depending on what follows them, turn into a different meaning
*
* @type {Array<string>}
*/
export const dangerous = [
'cent',
'copy',
'divide',
'gt',
'lt',
'not',
'para',
'times'
]
+38
View File
@@ -0,0 +1,38 @@
/**
* Encode certain characters in `value`.
*
* @param {string} value
* Value to encode.
* @param {CoreWithFormatOptions} options
* Configuration.
* @returns {string}
* Encoded value.
*/
export function core(value: string, options: CoreWithFormatOptions): string;
/**
* Configuration for `stringifyEntitiesLight`.
*/
export type LightOptions = {
/**
* Whether to only escape possibly dangerous characters (default: `false`);
* those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
*/
escapeOnly?: boolean | null | undefined;
/**
* Whether to only escape the given subset of characters (optional);
* only BMP characters are supported here (so no emoji).
*/
subset?: ReadonlyArray<string> | null | undefined;
};
/**
* Internal format options.
*/
export type FormatOptions = {
/**
* Format strategy.
*/
format: (code: number, next: number, options: CoreWithFormatOptions) => string;
};
export type CoreWithFormatOptions = LightOptions & FormatOptions & FormatSmartOptions;
import type { FormatSmartOptions } from './util/format-smart.js';
//# sourceMappingURL=core.d.ts.map
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["core.js"],"names":[],"mappings":"AAoCA;;;;;;;;;GASG;AACH,4BAPW,MAAM,WAEN,qBAAqB,GAEnB,MAAM,CAkElB;;;;;;;;;iBAtGa,OAAO,GAAG,IAAI,GAAG,SAAS;;;;;aAG1B,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS;;;;;;;;;YAQxC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,KAAK,MAAM;;oCAKvE,YAAY,GAAG,aAAa,GAAG,kBAAkB;wCAtBzB,wBAAwB"}
+151
View File
@@ -0,0 +1,151 @@
/**
* @import {FormatSmartOptions} from './util/format-smart.js'
*/
/**
* @typedef LightOptions
* Configuration for `stringifyEntitiesLight`.
* @property {boolean | null | undefined} [escapeOnly=false]
* Whether to only escape possibly dangerous characters (default: `false`);
* those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
* @property {ReadonlyArray<string> | null | undefined} [subset]
* Whether to only escape the given subset of characters (optional);
* only BMP characters are supported here (so no emoji).
*/
/**
* @typedef FormatOptions
* Internal format options.
* @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format
* Format strategy.
*/
/**
* @typedef {LightOptions & FormatOptions & FormatSmartOptions} CoreWithFormatOptions
*/
const defaultSubsetRegex = /["&'<>`]/g
const surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g
const controlCharactersRegex =
// eslint-disable-next-line no-control-regex, regexp/hexadecimal-escape, regexp/no-control-character, regexp/no-obscure-range -- matching control characters is the point.
/[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g
const regexEscapeRegex = /[|\\{}()[\]^$+*?.]/g
/** @type {WeakMap<ReadonlyArray<string>, RegExp>} */
const subsetToRegexCache = new WeakMap()
/**
* Encode certain characters in `value`.
*
* @param {string} value
* Value to encode.
* @param {CoreWithFormatOptions} options
* Configuration.
* @returns {string}
* Encoded value.
*/
export function core(value, options) {
value = value.replace(
options.subset
? charactersToExpressionCached(options.subset)
: defaultSubsetRegex,
basic
)
if (options.subset || options.escapeOnly) {
return value
}
return (
value
// Surrogate pairs.
.replace(surrogatePairsRegex, surrogate)
// BMP control characters (C0 except for LF, CR, SP; DEL; and some more
// non-ASCII ones).
.replace(controlCharactersRegex, basic)
)
/**
* Encode a surrogate pair.
*
* @param {string} pair
* Surrogate pair.
* @param {number} index
* Index of `pair` in `all`.
* @param {string} all
* Whole value.
* @returns {string}
* Character reference.
*/
function surrogate(pair, index, all) {
return options.format(
(pair.charCodeAt(0) - 0xd800) * 0x400 +
pair.charCodeAt(1) -
0xdc00 +
0x10000,
all.charCodeAt(index + 2),
options
)
}
/**
* Encode a character.
*
* @param {string} character
* Character.
* @param {number} index
* Index of `character` in `all`.
* @param {string} all
* Whole value.
* @returns {string}
* Character reference.
*/
function basic(character, index, all) {
return options.format(
character.charCodeAt(0),
all.charCodeAt(index + 1),
options
)
}
}
/**
* A wrapper function that caches the result of `charactersToExpression` with a WeakMap.
* This can improve performance when tooling calls `charactersToExpression` repeatedly
* with the same subset.
*
* @param {ReadonlyArray<string>} subset
* Characters to match.
* @returns {RegExp}
* Expression.
*/
function charactersToExpressionCached(subset) {
let cached = subsetToRegexCache.get(subset)
if (!cached) {
cached = charactersToExpression(subset)
subsetToRegexCache.set(subset, cached)
}
return cached
}
/**
* Create an expression that matches any of `subset`.
*
* @param {ReadonlyArray<string>} subset
* Characters to match.
* @returns {RegExp}
* Expression.
*/
function charactersToExpression(subset) {
/** @type {Array<string>} */
const groups = []
let index = -1
while (++index < subset.length) {
groups.push(subset[index].replace(regexEscapeRegex, '\\$&'))
}
return new RegExp('(?:' + groups.join('|') + ')', 'g')
}
+31
View File
@@ -0,0 +1,31 @@
/**
* Encode special characters in `value`.
*
* @param {string} value
* Value to encode.
* @param {Options | null | undefined} [options]
* Configuration.
* @returns {string}
* Encoded value.
*/
export function stringifyEntities(value: string, options?: Options | null | undefined): string;
/**
* Encode special characters in `value` as hexadecimal character references.
*
* @param {string} value
* Value to encode.
* @param {LightOptions | null | undefined} [options]
* Configuration.
* @returns {string}
* Encoded value.
*/
export function stringifyEntitiesLight(value: string, options?: LightOptions | null | undefined): string;
/**
* Configuration for `stringifyEntities`.
*
* Includes the fields of `LightOptions`.
*/
export type Options = LightOptions & FormatSmartOptions;
import type { LightOptions } from './core.js';
import type { FormatSmartOptions } from './util/format-smart.js';
//# sourceMappingURL=index.d.ts.map
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAgBA;;;;;;;;;GASG;AACH,yCAPW,MAAM,YAEN,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,MAAM,CAKlB;AAED;;;;;;;;;GASG;AACH,8CAPW,MAAM,YAEN,YAAY,GAAG,IAAI,GAAG,SAAS,GAE7B,MAAM,CAKlB;;;;;;sBApCY,YAAY,GAAG,kBAAkB;kCALf,WAAW;wCACL,wBAAwB"}
+43
View File
@@ -0,0 +1,43 @@
/**
* @import {LightOptions} from './core.js'
* @import {FormatSmartOptions} from './util/format-smart.js'
*/
/**
* @typedef {LightOptions & FormatSmartOptions} Options
* Configuration for `stringifyEntities`.
*
* Includes the fields of `LightOptions`.
*/
import {core} from './core.js'
import {formatSmart} from './util/format-smart.js'
import {formatBasic} from './util/format-basic.js'
/**
* Encode special characters in `value`.
*
* @param {string} value
* Value to encode.
* @param {Options | null | undefined} [options]
* Configuration.
* @returns {string}
* Encoded value.
*/
export function stringifyEntities(value, options) {
return core(value, Object.assign({format: formatSmart}, options))
}
/**
* Encode special characters in `value` as hexadecimal character references.
*
* @param {string} value
* Value to encode.
* @param {LightOptions | null | undefined} [options]
* Configuration.
* @returns {string}
* Encoded value.
*/
export function stringifyEntitiesLight(value, options) {
return core(value, Object.assign({format: formatBasic}, options))
}
+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 (`&amp;`) 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 (`&amp;`) 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:
//
// * `&#99;` vs `&#x63;` (decimal shorter)
// * `&#100;` vs `&#x64;` (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 ''
}