Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

node_modules/stringify-entities/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./lib/index.js";
+export type LightOptions = import('./lib/index.js').LightOptions;
+export type Options = import('./lib/index.js').Options;

node_modules/stringify-entities/index.js

@@ -0,0 +1,6 @@
+/**
+ * @typedef {import('./lib/index.js').LightOptions} LightOptions
+ * @typedef {import('./lib/index.js').Options} Options
+ */
+
+export * from './lib/index.js'

node_modules/stringify-entities/lib/constant/dangerous.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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>;

node_modules/stringify-entities/lib/constant/dangerous.js

@@ -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'
+]

node_modules/stringify-entities/lib/core.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Encode certain characters in `value`.
+ *
+ * @param {string} value
+ * @param {CoreWithFormatOptions} options
+ * @returns {string}
+ */
+export function core(value: string, options: CoreWithFormatOptions): string;
+export type CoreOptions = {
+    /**
+     * Whether to only escape the given subset of characters.
+     */
+    subset?: ReadonlyArray<string>;
+    /**
+     * Whether to only escape possibly dangerous characters.
+     * Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
+     */
+    escapeOnly?: boolean;
+};
+export type FormatOptions = {
+    /**
+     *  Format strategy.
+     */
+    format: (code: number, next: number, options: CoreWithFormatOptions) => string;
+};
+export type CoreWithFormatOptions = CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions;

node_modules/stringify-entities/lib/core.js

@@ -0,0 +1,117 @@
+/**
+ * @typedef CoreOptions
+ * @property {ReadonlyArray<string>} [subset=[]]
+ *   Whether to only escape the given subset of characters.
+ * @property {boolean} [escapeOnly=false]
+ *   Whether to only escape possibly dangerous characters.
+ *   Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
+ *
+ * @typedef FormatOptions
+ * @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format
+ *   Format strategy.
+ *
+ * @typedef {CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions} CoreWithFormatOptions
+ */
+
+const defaultSubsetRegex = /["&'<>`]/g
+const surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g
+const controlCharactersRegex =
+  // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
+  /[\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
+ * @param {CoreWithFormatOptions} options
+ * @returns {string}
+ */
+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)
+  )
+
+  /**
+   * @param {string} pair
+   * @param {number} index
+   * @param {string} all
+   */
+  function surrogate(pair, index, all) {
+    return options.format(
+      (pair.charCodeAt(0) - 0xd800) * 0x400 +
+        pair.charCodeAt(1) -
+        0xdc00 +
+        0x10000,
+      all.charCodeAt(index + 2),
+      options
+    )
+  }
+
+  /**
+   * @param {string} character
+   * @param {number} index
+   * @param {string} all
+   */
+  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
+ * @returns {RegExp}
+ */
+function charactersToExpressionCached(subset) {
+  let cached = subsetToRegexCache.get(subset)
+
+  if (!cached) {
+    cached = charactersToExpression(subset)
+    subsetToRegexCache.set(subset, cached)
+  }
+
+  return cached
+}
+
+/**
+ * @param {ReadonlyArray<string>} subset
+ * @returns {RegExp}
+ */
+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')
+}

node_modules/stringify-entities/lib/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Encode special characters in `value`.
+ *
+ * @param {string} value
+ *   Value to encode.
+ * @param {Options} [options]
+ *   Configuration.
+ * @returns {string}
+ *   Encoded value.
+ */
+export function stringifyEntities(value: string, options?: Options | undefined): string;
+/**
+ * Encode special characters in `value` as hexadecimals.
+ *
+ * @param {string} value
+ *   Value to encode.
+ * @param {LightOptions} [options]
+ *   Configuration.
+ * @returns {string}
+ *   Encoded value.
+ */
+export function stringifyEntitiesLight(value: string, options?: import("./core.js").CoreOptions | undefined): string;
+export type Options = import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions;
+export type LightOptions = import('./core.js').CoreOptions;

node_modules/stringify-entities/lib/index.js

@@ -0,0 +1,36 @@
+/**
+ * @typedef {import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions} Options
+ * @typedef {import('./core.js').CoreOptions} 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} [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 hexadecimals.
+ *
+ * @param {string} value
+ *   Value to encode.
+ * @param {LightOptions} [options]
+ *   Configuration.
+ * @returns {string}
+ *   Encoded value.
+ */
+export function stringifyEntitiesLight(value, options) {
+  return core(value, Object.assign({format: formatBasic}, options))
+}

node_modules/stringify-entities/lib/util/format-basic.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The smallest way to encode a character.
+ *
+ * @param {number} code
+ * @returns {string}
+ */
+export function formatBasic(code: number): string;

node_modules/stringify-entities/lib/util/format-basic.js

@@ -0,0 +1,9 @@
+/**
+ * The smallest way to encode a character.
+ *
+ * @param {number} code
+ * @returns {string}
+ */
+export function formatBasic(code) {
+  return '&#x' + code.toString(16).toUpperCase() + ';'
+}

node_modules/stringify-entities/lib/util/format-smart.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Configurable ways to encode a character yielding pretty or small results.
+ *
+ * @param {number} code
+ * @param {number} next
+ * @param {FormatSmartOptions} options
+ * @returns {string}
+ */
+export function formatSmart(code: number, next: number, options: FormatSmartOptions): string;
+export type FormatSmartOptions = {
+    /**
+     * Prefer named character references (`&`) where possible.
+     */
+    useNamedReferences?: boolean;
+    /**
+     * Prefer the shortest possible reference, if that results in less bytes.
+     * **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`.
+     */
+    useShortestReferences?: boolean;
+    /**
+     * Whether to omit semicolons when possible.
+     * **Note**: This creates what HTML calls “parse errors” but is otherwise still valid HTML — don’t use this except when building a minifier.
+     * Omitting semicolons is possible for certain named and numeric references in some cases.
+     */
+    omitOptionalSemicolons?: boolean;
+    /**
+     * Create character references which don’t fail in attributes.
+     * **Note**: `attribute` only applies when operating dangerously with
+     * `omitOptionalSemicolons: true`.
+     */
+    attribute?: boolean;
+};

node_modules/stringify-entities/lib/util/format-smart.js

@@ -0,0 +1,69 @@
+/**
+ * @typedef FormatSmartOptions
+ * @property {boolean} [useNamedReferences=false]
+ *   Prefer named character references (`&`) where possible.
+ * @property {boolean} [useShortestReferences=false]
+ *   Prefer the shortest possible reference, if that results in less bytes.
+ *   **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`.
+ * @property {boolean} [omitOptionalSemicolons=false]
+ *   Whether to omit semicolons when possible.
+ *   **Note**: This creates what HTML calls “parse errors” but is otherwise still valid HTML — don’t use this except when building a minifier.
+ *   Omitting semicolons is possible for certain named and numeric references in some cases.
+ * @property {boolean} [attribute=false]
+ *   Create character references which don’t fail in attributes.
+ *   **Note**: `attribute` only applies when operating dangerously with
+ *   `omitOptionalSemicolons: true`.
+ */
+
+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
+ * @param {number} next
+ * @param {FormatSmartOptions} options
+ * @returns {string}
+ */
+export function formatSmart(code, next, options) {
+  let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons)
+  /** @type {string|undefined} */
+  let named
+
+  if (options.useNamedReferences || options.useShortestReferences) {
+    named = toNamed(
+      code,
+      next,
+      options.omitOptionalSemicolons,
+      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, options.omitOptionalSemicolons)
+
+    if (decimal.length < numeric.length) {
+      numeric = decimal
+    }
+  }
+
+  return named &&
+    (!options.useShortestReferences || named.length < numeric.length)
+    ? named
+    : numeric
+}

node_modules/stringify-entities/lib/util/to-decimal.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Configurable ways to encode characters as decimal references.
+ *
+ * @param {number} code
+ * @param {number} next
+ * @param {boolean|undefined} omit
+ * @returns {string}
+ */
+export function toDecimal(code: number, next: number, omit: boolean | undefined): string;

node_modules/stringify-entities/lib/util/to-decimal.js

@@ -0,0 +1,16 @@
+const decimalRegex = /\d/
+
+/**
+ * Configurable ways to encode characters as decimal references.
+ *
+ * @param {number} code
+ * @param {number} next
+ * @param {boolean|undefined} omit
+ * @returns {string}
+ */
+export function toDecimal(code, next, omit) {
+  const value = '&#' + String(code)
+  return omit && next && !decimalRegex.test(String.fromCharCode(next))
+    ? value
+    : value + ';'
+}

node_modules/stringify-entities/lib/util/to-hexadecimal.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Configurable ways to encode characters as hexadecimal references.
+ *
+ * @param {number} code
+ * @param {number} next
+ * @param {boolean|undefined} omit
+ * @returns {string}
+ */
+export function toHexadecimal(code: number, next: number, omit: boolean | undefined): string;

node_modules/stringify-entities/lib/util/to-hexadecimal.js

@@ -0,0 +1,16 @@
+const hexadecimalRegex = /[\dA-Fa-f]/
+
+/**
+ * Configurable ways to encode characters as hexadecimal references.
+ *
+ * @param {number} code
+ * @param {number} next
+ * @param {boolean|undefined} omit
+ * @returns {string}
+ */
+export function toHexadecimal(code, next, omit) {
+  const value = '&#x' + code.toString(16).toUpperCase()
+  return omit && next && !hexadecimalRegex.test(String.fromCharCode(next))
+    ? value
+    : value + ';'
+}

node_modules/stringify-entities/lib/util/to-named.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Configurable ways to encode characters as named references.
+ *
+ * @param {number} code
+ * @param {number} next
+ * @param {boolean|undefined} omit
+ * @param {boolean|undefined} attribute
+ * @returns {string}
+ */
+export function toNamed(code: number, next: number, omit: boolean | undefined, attribute: boolean | undefined): string;

node_modules/stringify-entities/lib/util/to-named.js

@@ -0,0 +1,57 @@
+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
+ * @param {number} next
+ * @param {boolean|undefined} omit
+ * @param {boolean|undefined} attribute
+ * @returns {string}
+ */
+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 ''
+}

node_modules/stringify-entities/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2015 Titus Wormer <mailto:tituswormer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/stringify-entities/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "stringify-entities",
+  "version": "4.0.4",
+  "description": "Serialize (encode) HTML character references",
+  "license": "MIT",
+  "keywords": [
+    "stringify",
+    "encode",
+    "escape",
+    "html",
+    "character",
+    "reference",
+    "entity",
+    "entities"
+  ],
+  "repository": "wooorm/stringify-entities",
+  "bugs": "https://github.com/wooorm/stringify-entities/issues",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/wooorm"
+  },
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "character-entities-html4": "^2.0.0",
+    "character-entities-legacy": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "c8": "^9.0.0",
+    "character-entities": "^2.0.0",
+    "prettier": "^3.0.0",
+    "remark-cli": "^11.0.0",
+    "remark-preset-wooorm": "^9.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.58.0"
+  },
+  "scripts": {
+    "prepack": "npm run build && npm run format",
+    "generate": "node --conditions development build.js",
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix",
+    "test-api": "node --conditions development test.js",
+    "test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api",
+    "test": "npm run generate && npm run build && npm run format && npm run test-coverage"
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "bracketSpacing": false,
+    "semi": false,
+    "trailingComma": "none"
+  },
+  "xo": {
+    "prettier": true,
+    "rules": {
+      "unicorn/prefer-code-point": "off",
+      "unicorn/prefer-string-replace-all": "off",
+      "unicorn/numeric-separators-style": "off"
+    }
+  },
+  "remarkConfig": {
+    "plugins": [
+      "preset-wooorm"
+    ]
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "strict": true,
+    "ignoreCatch": true
+  }
+}

node_modules/stringify-entities/readme.md

@@ -0,0 +1,233 @@
+# stringify-entities
+
+[![Build Status][build-badge]][build]
+[![Coverage Status][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+
+Serialize (encode) HTML character references.
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`stringifyEntities(value[, options])`](#stringifyentitiesvalue-options)
+*   [Algorithm](#algorithm)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Security](#security)
+*   [Related](#related)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This is a small and powerful encoder of HTML character references (often called
+entities).
+This one has either all the options you need for a minifier/formatter, or a
+tiny size when using `stringifyEntitiesLight`.
+
+## When should I use this?
+
+You can use this for spec-compliant encoding of character references.
+It’s small and fast enough to do that well.
+You can also use this when making an HTML formatter or minifier, because there
+are different ways to produce pretty or tiny output.
+This package is reliable: ``'`'`` characters are encoded to ensure no scripts
+run in Internet Explorer 6 to 8.
+Additionally, only named references recognized by HTML 4 are encoded, meaning
+the infamous `'` (which people think is a [virus][]) won’t show up.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 14.14+, 16.0+), install with [npm][]:
+
+```sh
+npm install stringify-entities
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import {stringifyEntities} from 'https://esm.sh/stringify-entities@4'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+<script type="module">
+  import {stringifyEntities} from 'https://esm.sh/stringify-entities@4?bundle'
+</script>
+```
+
+## Use
+
+```js
+import {stringifyEntities} from 'stringify-entities'
+
+stringifyEntities('alpha © bravo ≠ charlie 𝌆 delta')
+// => 'alpha &#xA9; bravo &#x2260; charlie &#x1D306; delta'
+
+stringifyEntities('alpha © bravo ≠ charlie 𝌆 delta', {useNamedReferences: true})
+// => 'alpha &copy; bravo &ne; charlie &#x1D306; delta'
+```
+
+## API
+
+This package exports the identifiers `stringifyEntities` and
+`stringifyEntitiesLight`.
+There is no default export.
+
+### `stringifyEntities(value[, options])`
+
+Encode special characters in `value`.
+
+##### Core options
+
+###### `options.escapeOnly`
+
+Whether to only escape possibly dangerous characters (`boolean`, default:
+`false`).
+Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
+
+###### `options.subset`
+
+Whether to only escape the given subset of characters (`Array<string>`).
+Note that only BMP characters are supported here (so no emoji).
+
+##### Formatting options
+
+If you do not care about the following options, use `stringifyEntitiesLight`,
+which always outputs hexadecimal character references.
+
+###### `options.useNamedReferences`
+
+Prefer named character references (`&amp;`) where possible (`boolean?`, default:
+`false`).
+
+###### `options.useShortestReferences`
+
+Prefer the shortest possible reference, if that results in less bytes
+(`boolean?`, default: `false`).
+
+> ⚠️ **Note**: `useNamedReferences` can be omitted when using
+> `useShortestReferences`.
+
+###### `options.omitOptionalSemicolons`
+
+Whether to omit semicolons when possible (`boolean?`, default: `false`).
+
+> ⚠️ **Note**: This creates what HTML calls “parse errors” but is otherwise
+> still valid HTML — don’t use this except when building a minifier.
+> Omitting semicolons is possible for certain named and numeric references in
+> some cases.
+
+###### `options.attribute`
+
+Create character references which don’t fail in attributes (`boolean?`, default:
+`false`).
+
+> ⚠️ **Note**: `attribute` only applies when operating dangerously with
+> `omitOptionalSemicolons: true`.
+
+#### Returns
+
+Encoded value (`string`).
+
+## Algorithm
+
+By default, all dangerous, non-ASCII, and non-printable ASCII characters are
+encoded.
+A [subset][] of characters can be given to encode just those characters.
+Alternatively, pass [`escapeOnly`][escapeonly] to escape just the dangerous
+characters (`"`, `'`, `<`, `>`, `&`, `` ` ``).
+By default, hexadecimal character references are used.
+Pass [`useNamedReferences`][named] to use named character references when
+possible, or [`useShortestReferences`][short] to use whichever is shortest:
+decimal, hexadecimal, or named.
+There is also a `stringifyEntitiesLight` export, which works just like
+`stringifyEntities` but without the formatting options: it’s much smaller but
+always outputs hexadecimal character references.
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional types `Options` and `LightOptions` types.
+
+## Compatibility
+
+This package is at least compatible with all maintained versions of Node.js.
+As of now, that is Node.js 14.14+ and 16.0+.
+It also works in Deno and modern browsers.
+
+## Security
+
+This package is safe.
+
+## Related
+
+*   [`parse-entities`](https://github.com/wooorm/parse-entities)
+    — parse (decode) HTML character references
+*   [`wooorm/character-entities`](https://github.com/wooorm/character-entities)
+    — info on character references
+*   [`wooorm/character-entities-html4`](https://github.com/wooorm/character-entities-html4)
+    — info on HTML 4 character references
+*   [`wooorm/character-entities-legacy`](https://github.com/wooorm/character-entities-legacy)
+    — info on legacy character references
+*   [`wooorm/character-reference-invalid`](https://github.com/wooorm/character-reference-invalid)
+    — info on invalid numeric character references
+
+## Contribute
+
+Yes please!
+See [How to Contribute to Open Source][contribute].
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+<!-- Definitions -->
+
+[build-badge]: https://github.com/wooorm/stringify-entities/workflows/main/badge.svg
+
+[build]: https://github.com/wooorm/stringify-entities/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/wooorm/stringify-entities.svg
+
+[coverage]: https://codecov.io/github/wooorm/stringify-entities
+
+[downloads-badge]: https://img.shields.io/npm/dm/stringify-entities.svg
+
+[downloads]: https://www.npmjs.com/package/stringify-entities
+
+[size-badge]: https://img.shields.io/bundlephobia/minzip/stringify-entities.svg
+
+[size]: https://bundlephobia.com/result?p=stringify-entities
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esmsh]: https://esm.sh
+
+[license]: license
+
+[author]: https://wooorm.com
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[typescript]: https://www.typescriptlang.org
+
+[contribute]: https://opensource.guide/how-to-contribute/
+
+[virus]: https://www.telegraph.co.uk/technology/advice/10516839/Why-do-some-apostrophes-get-replaced-with-andapos.html
+
+[subset]: #optionssubset
+
+[escapeonly]: #optionsescapeonly
+
+[named]: #optionsusenamedreferences
+
+[short]: #optionsuseshortestreferences