🎉 initiate project *astro_rewrite*

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,42 @@
+/**
+ * @typedef CoreOptions
+ * @property {Array<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
+ */
+/**
+ * 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?: string[] | undefined
+  /**
+   * Whether to only escape possibly dangerous characters.
+   * Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
+   */
+  escapeOnly?: boolean | undefined
+}
+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,90 @@
+/**
+ * @typedef CoreOptions
+ * @property {Array<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
+ */
+
+/**
+ * Encode certain characters in `value`.
+ *
+ * @param {string} value
+ * @param {CoreWithFormatOptions} options
+ * @returns {string}
+ */
+export function core(value, options) {
+  value = value.replace(
+    options.subset ? charactersToExpression(options.subset) : /["&'<>`]/g,
+    basic
+  )
+
+  if (options.subset || options.escapeOnly) {
+    return value
+  }
+
+  return (
+    value
+      // Surrogate pairs.
+      .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, surrogate)
+      // BMP control characters (C0 except for LF, CR, SP; DEL; and some more
+      // non-ASCII ones).
+      .replace(
+        // 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,
+        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
+    )
+  }
+}
+
+/**
+ * @param {Array<string>} subset
+ * @returns {RegExp}
+ */
+function charactersToExpression(subset) {
+  /** @type {Array<string>} */
+  const groups = []
+  let index = -1
+
+  while (++index < subset.length) {
+    groups.push(subset[index].replace(/[|\\{}()[\]^$+*?.]/g, '\\$&'))
+  }
+
+  return new RegExp('(?:' + groups.join('|') + ')', 'g')
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 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,36 @@
+/**
+ * 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 | undefined
+  /**
+   * Prefer the shortest possible reference, if that results in less bytes.
+   * **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`.
+   */
+  useShortestReferences?: boolean | undefined
+  /**
+   * 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 | undefined
+  /**
+   * Create character references which don’t fail in attributes.
+   * **Note**: `attribute` only applies when operating dangerously with
+   * `omitOptionalSemicolons: true`.
+   */
+  attribute?: boolean | undefined
+}

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,13 @@
+/**
+ * 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,14 @@
+/**
+ * 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 && !/\d/.test(String.fromCharCode(next))
+    ? value
+    : value + ';'
+}

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

@@ -0,0 +1,13 @@
+/**
+ * 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,14 @@
+/**
+ * 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 && !/[\dA-Fa-f]/.test(String.fromCharCode(next))
+    ? value
+    : value + ';'
+}

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

@@ -0,0 +1,15 @@
+/**
+ * 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,55 @@
+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
+  }
+}
+
+/**
+ * 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 /* `=` */ &&
+          /[^\da-z]/i.test(String.fromCharCode(next))))
+    ) {
+      return value
+    }
+
+    return value + ';'
+  }
+
+  return ''
+}