gcf-aif-ext 0.2.0

package/node_modules/cnlp-kit/src/config.js

@@ -0,0 +1,352 @@
+// `cnlp.config.json` — the one file a project owns to say which profile applies to which
+// files. It exists so that adopting the format never means editing a file the package ships:
+// the corpus used to be constants at the top of a test, which put every project's own values
+// inside a file the next upgrade overwrote.
+
+import { existsSync } from 'node:fs';
+import { glob, readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { bodyIssues, loadProfileAt, pageRefs, resolveDoc } from './cnlp.js';
+
+export const CONFIG_NAME = 'cnlp.config.json';
+
+/** Nearest `cnlp.config.json` at or above a directory, or null. */
+export function findConfig(from = process.cwd()) {
+  let dir = path.resolve(from);
+  for (;;) {
+    const at = path.join(dir, CONFIG_NAME);
+    if (existsSync(at)) return at;
+    const up = path.dirname(dir);
+    if (up === dir) return null;
+    dir = up;
+  }
+}
+
+/**
+ * Read and validate a config. Every failure names the fix: a config that is silently empty
+ * reports a clean run over nothing, which is worse than no check at all.
+ */
+export async function readConfig(configPath) {
+  const abs = path.resolve(configPath);
+  let cfg;
+  try {
+    cfg = JSON.parse(await readFile(abs, 'utf8'));
+  } catch (e) {
+    throw new Error(`${abs}: ${e.message}`);
+  }
+  if (!Array.isArray(cfg.corpus) || cfg.corpus.length === 0) {
+    throw new Error(`${abs}: "corpus" is empty — name at least 1 entry of { "profile": …, "glob": … }`);
+  }
+  for (const entry of cfg.corpus) {
+    if (!entry?.profile || !entry?.glob) {
+      throw new Error(`${abs}: every corpus entry carries "profile" and "glob", found ${JSON.stringify(entry)}`);
+    }
+  }
+  const root = path.dirname(abs);
+  const profilesDir = cfg.profiles ? path.resolve(root, cfg.profiles) : null;
+  if (profilesDir && !existsSync(profilesDir)) {
+    throw new Error(`${abs}: "profiles" names ${JSON.stringify(cfg.profiles)}, which does not exist under ${root}`);
+  }
+  // §9: a project with no "docsets" key has no document set, and the reference rules do not apply
+  // to it. A key naming nothing would instead report a clean run over a corpus it never read.
+  const docsets = cfg.docsets ? String(cfg.docsets).replace(/\/+$/, '') : null;
+  if (docsets && !existsSync(path.resolve(root, docsets))) {
+    throw new Error(`${abs}: "docsets" names ${JSON.stringify(cfg.docsets)}, which does not exist under ${root}`);
+  }
+  // `agents` records what `cnlp init` last installed for, so a run with no terminal to ask in
+  // repeats that choice instead of guessing. A project that never ran `init` carries none.
+  if (cfg.agents !== undefined && !Array.isArray(cfg.agents)) {
+    throw new Error(`${abs}: "agents" is a list of agent names, found ${JSON.stringify(cfg.agents)}`);
+  }
+  return { path: abs, root, profilesDir, docsets, corpus: cfg.corpus, agents: cfg.agents ?? [] };
+}
+
+/**
+ * §9 page id of a project-relative path, or null when the path sits outside the docsets root.
+ * `examples/dragonecs/api/query.md` under a root of `examples` is `dragonecs:api/query`; a file
+ * directly under the root belongs to no set, so it has no id.
+ */
+export function pageIdOf(rel, docsets) {
+  const prefix = `${docsets}/`;
+  const at = rel.split(path.sep).join('/');
+  if (!at.startsWith(prefix) || !at.endsWith('.md')) return null;
+  const rest = at.slice(prefix.length, -3);
+  const cut = rest.indexOf('/');
+  if (cut < 0) return null;
+  return { docset: rest.slice(0, cut), page: rest.slice(cut + 1) };
+}
+
+/**
+ * Every document set under the docsets root, each with its index path and the sets its index names
+ * in `companions:`. A set is active because it is present: a project vendors the sets it uses, so
+ * presence is the declaration and no second config key can disagree with the files on disk.
+ */
+export async function docsetsOf(config) {
+  if (!config.docsets) {
+    throw new Error(`${config.path}: no "docsets" key — add one naming the directory whose subdirectories are 1 document set each`);
+  }
+  const found = new Map();
+  for await (const rel of glob(`${config.docsets}/*/index.md`, { cwd: config.root })) {
+    const id = pageIdOf(rel.split(path.sep).join('/'), config.docsets);
+    if (id) found.set(id.docset, { name: id.docset, index: rel });
+  }
+  for (const set of found.values()) {
+    const raw = await readFile(path.join(config.root, set.index), 'utf8');
+    set.raw = raw;
+    // `companions:` runs both ways — 2 packages name each other — so it fixes no order. `overrides:`
+    // does: a set correcting a page of another is read after the set it corrects, or the correction
+    // arrives for a page the reader has not seen yet.
+    set.overrides = [...new Set(pageRefs(raw)
+      .filter((r) => r.block === 'overrides' && r.key === 'page' && r.target.includes(':'))
+      .map((r) => r.target.slice(0, r.target.indexOf(':'))))];
+  }
+  return found;
+}
+
+/**
+ * The reading order for `cnlp docs`: every set a given set overrides comes before it. A cycle would
+ * mean 2 sets correcting each other, which has no reading order to give, so a set already on the
+ * path is left where it is rather than followed again.
+ */
+export function readingOrder(sets) {
+  const out = [];
+  const seen = new Set();
+  const visit = (name, guard) => {
+    if (seen.has(name) || guard.has(name)) return;
+    guard.add(name);
+    const set = sets.get(name);
+    if (!set) return;
+    for (const next of set.overrides) visit(next, guard);
+    seen.add(name);
+    out.push(set);
+  };
+  for (const name of [...sets.keys()].sort()) visit(name, new Set());
+  return out;
+}
+
+/**
+ * §9 reference conformance across a corpus, which is the 1 check no single document can make.
+ * `docs` is every file already read, so this adds no read of its own.
+ */
+export function linkIssues(docs, docsets) {
+  const pages = new Map();
+  const sets = new Set();
+  for (const { rel } of docs) {
+    const id = pageIdOf(rel, docsets);
+    if (!id) continue;
+    pages.set(`${id.docset}:${id.page}`, rel);
+    sets.add(id.docset);
+  }
+
+  const issues = [];
+  const reached = new Set();
+  for (const { rel, raw } of docs) {
+    const from = pageIdOf(rel, docsets);
+    if (!from) continue;
+    const self = `${from.docset}:${from.page}`;
+    for (const ref of pageRefs(raw)) {
+      if (ref.key === 'docset') {
+        if (!sets.has(ref.target)) {
+          issues.push({ file: rel, line: ref.line, message: `"${ref.target}" names no document set under ${docsets}/` });
+        }
+        continue;
+      }
+      const qualified = ref.target.includes(':') ? ref.target : `${from.docset}:${ref.target}`;
+      // §9: a "by:" value is local, so it carries no prefix at all — its own set's name there is a
+      // copy of what the file path already says, and another set's name is the defect this caught.
+      if (ref.key === 'by' && ref.target.includes(':')) {
+        issues.push({ file: rel, line: ref.line, message: `"by: ${ref.target}" carries a document set prefix — a "by:" value names a page of this set` });
+      }
+      if (!pages.has(qualified)) {
+        issues.push({ file: rel, line: ref.line, message: `page "${qualified}" does not resolve to a file under ${docsets}/` });
+      } else if (qualified !== self) {
+        reached.add(qualified);
+      }
+    }
+  }
+
+  // A page nothing reaches is a page nobody reads, so it goes stale with nobody watching. An
+  // index is the entry point of its set and is reached from outside the corpus, so it is exempt.
+  for (const [id, rel] of pages) {
+    if (!id.endsWith(':index') && !reached.has(id)) {
+      issues.push({ file: rel, line: 0, message: `no page references "${id}" — a page nothing reaches is a page nobody reads` });
+    }
+  }
+  return issues.sort((a, b) => (a.file === b.file ? a.line - b.line : a.file.localeCompare(b.file)));
+}
+
+// The agent runtimes a skill can be installed for, each with the directory it reads skills from.
+// A runtime is 1 record here and no branch anywhere else.
+export const AGENTS = [
+  { value: 'claude-code', label: 'Claude Code', base: '.claude' },
+  // Codex reads ".codex" implicitly, and ".agents" is the documented project-local location.
+  { value: 'codex', label: 'Codex', base: '.agents' },
+];
+
+/** Where an agent reads its skills from, under a project root. */
+export function skillsDirFor(root, agent) {
+  const known = AGENTS.find((a) => a.value === agent);
+  if (!known) throw new Error(`unknown agent ${JSON.stringify(agent)} — this kit knows ${AGENTS.map((a) => a.value).join(', ')}`);
+  return path.join(root, known.base, 'skills');
+}
+
+// The version of the skills an agent holds. A sidecar file and never frontmatter: `profiles/skill.md`
+// declares the 2 fields a SKILL.md carries, so a version added there fails the check of any project
+// whose corpus globs its own skills.
+export const STAMP_NAME = '.cnlp-version';
+
+/**
+ * The agents whose installed skills came from another version of this package, each with the
+ * version its stamp holds. A missing stamp reads as an install predating stamps, which wants the
+ * same answer — 1 `cnlp init` — so it reports as unknown rather than staying silent.
+ */
+export async function skillDrift(root, agents, version) {
+  const out = [];
+  for (const agent of agents ?? []) {
+    let dir;
+    try {
+      dir = skillsDirFor(root, agent);
+    } catch {
+      continue; // an agent this version does not know: the config outlived a rename
+    }
+    if (!existsSync(dir)) continue;
+    const stamp = path.join(dir, STAMP_NAME);
+    const held = existsSync(stamp) ? (await readFile(stamp, 'utf8')).trim() : null;
+    if (held !== version) out.push({ agent, dir, held });
+  }
+  return out;
+}
+
+// The layouts a corpus entry is usually written for. `cnlp init` keeps the ones that match a file,
+// so a project adopting the format starts from its own layout rather than from an example of one.
+// ponytail: path convention only, never content — a decision record filed under docs/references
+// reads as a reference here, and only a human opening it can say otherwise.
+/**
+ * The 4 entries of 1 document set, against the path its pages sit under. `base` carries whatever
+ * wildcard the caller wants — `docs/docsets/*` for every set of a project, `out/nanoid` for the 1
+ * set a path names — so the shape of a set is written here and nowhere else.
+ */
+export const docsetCorpus = (base) => [
+  { profile: 'docset', glob: `${base}/index.md` },
+  { profile: 'concept', glob: `${base}/concepts/*.md` },
+  { profile: 'api', glob: `${base}/api/*.md` },
+  { profile: 'task', glob: `${base}/tasks/*.md` },
+];
+
+const CANDIDATES = [
+  { profile: 'guide', glob: 'AGENTS.md' },
+  { profile: 'guide', glob: 'CLAUDE.md' },
+  // No agent's skills directory here: `cnlp init` writes this kit's own skills into those, and a
+  // corpus entry over them makes a project check files it does not own against its own profile.
+  { profile: 'skill', glob: 'skills/*/SKILL.md' },
+  { profile: 'adr', glob: 'docs/adr/*.md' },
+  { profile: 'adr', glob: 'docs/decisions/*.md' },
+  { profile: 'reference', glob: 'docs/references/*.md' },
+  ...docsetCorpus('docs/docsets/*'),
+];
+
+/**
+ * The corpus entries a directory's own layout supports, each with the count of files it matches.
+ * An entry matching nothing is left out: `checkProject` refuses a glob that matches no file, so a
+ * proposed entry no file answers would hand the project a config that fails on its first run.
+ */
+export async function proposeCorpus(root) {
+  const out = [];
+  for (const entry of CANDIDATES) {
+    const files = await filesFor(entry, root);
+    if (files.length) out.push({ ...entry, files: files.length });
+  }
+  return out;
+}
+
+/**
+ * A config for a directory, synthesized rather than read, so a document set that belongs to nobody
+ * can still be checked. A produced set is a folder of markdown handed to whoever asked for it: it
+ * carries no `cnlp.config.json`, and `readConfig` takes the root from the directory a config sits
+ * in, so a config kept outside the tree it describes cannot name it.
+ *
+ * `<dir>/index.md` present makes `<dir>` 1 set; otherwise a subdirectory holding an `index.md`
+ * makes `<dir>` the root of several. §9 resolves a page id against `<root>/<set>/<page>`, so the
+ * root sits 1 level above the directory the sets are in, and `pageIdOf` is unchanged.
+ *
+ * An entry matching no file is dropped here, which a written config is right to refuse: a glob a
+ * project typed and no file answers is a mistake, and a glob this function guessed is a folder the
+ * set does not have yet.
+ */
+export async function configForPath(dir) {
+  const abs = path.resolve(dir);
+  if (!existsSync(abs)) throw new Error(`no such directory: ${dir}`);
+  let root;
+  let docsets = null;
+  let corpus;
+  if (existsSync(path.join(abs, 'index.md'))) {
+    root = path.dirname(path.dirname(abs));
+    docsets = path.basename(path.dirname(abs));
+    corpus = docsetCorpus(`${docsets}/${path.basename(abs)}`);
+  } else if (await holdsASet(abs)) {
+    root = path.dirname(abs);
+    docsets = path.basename(abs);
+    corpus = docsetCorpus(`${docsets}/*`);
+  } else {
+    // Neither shape: fall back to the layouts `cnlp init` already knows, so pointing at a project
+    // reads the same as pointing at a set.
+    root = abs;
+    docsets = existsSync(path.join(abs, 'docs', 'docsets')) ? 'docs/docsets' : null;
+    corpus = (await proposeCorpus(abs)).map(({ profile, glob: g }) => ({ profile, glob: g }));
+  }
+  const kept = [];
+  for (const entry of corpus) {
+    if ((await filesFor(entry, root)).length) kept.push(entry);
+  }
+  if (kept.length === 0) {
+    throw new Error(`${abs} holds no document this kit knows the layout of — a document set is an index.md beside concepts, api and tasks`);
+  }
+  return { path: null, root, profilesDir: null, docsets, corpus: kept, agents: [] };
+}
+
+/** Whether an immediate subdirectory carries an index.md, which is what makes a directory a root. */
+async function holdsASet(abs) {
+  for (const entry of await readdir(abs, { withFileTypes: true })) {
+    if (entry.isDirectory() && existsSync(path.join(abs, entry.name, 'index.md'))) return true;
+  }
+  return false;
+}
+
+/** A project's own profile of that name, or the packaged one. */
+export async function profileFor(name, profilesDir) {
+  const local = profilesDir ? path.join(profilesDir, `${name}.md`) : null;
+  return loadProfileAt(local && existsSync(local) ? local : resolveDoc(name));
+}
+
+/** Paths a corpus entry matches, relative to the project root, sorted. */
+export async function filesFor(entry, root) {
+  const out = [];
+  for await (const f of glob(entry.glob, { cwd: root })) out.push(f);
+  return out.sort();
+}
+
+/**
+ * Run every corpus entry. Returns the files checked and the issues found, each carrying the
+ * project-relative path it came from. Severity is the caller's: an issue is an issue here.
+ */
+export async function checkProject(config) {
+  const issues = [];
+  const checked = [];
+  const docs = [];
+  for (const entry of config.corpus) {
+    const files = await filesFor(entry, config.root);
+    if (files.length === 0) {
+      throw new Error(`corpus entry ${JSON.stringify(entry.glob)} matches no file under ${config.root}`);
+    }
+    const profile = await profileFor(entry.profile, config.profilesDir);
+    for (const rel of files) {
+      const raw = await readFile(path.join(config.root, rel), 'utf8');
+      checked.push(rel);
+      docs.push({ rel, raw });
+      for (const issue of bodyIssues(raw, profile)) issues.push({ file: rel, ...issue });
+    }
+  }
+  // §9 is the 1 rule that needs the whole corpus, so it runs once over the files already read.
+  if (config.docsets) issues.push(...linkIssues(docs, config.docsets));
+  return { checked, issues };
+}

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
+})

package/node_modules/yaml/browser/dist/compose/compose-collection.js

@@ -0,0 +1,88 @@
+import { isNode } from '../nodes/identity.js';
+import { Scalar } from '../nodes/Scalar.js';
+import { YAMLMap } from '../nodes/YAMLMap.js';
+import { YAMLSeq } from '../nodes/YAMLSeq.js';
+import { resolveBlockMap } from './resolve-block-map.js';
+import { resolveBlockSeq } from './resolve-block-seq.js';
+import { resolveFlowCollection } from './resolve-flow-collection.js';
+
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection(CN, ctx, token, onError, tag);
+    const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
+    if (tagName === '!' || tagName === Coll.tagName) {
+        coll.tag = Coll.tagName;
+        return coll;
+    }
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
+    if (!tag) {
+        const kt = ctx.schema.knownTags[tagName];
+        if (kt?.collection === expType) {
+            ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+            tag = kt;
+        }
+        else {
+            if (kt) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
+        }
+    }
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+    const node = isNode(res)
+        ? res
+        : new Scalar(res);
+    node.range = coll.range;
+    node.tag = tagName;
+    if (tag?.format)
+        node.format = tag.format;
+    return node;
+}
+
+export { composeCollection };

package/node_modules/yaml/browser/dist/compose/compose-doc.js

@@ -0,0 +1,43 @@
+import { Document } from '../doc/Document.js';
+import { composeNode, composeEmptyNode } from './compose-node.js';
+import { resolveEnd } from './resolve-end.js';
+import { resolveProps } from './resolve-props.js';
+
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+    const opts = Object.assign({ _directives: directives }, options);
+    const doc = new Document(undefined, opts);
+    const ctx = {
+        atKey: false,
+        atRoot: true,
+        directives: doc.directives,
+        options: doc.options,
+        schema: doc.schema
+    };
+    const props = resolveProps(start, {
+        indicator: 'doc-start',
+        next: value ?? end?.[0],
+        offset,
+        onError,
+        parentIndent: 0,
+        startOnNewline: true
+    });
+    if (props.found) {
+        doc.directives.docStart = true;
+        if (value &&
+            (value.type === 'block-map' || value.type === 'block-seq') &&
+            !props.hasNewline)
+            onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
+    }
+    // @ts-expect-error If Contents is set, let's trust the user
+    doc.contents = value
+        ? composeNode(ctx, value, props, onError)
+        : composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd(end, contentEnd, false, onError);
+    if (re.comment)
+        doc.comment = re.comment;
+    doc.range = [offset, contentEnd, re.offset];
+    return doc;
+}
+
+export { composeDoc };