🎉 initiate project *astro_rewrite*

node_modules/hast-util-to-html/lib/omission/closing.d.ts

@@ -0,0 +1,3 @@
+export const closing: import('../types.js').OmitHandle
+export type Element = import('../types.js').Element
+export type Parent = import('../types.js').Parent

node_modules/hast-util-to-html/lib/omission/closing.js

@@ -0,0 +1,384 @@
+/**
+ * @typedef {import('../types.js').Element} Element
+ * @typedef {import('../types.js').Parent} Parent
+ */
+
+import {whitespace} from 'hast-util-whitespace'
+import {siblingAfter} from './util/siblings.js'
+import {omission} from './omission.js'
+
+export const closing = omission({
+  html,
+  head: headOrColgroupOrCaption,
+  body,
+  p,
+  li,
+  dt,
+  dd,
+  rt: rubyElement,
+  rp: rubyElement,
+  optgroup,
+  option,
+  menuitem,
+  colgroup: headOrColgroupOrCaption,
+  caption: headOrColgroupOrCaption,
+  thead,
+  tbody,
+  tfoot,
+  tr,
+  td: cells,
+  th: cells
+})
+
+/**
+ * Macro for `</head>`, `</colgroup>`, and `</caption>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function headOrColgroupOrCaption(_, index, parent) {
+  const next = siblingAfter(parent, index, true)
+  return (
+    !next ||
+    (next.type !== 'comment' &&
+      !(next.type === 'text' && whitespace(next.value.charAt(0))))
+  )
+}
+
+/**
+ * Whether to omit `</html>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function html(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return !next || next.type !== 'comment'
+}
+
+/**
+ * Whether to omit `</body>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function body(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return !next || next.type !== 'comment'
+}
+
+/**
+ * Whether to omit `</p>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+// eslint-disable-next-line complexity
+function p(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return next
+    ? next.type === 'element' &&
+        (next.tagName === 'address' ||
+          next.tagName === 'article' ||
+          next.tagName === 'aside' ||
+          next.tagName === 'blockquote' ||
+          next.tagName === 'details' ||
+          next.tagName === 'div' ||
+          next.tagName === 'dl' ||
+          next.tagName === 'fieldset' ||
+          next.tagName === 'figcaption' ||
+          next.tagName === 'figure' ||
+          next.tagName === 'footer' ||
+          next.tagName === 'form' ||
+          next.tagName === 'h1' ||
+          next.tagName === 'h2' ||
+          next.tagName === 'h3' ||
+          next.tagName === 'h4' ||
+          next.tagName === 'h5' ||
+          next.tagName === 'h6' ||
+          next.tagName === 'header' ||
+          next.tagName === 'hgroup' ||
+          next.tagName === 'hr' ||
+          next.tagName === 'main' ||
+          next.tagName === 'menu' ||
+          next.tagName === 'nav' ||
+          next.tagName === 'ol' ||
+          next.tagName === 'p' ||
+          next.tagName === 'pre' ||
+          next.tagName === 'section' ||
+          next.tagName === 'table' ||
+          next.tagName === 'ul')
+    : !parent ||
+        // Confusing parent.
+        !(
+          parent.type === 'element' &&
+          (parent.tagName === 'a' ||
+            parent.tagName === 'audio' ||
+            parent.tagName === 'del' ||
+            parent.tagName === 'ins' ||
+            parent.tagName === 'map' ||
+            parent.tagName === 'noscript' ||
+            parent.tagName === 'video')
+        )
+}
+
+/**
+ * Whether to omit `</li>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function li(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return !next || (next.type === 'element' && next.tagName === 'li')
+}
+
+/**
+ * Whether to omit `</dt>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function dt(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return (
+    next &&
+    next.type === 'element' &&
+    (next.tagName === 'dt' || next.tagName === 'dd')
+  )
+}
+
+/**
+ * Whether to omit `</dd>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function dd(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return (
+    !next ||
+    (next.type === 'element' &&
+      (next.tagName === 'dt' || next.tagName === 'dd'))
+  )
+}
+
+/**
+ * Whether to omit `</rt>` or `</rp>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function rubyElement(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return (
+    !next ||
+    (next.type === 'element' &&
+      (next.tagName === 'rp' || next.tagName === 'rt'))
+  )
+}
+
+/**
+ * Whether to omit `</optgroup>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function optgroup(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return !next || (next.type === 'element' && next.tagName === 'optgroup')
+}
+
+/**
+ * Whether to omit `</option>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function option(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return (
+    !next ||
+    (next.type === 'element' &&
+      (next.tagName === 'option' || next.tagName === 'optgroup'))
+  )
+}
+
+/**
+ * Whether to omit `</menuitem>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function menuitem(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return (
+    !next ||
+    (next.type === 'element' &&
+      (next.tagName === 'menuitem' ||
+        next.tagName === 'hr' ||
+        next.tagName === 'menu'))
+  )
+}
+
+/**
+ * Whether to omit `</thead>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function thead(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return (
+    next &&
+    next.type === 'element' &&
+    (next.tagName === 'tbody' || next.tagName === 'tfoot')
+  )
+}
+
+/**
+ * Whether to omit `</tbody>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function tbody(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return (
+    !next ||
+    (next.type === 'element' &&
+      (next.tagName === 'tbody' || next.tagName === 'tfoot'))
+  )
+}
+
+/**
+ * Whether to omit `</tfoot>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function tfoot(_, index, parent) {
+  return !siblingAfter(parent, index)
+}
+
+/**
+ * Whether to omit `</tr>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function tr(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return !next || (next.type === 'element' && next.tagName === 'tr')
+}
+
+/**
+ * Whether to omit `</td>` or `</th>`.
+ *
+ * @param {Element} _
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the closing tag can be omitted.
+ */
+function cells(_, index, parent) {
+  const next = siblingAfter(parent, index)
+  return (
+    !next ||
+    (next.type === 'element' &&
+      (next.tagName === 'td' || next.tagName === 'th'))
+  )
+}

node_modules/hast-util-to-html/lib/omission/omission.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Factory to check if a given node can have a tag omitted.
+ *
+ * @param {Record<string, OmitHandle>} handlers
+ *   Omission handlers, where each key is a tag name, and each value is the
+ *   corresponding handler.
+ * @returns {OmitHandle}
+ *   Whether to omit a tag of an element.
+ */
+export function omission(handlers: Record<string, OmitHandle>): OmitHandle
+export type OmitHandle = import('../types.js').OmitHandle

node_modules/hast-util-to-html/lib/omission/omission.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('../types.js').OmitHandle} OmitHandle
+ */
+
+const own = {}.hasOwnProperty
+
+/**
+ * Factory to check if a given node can have a tag omitted.
+ *
+ * @param {Record<string, OmitHandle>} handlers
+ *   Omission handlers, where each key is a tag name, and each value is the
+ *   corresponding handler.
+ * @returns {OmitHandle}
+ *   Whether to omit a tag of an element.
+ */
+export function omission(handlers) {
+  return omit
+
+  /**
+   * Check if a given node can have a tag omitted.
+   *
+   * @type {OmitHandle}
+   */
+  function omit(node, index, parent) {
+    return (
+      own.call(handlers, node.tagName) &&
+      handlers[node.tagName](node, index, parent)
+    )
+  }
+}

node_modules/hast-util-to-html/lib/omission/opening.d.ts

@@ -0,0 +1,4 @@
+export const opening: import('../types.js').OmitHandle
+export type Element = import('../types.js').Element
+export type Parent = import('../types.js').Parent
+export type Content = import('../types.js').Content

node_modules/hast-util-to-html/lib/omission/opening.js

@@ -0,0 +1,148 @@
+/**
+ * @typedef {import('../types.js').Element} Element
+ * @typedef {import('../types.js').Parent} Parent
+ * @typedef {import('../types.js').Content} Content
+ */
+
+import {whitespace} from 'hast-util-whitespace'
+import {siblingBefore, siblingAfter} from './util/siblings.js'
+import {closing} from './closing.js'
+import {omission} from './omission.js'
+
+export const opening = omission({
+  html,
+  head,
+  body,
+  colgroup,
+  tbody
+})
+
+/**
+ * Whether to omit `<html>`.
+ *
+ * @param {Element} node
+ *   Element.
+ * @returns {boolean}
+ *   Whether the opening tag can be omitted.
+ */
+function html(node) {
+  const head = siblingAfter(node, -1)
+  return !head || head.type !== 'comment'
+}
+
+/**
+ * Whether to omit `<head>`.
+ *
+ * @param {Element} node
+ *   Element.
+ * @returns {boolean}
+ *   Whether the opening tag can be omitted.
+ */
+function head(node) {
+  const children = node.children
+  /** @type {Array<string>} */
+  const seen = []
+  let index = -1
+
+  while (++index < children.length) {
+    const child = children[index]
+    if (
+      child.type === 'element' &&
+      (child.tagName === 'title' || child.tagName === 'base')
+    ) {
+      if (seen.includes(child.tagName)) return false
+      seen.push(child.tagName)
+    }
+  }
+
+  return children.length > 0
+}
+
+/**
+ * Whether to omit `<body>`.
+ *
+ * @param {Element} node
+ *   Element.
+ * @returns {boolean}
+ *   Whether the opening tag can be omitted.
+ */
+function body(node) {
+  const head = siblingAfter(node, -1, true)
+
+  return (
+    !head ||
+    (head.type !== 'comment' &&
+      !(head.type === 'text' && whitespace(head.value.charAt(0))) &&
+      !(
+        head.type === 'element' &&
+        (head.tagName === 'meta' ||
+          head.tagName === 'link' ||
+          head.tagName === 'script' ||
+          head.tagName === 'style' ||
+          head.tagName === 'template')
+      ))
+  )
+}
+
+/**
+ * Whether to omit `<colgroup>`.
+ * The spec describes some logic for the opening tag, but it’s easier to
+ * implement in the closing tag, to the same effect, so we handle it there
+ * instead.
+ *
+ * @param {Element} node
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the opening tag can be omitted.
+ */
+function colgroup(node, index, parent) {
+  const previous = siblingBefore(parent, index)
+  const head = siblingAfter(node, -1, true)
+
+  // Previous colgroup was already omitted.
+  if (
+    parent &&
+    previous &&
+    previous.type === 'element' &&
+    previous.tagName === 'colgroup' &&
+    closing(previous, parent.children.indexOf(previous), parent)
+  ) {
+    return false
+  }
+
+  return head && head.type === 'element' && head.tagName === 'col'
+}
+
+/**
+ * Whether to omit `<tbody>`.
+ *
+ * @param {Element} node
+ *   Element.
+ * @param {number | undefined} index
+ *   Index of element in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of element.
+ * @returns {boolean}
+ *   Whether the opening tag can be omitted.
+ */
+function tbody(node, index, parent) {
+  const previous = siblingBefore(parent, index)
+  const head = siblingAfter(node, -1)
+
+  // Previous table section was already omitted.
+  if (
+    parent &&
+    previous &&
+    previous.type === 'element' &&
+    (previous.tagName === 'thead' || previous.tagName === 'tbody') &&
+    closing(previous, parent.children.indexOf(previous), parent)
+  ) {
+    return false
+  }
+
+  return head && head.type === 'element' && head.tagName === 'tr'
+}

node_modules/hast-util-to-html/lib/omission/util/comment.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @typedef {import('../../types.js').Node} Node
+ * @typedef {import('../../types.js').Comment} Comment
+ */
+/**
+ * @param {Node} node
+ * @returns {node is Comment}
+ */
+export function comment(node: Node): node is import('hast').Comment
+export type Node = import('../../types.js').Node
+export type Comment = import('../../types.js').Comment

node_modules/hast-util-to-html/lib/omission/util/siblings.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Find applicable siblings in a direction.
+ *
+ * @param {Parent | null | undefined} parent
+ * @param {number | null | undefined} index
+ * @param {boolean | null | undefined} [includeWhitespace=false]
+ * @returns {Content}
+ */
+export function siblingAfter(
+  parent: Parent | null | undefined,
+  index: number | null | undefined,
+  includeWhitespace?: boolean | null | undefined
+): Content
+/**
+ * Find applicable siblings in a direction.
+ *
+ * @param {Parent | null | undefined} parent
+ * @param {number | null | undefined} index
+ * @param {boolean | null | undefined} [includeWhitespace=false]
+ * @returns {Content}
+ */
+export function siblingBefore(
+  parent: Parent | null | undefined,
+  index: number | null | undefined,
+  includeWhitespace?: boolean | null | undefined
+): Content
+export type Parent = import('../../types.js').Parent
+export type Content = import('../../types.js').Content

node_modules/hast-util-to-html/lib/omission/util/siblings.js

@@ -0,0 +1,41 @@
+/**
+ * @typedef {import('../../types.js').Parent} Parent
+ * @typedef {import('../../types.js').Content} Content
+ */
+
+import {whitespace} from 'hast-util-whitespace'
+
+export const siblingAfter = siblings(1)
+export const siblingBefore = siblings(-1)
+
+/**
+ * Factory to check siblings in a direction.
+ *
+ * @param {number} increment
+ */
+function siblings(increment) {
+  return sibling
+
+  /**
+   * Find applicable siblings in a direction.
+   *
+   * @param {Parent | null | undefined} parent
+   * @param {number | null | undefined} index
+   * @param {boolean | null | undefined} [includeWhitespace=false]
+   * @returns {Content}
+   */
+  function sibling(parent, index, includeWhitespace) {
+    const siblings = parent ? parent.children : []
+    let offset = (index || 0) + increment
+    let next = siblings && siblings[offset]
+
+    if (!includeWhitespace) {
+      while (next && whitespace(next)) {
+        offset += increment
+        next = siblings[offset]
+      }
+    }
+
+    return next
+  }
+}