@mrclrchtr/supi-code-intelligence 3.2.0 → 4.0.0

package/node_modules/@mrclrchtr/supi-tree-sitter/scripts/vendor-wasm.mjs

@@ -108,8 +108,14 @@ function checkGrammar(grammarId, source) {
 
   try {
     const pkg = readPackage(source.npmPackage);
+    const sourceWasmPath = path.join(pkg.dir, source.wasmFile);
+    if (!fs.existsSync(sourceWasmPath)) {
+      errors.push(`${grammarId}: installed package is missing ${source.wasmFile}`);
+      return errors;
+    }
     const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
     const actualSha = sha256(wasmPath);
+    const sourceSha = sha256(sourceWasmPath);
 
     if (metadata.source?.npmPackage !== source.npmPackage) {
       errors.push(`${grammarId}: metadata source npmPackage mismatch`);
@@ -119,8 +125,18 @@ function checkGrammar(grammarId, source) {
         `${grammarId}: metadata version ${metadata.source?.version} !== installed ${pkg.json.version}`,
       );
     }
+    if (actualSha !== sourceSha) {
+      errors.push(
+        `${grammarId}: vendored sha256 ${actualSha} !== installed package source ${sourceSha}`,
+      );
+    }
     if (metadata.sha256 !== actualSha) {
-      errors.push(`${grammarId}: metadata sha256 ${metadata.sha256} !== actual ${actualSha}`);
+      errors.push(`${grammarId}: metadata sha256 ${metadata.sha256} !== vendored ${actualSha}`);
+    }
+    if (metadata.sha256 !== sourceSha) {
+      errors.push(
+        `${grammarId}: metadata sha256 ${metadata.sha256} !== installed package source ${sourceSha}`,
+      );
     }
   } catch (err) {
     errors.push(`${grammarId}: ${err.message}`);

package/node_modules/@mrclrchtr/supi-tree-sitter/src/api.ts

@@ -12,6 +12,8 @@ export {
   isJsTsGrammar,
   isSupportedFile,
 } from "./language.ts";
+export type { StructuralSearchOperation } from "./operation-support.ts";
+export { getStructuralSearchSupportedExtensions } from "./operation-support.ts";
 export { TreeSitterRuntime } from "./session/runtime.ts";
 export type {
   TsControllerState,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/coordinates.ts

@@ -1,10 +1,16 @@
 // Coordinate conversion between public 1-based UTF-16 positions
-// and Tree-sitter runtime byte/row/column positions.
+// and Tree-sitter runtime positions.
+//
+// web-tree-sitter's Parser.parse(string) uses JavaScript string columns
+// (UTF-16 code unit offsets) for startPosition/endPosition. We convert
+// 1-based user-facing positions to 0-based row/column and back without
+// any byte-level encoding.
+//
+// This matches the column convention used by LSP and Monaco, so ranges
+// are directly shareable between tree-sitter and LSP workflows.
 
 import type { SourceRange } from "./types.ts";
 
-const encoder = new TextEncoder();
-
 /** Point in source: 1-based line and UTF-16 character. */
 export interface PublicPoint {
   line: number;
@@ -16,7 +22,8 @@ export interface PublicPoint {
  * for Tree-sitter lookup.
  *
  * `character` is a UTF-16 code-unit column (editor/LSP convention).
- * We convert it to a byte offset within the line by counting UTF-8 bytes.
+ * The column maps directly to JavaScript string code units — no byte
+ * conversion is needed for web-tree-sitter's string-parsing mode.
  */
 export function publicToTreeSitter(
   line: number,
@@ -25,32 +32,27 @@ export function publicToTreeSitter(
 ): { row: number; column: number } {
   const row = line - 1;
   const lines = splitSourceLines(source);
-  const lineText = row < lines.length ? lines[row] : "";
-  // character is 1-based; clamp to line length
-  const charIndex = Math.max(0, Math.min(character - 1, lineText.length));
-  // Convert UTF-16 code unit index to byte offset
-  const textBefore = lineText.substring(0, charIndex);
-  const byteOffset = encoder.encode(textBefore).length;
-  return { row, column: byteOffset };
+  const lineText = row < lines.length ? (lines[row] ?? "") : "";
+  // Clamp column to the line length.
+  const column = Math.max(0, Math.min(character - 1, lineText.length));
+  return { row, column };
 }
 
 /**
  * Convert a Tree-sitter (row, column) pair to a 1-based (line, character) pair.
  *
- * `column` is a byte offset within the line; we convert it to a UTF-16
- * code-unit index.
+ * `column` is a zero-based JavaScript string code unit offset within the line.
  */
 export function treeSitterToPublic(row: number, column: number, source: string): PublicPoint {
+  // Clamp to EOL for positions right after the last character.
   const lines = splitSourceLines(source);
-  const lineText = row < lines.length ? lines[row] : "";
-  // Convert byte offset to UTF-16 code unit index
-  const charIndex = byteToUtf16Index(lineText, column);
-  return { line: row + 1, character: charIndex + 1 };
+  const lineText = row < lines.length ? (lines[row] ?? "") : "";
+  const safeColumn = Math.max(0, Math.min(column, lineText.length));
+  return { line: row + 1, character: safeColumn + 1 };
 }
 
 /**
  * Convert a Tree-sitter point {row, column} to a SourceRange-compatible point.
- * Uses the source text for byte-to-UTF16 conversion.
  */
 export function tsPointToPublic(
   point: { row: number; column: number },
@@ -83,26 +85,3 @@ export function nodeToRange(
 export function splitSourceLines(source: string): string[] {
   return source.replace(/\r\n?/g, "\n").split("\n");
 }
-
-/**
- * Convert a byte offset within a line to a UTF-16 code unit index.
- */
-function byteToUtf16Index(line: string, byteOffset: number): number {
-  let byteCount = 0;
-  for (let i = 0; i < line.length; i++) {
-    if (byteCount >= byteOffset) return i;
-    const char = line.charCodeAt(i);
-    // surrogate pair — 4 bytes in UTF-8, but 2 UTF-16 code units
-    if (char >= 0xd800 && char <= 0xdbff) {
-      byteCount += 4;
-      i++; // skip low surrogate
-    } else if (char > 0x7f) {
-      // Non-ASCII: 2-3 bytes in UTF-8
-      if (char <= 0x7ff) byteCount += 2;
-      else byteCount += 3;
-    } else {
-      byteCount += 1;
-    }
-  }
-  return line.length;
-}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/index.ts

@@ -11,6 +11,8 @@ export {
   isJsTsGrammar,
   isSupportedFile,
 } from "./language.ts";
+export type { StructuralSearchOperation } from "./operation-support.ts";
+export { getStructuralSearchSupportedExtensions } from "./operation-support.ts";
 // Provider implementation
 export { createTreeSitterProvider } from "./provider/tree-sitter-provider.ts";
 export { TreeSitterRuntime } from "./session/runtime.ts";

package/node_modules/@mrclrchtr/supi-tree-sitter/src/language.ts

@@ -61,6 +61,13 @@ export function getSupportedExtensions(): string[] {
   return [...SUPPORTED_EXTENSIONS];
 }
 
+/** Internal registry snapshot used to derive operation-specific language support. */
+export function getSupportedExtensionGrammarEntries(): Array<
+  readonly [SupportedExtension, GrammarId]
+> {
+  return Object.entries(EXTENSION_GRAMMAR) as Array<readonly [SupportedExtension, GrammarId]>;
+}
+
 /** Get the file extension if it's supported, otherwise undefined. */
 export function getSupportedExtension(filePath: string): SupportedExtension | undefined {
   const ext = path.extname(filePath).toLowerCase();

package/node_modules/@mrclrchtr/supi-tree-sitter/src/operation-support.ts

@@ -0,0 +1,40 @@
+import { getSupportedExtensionGrammarEntries, isJsTsGrammar } from "./language.ts";
+import { supportsCallSitesGrammar } from "./tool/call-sites.ts";
+import type { GrammarId, SupportedExtension } from "./types.ts";
+
+/** Structural collection operations whose language support defines an AST Scan universe. */
+const STRUCTURAL_SEARCH_OPERATIONS = ["outline", "imports", "exports", "call-sites"] as const;
+
+/** One Tree-sitter structural collection operation used by code-aware search. */
+export type StructuralSearchOperation = (typeof STRUCTURAL_SEARCH_OPERATIONS)[number];
+
+/**
+ * Return the file extensions that the concrete extractor supports for an operation.
+ *
+ * This is operation support, not general parser support. The result is derived from
+ * the same grammar predicates and query registry used by the extractors themselves.
+ */
+export function getStructuralSearchSupportedExtensions(
+  operation: StructuralSearchOperation,
+): SupportedExtension[] {
+  return getSupportedExtensionGrammarEntries()
+    .filter(([, grammar]) => supportsGrammarOperation(grammar, operation))
+    .map(([extension]) => extension);
+}
+
+/** Return whether one grammar is supported by the requested structural operation. */
+export function supportsGrammarOperation(
+  grammar: GrammarId,
+  operation: StructuralSearchOperation,
+): boolean {
+  switch (operation) {
+    case "call-sites":
+      return supportsCallSitesGrammar(grammar);
+    case "outline":
+    case "imports":
+    case "exports":
+      return isJsTsGrammar(grammar);
+    default:
+      throw new TypeError(`Unsupported structural search operation: ${String(operation)}`);
+  }
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/session/session.ts

@@ -1,6 +1,7 @@
 // Session factory — creates runtime-backed Tree-sitter services and owned sessions.
 
-import { detectGrammar, isJsTsGrammar } from "../language.ts";
+import { detectGrammar } from "../language.ts";
+import { supportsGrammarOperation } from "../operation-support.ts";
 import {
   extractCallSites,
   extractExports,
@@ -45,15 +46,16 @@ export function createTreeSitterService(runtime: TreeSitterRuntime): TreeSitterS
     },
 
     async outline(file: string): Promise<TreeSitterResult<OutlineItem[]>> {
-      const parseResult = await runtime.parseFile(file);
-      if (parseResult.kind !== "success") return parseResult;
-      if (!isJsTsGrammar(parseResult.data.grammarId)) {
+      const grammarId = detectGrammar(file);
+      if (grammarId && !supportsGrammarOperation(grammarId, "outline")) {
         return {
           kind: "unsupported-language",
           file,
-          message: `outline is not supported for ${parseResult.data.grammarId} files`,
+          message: `outline is not supported for ${grammarId} files`,
         };
       }
+      const parseResult = await runtime.parseFile(file);
+      if (parseResult.kind !== "success") return parseResult;
       const { tree, source } = parseResult.data;
       try {
         const items = extractOutline(tree.rootNode, source);
@@ -65,7 +67,7 @@ export function createTreeSitterService(runtime: TreeSitterRuntime): TreeSitterS
 
     async imports(file: string): Promise<TreeSitterResult<ImportRecord[]>> {
       const grammarId = detectGrammar(file);
-      if (grammarId && !isJsTsGrammar(grammarId)) {
+      if (grammarId && !supportsGrammarOperation(grammarId, "imports")) {
         return {
           kind: "unsupported-language",
           file,
@@ -77,7 +79,7 @@ export function createTreeSitterService(runtime: TreeSitterRuntime): TreeSitterS
 
     async exports(file: string): Promise<TreeSitterResult<ExportRecord[]>> {
       const grammarId = detectGrammar(file);
-      if (grammarId && !isJsTsGrammar(grammarId)) {
+      if (grammarId && !supportsGrammarOperation(grammarId, "exports")) {
         return {
           kind: "unsupported-language",
           file,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/call-sites.ts

@@ -30,10 +30,15 @@ const CALL_SITE_QUERIES: Partial<Record<GrammarId, string>> = {
   kotlin:
     "(call_expression . (simple_identifier) @call) (call_expression . (navigation_expression . (simple_identifier) @call))",
   ruby: "(call method: (identifier) @call)",
-  bash: "(command name: (word) @call)",
+  bash: "(command name: (command_name) @call)",
   r: "(call function: (identifier) @call)",
 };
 
+/** Return whether the call-site extractor has a query for one grammar. */
+export function supportsCallSitesGrammar(grammarId: GrammarId): boolean {
+  return CALL_SITE_QUERIES[grammarId] !== undefined;
+}
+
 /**
  * Extract all call-site callee expressions from a file.
  *

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/callees.ts

@@ -188,7 +188,7 @@ export async function lookupCalleesAt(
 
   try {
     const scopes = ENCLOSING_SCOPE_TYPES[grammarId];
-    const tsPoint = tsPosition(line, character);
+    const tsPoint = { row: line - 1, column: character - 1 };
     const node = tree.rootNode.descendantForPosition(tsPoint);
 
     if (!node) {
@@ -222,13 +222,7 @@ export async function lookupCalleesAt(
       };
     }
 
-    const callees = filterCalleeCaptures(
-      queryResult.data,
-      enclosingNode,
-      scopes,
-      tsPoint.row,
-      depth,
-    );
+    const callees = filterCalleeCaptures(queryResult.data, enclosingNode, scopes, tsPoint, depth);
 
     const enclosingRange = nodeToSourceRange(enclosingNode);
     const scopeName = extractScopeName(enclosingNode.type, enclosingNode.text);
@@ -250,47 +244,74 @@ export async function lookupCalleesAt(
 }
 
 /**
- * Recursively collect line ranges of inner function/method/callback scopes that
- * do not contain the anchor row. Captures from these ranges are excluded so
+ * Recursively collect inner function/method/callback scopes that do NOT
+ * contain the anchor point. Captures from these ranges are excluded so
  * nested calls are not attributed to the parent scope.
+ *
+ * Containment compares both row and column to handle same-line nested
+ * functions correctly.
  */
 function collectInnerScopes(
   node: {
     type: string;
     children: unknown[];
-    startPosition: { row: number };
-    endPosition: { row: number };
+    startPosition: { row: number; column: number };
+    endPosition: { row: number; column: number };
   } | null,
   scopeTypes: ReadonlySet<string>,
-  anchorRow: number,
-  ranges: Array<{ startRow: number; endRow: number }>,
+  anchor: { row: number; column: number },
+  ranges: Array<{
+    startRow: number;
+    startColumn: number;
+    endRow: number;
+    endColumn: number;
+  }>,
 ): void {
   if (!node) return;
   // biome-ignore lint/complexity/noForEach: safe iteration over node children
   (node.children ?? []).forEach((child) => {
     const childNode = child as {
       type: string;
-      startPosition: { row: number };
-      endPosition: { row: number };
+      startPosition: { row: number; column: number };
+      endPosition: { row: number; column: number };
       children: unknown[];
     };
     if (scopeTypes.has(childNode.type)) {
-      // Exclude this inner scope if it does NOT contain the anchor
-      if (!(childNode.startPosition.row <= anchorRow && childNode.endPosition.row >= anchorRow)) {
+      // Exclude this inner scope if it does NOT contain the anchor point.
+      const contains = containsPoint(childNode, anchor);
+      if (!contains) {
         ranges.push({
-          startRow: childNode.startPosition.row + 1,
-          endRow: childNode.endPosition.row + 1,
+          startRow: childNode.startPosition.row,
+          startColumn: childNode.startPosition.column,
+          endRow: childNode.endPosition.row,
+          endColumn: childNode.endPosition.column,
         });
       }
       // Still recurse into it for deeper nesting
-      collectInnerScopes(childNode, scopeTypes, anchorRow, ranges);
+      collectInnerScopes(childNode, scopeTypes, anchor, ranges);
     } else {
       // Recurse into non-scope children to find deeper scopes
-      collectInnerScopes(childNode, scopeTypes, anchorRow, ranges);
+      collectInnerScopes(childNode, scopeTypes, anchor, ranges);
     }
   });
 }
 
+function containsPoint(
+  node: {
+    startPosition: { row: number; column: number };
+    endPosition: { row: number; column: number };
+  },
+  point: { row: number; column: number },
+): boolean {
+  const afterStart =
+    point.row > node.startPosition.row ||
+    (point.row === node.startPosition.row && point.column >= node.startPosition.column);
+  const beforeEnd =
+    point.row < node.endPosition.row ||
+    (point.row === node.endPosition.row && point.column <= node.endPosition.column);
+  return afterStart && beforeEnd;
+}
+
 /**
  * Filter query captures to only those within the enclosing scope.
  * In `direct` depth, excludes captures that fall within inner nested
@@ -298,35 +319,57 @@ function collectInnerScopes(
  * enclosing scope are included regardless of nesting.
  */
 // biome-ignore lint/complexity/useMaxParams: filtering needs captures + node context + depth
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: filtering combines scope containment, column-aware inner-scope exclusion, and dedup in one cohesive pass
 function filterCalleeCaptures(
   captures: Array<{ range: SourceRange; text: string }>,
   // biome-ignore lint/suspicious/noExplicitAny: tree-sitter SyntaxNode is complex
   enclosingNode: any,
   scopeTypes: ReadonlySet<string>,
-  anchorRow: number,
+  anchor: { row: number; column: number },
   depth: "direct" | "deep" = "direct",
 ): Array<{ name: string; range: SourceRange }> {
-  const excludeRanges: Array<{ startRow: number; endRow: number }> = [];
+  const excludeRanges: Array<{
+    startRow: number;
+    startColumn: number;
+    endRow: number;
+    endColumn: number;
+  }> = [];
   if (depth === "direct") {
-    collectInnerScopes(enclosingNode, scopeTypes, anchorRow, excludeRanges);
+    collectInnerScopes(enclosingNode, scopeTypes, anchor, excludeRanges);
   }
 
   const seen = new Set<string>();
   const callees: Array<{ name: string; range: SourceRange }> = [];
 
-  const enclosingStartRow = enclosingNode.startPosition.row + 1;
-  const enclosingEndRow = enclosingNode.endPosition.row + 1;
+  const enclosingStartRow = enclosingNode.startPosition.row;
+  const enclosingEndRow = enclosingNode.endPosition.row;
+  const enclosingStartColumn = enclosingNode.startPosition.column;
+  const enclosingEndColumn = enclosingNode.endPosition.column;
 
   for (const capture of captures) {
-    // Only include captures within the enclosing scope
-    if (capture.range.startLine < enclosingStartRow || capture.range.endLine > enclosingEndRow) {
+    // Only include captures within the enclosing scope, using columns
+    // for same-line containment.
+    const capStartLine = capture.range.startLine - 1;
+    const capEndLine = capture.range.endLine - 1;
+    const capStartChar = capture.range.startCharacter - 1;
+    const capEndChar = capture.range.endCharacter - 1;
+    if (capStartLine < enclosingStartRow || capEndLine > enclosingEndRow) {
+      continue;
+    }
+    if (capStartLine === enclosingStartRow && capStartChar < enclosingStartColumn) {
+      continue;
+    }
+    if (capEndLine === enclosingEndRow && capEndChar > enclosingEndColumn) {
       continue;
     }
 
-    // In direct depth, exclude captures that fall within inner nested function scopes
+    // In direct depth, exclude captures within inner nested function scopes
     if (depth === "direct") {
       const isInInner = excludeRanges.some(
-        (exc) => capture.range.startLine >= exc.startRow && capture.range.endLine <= exc.endRow,
+        (exc) =>
+          (capStartLine > exc.startRow ||
+            (capStartLine === exc.startRow && capStartChar >= exc.startColumn)) &&
+          (capEndLine < exc.endRow || (capEndLine === exc.endRow && capEndChar <= exc.endColumn)),
       );
       if (isInInner) continue;
     }
@@ -343,7 +386,8 @@ function filterCalleeCaptures(
 
 // ── Internal helpers ──────────────────────────────────────────────────
 
-/** Convert a tree-sitter node to a SourceRange. */
+/** Convert a tree-sitter node to a SourceRange using the source text for
+ * UTF-16 column conversion. */
 function nodeToSourceRange(node: {
   startPosition: { row: number; column: number };
   endPosition: { row: number; column: number };
@@ -355,8 +399,3 @@ function nodeToSourceRange(node: {
     endCharacter: node.endPosition.column + 1,
   };
 }
-
-/** Convert 1-based position to tree-sitter 0-based point. */
-function tsPosition(line: number, character: number): { row: number; column: number } {
-  return { row: line - 1, column: character - 1 };
-}

package/node_modules/yaml/LICENSE

@@ -0,0 +1,13 @@
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/node_modules/yaml/README.md

@@ -0,0 +1,172 @@
+# YAML <a href="https://www.npmjs.com/package/yaml"><img align="right" src="https://badge.fury.io/js/yaml.svg" title="npm package" /></a>
+
+`yaml` is a definitive library for [YAML](https://yaml.org/), the human friendly data serialization standard.
+This library:
+
+- Supports both YAML 1.1 and YAML 1.2 and all common data schemas,
+- Passes all of the [yaml-test-suite](https://github.com/yaml/yaml-test-suite) tests,
+- Can accept any string as input without throwing, parsing as much YAML out of it as it can, and
+- Supports parsing, modifying, and writing YAML comments and blank lines.
+
+The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/).
+It has no external dependencies and runs on Node.js as well as modern browsers.
+
+For the purposes of versioning, any changes that break any of the documented endpoints or APIs will be considered semver-major breaking changes.
+Undocumented library internals may change between minor versions, and previous APIs may be deprecated (but not removed).
+
+The minimum supported TypeScript version of the included typings is 3.9;
+for use in earlier versions you may need to set `skipLibCheck: true` in your config.
+This requirement may be updated between minor versions of the library.
+
+For more information, see the project's documentation site: [**eemeli.org/yaml**](https://eemeli.org/yaml/)
+
+For build instructions and contribution guidelines, see [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+
+To install:
+
+```sh
+npm install yaml
+# or
+deno add jsr:@eemeli/yaml
+```
+
+**Note:** These docs are for `yaml@2`. For v1, see the [v1.10.0 tag](https://github.com/eemeli/yaml/tree/v1.10.0) for the source and [eemeli.org/yaml/v1](https://eemeli.org/yaml/v1/) for the documentation.
+
+## API Overview
+
+The API provided by `yaml` has three layers, depending on how deep you need to go: [Parse & Stringify](https://eemeli.org/yaml/#parse-amp-stringify), [Documents](https://eemeli.org/yaml/#documents), and the underlying [Lexer/Parser/Composer](https://eemeli.org/yaml/#parsing-yaml).
+The first has the simplest API and "just works", the second gets you all the bells and whistles supported by the library along with a decent [AST](https://eemeli.org/yaml/#content-nodes), and the third lets you get progressively closer to YAML source, if that's your thing.
+
+A [command-line tool](https://eemeli.org/yaml/#command-line-tool) is also included.
+
+### Parse & Stringify
+
+```js
+import { parse, stringify } from 'yaml'
+```
+
+- [`parse(str, reviver?, options?): value`](https://eemeli.org/yaml/#yaml-parse)
+- [`stringify(value, replacer?, options?): string`](https://eemeli.org/yaml/#yaml-stringify)
+
+### Documents
+
+<!-- prettier-ignore -->
+```js
+import {
+  Document,
+  isDocument,
+  parseAllDocuments,
+  parseDocument
+} from 'yaml'
+```
+
+- [`Document`](https://eemeli.org/yaml/#documents)
+  - [`constructor(value, replacer?, options?)`](https://eemeli.org/yaml/#creating-documents)
+  - [`#contents`](https://eemeli.org/yaml/#content-nodes)
+  - [`#directives`](https://eemeli.org/yaml/#stream-directives)
+  - [`#errors`](https://eemeli.org/yaml/#errors)
+  - [`#warnings`](https://eemeli.org/yaml/#errors)
+- [`isDocument(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`parseAllDocuments(str, options?): Document[]`](https://eemeli.org/yaml/#parsing-documents)
+- [`parseDocument(str, options?): Document`](https://eemeli.org/yaml/#parsing-documents)
+
+### Content Nodes
+
+<!-- prettier-ignore -->
+```js
+import {
+  isAlias, isCollection, isMap, isNode,
+  isPair, isScalar, isSeq, Scalar,
+  visit, visitAsync, YAMLMap, YAMLSeq
+} from 'yaml'
+```
+
+- [`isAlias(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isCollection(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isMap(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isNode(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isPair(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isScalar(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isSeq(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`new Scalar(value)`](https://eemeli.org/yaml/#scalar-values)
+- [`new YAMLMap()`](https://eemeli.org/yaml/#collections)
+- [`new YAMLSeq()`](https://eemeli.org/yaml/#collections)
+- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createNode(value, options?): Node`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createPair(key, value): Pair`](https://eemeli.org/yaml/#creating-nodes)
+- [`visit(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+- [`visitAsync(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+
+### Parsing YAML
+
+```js
+import { Composer, Lexer, Parser } from 'yaml'
+```
+
+- [`new Lexer().lex(src)`](https://eemeli.org/yaml/#lexer)
+- [`new Parser(onNewLine?).parse(src)`](https://eemeli.org/yaml/#parser)
+- [`new Composer(options?).compose(tokens)`](https://eemeli.org/yaml/#composer)
+
+## YAML.parse
+
+```yaml
+# file.yml
+YAML:
+  - A human-readable data serialization language
+  - https://en.wikipedia.org/wiki/YAML
+yaml:
+  - A complete JavaScript implementation
+  - https://www.npmjs.com/package/yaml
+```
+
+```js
+import fs from 'fs'
+import YAML from 'yaml'
+
+YAML.parse('3.14159')
+// 3.14159
+
+YAML.parse('[ true, false, maybe, null ]\n')
+// [ true, false, 'maybe', null ]
+
+const file = fs.readFileSync('./file.yml', 'utf8')
+YAML.parse(file)
+// { YAML:
+//   [ 'A human-readable data serialization language',
+//     'https://en.wikipedia.org/wiki/YAML' ],
+//   yaml:
+//   [ 'A complete JavaScript implementation',
+//     'https://www.npmjs.com/package/yaml' ] }
+```
+
+## YAML.stringify
+
+```js
+import YAML from 'yaml'
+
+YAML.stringify(3.14159)
+// '3.14159\n'
+
+YAML.stringify([true, false, 'maybe', null])
+// `- true
+// - false
+// - maybe
+// - null
+// `
+
+YAML.stringify({ number: 3, plain: 'string', block: 'two\nlines\n' })
+// `number: 3
+// plain: string
+// block: |
+//   two
+//   lines
+// `
+```
+
+---
+
+Browser testing provided by:
+
+<a href="https://www.browserstack.com/open-source">
+<img width=200 src="https://eemeli.org/yaml/images/browserstack.svg" alt="BrowserStack" />
+</a>

package/node_modules/yaml/bin.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { UserError, cli, help } from './dist/cli.mjs'
+
+cli(process.stdin, error => {
+  if (error instanceof UserError) {
+    if (error.code === UserError.ARGS) console.error(`${help}\n`)
+    console.error(error.message)
+    process.exitCode = error.code
+  } else if (error) throw error
+})