@openclaw/feishu 2026.7.1-beta.6 → 2026.7.2-beta.1

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

@@ -0,0 +1,19 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {FlowChildren, FlowParents, TrackFields} from '../types.js'
+ */
+/**
+ * @param {FlowParents} parent
+ *   Parent of flow nodes.
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {TrackFields} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined by (blank) lines.
+ */
+export function containerFlow(parent: FlowParents, state: State, info: TrackFields): string;
+import type { FlowParents } from '../types.js';
+import type { State } from 'mdast-util-to-markdown';
+import type { TrackFields } from '../types.js';
+//# sourceMappingURL=container-flow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"container-flow.d.ts","sourceRoot":"","sources":["container-flow.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AACH,sCATW,WAAW,SAEX,KAAK,QAEL,WAAW,GAET,MAAM,CA0ClB;iCApDwD,aAAa;2BAD9C,wBAAwB;iCACS,aAAa"}

package/node_modules/mdast-util-to-markdown/lib/util/container-flow.js

@@ -0,0 +1,84 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {FlowChildren, FlowParents, TrackFields} from '../types.js'
+ */
+
+/**
+ * @param {FlowParents} parent
+ *   Parent of flow nodes.
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {TrackFields} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined by (blank) lines.
+ */
+export function containerFlow(parent, state, info) {
+  const indexStack = state.indexStack
+  const children = parent.children || []
+  const tracker = state.createTracker(info)
+  /** @type {Array<string>} */
+  const results = []
+  let index = -1
+
+  indexStack.push(-1)
+
+  while (++index < children.length) {
+    const child = children[index]
+
+    indexStack[indexStack.length - 1] = index
+
+    results.push(
+      tracker.move(
+        state.handle(child, parent, state, {
+          before: '\n',
+          after: '\n',
+          ...tracker.current()
+        })
+      )
+    )
+
+    if (child.type !== 'list') {
+      state.bulletLastUsed = undefined
+    }
+
+    if (index < children.length - 1) {
+      results.push(
+        tracker.move(between(child, children[index + 1], parent, state))
+      )
+    }
+  }
+
+  indexStack.pop()
+
+  return results.join('')
+}
+
+/**
+ * @param {FlowChildren} left
+ * @param {FlowChildren} right
+ * @param {FlowParents} parent
+ * @param {State} state
+ * @returns {string}
+ */
+function between(left, right, parent, state) {
+  let index = state.join.length
+
+  while (index--) {
+    const result = state.join[index](left, right, parent, state)
+
+    if (result === true || result === 1) {
+      break
+    }
+
+    if (typeof result === 'number') {
+      return '\n'.repeat(1 + result)
+    }
+
+    if (result === false) {
+      return '\n\n<!---->\n\n'
+    }
+  }
+
+  return '\n\n'
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Serialize the children of a parent that contains phrasing children.
+ *
+ * These children will be joined flush together.
+ *
+ * @param {PhrasingParents} parent
+ *   Parent of flow nodes.
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {Info} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined together.
+ */
+export function containerPhrasing(parent: PhrasingParents, state: State, info: Info): string;
+import type { PhrasingParents } from '../types.js';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+//# sourceMappingURL=container-phrasing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"container-phrasing.d.ts","sourceRoot":"","sources":["container-phrasing.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,0CATW,eAAe,SAEf,KAAK,QAEL,IAAI,GAEF,MAAM,CA0GlB;qCA1HiC,aAAa;2BADT,wBAAwB;0BAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js

@@ -0,0 +1,125 @@
+/**
+ * @import {Handle, Info, State} from 'mdast-util-to-markdown'
+ * @import {PhrasingParents} from '../types.js'
+ */
+
+import {encodeCharacterReference} from './encode-character-reference.js'
+
+/**
+ * Serialize the children of a parent that contains phrasing children.
+ *
+ * These children will be joined flush together.
+ *
+ * @param {PhrasingParents} parent
+ *   Parent of flow nodes.
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {Info} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined together.
+ */
+export function containerPhrasing(parent, state, info) {
+  const indexStack = state.indexStack
+  const children = parent.children || []
+  /** @type {Array<string>} */
+  const results = []
+  let index = -1
+  let before = info.before
+  /** @type {string | undefined} */
+  let encodeAfter
+
+  indexStack.push(-1)
+  let tracker = state.createTracker(info)
+
+  while (++index < children.length) {
+    const child = children[index]
+    /** @type {string} */
+    let after
+
+    indexStack[indexStack.length - 1] = index
+
+    if (index + 1 < children.length) {
+      /** @type {Handle} */
+      // @ts-expect-error: hush, it’s actually a `zwitch`.
+      let handle = state.handle.handlers[children[index + 1].type]
+      /** @type {Handle} */
+      // @ts-expect-error: hush, it’s actually a `zwitch`.
+      if (handle && handle.peek) handle = handle.peek
+      after = handle
+        ? handle(children[index + 1], parent, state, {
+            before: '',
+            after: '',
+            ...tracker.current()
+          }).charAt(0)
+        : ''
+    } else {
+      after = info.after
+    }
+
+    // In some cases, html (text) can be found in phrasing right after an eol.
+    // When we’d serialize that, in most cases that would be seen as html
+    // (flow).
+    // As we can’t escape or so to prevent it from happening, we take a somewhat
+    // reasonable approach: replace that eol with a space.
+    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>
+    if (
+      results.length > 0 &&
+      (before === '\r' || before === '\n') &&
+      child.type === 'html'
+    ) {
+      results[results.length - 1] = results[results.length - 1].replace(
+        /(\r?\n|\r)$/,
+        ' '
+      )
+      before = ' '
+
+      // To do: does this work to reset tracker?
+      tracker = state.createTracker(info)
+      tracker.move(results.join(''))
+    }
+
+    let value = state.handle(child, parent, state, {
+      ...tracker.current(),
+      after,
+      before
+    })
+
+    // If we had to encode the first character after the previous node and it’s
+    // still the same character,
+    // encode it.
+    if (encodeAfter && encodeAfter === value.slice(0, 1)) {
+      value =
+        encodeCharacterReference(encodeAfter.charCodeAt(0)) + value.slice(1)
+    }
+
+    const encodingInfo = state.attentionEncodeSurroundingInfo
+    state.attentionEncodeSurroundingInfo = undefined
+    encodeAfter = undefined
+
+    // If we have to encode the first character before the current node and
+    // it’s still the same character,
+    // encode it.
+    if (encodingInfo) {
+      if (
+        results.length > 0 &&
+        encodingInfo.before &&
+        before === results[results.length - 1].slice(-1)
+      ) {
+        results[results.length - 1] =
+          results[results.length - 1].slice(0, -1) +
+          encodeCharacterReference(before.charCodeAt(0))
+      }
+
+      if (encodingInfo.after) encodeAfter = after
+    }
+
+    tracker.move(value)
+    results.push(value)
+    before = value.slice(-1)
+  }
+
+  indexStack.pop()
+
+  return results.join('')
+}

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

@@ -0,0 +1,7 @@
+/**
+ * @this {State}
+ * @returns {'*' | '_'}
+ */
+export function emphasisStrongMarker(this: State): "*" | "_";
+import type { State } from '../types.js';
+//# sourceMappingURL=emphasis-strong-marker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emphasis-strong-marker.d.ts","sourceRoot":"","sources":["emphasis-strong-marker.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,mDAFa,GAAG,GAAG,GAAG,CAqBrB;2BA7BuB,aAAa"}

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

@@ -0,0 +1,10 @@
+/**
+ * Encode a code point as a character reference.
+ *
+ * @param {number} code
+ *   Code point to encode.
+ * @returns {string}
+ *   Encoded character reference.
+ */
+export function encodeCharacterReference(code: number): string;
+//# sourceMappingURL=encode-character-reference.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode-character-reference.d.ts","sourceRoot":"","sources":["encode-character-reference.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,+CALW,MAAM,GAEJ,MAAM,CAKlB"}

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

@@ -0,0 +1,11 @@
+/**
+ * Encode a code point as a character reference.
+ *
+ * @param {number} code
+ *   Code point to encode.
+ * @returns {string}
+ *   Encoded character reference.
+ */
+export function encodeCharacterReference(code) {
+  return '&#x' + code.toString(16).toUpperCase() + ';'
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Check whether to encode (as a character reference) the characters
+ * surrounding an attention run.
+ *
+ * Which characters are around an attention run influence whether it works or
+ * not.
+ *
+ * See <https://github.com/orgs/syntax-tree/discussions/60> for more info.
+ * See this markdown in a particular renderer to see what works:
+ *
+ * ```markdown
+ * |                         | A (letter inside) | B (punctuation inside) | C (whitespace inside) | D (nothing inside) |
+ * | ----------------------- | ----------------- | ---------------------- | --------------------- | ------------------ |
+ * | 1 (letter outside)      | x*y*z             | x*.*z                  | x* *z                 | x**z               |
+ * | 2 (punctuation outside) | .*y*.             | .*.*.                  | .* *.                 | .**.               |
+ * | 3 (whitespace outside)  | x *y* z           | x *.* z                | x * * z               | x ** z             |
+ * | 4 (nothing outside)     | *x*               | *.*                    | * *                   | **                 |
+ * ```
+ *
+ * @param {number} outside
+ *   Code point on the outer side of the run.
+ * @param {number} inside
+ *   Code point on the inner side of the run.
+ * @param {'*' | '_'} 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;
+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

@@ -0,0 +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"}

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

@@ -0,0 +1,82 @@
+/**
+ * @import {EncodeSides} from '../types.js'
+ */
+
+import {classifyCharacter} from 'micromark-util-classify-character'
+
+/**
+ * Check whether to encode (as a character reference) the characters
+ * surrounding an attention run.
+ *
+ * Which characters are around an attention run influence whether it works or
+ * not.
+ *
+ * See <https://github.com/orgs/syntax-tree/discussions/60> for more info.
+ * See this markdown in a particular renderer to see what works:
+ *
+ * ```markdown
+ * |                         | A (letter inside) | B (punctuation inside) | C (whitespace inside) | D (nothing inside) |
+ * | ----------------------- | ----------------- | ---------------------- | --------------------- | ------------------ |
+ * | 1 (letter outside)      | x*y*z             | x*.*z                  | x* *z                 | x**z               |
+ * | 2 (punctuation outside) | .*y*.             | .*.*.                  | .* *.                 | .**.               |
+ * | 3 (whitespace outside)  | x *y* z           | x *.* z                | x * * z               | x ** z             |
+ * | 4 (nothing outside)     | *x*               | *.*                    | * *                   | **                 |
+ * ```
+ *
+ * @param {number} outside
+ *   Code point on the outer side of the run.
+ * @param {number} inside
+ *   Code point on the inner side of the run.
+ * @param {'*' | '_'} marker
+ *   Marker of the run.
+ *   Underscores are handled more strictly (they form less often) than
+ *   asterisks.
+ * @returns {EncodeSides}
+ *   Whether to encode characters.
+ */
+// Important: punctuation must never be encoded.
+// Punctuation is solely used by markdown constructs.
+// And by encoding itself.
+// Encoding them will break constructs or double encode things.
+export function encodeInfo(outside, inside, marker) {
+  const outsideKind = classifyCharacter(outside)
+  const insideKind = classifyCharacter(inside)
+
+  // Letter outside:
+  if (outsideKind === undefined) {
+    return insideKind === undefined
+      ? // Letter inside:
+        // we have to encode *both* letters for `_` as it is looser.
+        // it already forms for `*` (and GFMs `~`).
+        marker === '_'
+        ? {inside: true, outside: true}
+        : {inside: false, outside: false}
+      : insideKind === 1
+        ? // Whitespace inside: encode both (letter, whitespace).
+          {inside: true, outside: true}
+        : // Punctuation inside: encode outer (letter)
+          {inside: false, outside: true}
+  }
+
+  // Whitespace outside:
+  if (outsideKind === 1) {
+    return insideKind === undefined
+      ? // Letter inside: already forms.
+        {inside: false, outside: false}
+      : insideKind === 1
+        ? // Whitespace inside: encode both (whitespace).
+          {inside: true, outside: true}
+        : // Punctuation inside: already forms.
+          {inside: false, outside: false}
+  }
+
+  // Punctuation outside:
+  return insideKind === undefined
+    ? // Letter inside: already forms.
+      {inside: false, outside: false}
+    : insideKind === 1
+      ? // Whitespace inside: encode inner (whitespace).
+        {inside: true, outside: false}
+      : // Punctuation inside: already forms.
+        {inside: false, outside: false}
+}

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

@@ -0,0 +1,13 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Code} from 'mdast'
+ */
+/**
+ * @param {Code} node
+ * @param {State} state
+ * @returns {boolean}
+ */
+export function formatCodeAsIndented(node: Code, state: State): boolean;
+import type { Code } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+//# sourceMappingURL=format-code-as-indented.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,22 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Code} from 'mdast'
+ */
+
+/**
+ * @param {Code} node
+ * @param {State} state
+ * @returns {boolean}
+ */
+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)
+  )
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @param {Heading} node
+ * @param {State} state
+ * @returns {boolean}
+ */
+export function formatHeadingAsSetext(node: Heading, state: State): boolean;
+import type { Heading } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+//# sourceMappingURL=format-heading-as-setext.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,34 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Heading} from 'mdast'
+ */
+
+import {EXIT, visit} from 'unist-util-visit'
+import {toString} from 'mdast-util-to-string'
+
+/**
+ * @param {Heading} node
+ * @param {State} state
+ * @returns {boolean}
+ */
+export function formatHeadingAsSetext(node, state) {
+  let literalWithBreak = false
+
+  // Look for literals with a line break.
+  // Note that this also
+  visit(node, function (node) {
+    if (
+      ('value' in node && /\r?\n|\r/.test(node.value)) ||
+      node.type === 'break'
+    ) {
+      literalWithBreak = true
+      return EXIT
+    }
+  })
+
+  return Boolean(
+    (!node.depth || node.depth < 3) &&
+      toString(node) &&
+      (state.options.setext || literalWithBreak)
+  )
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @param {Link} node
+ * @param {State} state
+ * @returns {boolean}
+ */
+export function formatLinkAsAutolink(node: Link, state: State): boolean;
+import type { Link } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+//# sourceMappingURL=format-link-as-autolink.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,34 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Link} from 'mdast'
+ */
+
+import {toString} from 'mdast-util-to-string'
+
+/**
+ * @param {Link} node
+ * @param {State} state
+ * @returns {boolean}
+ */
+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)
+  )
+}

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

@@ -0,0 +1,2 @@
+export function indentLines(value: string, map: import("../types.js").Map): string;
+//# sourceMappingURL=indent-lines.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indent-lines.d.ts","sourceRoot":"","sources":["indent-lines.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,35 @@
+/**
+ * @import {IndentLines} from '../types.js'
+ */
+
+const eol = /\r?\n|\r/g
+
+/**
+ * @type {IndentLines}
+ */
+export function indentLines(value, map) {
+  /** @type {Array<string>} */
+  const result = []
+  let start = 0
+  let line = 0
+  /** @type {RegExpExecArray | null} */
+  let match
+
+  while ((match = eol.exec(value))) {
+    one(value.slice(start, match.index))
+    result.push(match[0])
+    start = match.index + match[0].length
+    line++
+  }
+
+  one(value.slice(start))
+
+  return result.join('')
+
+  /**
+   * @param {string} value
+   */
+  function one(value) {
+    result.push(map(value, line, !value))
+  }
+}

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

@@ -0,0 +1,12 @@
+/**
+ * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
+ */
+/**
+ * @param {Array<ConstructName>} stack
+ * @param {Unsafe} pattern
+ * @returns {boolean}
+ */
+export function patternInScope(stack: Array<ConstructName>, pattern: Unsafe): boolean;
+import type { ConstructName } from 'mdast-util-to-markdown';
+import type { Unsafe } from 'mdast-util-to-markdown';
+//# sourceMappingURL=pattern-in-scope.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,41 @@
+/**
+ * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * @param {Array<ConstructName>} stack
+ * @param {Unsafe} pattern
+ * @returns {boolean}
+ */
+export function patternInScope(stack, pattern) {
+  return (
+    listInScope(stack, pattern.inConstruct, true) &&
+    !listInScope(stack, pattern.notInConstruct, false)
+  )
+}
+
+/**
+ * @param {Array<ConstructName>} stack
+ * @param {Unsafe['inConstruct']} list
+ * @param {boolean} none
+ * @returns {boolean}
+ */
+function listInScope(stack, list, none) {
+  if (typeof list === 'string') {
+    list = [list]
+  }
+
+  if (!list || list.length === 0) {
+    return none
+  }
+
+  let index = -1
+
+  while (++index < list.length) {
+    if (stack.includes(list[index])) {
+      return true
+    }
+  }
+
+  return false
+}