@tickernelz/paperclip-pro-server 2026.927.0 → 2026.927.2

package/node_modules/mdast-util-to-markdown/lib/handle/root.js

@@ -6,11 +6,18 @@
 import {phrasing} from 'mdast-util-phrasing'
 
 /**
+ * Serialize a root node.
+ *
  * @param {Root} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 export function root(node, _, state, info) {
   // Note: `html` nodes are ambiguous.
@@ -18,6 +25,10 @@ export function root(node, _, state, info) {
     return phrasing(d)
   })
 
-  const container = hasPhrasing ? state.containerPhrasing : state.containerFlow
-  return container.call(state, node, info)
+  if (!hasPhrasing) return state.containerFlow(node, info)
+
+  const exit = state.enter('phrasing')
+  const value = state.containerPhrasing(node, info)
+  exit()
+  return value
 }

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

@@ -1,24 +1,52 @@
 /**
+ * Serialize a strong node.
+ *
+ * Attention is properly handled by `containerPhrasing`.
+ *
  * @param {Strong} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 export function strong(node: Strong, _: Parents | undefined, state: State, info: Info): string;
 export namespace strong {
-    export { strongPeek as peek };
+    export { attention };
+    export { peek };
 }
 import type { Strong } from 'mdast';
 import type { Parents } from 'mdast';
 import type { State } from 'mdast-util-to-markdown';
 import type { Info } from 'mdast-util-to-markdown';
 /**
+ * Serialize a strong node as attention.
+ *
  * @param {Strong} _
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {AttentionInfo}
+ *   Info on how to serialize the node.
+ */
+declare function attention(_: Strong, state: State): AttentionInfo;
+/**
+ * Peek at this node.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
  * @param {Parents | undefined} _1
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Start of the serialized markdown.
  */
-declare function strongPeek(_: Strong, _1: Parents | undefined, state: State): string;
+declare function peek(_: Strong, _1: Parents | undefined, state: State): string;
+import type { AttentionInfo } from 'mdast-util-to-markdown';
 export {};
 //# sourceMappingURL=strong.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"strong.d.ts","sourceRoot":"","sources":["strong.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,6BANW,MAAM,KACN,OAAO,GAAG,SAAS,SACnB,KAAK,QACL,IAAI,GACF,MAAM,CA0ClB;;;;4BAxDiC,OAAO;6BAAP,OAAO;2BADX,wBAAwB;0BAAxB,wBAAwB;AA2DtD;;;;;GAKG;AACH,+BALW,MAAM,MACN,OAAO,GAAG,SAAS,SACnB,KAAK,GACH,MAAM,CAIlB"}
+{"version":3,"file":"strong.d.ts","sourceRoot":"","sources":["strong.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH,6BAXW,MAAM,KAEN,OAAO,GAAG,SAAS,SAEnB,KAAK,QAEL,IAAI,GAEF,MAAM,CAQlB;;;;;4BA7BiC,OAAO;6BAAP,OAAO;2BADI,wBAAwB;0BAAxB,wBAAwB;AAgCrE;;;;;;;;;GASG;AACH,8BAPW,MAAM,SAEN,KAAK,GAEH,aAAa,CAUzB;AAED;;;;;;;;;;;GAWG;AACH,yBATW,MAAM,MAEN,OAAO,GAAG,SAAS,SAEnB,KAAK,GAEH,MAAM,CAKlB;mCAjE4C,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/handle/strong.js

@@ -1,69 +1,67 @@
 /**
- * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {AttentionInfo, Info, State} from 'mdast-util-to-markdown'
  * @import {Parents, Strong} from 'mdast'
  */
 
 import {checkStrong} from '../util/check-strong.js'
-import {encodeCharacterReference} from '../util/encode-character-reference.js'
-import {encodeInfo} from '../util/encode-info.js'
 
-strong.peek = strongPeek
+strong.attention = attention
+strong.peek = peek
 
 /**
+ * Serialize a strong node.
+ *
+ * Attention is properly handled by `containerPhrasing`.
+ *
  * @param {Strong} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 export function strong(node, _, state, info) {
-  const marker = checkStrong(state)
-  const exit = state.enter('strong')
-  const tracker = state.createTracker(info)
-  const before = tracker.move(marker + marker)
-
-  let between = tracker.move(
-    state.containerPhrasing(node, {
-      after: marker,
-      before,
-      ...tracker.current()
-    })
-  )
-  const betweenHead = between.charCodeAt(0)
-  const open = encodeInfo(
-    info.before.charCodeAt(info.before.length - 1),
-    betweenHead,
-    marker
-  )
-
-  if (open.inside) {
-    between = encodeCharacterReference(betweenHead) + between.slice(1)
-  }
-
-  const betweenTail = between.charCodeAt(between.length - 1)
-  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker)
-
-  if (close.inside) {
-    between = between.slice(0, -1) + encodeCharacterReference(betweenTail)
-  }
-
-  const after = tracker.move(marker + marker)
-
+  const exit = state.enter('phrasing')
+  const value = state.containerPhrasing({type: 'root', children: [node]}, info)
   exit()
+  return value
+}
 
-  state.attentionEncodeSurroundingInfo = {
-    after: close.outside,
-    before: open.outside
+/**
+ * Serialize a strong node as attention.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {AttentionInfo}
+ *   Info on how to serialize the node.
+ */
+function attention(_, state) {
+  const marker = checkStrong(state)
+  return {
+    construct: 'strong',
+    markers: marker === '*' ? ['*', '_'] : ['_', '*'],
+    sizes: [2]
   }
-  return before + between + after
 }
 
 /**
+ * Peek at this node.
+ *
  * @param {Strong} _
+ *   Node to serialize.
  * @param {Parents | undefined} _1
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Start of the serialized markdown.
  */
-function strongPeek(_, _1, state) {
+function peek(_, _1, state) {
   return state.options.strong || '*'
 }

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

@@ -3,11 +3,18 @@
  * @import {Parents, Text} from 'mdast'
  */
 /**
+ * Serialize a text node.
+ *
  * @param {Text} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 export function text(node: Text, _: Parents | undefined, state: State, info: Info): string;
 import type { Text } from 'mdast';

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

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["text.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,2BANW,IAAI,KACJ,OAAO,GAAG,SAAS,SACnB,KAAK,QACL,IAAI,GACF,MAAM,CAIlB;0BAZ+B,OAAO;6BAAP,OAAO;2BADT,wBAAwB;0BAAxB,wBAAwB"}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["text.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AACH,2BAXW,IAAI,KAEJ,OAAO,GAAG,SAAS,SAEnB,KAAK,QAEL,IAAI,GAEF,MAAM,CAKlB;0BAnB+B,OAAO;6BAAP,OAAO;2BADT,wBAAwB;0BAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/handle/text.js

@@ -4,11 +4,18 @@
  */
 
 /**
+ * Serialize a text node.
+ *
  * @param {Text} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 export function text(node, _, state, info) {
   return state.safe(node.value, info)

package/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.d.ts

@@ -1,8 +1,14 @@
 /**
+ * Serialize a thematic break node.
+ *
  * @param {ThematicBreak} _
+ *   Node to serialize.
  * @param {Parents | undefined} _1
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Serialized markdown.
  */
 export function thematicBreak(_: ThematicBreak, _1: Parents | undefined, state: State): string;
 import type { ThematicBreak } from 'mdast';

package/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thematic-break.d.ts","sourceRoot":"","sources":["thematic-break.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,iCALW,aAAa,MACb,OAAO,GAAG,SAAS,SACnB,KAAK,GACH,MAAM,CAQlB;mCAlBwC,OAAO;6BAAP,OAAO;2BADxB,wBAAwB"}
+{"version":3,"file":"thematic-break.d.ts","sourceRoot":"","sources":["thematic-break.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,iCATW,aAAa,MAEb,OAAO,GAAG,SAAS,SAEnB,KAAK,GAEH,MAAM,CASlB;mCAxBwC,OAAO;6BAAP,OAAO;2BADxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js

@@ -7,10 +7,16 @@ import {checkRuleRepetition} from '../util/check-rule-repetition.js'
 import {checkRule} from '../util/check-rule.js'
 
 /**
+ * Serialize a thematic break node.
+ *
  * @param {ThematicBreak} _
+ *   Node to serialize.
  * @param {Parents | undefined} _1
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Serialized markdown.
  */
 export function thematicBreak(_, _1, state) {
   const value = (

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAmBA;;;;;;;;;GASG;AACH,iCAPW,KAAK,YAEL,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,MAAM,CAoElB;2BA5FuB,OAAO;6BAD0B,wBAAwB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAoBA;;;;;;;;;GASG;AACH,iCAPW,KAAK,YAEL,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,MAAM,CA6ElB;2BAtGuB,OAAO;6BAD0B,wBAAwB"}

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

@@ -4,6 +4,7 @@
  * @import {Enter, FlowParents, PhrasingParents, TrackFields} from './types.js'
  */
 
+import {phrasing} from 'mdast-util-phrasing'
 import {zwitch} from 'zwitch'
 import {configure} from './configure.js'
 import {handle as handlers} from './handle/index.js'
@@ -32,6 +33,8 @@ export function toMarkdown(tree, options) {
   /** @type {State} */
   const state = {
     associationId: association,
+    bulletCurrent: undefined,
+    bulletLastUsed: undefined,
     containerPhrasing: containerPhrasingBound,
     containerFlow: containerFlowBound,
     createTracker: track,
@@ -63,12 +66,12 @@ export function toMarkdown(tree, options) {
     handlers: state.handlers
   })
 
-  let result = state.handle(tree, undefined, state, {
-    before: '\n',
-    after: '\n',
-    now: {line: 1, column: 1},
-    lineShift: 0
-  })
+  let result = state.handle(
+    phrasing(tree) ? {type: 'root', children: [tree]} : tree,
+    undefined,
+    state,
+    {before: '\n', after: '\n', now: {line: 1, column: 1}, lineShift: 0}
+  )
 
   if (
     result &&
@@ -80,13 +83,20 @@ export function toMarkdown(tree, options) {
 
   return result
 
-  /** @type {Enter} */
+  /**
+   * Enter a construct.
+   *
+   * @type {Enter}
+   */
   function enter(name) {
     state.stack.push(name)
     return exit
 
     /**
+     * Exit a construct.
+     *
      * @returns {undefined}
+     *   Nothing.
      */
     function exit() {
       state.stack.pop()
@@ -95,16 +105,28 @@ export function toMarkdown(tree, options) {
 }
 
 /**
+ * Handle an invalid value that cannot be processed.
+ *
  * @param {unknown} value
+ *   Value.
  * @returns {never}
+ *   Never.
+ * @throws {Error}
+ *   Always.
  */
 function invalid(value) {
   throw new Error('Cannot handle value `' + value + '`, expected node')
 }
 
 /**
+ * Handle an unknown node.
+ *
  * @param {unknown} value
+ *   Value.
  * @returns {never}
+ *   Never.
+ * @throws {Error}
+ *   Always.
  */
 function unknown(value) {
   // Always a node.
@@ -112,7 +134,11 @@ function unknown(value) {
   throw new Error('Cannot handle unknown node `' + node.type + '`')
 }
 
-/** @type {Join} */
+/**
+ * Join function for `tightDefinitions` option.
+ *
+ * @type {Join}
+ */
 function joinDefinition(left, right) {
   // No blank line between adjacent definitions.
   if (left.type === 'definition' && left.type === right.type) {

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

@@ -1 +1 @@
-{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["join.js"],"names":[],"mappings":"AAOA,0BAA0B;AAC1B,mBADW,KAAK,CAAC,IAAI,CAAC,CACY;0BAPX,wBAAwB"}
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["join.js"],"names":[],"mappings":"AAQA,0BAA0B;AAC1B,mBADW,KAAK,CAAC,IAAI,CAAC,CACY;0BARX,wBAAwB"}

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

@@ -4,11 +4,16 @@
 
 import {formatCodeAsIndented} from './util/format-code-as-indented.js'
 import {formatHeadingAsSetext} from './util/format-heading-as-setext.js'
+import {htmlKind} from './util/html-kind.js'
 
 /** @type {Array<Join>} */
 export const join = [joinDefaults]
 
-/** @type {Join} */
+/**
+ * Default join function.
+ *
+ * @type {Join}
+ */
 function joinDefaults(left, right, parent, state) {
   // Indented code after list or another indented code.
   if (
@@ -34,6 +39,18 @@ function joinDefaults(left, right, parent, state) {
       return
     }
 
+    // HTML that only ends at a blank line followed by something.
+    if (left.type === 'html') {
+      const kind = htmlKind(left.value)
+      if (kind === undefined || kind === 6 || kind === 7) return 1
+    }
+
+    // HTML that cannot interrupt a paragraph (kind 7) after one.
+    if (left.type === 'paragraph' && right.type === 'html') {
+      const kind = htmlKind(right.value)
+      if (kind === undefined || kind === 7) return 1
+    }
+
     return parent.spread ? 1 : 0
   }
 }

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

@@ -392,22 +392,6 @@ export type ContainerPhrasing = (parent: PhrasingParents, info: Info) => string
  */
 export type CreateTracker = (info: TrackFields) => Tracker
 
-/**
- * Whether to encode things — with fields representing the surrounding of a
- * whole.
- */
-export interface EncodeSurrounding {
-  /**
-   * Whether to encode after.
-   */
-  after: boolean
-
-  /**
-   * Whether to encode before.
-   */
-  before: boolean
-}
-
 /**
  * Whether to encode things — with fields representing the relationship to a
  * whole.
@@ -482,12 +466,54 @@ export type Handlers = Record<Nodes['type'], Handle>
  *   Serialized markdown representing `node`.
  */
 export type Handle = (
+  // type-coverage:ignore-next-line
   node: any,
   parent: Parents | undefined,
   state: State,
   Info: Info
 ) => string
 
+/**
+ * Serialize a node as attention (emphasis, strong, strikethrough).
+ *
+ * Set as the `attention` field of a handler (`handle.attention = x`).
+ * This switches to a different algorithm,
+ * where attention is properly handled by `containerPhrasing`.
+ *
+ * @param node
+ *   Expected mdast node.
+ * @param state
+ *   Info passed around about the current state.
+ * @returns
+ *   Info on how to serialize `node`.
+ */
+export type Attention = (
+  // type-coverage:ignore-next-line
+  node: any,
+  state: State
+) => AttentionInfo
+
+/**
+ * Info on how to serialize attention.
+ */
+export interface AttentionInfo {
+  /**
+   * Construct to enter (such as `'emphasis'`).
+   */
+  construct: ConstructName
+  /**
+   * Markers that can be used in order of preference (such as `['*', '_']`);
+   * one or more strings, each just one ASCII punctuation character.
+   */
+  markers: Array<string>
+  /**
+   * Sizes of sequences that can be used in order of preference (such as `[2]`
+   * for strong or `[2, 1]` for GFM strikethrough);
+   * one or more numbers, each a positive integer.
+   */
+  sizes: Array<number>
+}
+
 /**
  * Pad serialized markdown.
  *
@@ -610,7 +636,10 @@ export interface Options {
    */
   closeAtx?: boolean | null | undefined
   /**
-   * Marker to use for emphasis (default: `'*'`).
+   * Preferred marker to use for emphasis (default: `'*'`).
+   *
+   * The other marker is sometimes used, to form for example emphasis next to
+   * or inside of other emphasis (`*a*_b_`).
    */
   emphasis?: '*' | '_' | null | undefined
   /**
@@ -687,7 +716,10 @@ export interface Options {
    */
   setext?: boolean | null | undefined
   /**
-   * Marker to use for strong (default: `'*'`).
+   * Preferred marker to use for strong (default: `'*'`).
+   *
+   * The other marker is sometimes used, to form for example strong next to or
+   * inside of other strong (`**a**__b__`).
    */
   strong?: '*' | '_' | null | undefined
   /**
@@ -786,18 +818,6 @@ export interface State {
    * Get an identifier from an association to match it to others.
    */
   associationId: AssociationId
-  /**
-   * Info on whether to encode the surrounding of *attention*.
-   *
-   * Whether attention (emphasis, strong, strikethrough) forms
-   * depends on the characters inside and outside them.
-   * The characters inside can be handled by *attention* itself.
-   * However the outside characters are already handled.
-   * Or handled afterwards.
-   * This field can be used to signal from *attention* that some parent
-   * function (practically `containerPhrasing`) has to handle the surrounding.
-   */
-  attentionEncodeSurroundingInfo: EncodeSurrounding | undefined
   /**
    * List marker currently in use.
    */

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

@@ -1 +1 @@
-{"version":3,"file":"unsafe.d.ts","sourceRoot":"","sources":["unsafe.js"],"names":[],"mappings":"AAqBA,4BAA4B;AAC5B,qBADW,KAAK,CAAC,MAAM,CAAC,CA4HvB;4BAhJuC,wBAAwB"}
+{"version":3,"file":"unsafe.d.ts","sourceRoot":"","sources":["unsafe.js"],"names":[],"mappings":"AAqBA,4BAA4B;AAC5B,qBADW,KAAK,CAAC,MAAM,CAAC,CAmIvB;4BAvJuC,wBAAwB"}

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

@@ -49,6 +49,10 @@ export const unsafe = [
       'headingAtx'
     ]
   },
+  {character: '\r', before: '[\\r\\n]', inConstruct: 'phrasing'},
+  {character: '\r', after: '\\r', inConstruct: 'phrasing'},
+  {character: '\n', before: '\\n', inConstruct: 'phrasing'},
+  {character: '\n', after: '[\\r\\n]', inConstruct: 'phrasing'},
   {character: ' ', after: '[\\r\\n]', inConstruct: 'phrasing'},
   {character: ' ', before: '[\\r\\n]', inConstruct: 'phrasing'},
   {
@@ -142,5 +146,15 @@ export const unsafe = [
   // Left brace, vertical bar, right brace are not used in markdown for
   // constructs.
   // A tilde can start code (fenced).
-  {atBreak: true, character: '~'}
+  {atBreak: true, character: '~'},
+  {character: '<', inConstruct: 'autolink'},
+  {character: '>', inConstruct: 'autolink'},
+  {character: '\u007F', inConstruct: 'autolink'}
 ]
+
+// Also the low ASCII control characters including space.
+let code = -1
+
+while (++code < 33) {
+  unsafe.push({character: String.fromCharCode(code), inConstruct: 'autolink'})
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Get the first character of a value.
+ *
+ * Is aware of astral characters (such as emoji).
+ *
+ * @param {string} value
+ *   Value.
+ * @returns {string}
+ *   First character; empty if `value` is empty.
+ */
+export function firstCharacter(value: string): string;
+/**
+ * Get the last character of a value.
+ *
+ * Is aware of astral characters (such as emoji).
+ *
+ * @param {string} value
+ *   Value.
+ * @returns {string}
+ *   Last character; empty if `value` is empty.
+ */
+export function lastCharacter(value: string): string;
+//# sourceMappingURL=character.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"character.d.ts","sourceRoot":"","sources":["character.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,sCALW,MAAM,GAEJ,MAAM,CAMlB;AAED;;;;;;;;;GASG;AACH,qCALW,MAAM,GAEJ,MAAM,CASlB"}

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

@@ -0,0 +1,32 @@
+/**
+ * Get the first character of a value.
+ *
+ * Is aware of astral characters (such as emoji).
+ *
+ * @param {string} value
+ *   Value.
+ * @returns {string}
+ *   First character; empty if `value` is empty.
+ */
+export function firstCharacter(value) {
+  const code = value.codePointAt(0)
+  return code === undefined ? '' : String.fromCodePoint(code)
+}
+
+/**
+ * Get the last character of a value.
+ *
+ * Is aware of astral characters (such as emoji).
+ *
+ * @param {string} value
+ *   Value.
+ * @returns {string}
+ *   Last character; empty if `value` is empty.
+ */
+export function lastCharacter(value) {
+  // Only a surrogate pair gives a code point above the BMP.
+  const code = value.codePointAt(value.length - 2)
+  return code !== undefined && code > 0xff_ff
+    ? value.slice(-2)
+    : value.slice(-1)
+}

package/node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.d.ts

@@ -2,8 +2,12 @@
  * @import {Options, State} from 'mdast-util-to-markdown'
  */
 /**
+ * Checks the preferred ordered list bullet option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['bulletOrdered'], null | undefined>}
+ *   Preferred ordered list bullet.
  */
 export function checkBulletOrdered(state: State): Exclude<Options["bulletOrdered"], null | undefined>;
 import type { State } from 'mdast-util-to-markdown';

package/node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-bullet-ordered.d.ts","sourceRoot":"","sources":["check-bullet-ordered.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,0CAHW,KAAK,GACH,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,CAc/D;2BAnBgC,wBAAwB;6BAAxB,wBAAwB"}
+{"version":3,"file":"check-bullet-ordered.d.ts","sourceRoot":"","sources":["check-bullet-ordered.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;GAOG;AACH,0CALW,KAAK,GAEH,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,CAe/D;2BAvBgC,wBAAwB;6BAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js

@@ -3,8 +3,12 @@
  */
 
 /**
+ * Checks the preferred ordered list bullet option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['bulletOrdered'], null | undefined>}
+ *   Preferred ordered list bullet.
  */
 export function checkBulletOrdered(state) {
   const marker = state.options.bulletOrdered || '.'