@tickernelz/paperclip-pro-server 2026.927.0 → 2026.927.2

package/node_modules/mdast-util-to-markdown/lib/util/encode-info.d.ts

@@ -21,13 +21,13 @@
  *   Code point on the outer side of the run.
  * @param {number} inside
  *   Code point on the inner side of the run.
- * @param {'*' | '_'} marker
+ * @param {string} marker
  *   Marker of the run.
  *   Underscores are handled more strictly (they form less often) than
  *   asterisks.
  * @returns {EncodeSides}
  *   Whether to encode characters.
  */
-export function encodeInfo(outside: number, inside: number, marker: "*" | "_"): EncodeSides;
+export function encodeInfo(outside: number, inside: number, marker: string): EncodeSides;
 import type { EncodeSides } from '../types.js';
 //# sourceMappingURL=encode-info.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/util/encode-info.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode-info.d.ts","sourceRoot":"","sources":["encode-info.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAKH,oCAfW,MAAM,UAEN,MAAM,UAEN,GAAG,GAAG,GAAG,GAIP,WAAW,CAgDvB;iCAhF6B,aAAa"}
+{"version":3,"file":"encode-info.d.ts","sourceRoot":"","sources":["encode-info.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAKH,oCAfW,MAAM,UAEN,MAAM,UAEN,MAAM,GAIJ,WAAW,CAgDvB;iCAhF6B,aAAa"}

package/node_modules/mdast-util-to-markdown/lib/util/encode-info.js

@@ -27,7 +27,7 @@ import {classifyCharacter} from 'micromark-util-classify-character'
  *   Code point on the outer side of the run.
  * @param {number} inside
  *   Code point on the inner side of the run.
- * @param {'*' | '_'} marker
+ * @param {string} marker
  *   Marker of the run.
  *   Underscores are handled more strictly (they form less often) than
  *   asterisks.

package/node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.d.ts

@@ -3,9 +3,14 @@
  * @import {Code} from 'mdast'
  */
 /**
+ * Checks if a code block can be formatted as an indented code block.
+ *
  * @param {Code} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the code can be formatted as an indented code block.
  */
 export function formatCodeAsIndented(node: Code, state: State): boolean;
 import type { Code } from 'mdast';

package/node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format-code-as-indented.d.ts","sourceRoot":"","sources":["format-code-as-indented.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,2CAJW,IAAI,SACJ,KAAK,GACH,OAAO,CAanB;0BAnBsB,OAAO;2BADN,wBAAwB"}
+{"version":3,"file":"format-code-as-indented.d.ts","sourceRoot":"","sources":["format-code-as-indented.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AACH,2CAPW,IAAI,SAEJ,KAAK,GAEH,OAAO,CAcnB;0BAxBsB,OAAO;2BADN,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js

@@ -4,19 +4,24 @@
  */
 
 /**
+ * Checks if a code block can be formatted as an indented code block.
+ *
  * @param {Code} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the code can be formatted as an indented code block.
  */
 export function formatCodeAsIndented(node, state) {
   return Boolean(
     state.options.fences === false &&
-      node.value &&
-      // If there’s no info…
-      !node.lang &&
-      // And there’s a non-whitespace character…
-      /[^ \r\n]/.test(node.value) &&
-      // And the value doesn’t start or end in a blank…
-      !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node.value)
+    node.value &&
+    // If there’s no info…
+    !node.lang &&
+    // And there’s a non-whitespace character…
+    /[^\n\r ]/.test(node.value) &&
+    // And the value doesn’t start or end in a blank…
+    !/^[\t ]*(?:[\n\r]|$)|(?:^|[\n\r])[\t ]*$/.test(node.value)
   )
 }

package/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.d.ts

@@ -1,7 +1,12 @@
 /**
+ * Checks if a heading can be formatted as a setext heading.
+ *
  * @param {Heading} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the heading can be formatted as a setext heading.
  */
 export function formatHeadingAsSetext(node: Heading, state: State): boolean;
 import type { Heading } from 'mdast';

package/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format-heading-as-setext.d.ts","sourceRoot":"","sources":["format-heading-as-setext.js"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,4CAJW,OAAO,SACP,KAAK,GACH,OAAO,CAsBnB;6BA/ByB,OAAO;2BADT,wBAAwB"}
+{"version":3,"file":"format-heading-as-setext.d.ts","sourceRoot":"","sources":["format-heading-as-setext.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,4CAPW,OAAO,SAEP,KAAK,GAEH,OAAO,CAuBnB;6BApCyB,OAAO;2BADT,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js

@@ -7,9 +7,14 @@ import {EXIT, visit} from 'unist-util-visit'
 import {toString} from 'mdast-util-to-string'
 
 /**
+ * Checks if a heading can be formatted as a setext heading.
+ *
  * @param {Heading} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the heading can be formatted as a setext heading.
  */
 export function formatHeadingAsSetext(node, state) {
   let literalWithBreak = false
@@ -28,7 +33,7 @@ export function formatHeadingAsSetext(node, state) {
 
   return Boolean(
     (!node.depth || node.depth < 3) &&
-      toString(node) &&
-      (state.options.setext || literalWithBreak)
+    toString(node) &&
+    (state.options.setext || literalWithBreak)
   )
 }

package/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.d.ts

@@ -1,7 +1,12 @@
 /**
+ * Checks if a link can be formatted as an autolink.
+ *
  * @param {Link} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the link can be formatted as an autolink.
  */
 export function formatLinkAsAutolink(node: Link, state: State): boolean;
 import type { Link } from 'mdast';

package/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format-link-as-autolink.d.ts","sourceRoot":"","sources":["format-link-as-autolink.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,2CAJW,IAAI,SACJ,KAAK,GACH,OAAO,CAuBnB;0BA/BsB,OAAO;2BADN,wBAAwB"}
+{"version":3,"file":"format-link-as-autolink.d.ts","sourceRoot":"","sources":["format-link-as-autolink.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,2CAPW,IAAI,SAEJ,KAAK,GAEH,OAAO,CAwBnB;0BApCsB,OAAO;2BADN,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js

@@ -6,29 +6,34 @@
 import {toString} from 'mdast-util-to-string'
 
 /**
+ * Checks if a link can be formatted as an autolink.
+ *
  * @param {Link} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the link can be formatted as an autolink.
  */
 export function formatLinkAsAutolink(node, state) {
   const raw = toString(node)
 
   return Boolean(
     !state.options.resourceLink &&
-      // If there’s a url…
-      node.url &&
-      // And there’s a no title…
-      !node.title &&
-      // And the content of `node` is a single text node…
-      node.children &&
-      node.children.length === 1 &&
-      node.children[0].type === 'text' &&
-      // And if the url is the same as the content…
-      (raw === node.url || 'mailto:' + raw === node.url) &&
-      // And that starts w/ a protocol…
-      /^[a-z][a-z+.-]+:/i.test(node.url) &&
-      // And that doesn’t contain ASCII control codes (character escapes and
-      // references don’t work), space, or angle brackets…
-      !/[\0- <>\u007F]/.test(node.url)
+    // If there’s a url…
+    node.url &&
+    // And there’s no title…
+    !node.title &&
+    // And the content of `node` is a single text node…
+    node.children &&
+    node.children.length === 1 &&
+    node.children[0].type === 'text' &&
+    // And if the url is the same as the content…
+    (raw === node.url || 'mailto:' + raw === node.url) &&
+    // And that starts w/ a protocol…
+    /^[a-z][+\-.a-z]+:/i.test(node.url) &&
+    // And that doesn’t contain ASCII control codes (character escapes and
+    // references don’t work), space, or angle brackets…
+    !/[\0- <>\u007F]/.test(node.url)
   )
 }

package/node_modules/mdast-util-to-markdown/lib/util/html-kind.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @typedef {1 | 2 | 3 | 4 | 5 | 6 | 7} Kind
+ *   Kind of HTML (flow) element.
+ */
+/**
+ * Infer the kind of HTML that `value` is.
+ *
+ * This works on valid trees as produced by `micromark`.
+ * Kinds:
+ *
+ * 1. raw
+ * 2. comment
+ * 3. instruction
+ * 4. declaration
+ * 5. cdata
+ * 6. block
+ * 7. other
+ *
+ * See: <https://spec.commonmark.org/0.31.2/#html-blocks>.
+ *
+ * @param {string} value
+ *   HTML.
+ * @returns {Kind | undefined}
+ *   Kind; `undefined` if unknown.
+ */
+export function htmlKind(value: string): Kind | undefined;
+/**
+ * Kind of HTML (flow) element.
+ */
+export type Kind = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+//# sourceMappingURL=html-kind.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/util/html-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-kind.d.ts","sourceRoot":"","sources":["html-kind.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,gCALW,MAAM,GAEJ,IAAI,GAAG,SAAS,CAoC5B;;;;mBA1DY,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC"}

package/node_modules/mdast-util-to-markdown/lib/util/html-kind.js

@@ -0,0 +1,63 @@
+import {asciiAlpha, asciiAlphanumeric} from 'micromark-util-character'
+import {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'
+
+/**
+ * @typedef {1 | 2 | 3 | 4 | 5 | 6 | 7} Kind
+ *   Kind of HTML (flow) element.
+ */
+
+/**
+ * Infer the kind of HTML that `value` is.
+ *
+ * This works on valid trees as produced by `micromark`.
+ * Kinds:
+ *
+ * 1. raw
+ * 2. comment
+ * 3. instruction
+ * 4. declaration
+ * 5. cdata
+ * 6. block
+ * 7. other
+ *
+ * See: <https://spec.commonmark.org/0.31.2/#html-blocks>.
+ *
+ * @param {string} value
+ *   HTML.
+ * @returns {Kind | undefined}
+ *   Kind; `undefined` if unknown.
+ */
+export function htmlKind(value) {
+  if (value.charCodeAt(0) !== 60 /* `<` */) return
+
+  const next = value.charCodeAt(1)
+
+  if (next === 33 /* `!` */) {
+    const code = value.charCodeAt(2)
+    if (code === 45 /* `-` */) return 2
+    if (code === 91 /* `[` */) return 5
+    if (asciiAlpha(code)) return 4
+    return
+  }
+
+  if (next === 63 /* `?` */) return 3
+
+  const closing = next === 47 /* `/` */
+  const start = closing ? 2 : 1
+  let end = start
+  let code = value.charCodeAt(end)
+
+  if (!asciiAlpha(code)) return
+
+  while (code === 45 /* `-` */ || asciiAlphanumeric(code)) {
+    code = value.charCodeAt(++end)
+  }
+
+  const name = value.slice(start, end).toLowerCase()
+
+  if (!closing && code !== 47 /* `/` */ && htmlRawNames.includes(name)) {
+    return 1
+  }
+
+  return htmlBlockNames.includes(name) ? 6 : 7
+}

package/node_modules/mdast-util-to-markdown/lib/util/indent-lines.js

@@ -5,6 +5,8 @@
 const eol = /\r?\n|\r/g
 
 /**
+ * Indents each line.
+ *
  * @type {IndentLines}
  */
 export function indentLines(value, map) {
@@ -27,7 +29,10 @@ export function indentLines(value, map) {
   return result.join('')
 
   /**
+   * Indents a single line.
+   *
    * @param {string} value
+   *   Line.
    */
   function one(value) {
     result.push(map(value, line, !value))

package/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.d.ts

@@ -2,9 +2,14 @@
  * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
  */
 /**
+ * Check if a pattern is in scope based on the current stack of constructs.
+ *
  * @param {Array<ConstructName>} stack
+ *   Current stack of constructs.
  * @param {Unsafe} pattern
+ *   Pattern to check.
  * @returns {boolean}
+ *   Whether the pattern is in scope.
  */
 export function patternInScope(stack: Array<ConstructName>, pattern: Unsafe): boolean;
 import type { ConstructName } from 'mdast-util-to-markdown';

package/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pattern-in-scope.d.ts","sourceRoot":"","sources":["pattern-in-scope.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,sCAJW,KAAK,CAAC,aAAa,CAAC,WACpB,MAAM,GACJ,OAAO,CAOnB;mCAbuC,wBAAwB;4BAAxB,wBAAwB"}
+{"version":3,"file":"pattern-in-scope.d.ts","sourceRoot":"","sources":["pattern-in-scope.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,sCAPW,KAAK,CAAC,aAAa,CAAC,WAEpB,MAAM,GAEJ,OAAO,CAQnB;mCAlBuC,wBAAwB;4BAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js

@@ -3,9 +3,14 @@
  */
 
 /**
+ * Check if a pattern is in scope based on the current stack of constructs.
+ *
  * @param {Array<ConstructName>} stack
+ *   Current stack of constructs.
  * @param {Unsafe} pattern
+ *   Pattern to check.
  * @returns {boolean}
+ *   Whether the pattern is in scope.
  */
 export function patternInScope(stack, pattern) {
   return (
@@ -15,10 +20,16 @@ export function patternInScope(stack, pattern) {
 }
 
 /**
+ * Check if any of the constructs in the list are present in the stack.
+ *
  * @param {Array<ConstructName>} stack
+ *   Current stack of constructs.
  * @param {Unsafe['inConstruct']} list
+ *   List of constructs to check for in the stack.
  * @param {boolean} none
+ *   Value to return if the list is empty or not provided.
  * @returns {boolean}
+ *   Whether any of the constructs in the list are present in the stack.
  */
 function listInScope(stack, list, none) {
   if (typeof list === 'string') {

package/node_modules/mdast-util-to-markdown/lib/util/safe.d.ts

@@ -8,8 +8,8 @@
  *
  * To solve this, `mdast-util-to-markdown` tracks:
  *
- * * Characters before and after something;
- * * What “constructs” we are in.
+ * * characters before and after something;
+ * * what “constructs” we are in.
  *
  * This information is then used by this function to escape or encode
  * special characters.

package/node_modules/mdast-util-to-markdown/lib/util/safe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safe.d.ts","sourceRoot":"","sources":["safe.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,4BATW,KAAK,SAEL,MAAM,GAAG,IAAI,GAAG,SAAS,UAEzB,UAAU,GAER,MAAM,CAoGlB;2BAhImC,wBAAwB;gCAAxB,wBAAwB"}
+{"version":3,"file":"safe.d.ts","sourceRoot":"","sources":["safe.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,4BATW,KAAK,SAEL,MAAM,GAAG,IAAI,GAAG,SAAS,UAEzB,UAAU,GAER,MAAM,CAuJlB;2BAtLmC,wBAAwB;gCAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/util/safe.js

@@ -2,9 +2,12 @@
  * @import {SafeConfig, State} from 'mdast-util-to-markdown'
  */
 
+import {classifyCharacter} from 'micromark-util-classify-character'
 import {encodeCharacterReference} from './encode-character-reference.js'
 import {patternInScope} from './pattern-in-scope.js'
 
+const own = {}.hasOwnProperty
+
 /**
  * Make a string safe for embedding in markdown constructs.
  *
@@ -15,8 +18,8 @@ import {patternInScope} from './pattern-in-scope.js'
  *
  * To solve this, `mdast-util-to-markdown` tracks:
  *
- * * Characters before and after something;
- * * What “constructs” we are in.
+ * * characters before and after something;
+ * * what “constructs” we are in.
  *
  * This information is then used by this function to escape or encode
  * special characters.
@@ -38,6 +41,9 @@ export function safe(state, input, config) {
   const result = []
   /** @type {Record<number, {before: boolean, after: boolean}>} */
   const infos = {}
+  // Character escapes and references do not work in autolinks, so
+  // percent-encoding is used instead.
+  const percentEncode = state.stack.includes('autolink')
   let index = -1
 
   while (++index < state.unsafe.length) {
@@ -56,7 +62,7 @@ export function safe(state, input, config) {
       const after = 'after' in pattern
       const position = match.index + (before ? match[1].length : 0)
 
-      if (positions.includes(position)) {
+      if (own.call(infos, position)) {
         if (infos[position].before && !before) {
           infos[position].before = false
         }
@@ -73,8 +79,9 @@ export function safe(state, input, config) {
 
   positions.sort(numerical)
 
-  let start = config.before ? config.before.length : 0
+  const offset = config.before ? config.before.length : 0
   const end = value.length - (config.after ? config.after.length : 0)
+  let start = offset
   index = -1
 
   while (++index < positions.length) {
@@ -85,6 +92,44 @@ export function safe(state, input, config) {
       continue
     }
 
+    // Special handling for “intraword” underscores (`a_b`, `a__b`).
+    // Those are different from asterisks in forming attention.
+    // Note that `a _ b` also cannot form but not escaping it is very complex,
+    // so that’s not handled.
+    if (
+      value.charAt(position) === '_' &&
+      // Preceded by an unescaped character that is not punctuation or whitespace:
+      position > 0 &&
+      classifyCharacter(value.charCodeAt(position - 1)) === undefined &&
+      !own.call(infos, position - 1) &&
+      // Characters next to attention markers can become character references
+      // later, turning `a` into `&#x61;`, so those do not count.
+      !(position - 1 === offset && /[*_]/.test(value.charAt(offset - 1)))
+    ) {
+      let sequenceEnd = position + 1
+
+      // Look for the whole run.
+      while (sequenceEnd < end && value.charAt(sequenceEnd) === '_') {
+        sequenceEnd++
+      }
+
+      const skip = sequenceEnd - position - 1
+
+      if (
+        // All underscores in the run are unsafe positions, so they can be
+        // skipped.
+        positions[index + skip] === sequenceEnd - 1 &&
+        // Rest as above.
+        sequenceEnd < value.length &&
+        classifyCharacter(value.charCodeAt(sequenceEnd)) === undefined &&
+        !own.call(infos, sequenceEnd) &&
+        !(sequenceEnd === end - 1 && /[*_]/.test(value.charAt(end)))
+      ) {
+        index += skip
+        continue
+      }
+    }
+
     // If this character is supposed to be escaped because it has a condition on
     // the next character, and the next character is definitly being escaped,
     // then skip this escape.
@@ -103,15 +148,23 @@ export function safe(state, input, config) {
     }
 
     if (start !== position) {
+      const slice = value.slice(start, position)
       // If we have to use a character reference, an ampersand would be more
       // correct, but as backslashes only care about punctuation, either will
       // do the trick
-      result.push(escapeBackslashes(value.slice(start, position), '\\'))
+      result.push(percentEncode ? slice : escapeBackslashes(slice, '\\'))
     }
 
     start = position
 
-    if (
+    // Percent-encoding such as `%20`.
+    if (percentEncode) {
+      result.push(
+        '%' +
+          value.charCodeAt(position).toString(16).toUpperCase().padStart(2, '0')
+      )
+      start++
+    } else if (
       /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&
       (!config.encode || !config.encode.includes(value.charAt(position)))
     ) {
@@ -124,24 +177,35 @@ export function safe(state, input, config) {
     }
   }
 
-  result.push(escapeBackslashes(value.slice(start, end), config.after))
+  const rest = value.slice(start, end)
+  result.push(percentEncode ? rest : escapeBackslashes(rest, config.after))
 
   return result.join('')
 }
 
 /**
+ * Compare two numbers.
+ *
  * @param {number} a
+ *   Number.
  * @param {number} b
+ *   Other number.
  * @returns {number}
+ *   Result.
  */
 function numerical(a, b) {
   return a - b
 }
 
 /**
+ * Escape backslashes in a string, considering characters that follow.
+ *
  * @param {string} value
+ *   Value.
  * @param {string} after
+ *   Characters that follow the value.
  * @returns {string}
+ *   Escaped string.
  */
 function escapeBackslashes(value, after) {
   const expression = /\\(?=[!-/:-@[-`{-~])/g

package/node_modules/mdast-util-to-markdown/package.json

@@ -10,29 +10,31 @@
     "longest-streak": "^3.0.0",
     "mdast-util-phrasing": "^4.0.0",
     "mdast-util-to-string": "^4.0.0",
+    "micromark-util-character": "^2.0.0",
     "micromark-util-classify-character": "^2.0.0",
     "micromark-util-decode-string": "^2.0.0",
+    "micromark-util-html-tag-name": "^2.0.0",
     "unist-util-visit": "^5.0.0",
     "zwitch": "^2.0.0"
   },
   "description": "mdast utility to serialize markdown",
   "devDependencies": {
-    "@types/node": "^22.0.0",
-    "c8": "^10.0.0",
+    "@types/node": "^26.0.0",
+    "c8": "^12.0.0",
     "mdast-util-from-markdown": "^2.0.0",
     "prettier": "^3.0.0",
     "remark-cli": "^12.0.0",
-    "remark-preset-wooorm": "^10.0.0",
+    "remark-preset-wooorm": "^11.0.0",
     "type-coverage": "^2.0.0",
-    "typescript": "^5.0.0",
+    "typescript": "^6.0.0",
     "unist-util-remove-position": "^5.0.0",
-    "xo": "^0.59.0"
+    "xo": "^5.0.0"
   },
   "exports": "./index.js",
   "files": [
-    "lib/",
     "index.d.ts",
-    "index.js"
+    "index.js",
+    "lib/"
   ],
   "funding": {
     "type": "opencollective",
@@ -69,64 +71,18 @@
     ]
   },
   "repository": "syntax-tree/mdast-util-to-markdown",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "scripts": {
-    "prepack": "npm run build && npm run format",
     "build": "tsc --build --clean && tsc --build && type-coverage",
-    "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix",
+    "format": "remark --frail --output --quiet -- . && prettier --log-level warn --write -- . && xo --fix",
     "test-api": "node --conditions development test/index.js",
-    "test-coverage": "c8 --100 --reporter lcov npm run test-api",
+    "test-coverage": "c8 --100 --reporter lcov -- npm run test-api",
     "test": "npm run build && npm run format && npm run test-coverage"
   },
   "sideEffects": false,
   "typeCoverage": {
     "atLeast": 100,
-    "ignoreFiles": [
-      "lib/types.d.ts"
-    ],
     "strict": true
   },
-  "type": "module",
-  "xo": {
-    "overrides": [
-      {
-        "files": [
-          "**/*.d.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/array-type": [
-            "error",
-            {
-              "default": "generic"
-            }
-          ],
-          "@typescript-eslint/ban-types": [
-            "error",
-            {
-              "extendDefaults": true
-            }
-          ],
-          "@typescript-eslint/consistent-type-definitions": [
-            "error",
-            "interface"
-          ]
-        }
-      },
-      {
-        "files": [
-          "test/**/*.js"
-        ],
-        "rules": {
-          "max-depth": "off",
-          "no-await-in-loop": "off"
-        }
-      }
-    ],
-    "prettier": true,
-    "rules": {
-      "complexity": "off",
-      "unicorn/prefer-at": "off",
-      "unicorn/prefer-code-point": "off"
-    }
-  }
+  "type": "module"
 }