pax_global_header00006660000000000000000000000064151127741020014512gustar00rootroot0000000000000052 comment=086fa6b5bae325da18734750cddee231ce578930 eemeli-yaml-086fa6b/000077500000000000000000000000001511277410200143305ustar00rootroot00000000000000eemeli-yaml-086fa6b/.editorconfig000066400000000000000000000002751511277410200170110ustar00rootroot00000000000000root = true [*] end_of_line = lf indent_style = space indent_size = 2 charset = utf-8 trim_trailing_whitespace = true insert_final_newline = false [*.md] trim_trailing_whitespace = false eemeli-yaml-086fa6b/.github/000077500000000000000000000000001511277410200156705ustar00rootroot00000000000000eemeli-yaml-086fa6b/.github/ISSUE_TEMPLATE/000077500000000000000000000000001511277410200200535ustar00rootroot00000000000000eemeli-yaml-086fa6b/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000010421511277410200225420ustar00rootroot00000000000000--- name: Bug report about: Report an issue to help us improve the library title: '' labels: bug assignees: '' --- **Describe the bug** A clear and concise description of what the bug is. **To Reproduce** Steps to reproduce the behaviour. **Expected behaviour** A clear and concise description of what you expected to happen. **Versions (please complete the following information):** - Environment: [e.g. Node.js 14.7.0 or Chrome 87.0] - `yaml`: [e.g. 1.10.0 or 2.0.0-2] **Additional context** Add any other context about the problem here. eemeli-yaml-086fa6b/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000005561511277410200220510ustar00rootroot00000000000000blank_issues_enabled: false contact_links: - name: Discussions url: https://github.com/eemeli/yaml/discussions about: Please ask and answer questions here. - name: Documentation (v1) url: https://eemeli.org/yaml/v1 about: Documentation for yaml@1 - name: Documentation (v2) url: https://eemeli.org/yaml/ about: Documentation for yaml@2 eemeli-yaml-086fa6b/.github/ISSUE_TEMPLATE/feature_request.md000066400000000000000000000011331511277410200235760ustar00rootroot00000000000000--- name: Feature request about: Suggest an idea for this library title: '' labels: enhancement assignees: '' --- **Is your feature request related to a problem? Please describe.** A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] **Describe the solution you'd like** A clear and concise description of what you want to happen. **Describe alternatives you've considered** A clear and concise description of any alternative solutions or features you've considered. **Additional context** Add any other context or screenshots about the feature request here. eemeli-yaml-086fa6b/.github/workflows/000077500000000000000000000000001511277410200177255ustar00rootroot00000000000000eemeli-yaml-086fa6b/.github/workflows/browsers.yml000066400000000000000000000022051511277410200223150ustar00rootroot00000000000000name: Browsers permissions: {} on: - push - workflow_dispatch jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: { submodules: true } - uses: actions/setup-node@v4 with: { node-version: 20 } - uses: browserstack/github-actions/setup-env@master with: username: ${{ secrets.BROWSERSTACK_USERNAME }} access-key: ${{ secrets.BROWSERSTACK_ACCESS_KEY }} project-name: yaml - uses: browserstack/github-actions/setup-local@master with: local-testing: start local-identifier: random - run: npm ci - run: npm run build:browser - name: Playground setup working-directory: ./playground run: npm ci - name: Playground build working-directory: ./playground run: npm run build - run: npx http-server site & working-directory: ./playground - run: npx browserstack-node-sdk jest working-directory: ./playground - uses: browserstack/github-actions/setup-local@master if: always() with: local-testing: stop eemeli-yaml-086fa6b/.github/workflows/codeql-analysis.yml000066400000000000000000000007501511277410200235420ustar00rootroot00000000000000name: CodeQL permissions: security-events: write on: push: branches: [main] pull_request: branches: [main] workflow_dispatch: jobs: analyze: name: Analyze runs-on: ubuntu-latest steps: - name: Checkout repository uses: actions/checkout@v4 - name: Initialize CodeQL uses: github/codeql-action/init@v3 with: { languages: javascript } - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@v3 eemeli-yaml-086fa6b/.github/workflows/deno.yml000066400000000000000000000006751511277410200214050ustar00rootroot00000000000000name: Deno permissions: {} on: pull_request: branches: [main] push: branches: [main] workflow_dispatch: jobs: test: runs-on: ubuntu-latest strategy: matrix: deno-version: [v1.x, v2.x] steps: - uses: actions/checkout@v4 with: { submodules: true } - uses: denoland/setup-deno@v2 with: deno-version: ${{ matrix.deno-version }} - run: deno src/public-api.ts eemeli-yaml-086fa6b/.github/workflows/jsr-publish.yml000066400000000000000000000003631511277410200227140ustar00rootroot00000000000000name: JSR Publish permissions: contents: read id-token: write on: push: tags: - v2.* workflow_dispatch: jobs: publish: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - run: npx jsr publish eemeli-yaml-086fa6b/.github/workflows/nodejs.yml000066400000000000000000000043531511277410200217370ustar00rootroot00000000000000name: Node.js permissions: {} on: pull_request: branches: [main] push: branches: [main] workflow_dispatch: jobs: test: runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest, windows-latest, macos-latest] node-version: [18, 20, latest] steps: - uses: actions/checkout@v4 with: { submodules: true } - uses: actions/setup-node@v4 with: node-version: ${{ matrix.node-version }} - run: npm ci - run: npm test - run: npm run test:dist lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Use Node.js uses: actions/setup-node@v4 with: { node-version: 20 } - run: npm ci - run: npm run lint node-16: runs-on: ubuntu-latest strategy: matrix: node-version: ['16.0.0', '16'] steps: - uses: actions/checkout@v4 with: { submodules: true } - uses: actions/setup-node@v4 with: node-version: ${{ matrix.node-version }} - run: npm ci - run: npm install --no-save rollup@3 - run: npm test - run: npm run test:dist node-14-build: runs-on: ubuntu-latest strategy: matrix: node-version: ['14.18.0'] steps: - uses: actions/checkout@v4 with: { submodules: true } - uses: actions/setup-node@v4 with: node-version: ${{ matrix.node-version }} - run: npm install --global npm@7 - run: npm ci - run: npm install --no-save rollup@2 - run: npm run test:dist - uses: actions/upload-artifact@v4 with: name: yaml-node14 path: dist/ node-14-run: needs: node-14-build runs-on: ubuntu-latest strategy: matrix: node-version: ['14.6.0', '14', '15.0.0'] steps: - uses: actions/checkout@v4 with: { submodules: true } - uses: actions/setup-node@v4 with: node-version: ${{ matrix.node-version }} - run: npm install --global npm@7 - run: npm ci - uses: actions/download-artifact@v4 with: name: yaml-node14 path: dist/ - run: npx jest --config config/jest.config.js env: TEST: dist eemeli-yaml-086fa6b/.github/workflows/typescript.yml000066400000000000000000000017471511277410200226670ustar00rootroot00000000000000name: TypeScript permissions: {} on: pull_request: branches: [main] push: branches: [main] workflow_dispatch: jobs: typescript: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Use Node.js uses: actions/setup-node@v4 with: { node-version: 20 } - run: npm ci - run: npm run build:node - run: npm run test:types - run: npm run test:dist:types - run: npm install --no-save @types/node@14 typescript@4.2 - run: for d in node_modules/@types/*; do [[ $d == *node ]] || rm -r $d; done - run: npm run test:dist:types - run: npm install --no-save @types/node@14 typescript@4.0 - run: for d in node_modules/@types/*; do [[ $d == *node ]] || rm -r $d; done - run: npm run test:dist:types - run: npm install --no-save @types/node@14 typescript@3.9 - run: for d in node_modules/@types/*; do [[ $d == *node ]] || rm -r $d; done - run: npm run test:dist:types eemeli-yaml-086fa6b/.gitignore000066400000000000000000000000461511277410200163200ustar00rootroot00000000000000.* coverage/ dist/ lib/ node_modules/ eemeli-yaml-086fa6b/.gitmodules000066400000000000000000000007031511277410200165050ustar00rootroot00000000000000[submodule "tests/yaml-test-suite"] path = tests/yaml-test-suite url = https://github.com/eemeli/yaml-test-suite.git branch = fixed-data [submodule "docs"] path = docs-slate url = https://github.com/eemeli/yaml-docs.git [submodule "playground"] path = playground url = https://github.com/eemeli/yaml-playground.git [submodule "tests/json-test-suite"] path = tests/json-test-suite url = https://github.com/nst/JSONTestSuite.git branch = main eemeli-yaml-086fa6b/.prettierignore000066400000000000000000000001501511277410200173670ustar00rootroot00000000000000coverage/ dist/ node_modules/ /docs-slate/ /playground/ /tests/json-test-suite/ /tests/yaml-test-suite/ eemeli-yaml-086fa6b/.well-known/000077500000000000000000000000001511277410200165035ustar00rootroot00000000000000eemeli-yaml-086fa6b/.well-known/funding-manifest-urls000066400000000000000000000000401511277410200226410ustar00rootroot00000000000000https://eemeli.org/funding.json eemeli-yaml-086fa6b/LICENSE000066400000000000000000000013421511277410200153350ustar00rootroot00000000000000Copyright Eemeli Aro 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. eemeli-yaml-086fa6b/README.md000066400000000000000000000141721511277410200156140ustar00rootroot00000000000000# YAML `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 ```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 ```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: BrowserStack eemeli-yaml-086fa6b/bin.mjs000077500000000000000000000004661511277410200156240ustar00rootroot00000000000000#!/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 }) eemeli-yaml-086fa6b/browser/000077500000000000000000000000001511277410200160135ustar00rootroot00000000000000eemeli-yaml-086fa6b/browser/index.js000066400000000000000000000002771511277410200174660ustar00rootroot00000000000000// `export * as default from ...` fails on Webpack v4 // https://github.com/eemeli/yaml/issues/228 import * as YAML from './dist/index.js' export default YAML export * from './dist/index.js' eemeli-yaml-086fa6b/browser/package.json000066400000000000000000000000271511277410200203000ustar00rootroot00000000000000{ "type": "module" } eemeli-yaml-086fa6b/config/000077500000000000000000000000001511277410200155755ustar00rootroot00000000000000eemeli-yaml-086fa6b/config/jest.config.js000066400000000000000000000025551511277410200203530ustar00rootroot00000000000000let moduleNameMapper const babel = [ 'babel-jest', { overrides: [ { test: '**/*.ts', plugins: [ ['@babel/plugin-transform-typescript', { allowDeclareFields: true }] ] } ], presets: [['@babel/env', { targets: { node: 'current' } }]] } ] const transform = { '[/\\\\]tests[/\\\\].*\\.(m?js|ts)$': babel } // npm_lifecycle_event is the npm script name. if ( process.env.TEST === 'dist' || process.env.npm_lifecycle_event === 'test:dist' ) { console.log('Testing build output from dist/') moduleNameMapper = { '^yaml$': '/dist/index.js', '^yaml/cli$': '/dist/cli.mjs', '^yaml/util$': '/dist/util.js', '^../src/test-events.ts$': '/dist/test-events.js' } transform['[/\\\\]dist[/\\\\].*\\.mjs$'] = babel } else { process.env.TRACE_LEVEL = 'log' moduleNameMapper = { '^yaml$': '/src/index.ts', '^yaml/cli$': '/src/cli.ts', '^yaml/util$': '/src/util.ts' } transform['[/\\\\]src[/\\\\].*\\.ts$'] = babel } module.exports = { collectCoverageFrom: ['src/**/*.{js,ts}', '!src/**/*.d.ts'], moduleNameMapper, resolver: 'jest-ts-webcompat-resolver', rootDir: '..', testEnvironment: 'node', testMatch: ['**/tests/**/*.{js,ts}'], testPathIgnorePatterns: ['tests/_utils', 'tests/json-test-suite/'], transform } eemeli-yaml-086fa6b/config/rollup.browser-config.mjs000066400000000000000000000021531511277410200225530ustar00rootroot00000000000000import babel from '@rollup/plugin-babel' import replace from '@rollup/plugin-replace' import typescript from '@rollup/plugin-typescript' /** @type {import('rollup').RollupOptions} */ export default { input: { index: 'src/index.ts', util: 'src/util.ts' }, output: { dir: 'browser/dist', format: 'esm', preserveModules: true }, plugins: [ replace({ preventAssignment: true }), babel({ babelHelpers: 'bundled', presets: [['@babel/env', { modules: false }]] }), typescript({ declaration: false, outDir: 'browser/dist' }), { resolveId: source => ['node:buffer', 'node:process'].includes(source) ? source : null, load(id) { switch (id) { case 'node:buffer': return 'export const Buffer = null;' case 'node:process': return ( 'export const emitWarning = null;' + `export const env = { LOG_STREAM: ${!!process.env.LOG_STREAM}, LOG_TOKENS: ${!!process.env.LOG_TOKENS} };` ) } } } ], treeshake: { moduleSideEffects: false, propertyReadSideEffects: false } } eemeli-yaml-086fa6b/config/rollup.node-config.mjs000066400000000000000000000046011511277410200220150ustar00rootroot00000000000000import typescript from '@rollup/plugin-typescript' import * as ts from 'typescript' /** * Drop .ts extension from import & export paths in .d.ts files * to support older TS versions. * * @param {ts.TransformationContext} context */ function fixDeclarationImportPaths(context) { /** @param {ts.SourceFile} source */ return function fixPaths(source) { /** @param {ts.Node} node */ function visitor(node) { if (ts.isStringLiteral(node) && /^\.+\/.*\.ts$/.test(node.text)) { return ts.factory.createStringLiteral(node.text.slice(0, -3), true) } return ts.visitEachChild(node, visitor, context) } return ts.visitNode(source, visitor) } } /** * Strip out TS relative import path rewrite helper from dynamic import() calls * * Required due to * https://github.com/rollup/plugins/issues/1820 * * @param {ts.TransformationContext} context */ function fixDynamicImportRewrite(context) { /** @param {ts.SourceFile} source */ return function fixDynamicImport(source) { /** @param {ts.Node} node */ function visitor(node) { if ( ts.isCallExpression(node) && ts.isIdentifier(node.expression) && String(node.expression.escapedText) === '___rewriteRelativeImportExtension' && node.arguments.length === 1 ) { return node.arguments[0] } return ts.visitEachChild(node, visitor, context) } return ts.visitNode(source, visitor) } } /** * Leave out `node:` prefix as unsupported in Node.js < 14.18 * * @param {string} id */ const fixNodePaths = id => id.startsWith('node:') ? id.substring(5) : undefined export default [ { input: { index: 'src/index.ts', 'test-events': 'src/test-events.ts', util: 'src/util.ts' }, output: { dir: 'dist', format: 'cjs', esModule: false, preserveModules: true, paths: fixNodePaths }, external: ['node:buffer', 'node:process'], plugins: [ typescript({ transformers: { afterDeclarations: [fixDeclarationImportPaths] } }) ], treeshake: { moduleSideEffects: false, propertyReadSideEffects: false } }, { input: 'src/cli.ts', output: { file: 'dist/cli.mjs', paths: fixNodePaths }, external: () => true, plugins: [ typescript({ declaration: false, transformers: { after: [fixDynamicImportRewrite] } }) ] } ] eemeli-yaml-086fa6b/docs-slate/000077500000000000000000000000001511277410200163665ustar00rootroot00000000000000eemeli-yaml-086fa6b/docs/000077500000000000000000000000001511277410200152605ustar00rootroot00000000000000eemeli-yaml-086fa6b/docs/01_intro.md000066400000000000000000000074131511277410200172420ustar00rootroot00000000000000# YAML > To install: ```sh npm install yaml # or deno add jsr:@eemeli/yaml ``` > To use: ```js import { parse, stringify } from 'yaml' // or import YAML from 'yaml' // or const YAML = require('yaml') ``` `yaml` is a definitive library for [YAML](http://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 endpoints or APIs documented here 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 build instructions and contribution guidelines, see [docs/CONTRIBUTING.md](https://github.com/eemeli/yaml/blob/main/docs/CONTRIBUTING.md) in the repo. **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](#parse-amp-stringify), [Documents](#documents), and the underlying [Lexer/Parser/Composer](#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](#content-nodes), and the third lets you get progressively closer to YAML source, if that's your thing. A [command-line tool](#command-line-tool) is also included.

Parse & Stringify

```js import { parse, stringify } from 'yaml' ``` - [`parse(str, reviver?, options?): value`](#yaml-parse) - [`stringify(value, replacer?, options?): string`](#yaml-stringify)

Documents

```js import { Document, isDocument, parseAllDocuments, parseDocument } from 'yaml' ``` - [`Document`](#documents) - [`constructor(value, replacer?, options?)`](#creating-documents) - [`#contents`](#content-nodes) - [`#directives`](#stream-directives) - [`#errors`](#errors) - [`#warnings`](#errors) - [`parseAllDocuments(str, options?): Document[]`](#parsing-documents) - [`parseDocument(str, options?): Document`](#parsing-documents)

Content Nodes

```js import { isAlias, isCollection, isMap, isNode, isPair, isScalar, isSeq, Scalar, visit, visitAsync, YAMLMap, YAMLSeq } from 'yaml' ``` - [`is*(foo): boolean`](#identifying-node-types) - [`new Scalar(value)`](#scalar-values) - [`new YAMLMap()`](#collections) - [`new YAMLSeq()`](#collections) - [`doc.createAlias(node, name?): Alias`](#creating-nodes) - [`doc.createNode(value, options?): Node`](#creating-nodes) - [`doc.createPair(key, value): Pair`](#creating-nodes) - [`visit(node, visitor)`](#finding-and-modifying-nodes) - [`visitAsync(node, visitor)`](#finding-and-modifying-nodes)

Parsing YAML

```js import { Composer, Lexer, Parser } from 'yaml' ``` - [`new Lexer().lex(src)`](#lexer) - [`new Parser(onNewLine?).parse(src)`](#parser) - [`new Composer(options?).compose(tokens)`](#composer) eemeli-yaml-086fa6b/docs/02_parse_stringify.md000066400000000000000000000060131511277410200213130ustar00rootroot00000000000000# Parse & Stringify ```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 ``` At its simplest, you can use `YAML.parse(str)` and `YAML.stringify(value)` just as you'd use `JSON.parse(str)` and `JSON.stringify(value)`. If that's enough for you, everything else in these docs is really just implementation details. ## YAML.parse ```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.parse(str, reviver?, options = {}): any` `str` should be a string with YAML formatting. If defined, the `reviver` function follows the [JSON implementation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Using_the_reviver_parameter). See [Options](#options) for more information on the last argument, an optional configuration object. The returned value will match the type of the root value of the parsed YAML document, so Maps become objects, Sequences arrays, and scalars result in nulls, booleans, numbers and strings. `YAML.parse` may throw on error, and it may log warnings using `console.warn`. It only supports input consisting of a single YAML document; for multi-document support you should use [`YAML.parseAllDocuments`](#parsing-documents). ## YAML.stringify ```js 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 // ` ``` #### `YAML.stringify(value, replacer?, options = {}): string` `value` can be of any type. The returned string will always include `\n` as the last character, as is expected of YAML documents. If defined, the `replacer` array or function follows the [JSON implementation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter). See [Options](#options) for more information on the last argument, an optional configuration object. For JSON compatibility, using a number or a string as the `options` value will set the `indent` option accordingly. As strings in particular may be represented in a number of different styles, the simplest option for the value in question will always be chosen, depending mostly on the presence of escaped or control characters and leading & trailing whitespace. To create a stream of documents, you may call `YAML.stringify` separately for each document's `value`, and concatenate the documents with the string `...\n` as a separator. eemeli-yaml-086fa6b/docs/03_options.md000066400000000000000000000470111511277410200176020ustar00rootroot00000000000000# Options ```js import { parse, stringify } from 'yaml' parse('number: 999') // { number: 999 } parse('number: 999', { intAsBigInt: true }) // { number: 999n } parse('number: 999', { schema: 'failsafe' }) // { number: '999' } ``` The options supported by various `yaml` features are split into various categories, depending on how and where they are used. Options in various categories do not overlap, so it's fine to use a single "bag" of options and pass it to each function or method. ## Parse Options Parse options affect the parsing and composition of a YAML Document from it source. Used by: `parse()`, `parseDocument()`, `parseAllDocuments()`, `new Composer()`, and `new Document()` | Name | Type | Default | Description | | ---------------- | ----------------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | intAsBigInt | `boolean` | `false` | Whether integers should be parsed into [BigInt] rather than `number` values. | | keepSourceTokens | `boolean` | `false` | Include a `srcToken` value on each parsed `Node`, containing the [CST token](#working-with-cst-tokens) that was composed into this node. | | lineCounter | `LineCounter` | | If set, newlines will be tracked, to allow for `lineCounter.linePos(offset)` to provide the `{ line, col }` positions within the input. | | prettyErrors | `boolean` | `true` | Include line/col position in errors, along with an extract of the source string. | | strict | `boolean` | `true` | When parsing, do not ignore errors [required](#silencing-errors-and-warnings) by the YAML 1.2 spec, but caused by unambiguous content. | | stringKeys | `boolean` | `false` | Parse all mapping keys as strings. Treat all non-scalar keys as errors. | | uniqueKeys | `boolean ⎮ (a, b) => boolean` | `true` | Whether key uniqueness is checked, or customised. If set to be a function, it will be passed two parsed nodes and should return a boolean value indicating their equality. | [bigint]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/BigInt ## Document Options Document options are relevant for operations on the `Document` object, which makes them relevant for both conversion directions. Used by: `parse()`, `parseDocument()`, `parseAllDocuments()`, `stringify()`, `new Composer()`, and `new Document()` | Name | Type | Default | Description | | -------- | ------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------ | | logLevel | `'warn' ⎮ 'error' ⎮` `'silent'` | `'warn'` | Control the verbosity of `parse()`. Set to `'error'` to silence warnings, and to `'silent'` to also silence most errors (not recommended). | | version | `'1.1' ⎮ '1.2'` | `'1.2'` | The YAML version used by documents without a `%YAML` directive. | By default, the library will emit warnings as required by the YAML spec during parsing. If you'd like to silence these, set the `logLevel` option to `'error'`. ## Schema Options ```js parse('3') // 3 (Using YAML 1.2 core schema by default) parse('3', { schema: 'failsafe' }) // '3' parse('No') // 'No' parse('No', { schema: 'json' }) // SyntaxError: Unresolved plain scalar "No" parse('No', { schema: 'yaml-1.1' }) // false parse('No', { version: '1.1' }) // false ``` Schema options determine the types of values that the document supports. Aside from defining the language structure, the YAML 1.2 spec defines a number of different _schemas_ that may be used. The default is the [`core`](http://yaml.org/spec/1.2/spec.html#id2804923) schema, which is the most common one. The [`json`](http://yaml.org/spec/1.2/spec.html#id2803231) schema is effectively the minimum schema required to parse JSON; both it and the core schema are supersets of the minimal [`failsafe`](http://yaml.org/spec/1.2/spec.html#id2802346) schema. The `yaml-1.1` schema matches the more liberal [YAML 1.1 types](http://yaml.org/type/) (also used by YAML 1.0), including binary data and timestamps as distinct tags. This schema accepts a greater variance in scalar values (with e.g. `'No'` being parsed as `false` rather than a string value). The `!!value` and `!!yaml` types are not supported. Used by: `parse()`, `parseDocument()`, `parseAllDocuments()`, `stringify()`, `new Composer()`, `new Document()`, and `doc.setSchema()` | Name | Type | Default | Description | | ---------------- | ------------------------------------ | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | compat | `string ⎮ Tag[] ⎮ null` | `null` | When parsing, warn about compatibility issues with the given schema. When stringifying, use scalar styles that are parsed correctly by the `compat` schema as well as the actual schema. | | customTags | `Tag[] ⎮ function` | | Array of [additional tags](#custom-data-types) to include in the schema | | merge | `boolean` | 1.1: `true` 1.2: `false` | Enable support for `<<` merge keys. Default value depends on YAML version. | | resolveKnownTags | `boolean` | `true` | When using the `'core'` schema, support parsing values with these explicit [YAML 1.1 tags]: `!!binary`, `!!omap`, `!!pairs`, `!!set`, `!!timestamp`. By default `true`. | | schema | `string ⎮ Schema` | 1.1: `'yaml-1.1'` 1.2: `'core'` | The base schema to use. Default value depends on YAML version. Built-in support is provided for `'core'`, `'failsafe'`, `'json'`, and `'yaml-1.1'`. If using another string value, `customTags` must be an array of tags. | | sortMapEntries | `boolean ⎮` `(a, b: Pair) => number` | `false` | When stringifying, sort map entries. If `true`, sort by comparing key values using the native less-than `<` operator. | | toStringDefaults | `ToStringOptions` | | Override default values for `toString()` options. | [yaml 1.1 tags]: https://yaml.org/type/ ```js const src = ` source: &base { a: 1, b: 2 } target: <<: *base b: base` const mergeResult = parse(src, { merge: true }) mergeResult.target // { a: 1, b: 'base' } ``` **Merge** keys are a [YAML 1.1 feature](http://yaml.org/type/merge.html) that is not a part of the 1.2 spec. To use a merge key, assign a map or its alias or an array of such as the value of a `<<` key in a mapping. Multiple merge keys may be used on the same map, with earlier values taking precedence over latter ones, in case both define a value for the same key. ## CreateNode Options Used by: `stringify()`, `new Document()`, `doc.createNode()`, and `doc.createPair()` | Name | Type | Default | Description | | --------------------- | --------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | | aliasDuplicateObjects | `boolean` | `true` | During node construction, use anchors and aliases to keep strictly equal non-null objects as equivalent in YAML. | | anchorPrefix | `string` | `'a'` | Default prefix for anchors, resulting in anchors `a1`, `a2`, ... by default. | | flow | `boolean` | `false` | Force the top-level collection node to use flow style. | | keepUndefined | `boolean` | `false` | Keep `undefined` object values when creating mappings and return a Scalar node when stringifying `undefined`. | | tag | `string` | | Specify the top-level collection type, e.g. `'!!omap'`. Note that this requires the corresponding tag to be available in this document's schema. | ## ToJS Options ```js parse('{[1, 2]: many}') // { '[ 1, 2 ]': 'many' } parse('{[1, 2]: many}', { mapAsMap: true }) // Map { [ 1, 2 ] => 'many' } ``` These options influence how the document is transformed into "native" JavaScript representation. Used by: `parse()`, `doc.toJS()` and `node.toJS()` | Name | Type | Default | Description | | ------------- | ------------------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | | mapAsMap | `boolean` | `false` | Use Map rather than Object to represent mappings. | | maxAliasCount | `number` | `100` | Prevent [exponential entity expansion attacks] by limiting data aliasing; set to `-1` to disable checks; `0` disallows all alias nodes. | | onAnchor | `(value: any, count: number) => void` | | Optional callback for each aliased anchor in the document. | | reviver | `(key: any, value: any) => any` | | Optionally apply a [reviver function] to the output, following the JSON specification but with appropriate extensions for handling `Map` and `Set`. | [exponential entity expansion attacks]: https://en.wikipedia.org/wiki/Billion_laughs_attack [reviver function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Using_the_reviver_parameter ## ToString Options ```js stringify( { this: null, that: 'value' }, { defaultStringType: 'QUOTE_SINGLE', nullStr: '~' } ) // 'this': ~ // 'that': 'value' ``` The `doc.toString()` method may be called with additional options to control the resulting YAML string representation of the document. Used by: `stringify()` and `doc.toString()` | Name | Type | Default | Description | | ------------------------------ | ----------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | blockQuote | `boolean ⎮ 'folded' ⎮ 'literal'` | `true` | Use block quote styles for scalar values where applicable. Set to `false` to disable block quotes completely. | | collectionStyle | `'any' ⎮ 'block' ⎮ 'flow'` | `'any'` | Enforce `'block'` or `'flow'` style on maps and sequences. By default, allows each collection to set its own `flow: boolean` property. | | commentString | `(comment: string) => string` | | Output should be valid for the current schema. By default, empty comment lines are left empty, lines consisting of a single space are replaced by `#`, and all other lines are prefixed with a `#`. | | defaultKeyType | `'BLOCK_FOLDED' ⎮ 'BLOCK_LITERAL' ⎮` `'QUOTE_DOUBLE' ⎮ 'QUOTE_SINGLE' ⎮` `'PLAIN' ⎮ null` | `null` | If not `null`, overrides `defaultStringType` for implicit key values. | | defaultStringType | `'BLOCK_FOLDED' ⎮ 'BLOCK_LITERAL' ⎮` `'QUOTE_DOUBLE' ⎮ 'QUOTE_SINGLE' ⎮` `'PLAIN'` | `'PLAIN'` | The default type of string literal used to stringify values. | | directives | `boolean ⎮ null` | `null` | Include directives in the output. If `true`, at least the document-start marker `---` is always included. If `false`, no directives or marker is ever included. If `null`, directives and marker may be included if required. | | doubleQuotedAsJSON | `boolean` | `false` | Restrict double-quoted strings to use JSON-compatible syntax. | | doubleQuotedMinMultiLineLength | `number` | `40` | Minimum length for double-quoted strings to use multiple lines to represent the value instead of escaping newlines. | | falseStr | `string` | `'false'` | String representation for `false` values. | | flowCollectionPadding | `boolean` | `true` | When true, a single space of padding will be added inside the delimiters of non-empty single-line flow collections. | | indent | `number` | `2` | The number of spaces to use when indenting code. Should be a strictly positive integer. | | indentSeq | `boolean` | `true` | Whether block sequences should be indented. | | lineWidth | `number` | `80` | Maximum line width (set to `0` to disable folding). This is a soft limit, as only double-quoted semantics allow for inserting a line break in the middle of a word. | | minContentWidth | `number` | `20` | Minimum line width for highly-indented content (set to `0` to disable). Ignored if greater than lineWidth. | | nullStr | `string` | `'null'` | String representation for `null` values. | | simpleKeys | `boolean` | `false` | Require keys to be scalars and always use implicit rather than explicit notation. | | singleQuote | `boolean ⎮ null` | `null` | Use 'single quote' rather than "double quote" where applicable. Set to `false` to disable single quotes completely. | | trueStr | `string` | `'true'` | String representation for `true` values. | eemeli-yaml-086fa6b/docs/04_documents.md000066400000000000000000000246271511277410200201210ustar00rootroot00000000000000# Documents In order to work with YAML features not directly supported by native JavaScript data types, such as comments, anchors and aliases, `yaml` provides the `Document` API. ## Parsing Documents ```js import fs from 'fs' import { parseAllDocuments, parseDocument } from 'yaml' const file = fs.readFileSync('./file.yml', 'utf8') const doc = parseDocument(file) doc.contents // YAMLMap { // items: // [ Pair { // key: Scalar { value: 'YAML', range: [ 0, 4, 4 ] }, // value: // YAMLSeq { // items: // [ Scalar { // value: 'A human-readable data serialization language', // range: [ 10, 54, 55 ] }, // Scalar { // value: 'https://en.wikipedia.org/wiki/YAML', // range: [ 59, 93, 94 ] } ], // range: [ 8, 94, 94 ] } }, // Pair { // key: Scalar { value: 'yaml', range: [ 94, 98, 98 ] }, // value: // YAMLSeq { // items: // [ Scalar { // value: 'A complete JavaScript implementation', // range: [ 104, 140, 141 ] }, // Scalar { // value: 'https://www.npmjs.com/package/yaml', // range: [ 145, 180, 180 ] } ], // range: [ 102, 180, 180 ] } } ], // range: [ 0, 180, 180 ] } ``` These functions should never throw, provided that `str` is a string and the `options` are valid. Errors and warnings are included in the documents' `errors` and `warnings` arrays. In particular, if `errors` is not empty it's likely that the document's parsed `contents` are not entirely correct. The `contents` of a parsed document will always consist of `Scalar`, `Map`, `Seq` or `null` values. #### `parseDocument(str, options = {}): Document` Parses a single `Document` from the input `str`; used internally by `parse`. Will include an error if `str` contains more than one document. See [Options](#options) for more information on the second parameter.
#### `parseAllDocuments(str, options = {}): Document[]` When parsing YAML, the input string `str` may consist of a stream of documents separated from each other by `...` document end marker lines. `parseAllDocuments` will return an array of `Document` objects that allow these documents to be parsed and manipulated with more control. See [Options](#options) for more information on the second parameter.
## Creating Documents #### `new Document(value, replacer?, options = {})` Creates a new document. If `value` is defined, the document `contents` are initialised with that value, wrapped recursively in appropriate [content nodes](#content-nodes). If `value` is `undefined`, the document's `contents` is initialised as `null`. If defined, a `replacer` may filter or modify the initial document contents, following the same algorithm as the [JSON implementation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter). See [Options](#options) for more information on the last argument. | Member | Type | Description | | ------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | commentBefore | `string?` | A comment at the very beginning of the document. If not empty, separated from the rest of the document by a blank line or the doc-start indicator when stringified. | | comment | `string?` | A comment at the end of the document. If not empty, separated from the rest of the document by a blank line when stringified. | | contents | [`Node`](#content-nodes) `⎮ any` | The document contents. | | directives | [`Directives`](#stream-directives) | Controls for the `%YAML` and `%TAG` directives, as well as the doc-start marker `---`. | | errors | [`Error[]`](#errors) | Errors encountered during parsing. | | schema | `Schema` | The schema used with the document. | | warnings | [`Error[]`](#errors) | Warnings encountered during parsing. | ```js import { Document } from 'yaml' const doc = new Document(['some', 'values', { balloons: 99 }]) doc.commentBefore = ' A commented document' String(doc) // # A commented document // // - some // - values // - balloons: 99 ``` The Document members are all modifiable, though it's unlikely that you'll have reason to change `errors`, `schema` or `warnings`. In particular you may be interested in both reading and writing **`contents`**. Although `parseDocument()` and `parseAllDocuments()` will leave it with `YAMLMap`, `YAMLSeq`, `Scalar` or `null` contents, it can be set to anything. ## Document Methods | Method | Returns | Description | | ------------------------------------------ | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------- | | clone() | `Document` | Create a deep copy of this Document and its contents. Custom Node values that inherit from `Object` still refer to their original instances. | | createAlias(node: Node, name?: string) | `Alias` | Create a new `Alias` node, adding the required anchor for `node`. If `name` is empty, a new anchor name will be generated. | | createNode(value, options?) | `Node` | Recursively wrap any input with appropriate `Node` containers. See [Creating Nodes](#creating-nodes) for more information. | | createPair(key, value, options?) | `Pair` | Recursively wrap `key` and `value` into a `Pair` object. See [Creating Nodes](#creating-nodes) for more information. | | setSchema(version, options?) | `void` | Change the YAML version and schema used by the document. `version` must be either `'1.1'` or `'1.2'`; accepts all Schema options. | | toJS(options?) | `any` | A plain JavaScript representation of the document `contents`. | | toJSON() | `any` | A JSON representation of the document `contents`. | | toString(options?) | `string` | A YAML representation of the document. | ```js const doc = parseDocument('a: 1\nb: [2, 3]\n') doc.get('a') // 1 doc.getIn([]) // YAMLMap { items: [Pair, Pair], ... } doc.hasIn(['b', 0]) // true doc.addIn(['b'], 4) // -> doc.get('b').items.length === 3 doc.deleteIn(['b', 1]) // true doc.getIn(['b', 1]) // 4 ``` In addition to the above, the document object also provides the same **accessor methods** as [collections](#collections), based on the top-level collection: `add`, `delete`, `get`, `has`, and `set`, along with their deeper variants `addIn`, `deleteIn`, `getIn`, `hasIn`, and `setIn`. For the `*In` methods using an empty `path` value (i.e. `null`, `undefined`, or `[]`) will refer to the document's top-level `contents`. #### `Document#toJS()`, `Document#toJSON()` and `Document#toString()` ```js const src = '1969-07-21T02:56:15Z' const doc = parseDocument(src, { customTags: ['timestamp'] }) doc.toJS() // Date { 1969-07-21T02:56:15.000Z } doc.toJSON() // '1969-07-21T02:56:15.000Z' String(doc) // '1969-07-21T02:56:15\n' ``` For a plain JavaScript representation of the document, **`toJS(options = {})`** is your friend. Its output may include `Map` and `Set` collections (e.g. if the `mapAsMap` option is true) and complex scalar values like `Date` for `!!timestamp`, but all YAML nodes will be resolved. See [Options](#options) for more information on the optional parameter. For a representation consisting only of JSON values, use **`toJSON()`**. To stringify a document as YAML, use **`toString(options = {})`**. This will also be called by `String(doc)` (with no options). This method will throw if the `errors` array is not empty. See [Options](#options) for more information on the optional parameter. ## Stream Directives ```js const doc = new Document() doc.directives > { docStart: null, // set true to force the doc-start marker docEnd: false, // set true to force the doc-end marker tags: { '!!': 'tag:yaml.org,2002:' }, // Record yaml: { explicit: false, version: '1.2' } } ``` A YAML document may be preceded by `%YAML` and `%TAG` directives; their state is accessible via the `directives` member of a `Document`. After parsing or other creation, the contents of `doc.directives` are mutable, and will influence the YAML string representation of the document. The contents of `doc.directives.tags` are used both for the `%TAG` directives and when stringifying tags within the document. Each of the handles must start and end with a `!` character; `!` is by default the local tag and `!!` is used for default tags. See the section on [custom tags](#writing-custom-tags) for more on this topic. `doc.contents.yaml` determines if an explicit `%YAML` directive should be included in the output, and what version it should use. If changing the version after the document's creation, you'll probably want to use `doc.setSchema()` as it will also update the schema accordingly. eemeli-yaml-086fa6b/docs/05_content_nodes.md000066400000000000000000000455151511277410200207620ustar00rootroot00000000000000# Content Nodes After parsing, the `contents` value of each `YAML.Document` is the root of an [Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) of nodes representing the document (or `null` for an empty document). Both scalar and collection values may have an `anchor` associated with them; this is rendered in the string representation with a `&` prefix, so e.g. in `foo: &aa bar`, the value `bar` has the anchor `aa`. Anchors are used by [Alias nodes](#alias-nodes) to allow for the same value to be used in multiple places in the document. It is valid to have an anchor associated with a node even if it has no aliases. ## Scalar Values ```js class NodeBase { comment?: string // a comment on or immediately after this commentBefore?: string // a comment before this range?: [number, number, number] // The `[start, value-end, node-end]` character offsets for the part // of the source parsed into this node (undefined if not parsed). // The `value-end` and `node-end` positions are themselves not // included in their respective ranges. spaceBefore?: boolean // a blank line before this node and its commentBefore tag?: string // a fully qualified tag, if required clone(): NodeBase // a copy of this node toJS(doc, options?): any // a plain JS representation of this node toJSON(): any // a plain JSON representation of this node } ``` For scalar values, the `tag` will not be set unless it was explicitly defined in the source document; this also applies for unsupported tags that have been resolved using a fallback tag (string, `YAMLMap`, or `YAMLSeq`). ```js class Scalar extends NodeBase { anchor?: string // an anchor associated with this node format?: 'BIN' | 'HEX' | 'OCT' | 'TIME' | undefined // By default (undefined), numbers use decimal notation. // The YAML 1.2 core schema only supports 'HEX' and 'OCT'. type?: 'BLOCK_FOLDED' | 'BLOCK_LITERAL' | 'PLAIN' | 'QUOTE_DOUBLE' | 'QUOTE_SINGLE' | undefined value: T } ``` A parsed document's contents will have all of its non-object values wrapped in `Scalar` objects, which themselves may be in some hierarchy of `YAMLMap` and `YAMLSeq` collections. However, this is not a requirement for the document's stringification, which is rather tolerant regarding its input values, and will use [`doc.createNode()`](#creating-nodes) when encountering an unwrapped value. When stringifying, the node `type` will be taken into account by `!!str` and `!!binary` values, and ignored by other scalars. On the other hand, `!!int` and `!!float` stringifiers will take `format` into account. ## Collections ```js class Pair { key: K // When parsed, key and value are always value: V // Node or null, but can be set to anything } class Collection extends NodeBase { anchor?: string // an anchor associated with this node flow?: boolean // use flow style when stringifying this schema?: Schema addIn(path: Iterable, value: unknown): void clone(schema?: Schema): NodeBase // a deep copy of this collection deleteIn(path: Iterable): boolean getIn(path: Iterable, keepScalar?: boolean): unknown hasIn(path: Iterable): boolean setIn(path: Iterable, value: unknown): void } class YAMLMap extends Collection { items: Pair[] add(pair: Pair | { key: K; value: V }, overwrite?: boolean): void delete(key: K): boolean get(key: K, keepScalar?: boolean): unknown has(key: K): boolean set(key: K, value: V): void } class YAMLSeq extends Collection { items: T[] add(value: T): void delete(key: number | Scalar): boolean get(key: number | Scalar, keepScalar?: boolean): unknown has(key: number | Scalar): boolean set(key: number | Scalar, value: T): void } ``` Within all YAML documents, two forms of collections are supported: sequential `YAMLSeq` collections and key-value `YAMLMap` collections. The JavaScript representations of these collections both have an `items` array, which may (`YAMLSeq`) or must (`YAMLMap`) consist of `Pair` objects that contain a `key` and a `value` of any type, including `null`. The `items` array of a `YAMLSeq` object may contain values of any type. When stringifying collections, by default block notation will be used. Flow notation will be selected if `flow` is `true`, the collection is within a surrounding flow collection, or if the collection is in an implicit key. The `yaml-1.1` schema includes [additional collections](https://yaml.org/type/index.html) that are based on `YAMLMap` and `YAMLSeq`: `OMap` and `Pairs` are sequences of `Pair` objects (`OMap` requires unique keys & corresponds to the JS Map object), and `Set` is a map of keys with null values that corresponds to the JS Set object. All of the collections provide the following accessor methods: | Method | Returns | Description | | ----------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | add(value), addIn(path, value) | `void` | Adds a value to the collection. For `!!map` and `!!omap` the value must be a Pair instance or a `{ key, value }` object, which may not have a key that already exists in the map. | | delete(key), deleteIn(path) | `boolean` | Removes a value from the collection. Returns `true` if the item was found and removed. | | get(key, [keep]), getIn(path, [keep]) | `any` | Returns value at `key`, or `undefined` if not found. By default unwraps scalar values from their surrounding node; to disable set `keep` to `true` (collections are always returned intact). | | has(key), hasIn(path) | `boolean` | Checks if the collection includes a value with the key `key`. | | set(key, value), setIn(path, value) | `any` | Sets a value in this collection. For `!!set`, `value` needs to be a boolean to add/remove the item from the set. When overwriting a `Scalar` value with a scalar, the original node is retained. | ```js const doc = new YAML.Document({ a: 1, b: [2, 3] }) // { a: 1, b: [ 2, 3 ] } doc.add({ key: 'c', value: 4 }) // { a: 1, b: [ 2, 3 ], c: 4 } doc.addIn(['b'], 5) // { a: 1, b: [ 2, 3, 5 ], c: 4 } doc.set('c', 42) // { a: 1, b: [ 2, 3, 5 ], c: 42 } doc.setIn(['c', 'x']) // Error: Expected YAML collection at c. Remaining path: x doc.delete('c') // { a: 1, b: [ 2, 3, 5 ] } doc.deleteIn(['b', 1]) // { a: 1, b: [ 2, 5 ] } doc.get('a') // 1 doc.get('a', true) // Scalar { value: 1 } doc.getIn(['b', 1]) // 5 doc.has(doc.createNode('a')) // true doc.has('c') // false doc.hasIn(['b', '0']) // true ``` For all of these methods, the keys may be nodes or their wrapped scalar values (i.e. `42` will match `Scalar { value: 42 }`). Keys for `!!seq` should be positive integers, or their string representations. `add()` and `set()` do not automatically call `doc.createNode()` to wrap the value. Each of the methods also has a variant that requires an iterable as the first parameter, and allows fetching or modifying deeper collections. If any intermediate node in `path` is a scalar rather than a collection, an error will be thrown. If any of the intermediate collections is not found: - `getIn` and `hasIn` will return `undefined` or `false` (respectively) - `addIn` and `setIn` will create missing collections; non-negative integer keys will create sequences, all other keys create maps - `deleteIn` will throw an error Note that for `addIn` the path argument points to the collection rather than the item; for maps its `value` should be a `Pair` or an object with `{ key, value }` fields. ## Alias Nodes ```js class Alias extends NodeBase { source: string resolve(doc: Document): Scalar | YAMLMap | YAMLSeq | undefined } const obj = YAML.parse('[ &x { X: 42 }, Y, *x ]') // => [ { X: 42 }, 'Y', { X: 42 } ] obj[2].Z = 13 // => [ { X: 42, Z: 13 }, 'Y', { X: 42, Z: 13 } ] YAML.stringify(obj) // - &a1 // X: 42 // Z: 13 // - Y // - *a1 ``` `Alias` nodes provide a way to include a single node in multiple places in a document; the `source` of an alias node must be a preceding anchor in the document. Circular references are fully supported, and where possible the JS representation of alias nodes will be the actual source object. For ease of use, alias nodes also provide a `resolve(doc)` method to dereference its source node. When nodes are constructed from JS structures (e.g. during `YAML.stringify()`), multiple references to the same object will result in including an autogenerated anchor at its first instance, and alias nodes to that anchor at later references. ## Creating Nodes ```js const doc = new YAML.Document(['some', 'values']) // Document { // contents: // YAMLSeq { // items: // [ Scalar { value: 'some' }, // Scalar { value: 'values' } ] } } const map = doc.createNode({ balloons: 99 }) // YAMLMap { // items: // [ Pair { // key: Scalar { value: 'balloons' }, // value: Scalar { value: 99 } } ] } doc.add(map) doc.get(0, true).comment = ' A commented item' String(doc) // - some # A commented item // - values // - balloons: 99 ``` #### `doc.createNode(value, replacer?, options?): Node` To create a new node, use the `createNode(value, options?)` document method. This will recursively wrap any input with appropriate `Node` containers. Generic JS `Object` values as well as `Map` and its descendants become mappings, while arrays and other iterable objects result in sequences. With `Object`, entries that have an `undefined` value are dropped. If `value` is already a `Node` instance, it will be directly returned. To create a copy of a node, use instead the `node.clone()` method. For collections, the method accepts a single `Schema` argument, which allows overwriting the original's `schema` value. Use a `replacer` to apply a replacer array or function, following the [JSON implementation][replacer]. To force flow styling on a collection, use the `flow: true` option. For all available options, see the [CreateNode Options](#createnode-options) section. [replacer]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter The primary purpose of this method is to enable attaching comments or other metadata to a value, or to otherwise exert more fine-grained control over the stringified output. To that end, you'll need to assign its return value to the `contents` of a document (or somewhere within said contents), as the document's schema is required for YAML string output. If you're not interested in working with such metadata, document `contents` may also include non-`Node` values at any level.

doc.createAlias(node, name?): Alias

```js const alias = doc.createAlias(doc.get(1, true), 'foo') doc.add(alias) String(doc) // - some # A commented item // - &foo values // - balloons: 99 // - *foo ``` Create a new `Alias` node, ensuring that the target `node` has the required anchor. If `node` already has an anchor, `name` is ignored. Otherwise, the `node.anchor` value will be set to `name`, or if an anchor with that name is already present in the document, `name` will be used as a prefix for a new unique anchor. If `name` is undefined, the generated anchor will use 'a' as a prefix. You should make sure to only add alias nodes to the document after the nodes to which they refer, or the document's YAML stringification will fail.

new YAMLMap(), new YAMLSeq(), doc.createPair(key, value): Pair

```js import { Document, YAMLSeq } from 'yaml' const doc = new Document(new YAMLSeq()) doc.contents.items = [ 'some values', 42, { including: 'objects', 3: 'a string' } ] doc.add(doc.createPair(1, 'a number')) doc.toString() // - some values // - 42 // - "3": a string // including: objects // - 1: a number ``` To construct a `YAMLSeq` or `YAMLMap`, use `new Document()` or `doc.createNode()` with array, object or iterable input, or create the collections directly by importing the classes from `yaml`. Once created, normal array operations may be used to modify the `items` array. New `Pair` objects may created either by importing the class from `yaml` and using its `new Pair(key, value)` constructor, or by using the `doc.createPair(key, value, options?)` method. The latter will recursively wrap the `key` and `value` as nodes, and accepts the same options as `doc.createNode()` ## Finding and Modifying Nodes ```js const doc = YAML.parseDocument(` - some values - 42 - "3": a string including: objects - 1: a number `) const obs = doc.getIn([2, 'including'], true) obs.type = 'QUOTE_DOUBLE' YAML.visit(doc, { Pair(_, pair) { if (pair.key && pair.key.value === '3') return YAML.visit.REMOVE }, Scalar(key, node) { if ( key !== 'key' && typeof node.value === 'string' && node.type === 'PLAIN' ) { node.type = 'QUOTE_SINGLE' } } }) String(doc) // - 'some values' // - 42 // - including: "objects" // - 1: 'a number' ``` In general, it's safe to modify nodes manually, e.g. splicing the `items` array of a `YAMLMap` or setting its `flow` value to `true`. For operations on nodes at a known location in the tree, it's probably easiest to use `doc.getIn(path, true)` to access them. For more complex or general operations, a visitor API is provided: #### `YAML.visit(node, visitor): void` Apply a visitor to an AST node or document. Walks through the tree (depth-first) starting from `node`, calling a `visitor` function with three arguments: - `key`: For sequence values and map `Pair`, the node's index in the collection. Within a `Pair`, `'key'` or `'value'`, correspondingly. `null` for the root node. - `node`: The current node. - `path`: The ancestry of the current node. The return value of the visitor may be used to control the traversal: - `undefined` (default): Do nothing and continue - `YAML.visit.SKIP`: Do not visit the children of this node, continue with next sibling - `YAML.visit.BREAK`: Terminate traversal completely - `YAML.visit.REMOVE`: Remove the current node, then continue with the next one - `Node`: Replace the current node, then continue by visiting it - `number`: While iterating the items of a sequence or map, set the index of the next step. This is useful especially if the index of the current node has changed. If `visitor` is a single function, it will be called with all values encountered in the tree, including e.g. `null` values. Alternatively, separate visitor functions may be defined for each `Map`, `Pair`, `Seq`, `Alias` and `Scalar` node. To define the same visitor function for more than one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar) and `Node` (alias, map, seq & scalar) targets. Of all these, only the most specific defined one will be used for each node. #### `YAML.visitAsync(node, visitor): Promise` The same as `visit()`, but allows for visitor functions that return a promise which resolves to one of the above-defined control values. ## Identifying Node Types ```js import { isAlias, isCollection, // map or seq isDocument, isMap, isNode, // alias, scalar, map or seq isPair, isScalar, isSeq } from 'yaml' const doc = new Document({ foo: [13, 42] }) isDocument(doc) === true isNode(doc) === false isMap(doc.contents) === true isNode(doc.contents) === true isPair(doc.contents.items[0]) === true isCollection(doc.get('foo')) === true isScalar(doc.getIn(['foo', 1])) === true ``` #### `isAlias(x: unknown): boolean` #### `isCollection(x: unknown): boolean` #### `isDocument(x: unknown): boolean` #### `isMap(x: unknown): boolean` #### `isNode(x: unknown): boolean` #### `isPair(x: unknown): boolean` #### `isScalar(x: unknown): boolean` #### `isSeq(x: unknown): boolean` To find out what you've got, a family of custom type guard functions is provided. These should be preferred over other methods such as `instanceof` checks, as they'll work even if the nodes have been created by a different instance of the library. Internally, node identification uses property symbols that are set on instances during their construction. ## Comments and Blank Lines ```js const doc = YAML.parseDocument(` # This is YAML. --- it has: - an array - of values `) doc.toJS() // { 'it has': [ 'an array', 'of values' ] } doc.commentBefore // ' This is YAML.' const seq = doc.get('it has') seq.spaceBefore // true seq.items[0].comment = ' item comment' seq.comment = ' collection end comment' doc.toString() // # This is YAML. // // it has: // // - an array # item comment // // - of values // # collection end comment ``` A primary differentiator between this and other YAML libraries is the ability to programmatically handle comments, which according to [the spec](http://yaml.org/spec/1.2/spec.html#id2767100) "must not have any effect on the serialization tree or representation graph. In particular, comments are not associated with a particular node." Similarly to comments, the YAML spec instructs non-content blank lines to be discarded. This library _does_ allow comments and blank lines to be handled programmatically, and does attach them to particular nodes (most often, the following node). Each `Scalar`, `Map`, `Seq` and the `Document` itself has `comment`, `commentBefore` members that may be set to a stringifiable value, and a `spaceBefore` boolean to add an empty line before the comment. The string contents of comments are not processed by the library, except for merging adjacent comment and blank lines together. Document comments will be separated from the rest of the document by a blank line. In the node member values, comment lines terminating with the `#` indicator are represented by a single space, while completely empty lines are represented as empty strings. Scalar block values with "keep" chomping (i.e. with `+` in their header) consider any trailing empty lines to be a part of their content, so the following node's `spaceBefore` or `commentBefore` with leading whitespace is ignored. **Note**: Due to implementation details, the library's comment handling is not completely stable, in particular for trailing comments. When creating, writing, and then reading a YAML file, comments may sometimes be associated with a different node. eemeli-yaml-086fa6b/docs/06_custom_tags.md000066400000000000000000000356111511277410200204450ustar00rootroot00000000000000# Custom Data Types ```js import { parse, parseDocument } from 'yaml' parse('2001-12-15 2:59:43') // '2001-12-15 2:59:43' parse('!!timestamp 2001-12-15 2:59:43') // 2001-12-15T02:59:43.000Z (Date instance) const doc = parseDocument('2001-12-15 2:59:43', { customTags: ['timestamp'] }) doc.contents.value.toDateString() // 'Sat Dec 15 2001' ``` The easiest way to extend a [schema](#data-schemas) is by defining the additional **tags** that you wish to support. To do that, the `customTags` option allows you to provide an array of custom tag objects or tag identifiers. In particular, the built-in tags that are a part of the `core` and `yaml-1.1` schemas may be referred to by their string identifiers. For those tags that are available in both, only the `core` variant is provided as a custom tag. For further customisation, `customTags` may also be a function `(Tag[]) => (Tag[])` that may modify the schema's base tag array. Some additional data types are available separately via the [`yaml-types`](https://github.com/eemeli/yaml-types) package, including support for: - BigInt values - Error objects - Objects with a null prototype - RegExp values - Symbols ## Built-in Custom Tags ```js parse('[ one, true, 42 ]') // [ 'one', true, 42 ] parse('[ one, true, 42 ]', { schema: 'failsafe' }) // [ 'one', 'true', '42' ] parse('[ one, true, 42 ]', { schema: 'failsafe', customTags: ['int'] }) // [ 'one', 'true', 42 ] ``` ### YAML 1.2 Core Schema These tags are a part of the YAML 1.2 [Core Schema](https://yaml.org/spec/1.2/spec.html#id2804923), and may be useful when constructing a parser or stringifier for a more limited set of types, based on the `failsafe` schema. Some of these define a `format` value; this will be added to the parsed nodes and affects the node's stringification. If including more than one custom tag from this set, make sure that the `'float'` and `'int'` tags precede any of the other `!!float` and `!!int` tags. | Identifier | Regular expression | YAML Type | Format | Example values | | ------------ | ------------------------------------------------ | --------- | ------- | --------------- | | `'bool'` | `true⎮True⎮TRUE⎮false⎮False⎮FALSE` | `!!bool` | | `true`, `false` | | `'float'` | `[-+]?(0⎮[1-9][0-9]*)\.[0-9]*` | `!!float` | | `4.2`, `-0.0` | | `'floatExp'` | `[-+]?(0⎮[1-9][0-9]*)(\.[0-9]*)?[eE][-+]?[0-9]+` | `!!float` | `'EXP'` | `4.2e9` | | `'floatNaN'` | `[-+]?(\.inf⎮\.Inf⎮\.INF)⎮\.nan⎮\.NaN⎮\.NAN` | `!!float` | | `-Infinity` | | `'int'` | `[-+]?[0-9]+` | `!!int` | | `42`, `-0` | | `'intHex'` | `0x[0-9a-fA-F]+` | `!!int` | `'HEX'` | `0xff0033` | | `'intOct'` | `0o[0-7]+` | `!!int` | `'OCT'` | `0o127` | | `'null'` | `~⎮null⎮Null⎮NULL` | `!!null` | | `null` | ### YAML 1.1 These tags are a part of the YAML 1.1 [language-independent types](https://yaml.org/type/), but are not a part of any default YAML 1.2 schema. | Identifier | YAML Type | JS Type | Description | | ------------- | ----------------------------------------------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `'binary'` | [`!!binary`](https://yaml.org/type/binary.html) | `Uint8Array` | Binary data, represented in YAML as base64 encoded characters. | | `'floatTime'` | [`!!float`](https://yaml.org/type/float.html) | `Number` | Sexagesimal floating-point number format, e.g. `190:20:30.15`. To stringify with this tag, the node `format` must be `'TIME'`. | | `'intTime'` | [`!!int`](https://yaml.org/type/int.html) | `Number` | Sexagesimal integer number format, e.g. `190:20:30`. To stringify with this tag, the node `format` must be `'TIME'`. | | `'merge'` | [`!!merge`](https://yaml.org/type/merge.html) | `Symbol('<<')` | A `<<` merge key which allows one or more mappings to be merged with the current one. | | `'omap'` | [`!!omap`](https://yaml.org/type/omap.html) | `Map` | Ordered sequence of key: value pairs without duplicates. Using `mapAsMap: true` together with this tag is not recommended, as it makes the parse → stringify loop non-idempotent. | | `'pairs'` | [`!!pairs`](https://yaml.org/type/pairs.html) | `Array` | Ordered sequence of key: value pairs allowing duplicates. To create from JS, use `doc.createNode(array, { tag: '!!pairs' })`. | | `'set'` | [`!!set`](https://yaml.org/type/set.html) | `Set` | Unordered set of non-equal values. | | `'timestamp'` | [`!!timestamp`](https://yaml.org/type/timestamp.html) | `Date` | A point in time, e.g. `2001-12-15T02:59:43`. | ## Writing Custom Tags ```js import { YAMLMap, stringify } from 'yaml' import { stringifyString } from 'yaml/util' const regexp = { identify: value => value instanceof RegExp, tag: '!re', resolve(str) { const match = str.match(/^\/([\s\S]+)\/([gimuy]*)$/) if (!match) throw new Error('Invalid !re value') return new RegExp(match[1], match[2]) } } const sharedSymbol = { identify: value => value?.constructor === Symbol, tag: '!symbol/shared', resolve: str => Symbol.for(str), stringify(item, ctx, onComment, onChompKeep) { const key = Symbol.keyFor(item.value) if (key === undefined) throw new Error('Only shared symbols are supported') return stringifyString({ value: key }, ctx, onComment, onChompKeep) } } class YAMLNullObject extends YAMLMap { tag = '!nullobject' toJSON(_, ctx) { const obj = super.toJSON(_, { ...ctx, mapAsMap: false }, Object) return Object.assign(Object.create(null), obj) } } const nullObject = { tag: '!nullobject', collection: 'map', nodeClass: YAMLNullObject, identify: v => !!(typeof v === 'object' && v && !Object.getPrototypeOf(v)) } // slightly more complicated object type class YAMLError extends YAMLMap { tag = '!error' toJSON(_, ctx) { const { name, message, stack, ...rest } = super.toJSON( _, { ...ctx, mapAsMap: false }, Object ) // craft the appropriate error type const Cls = name === 'EvalError' ? EvalError : name === 'RangeError' ? RangeError : name === 'ReferenceError' ? ReferenceError : name === 'SyntaxError' ? SyntaxError : name === 'TypeError' ? TypeError : name === 'URIError' ? URIError : Error if (Cls.name !== name) { Object.defineProperty(er, 'name', { value: name, enumerable: false, configurable: true }) } Object.defineProperty(er, 'stack', { value: stack, enumerable: false, configurable: true }) return Object.assign(er, rest) } static from(schema, obj, ctx) { const { name, message, stack } = obj // ensure these props remain, even if not enumerable return super.from(schema, { ...obj, name, message, stack }, ctx) } } const error = { tag: '!error', collection: 'map', nodeClass: YAMLError, identify: v => !!(typeof v === 'object' && v && v instanceof Error) } stringify( { regexp: /foo/gi, symbol: Symbol.for('bar'), nullobj: Object.assign(Object.create(null), { a: 1, b: 2 }), error: new Error('This was an error') }, { customTags: [regexp, sharedSymbol, nullObject, error] } ) // regexp: !re /foo/gi // symbol: !symbol/shared bar // nullobj: !nullobject // a: 1 // b: 2 // error: !error // name: Error // message: 'This was an error' // stack: | // at some-file.js:1:3 ``` In YAML-speak, a custom data type is represented by a _tag_. To define your own tag, you need to account for the ways that your data is both parsed and stringified. Furthermore, both of those processes are split into two stages by the intermediate AST node structure. If you wish to implement your own custom tags, the [`!!binary`](https://github.com/eemeli/yaml/blob/main/src/schema/yaml-1.1/binary.ts) and [`!!set`](https://github.com/eemeli/yaml/blob/main/src/schema/yaml-1.1/set.ts) tags as well as the [`yaml-types`](https://github.com/eemeli/yaml-types) package provide relatively cohesive examples to study in addition to the simple examples in the sidebar here. Custom collection types (ie, Maps, Sets, objects, and arrays; anything with child properties that may not be propertly serialized to a scalar value) may provide a `nodeClass` property that extends the [`YAMLMap`](https://github.com/eemeli/yaml/blob/main/src/nodes/YAMLMap.ts) and [`YAMLSeq`](https://github.com/eemeli/yaml/blob/main/src/nodes/YAMLSeq.ts) classes, which will be used for parsing and stringifying objects with the specified tag. ### Parsing Custom Data At the lowest level, the [`Lexer`](#lexer) and [`Parser`](#parser) will take care of turning string input into a concrete syntax tree (CST). In the CST all scalar values are available as strings, and maps & sequences as collections of nodes. Each schema includes a set of default data types, which handle converting at least strings, maps and sequences into their AST nodes. These are considered to have _implicit_ tags, and are autodetected. Custom tags, on the other hand, should almost always define an _explicit_ `tag` with which their value will be prefixed. This may be application-specific local `!tag`, a shorthand `!ns!tag`, or a verbatim `!`. Once identified by matching the `tag`, the `resolve(value, onError): Node | any` function will turn a parsed value into an AST node. `value` may be either a `string`, a `YAMLMap` or a `YAMLSeq`, depending on the node's shape. A custom tag should verify that value is of its expected type. Note that during the CST -> AST composition, the anchors and comments attached to each node are also resolved for each node. This metadata will unfortunately be lost when converting the values to JS objects, so collections should have values that extend one of the existing collection classes. Collections should therefore either fall back to their parent classes' `toJSON()` methods, or define their own in order to allow their contents to be expressed as the appropriate JS object. ### Creating Nodes and Stringifying Custom Data As with parsing, turning input data into its YAML string representation is a two-stage process as the input is first turned into an AST tree before stringifying it. This allows for metadata and comments to be attached to each node, and for e.g. circular references to be resolved. For scalar values, this means just wrapping the value within a `Scalar` class while keeping it unchanged. As values may be wrapped within objects and arrays, `doc.createNode()` uses each tag's `identify(value): boolean` function to detect custom data types. For the same reason, collections need to define their own `createNode(schema, value, ctx): Collection` functions that may recursively construct their equivalent collection class instances. Finally, `stringify(item, ctx, ...): string` defines how your data should be represented as a YAML string, in case the default stringifiers aren't enough. For collections in particular, the default stringifier should be perfectly sufficient. `'yaml/util'` exports `stringifyNumber(item)` and `stringifyString(item, ctx, ...)`, which may be of use for custom scalar data. ### Custom Tag API ```js import { createNode, // (value, tagName, ctx) => Node -- Create a new node createPair, // (key, value, ctx) => Pair -- Create a new pair debug, // (logLevel, ...messages) => void -- Log debug messages to console findPair, // (items, key) => Pair? -- Given a key, find a matching Pair foldFlowLines, // (text, indent, mode, options) => string -- Fold long lines mapTag, // CollectionTag seqTag, // CollectionTag stringTag, // ScalarTag stringifyNumber, // (node) => string stringifyString, // (node, ctx, ...) => string toJS, // (value, arg, ctx) => any -- Recursively convert to plain JS warn // (logLevel, warning) => void -- Emit a warning } from 'yaml/util' ``` To define your own tag, you'll need to define an object comprising of some of the following fields. Those in bold are required: - `createNode(schema, value, ctx): Node` is an optional factory function, used e.g. by collections when wrapping JS objects as AST nodes. - `format: string` If a tag has multiple forms that should be parsed and/or stringified differently, use `format` to identify them. Used by `!!int` and `!!float`. - **`identify(value): boolean`** is used by `doc.createNode()` to detect your data type, e.g. using `typeof` or `instanceof`. Required. - `nodeClass: Node` is the `Node` child class that implements this tag. Required for collections and tags that have overlapping JS representations. - **`resolve(value, onError): Node | any`** turns a parsed value into an AST node; `value` is either a `string`, a `YAMLMap` or a `YAMLSeq`. `onError(msg)` should be called with an error message string when encountering errors, as it'll allow you to still return some value for the node. If returning a non-`Node` value, the output will be wrapped as a `Scalar`. Required. - `stringify(item, ctx, onComment, onChompKeep): string` is an optional function stringifying the `item` AST node in the current context `ctx`. `onComment` and `onChompKeep` are callback functions for a couple of special cases. If your data includes a suitable `.toString()` method, you can probably leave this undefined and use the default stringifier. - **`tag: string`** is the identifier for your data type, with which its stringified form will be prefixed. Should either be a !-prefixed local `!tag`, or a fully qualified `tag:domain,date:foo`. Required. - `test: RegExp` and `default: boolean` allow for values to be stringified without an explicit tag and detected using a regular expression. For most cases, it's unlikely that you'll actually want to use these, even if you first think you do. eemeli-yaml-086fa6b/docs/07_parsing_yaml.md000066400000000000000000000575551511277410200206160ustar00rootroot00000000000000# Parsing YAML ```js import { Composer, CST, Lexer, LineCounter, Parser, } from 'yaml' ``` If you're interested only in the final output, [`parse()`](#yaml-parse) will directly produce native JavaScript If you'd like to retain the comments and other metadata, [`parseDocument()` and `parseAllDocuments()`](#parsing-documents) will produce Document instances that allow for further processing. If you're looking to do something more specific, this section might be for you. Internally, the process of turning a sequence of characters into Documents relies on three stages, each of which is also exposed to external users. First, the [Lexer](#lexer) splits the character stream into lexical tokens, i.e. sequences of characters and control codes. Next, the [Parser](#parser) builds concrete syntax tree representations of each document and directive in the stream. Finally, the [Composer](#composer) builds a more user-friendly and accessible [Document](#documents) representation of each document. Both the Lexer and Parser accept incomplete input, allowing for them and the Composer to be used with e.g. [Node.js streams](https://nodejs.org/api/stream.html) or other systems that handle data in chunks. ## Lexer ```js import { Lexer } from 'yaml' const tokens = new Lexer().lex('foo: bar\nfee:\n [24,"42"]\n') console.dir(Array.from(tokens)) > [ '\x02', '\x1F', 'foo', ':', ' ', '\x1F', 'bar', '\n', '\x1F', 'fee', ':', '\n', ' ', '[', '\x1F', '24', ',', '"42"', ']', '\n' ] ``` #### `new Lexer()` #### `lexer.lex(src: string, incomplete?: boolean): Generator` The API for the lexer is rather minimal, and offers no configuration. If the input stream is chunked, the `lex()` method may be called separately for each chunk if the `incomplete` argument is `true`. At the end of input, `lex()` should be called a final time with `incomplete: false` to ensure that the remaining tokens are emitted. Internally, the lexer operates a state machine that determines how it parses its input. Initially, the lexer is always in the `stream` state. The lexer constructor and its `lex()` method should never throw an error. All tokens are identifiable either by their exact value or their first character. In addition to slices of the input stream, a few control characters are additionally used within the output. | Value | Token | Meaning | | ------------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------ | | `\x02` | doc-mode | Start of a document within the default stream context. | | `\x18` | flow-error-end | Unexpected end of a flow collection, e.g. due to an unindent. Should be considered an error. | | `\x1f` | scalar | The next token after this one is a scalar value, irrespective of its value or first character. | | `\n`, `\r\n` | newline | In certain cases (such as end of input), an empty string may also be emitted; it should also be considered as a newline. | | `---` | doc-start | Explicit marker for the start of a document. Will be preceded by a doc-mode token. | | `...` | doc-end | Explicit marker for the end of a document. | | `-` | seq-item-ind | Block sequence item indicator, separated by whitespace. | | `?` | explicit-key-ind | Explicit block map key indicator, separated by whitespace. | | `:` | map-value-ind | Block map value indicator. | | `{` | flow-map-start | | | `}` | flow-map-end | | | `[` | flow-seq-start | | | `]` | flow-seq-end | | | `,` | comma | Separator between flow collection items. | | `\u{FEFF}` | byte-order-mark | Treated as whitespace in stream & content in a document. | If any of the control characters do show up directly in the input stream, they will be treated normally, and even when bare will be preceded by a SCALAR control token in the output. All remaining tokens are identifiable by their first character: | First char | Token | Meaning | | ---------- | -------------------- | ----------------------------------------------------------------------------------------------------------------- | | ` `, `\t` | space | Only contains space characters if token indicates indentation. Otherwise may contain repeats of either character. | | `#` | comment | Separated from preceding by whitespace. Does not include the trailing newline. | | `%` | directive-line | Only produced in a stream context. | | `*` | alias | | | `&` | anchor | | | `!` | tag | | | `'` | single-quoted-scalar | Should also include `'` as a last character, if input is valid. | | `"` | double-quoted-scalar | Should also include `"` as a last character, if input is valid. | | `⎮`, `>` | block-scalar-header | Expected to be followed by optional whitespace & comment, a newline, and then a scalar value. | ## Parser ```js import { Parser } from 'yaml' for (const token of new Parser().parse('foo: [24,"42"]\n')) console.dir(token, { depth: null }) > { type: 'document', offset: 0, start: [], value: { type: 'block-map', offset: 0, indent: 0, items: [ { start: [], key: { type: 'scalar', offset: 0, indent: 0, source: 'foo' }, sep: [ { type: 'map-value-ind', offset: 3, indent: 0, source: ':' }, { type: 'space', offset: 4, indent: 0, source: ' ' } ], value: { type: 'flow-collection', offset: 5, indent: 0, start: { type: 'flow-seq-start', offset: 5, indent: 0, source: '[' }, items: [ { type: 'scalar', offset: 6, indent: 0, source: '24' }, { type: 'comma', offset: 8, indent: 0, source: ',' }, { type: 'double-quoted-scalar', offset: 9, indent: 0, source: '"42"' } ], end: [ { type: 'flow-seq-end', offset: 13, indent: 0, source: ']' }, { type: 'newline', offset: 14, indent: 0, source: '\n' } ] } } ] } } ``` The parser by default uses an internal Lexer instance, and provides a similarly minimal API for producing a [Concrete Syntax Tree](https://en.wikipedia.org/wiki/Concrete_syntax_tree) representation of the input stream. The tokens emitted by the parser are JavaScript objects, each of which has a `type` value that's one of the following: `directive-line`, `document`, `byte-order-mark`, `space`, `comment`, `newline`. Of these, only `directive-line` and `document` should be considered as content. The parser does not validate its output, trying instead to produce a most YAML-ish representation of any input. It should never throw errors, but may (rarely) include error tokens in its output. To validate a CST, you will need to compose it into a `Document`. If the document contains errors, they will be included in the document's `errors` array, and each error will will contain an `offset` within the source string, which you may then use to find the corresponding node in the CST. #### `new Parser(onNewLine?: (offset: number) => void)` Create a new parser. If defined, `onNewLine` is called separately with the start position of each new line (in `parse()`, including the start of input). #### `parser.parse(source: string, incomplete = false): Generator` Parse `source` as a YAML stream, generating tokens for each directive, document and other structure as it is completely parsed. If `incomplete`, a part of the last line may be left as a buffer for the next call. Errors are not thrown, but are yielded as `{ type: 'error', offset, message }` tokens. #### `parser.next(lexToken: string): Generator` Advance the parser by one lexical token. Used internally by `parser.parse()`; exposed to allow for use with an external lexer. For debug purposes, if the `LOG_TOKENS` env var is true-ish, all lexical tokens will be pretty-printed using `console.log()` as they are being processed. ### CST Nodes For a complete description of CST node interfaces, please consult the [cst.ts source](https://github.com/eemeli/yaml/blob/main/src/parse/cst.ts). Some of the most common node properties include: | Property | Type | Description | | --------------------- | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | | `type` | `string` | The only node property that's always defined. Identifies the node type. May be used as a TS type guard. | | `offset` | `number` | The start index within the source string or character stream. | | `source` | `string` | A raw string representation of the node's value, including all newlines and indentation. | | `indent` | `number` | The indent level of the current line; mostly just for internal use. | | `items` | `Item[]` | The contents of a collection; exact shape depends on the collection type. | | `start`, `sep`, `end` | `SourceToken[]` | Content before, within, and after "actual" values. Includes item and collection indicators, anchors, tags, comments, as well as other things. | Collection items contain some subset of the following properties: | Item property | Type | Description | | ------------- | --------------- | -------------------------------------------------------------------------------------------------------------------------- | | `start` | `SourceToken[]` | Always defined. Content before the actual value. May include comments that are later assigned to the preceding item. | | `key` | `Token ⎮ null` | Set for key/value pairs only, so never used in block sequences. | | `sep` | `SourceToken[]` | Content between the key and the value. If defined, indicates that the `key` logically exists, even if its value is `null`. | | `value` | `Token ⎮ null` | The value. Normally set, but may be left out for e.g. explicit keys with no matching value. | ### Counting Lines ```js import { LineCounter, Parser } from 'yaml' const lineCounter = new LineCounter() const parser = new Parser(lineCounter.addNewLine)) const tokens = parser.parse('foo:\n- 24\n- "42"\n') Array.from(tokens) // forces iteration lineCounter.lineStarts > [ 0, 5, 10, 17 ] lineCounter.linePos(3) > { line: 1, col: 4 } lineCounter.linePos(5) > { line: 2, col: 1 } ``` #### `new LineCounter()` Tracks newlines during parsing in order to provide an efficient API for determining the one-indexed `{ line, col }` position for any offset within the input. #### `lineCounter.addNewLine(offset: number)` Adds the starting index of a new line. Should be called in order, or the internal `lineStarts` array will need to be sorted before calling `linePos()`. Bound to the instance, so may be used directly as a callback. #### `lineCounter.linePos(offset: number): { line: number, col: number }` Performs a binary search and returns the 1-indexed `{ line, col }` position of `offset`. If `line === 0`, `addNewLine` has never been called or `offset` is before the first known newline. ## Composer ```js import { Composer, Parser } from 'yaml' const src = 'foo: bar\nfee: [24, "42"]' const tokens = new Parser().parse(src) const docs = new Composer().compose(tokens) Array.from(docs, doc => doc.toJS()) > [{ foo: 'bar', fee: [24, '42'] }] ``` #### `new Composer(options?: ParseOptions & DocumentOptions & SchemaOptions)` Create a new Document composer. Does not include an internal Parser instance, so an external one will be needed. `options` will be used during composition, and passed to the `new Document` constructor. #### `composer.compose(tokens: Iterable, forceDoc?: boolean, endOffset?: number): Generator` Compose tokens into documents. Convenience wrapper combining calls to `composer.next()` and `composer.end()`. #### `composer.next(token: Token): Generator` Advance the composed by one CST token. #### `composer.end(forceDoc?: boolean, offset?: number): Generator` Always call at end of input to push out any remaining document. If `forceDoc` is true and the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document. `offset` should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly. #### `composer.streamInfo(): { comment, directives, errors, warnings }` Current stream status information. Mostly useful at the end of input for an empty stream. ## Working with CST Tokens ```ts import { CST } from 'yaml' ``` For most use cases, the Document or pure JS interfaces provided by the library are the right tool. Sometimes, though, it's important to keep the original YAML source in as pristine a condition as possible. For those cases, the concrete syntax tree (CST) representation is provided, as it retains every character of the input, including whitespace. #### `CST.createScalarToken(value: string, context): BlockScalar | FlowScalar` Create a new scalar token with the value `value`. Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`, as this function does not support any schema operations and won't check for such conflicts. | Argument | Type | Default | Description | | ------------------- | --------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------- | | value | `string` | | The string representation of the value, which will have its content properly indented. **Required.** | | context.end | `SourceToken[]` | | Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added. | | context.implicitKey | `boolean` | `false` | Being within an implicit key may affect the resolved type of the token's value. | | context.indent | `number` | | The indent level of the token. **Required.** | | context.inFlow | `boolean` | `false` | Is this scalar within a flow collection? This may affect the resolved type of the token's value. | | context.offset | `number` | `-1` | The offset position of the token. | | context.type | `Scalar.Type` | | The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`. | ```js const [doc] = new Parser().parse('foo: "bar" #comment') const item = doc.value.items[0].value > { type: 'double-quoted-scalar', offset: 5, indent: 0, source: '"bar"', end: [ { type: 'space', offset: 10, indent: 0, source: ' ' }, { type: 'comment', offset: 11, indent: 0, source: '#comment' } ] } CST.resolveAsScalar(item) > { value: 'bar', type: 'QUOTE_DOUBLE', comment: 'comment', range: [5, 9, 19] } ``` #### `CST.isCollection(token?: Token): boolean` #### `CST.isScalar(token?: Token): boolean` Custom type guards for detecting CST collections and scalars, in both their block and flow forms. #### `CST.resolveAsScalar(token?: Token, strict = true, onError?: ComposeErrorHandler)` If `token` is a CST flow or block scalar, determine its string value and a few other attributes. Otherwise, return `null`. #### `CST.setScalarValue(token: Token, value: string, context?)` Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have. Best efforts are made to retain any comments previously associated with the `token`, though all contents within a collection's `items` will be overwritten. Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`, as this function does not support any schema operations and won't check for such conflicts. | Argument | Type | Default | Description | | ------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------- | | token | `Token` | | Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key. **Required.** | | value | `string` | | The string representation of the value, which will have its content properly indented. **Required.** | | context.afterKey | `boolean` | `false` | In most cases, values after a key should have an additional level of indentation. | | context.implicitKey | `boolean` | `false` | Being within an implicit key may affect the resolved type of the token's value. | | context.inFlow | `boolean` | `false` | Being within a flow collection may affect the resolved type of the token's value. | | context.type | `Scalar.Type` | | The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`. | ```ts function findScalarAtOffset( cst: CST.Document, offset: number ): CST.FlowScalar | CST.BlockScalar | undefined { let res: CST.FlowScalar | CST.BlockScalar | undefined = undefined CST.visit(cst, ({ key, value }) => { for (const token of [key, value]) if (CST.isScalar(token)) { if (token.offset > offset) return CST.visit.BREAK if ( token.offset == offset || (token.offset < offset && token.offset + token.source.length > offset) ) { res = token return CST.visit.BREAK } } }) return res } ``` #### `CST.stringify(cst: Token | CollectionItem): string` Stringify a CST document, token, or collection item. Fair warning: This applies no validation whatsoever, and simply concatenates the sources in their logical order. #### `CST.visit(cst: CST.Document | CST.CollectionItem, visitor: CSTVisitor)` Apply a visitor to a CST document or item. Effectively, the general-purpose workhorse of navigating the CST. Walks through the tree (depth-first) starting from `cst` as the root, calling a `visitor` function with two arguments when entering each item: - `item`: The current item, which includes the following members: - `start: SourceToken[]` – Source tokens before the key or value, possibly including its anchor or tag. - `key?: Token | null` – Set for pair values. May then be `null`, if the key before the `:` separator is empty. - `sep?: SourceToken[]` – Source tokens between the key and the value, which should include the `:` map value indicator if `value` is set. - `value?: Token` – The value of a sequence item, or of a map pair. - `path`: The steps from the root to the current node, as an array of `['key' | 'value', number]` tuples. The return value of the visitor may be used to control the traversal: - `undefined` (default): Do nothing and continue - `CST.visit.SKIP`: Do not visit the children of this token, continue with next sibling - `CST.visit.BREAK`: Terminate traversal completely - `CST.visit.REMOVE`: Remove the current item, then continue with the next one - `number`: Set the index of the next step. This is useful especially if the index of the current token has changed. - `function`: Define the next visitor for this item. After the original visitor is called on item entry, next visitors are called after handling a non-empty `key` and when exiting the item. ```js const [doc] = new Parser().parse('[ foo, bar, baz ]') CST.visit(doc, (item, path) => { if (!CST.isScalar(item.value)) return const scalar = CST.resolveAsScalar(item.value) if (scalar?.value === 'bar') { const parent = CST.visit.parentCollection(doc, path) const idx = path[path.length - 1][1] const { indent } = item.value parent.items.splice(idx, 0, { start: item.start.slice(), value: CST.createScalarToken('bing', { end: [], indent }) }) return idx + 2 } }) CST.stringify(doc) > '[ foo, bing, bar, baz ]' ``` A couple of utility functions are provided for working with the `path`: - `CST.visit.itemAtPath(cst, path): CST.CollectionItem | undefined` – Find the item at `path` from `cst` as the root. - `CST.visit.parentCollection(cst, path): CST.BlockMap | CST.BlockSequence | CST.FlowCollection` – Get the immediate parent collection of the item at `path` from `cst` as the root. Throws an error if the collection is not found, which should never happen if the item itself exists. eemeli-yaml-086fa6b/docs/08_errors.md000066400000000000000000000171051511277410200174310ustar00rootroot00000000000000# Errors Nearly all errors and warnings produced by the `yaml` parser functions contain the following fields: | Member | Type | Description | | ------- | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- | | code | `string` | An identifier for the error type. | | linePos | `[LinePos, LinePos] ⎮` `undefined` | If `prettyErrors` is enabled and `offset` is known, the one-indexed human-friendly source location `{ line: number, col: number }`. | | name | `'YAMLParseError' ⎮` `'YAMLWarning'` | | | message | `string` | A human-readable description of the error | | pos | `[number, number]` | The position in the source at which this error or warning was encountered. | A `YAMLParseError` is an error encountered while parsing a source as YAML. They are included in the `doc.errors` array. If that array is not empty when constructing a native representation of a document, the first error will be thrown. A `YAMLWarning` is not an error, but a spec-mandated warning about unsupported directives or a fallback resolution being used for a node with an unavailable tag. They are included in the `doc.warnings` array. In rare cases, the library may produce a more generic error. In particular, `TypeError` may occur when parsing invalid input using the `json` schema, and `ReferenceError` when the `maxAliasCount` limit is enountered. To identify errors for special handling, you should primarily use `code` to differentiate them from each other. | Code | Description | | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `ALIAS_PROPS` | Unlike scalars and collections, alias nodes cannot have an anchor or tag associated with it. | | `BAD_ALIAS` | An alias identifier must be a non-empty sequence of valid characters. | | `BAD_COLLECTION_TYPE` | Explicit collection tag used on a collection type it does not support. | | `BAD_DIRECTIVE` | Only the `%YAML` and `%TAG` directives are supported, and they need to follow the specified structure. | | `BAD_DQ_ESCAPE` | Double-quotes strings may include `\` escaped content, but that needs to be valid. | | `BAD_INDENT` | Indentation is important in YAML, and collection items need to all start at the same level. Block scalars are also picky about their leading content. | | `BAD_PROP_ORDER` | Anchors and tags must be placed after the `?`, `:` and `-` indicators. | | `BAD_SCALAR_START` | Plain scalars cannot start with a block scalar indicator, or one of the two reserved characters: `@` and `. To fix, use a block or quoted scalar for the value. | | `BLOCK_AS_IMPLICIT_KEY` | There's probably something wrong with the indentation, or you're trying to parse something like `a: b: c`, where it's not clear what's the key and what's the value. | | `BLOCK_IN_FLOW` | YAML scalars and collections both have block and flow styles. Flow is allowed within block, but not the other way around. | | `DUPLICATE_KEY` | Map keys must be unique. Use the `uniqueKeys` option to disable or customise this check when parsing. | | `IMPOSSIBLE` | This really should not happen. If you encounter this error code, please file a bug. | | `KEY_OVER_1024_CHARS` | Due to legacy reasons, implicit keys must have their following `:` indicator after at most 1k characters. | | `MISSING_CHAR` | Some character or characters are missing here. See the error message for what you need to add. | | `MULTILINE_IMPLICIT_KEY` | Implicit keys need to be on a single line. Does the input include a plain scalar with a `:` followed by whitespace, which is getting parsed as a map key? | | `MULTIPLE_ANCHORS` | A node is only allowed to have one anchor. | | `MULTIPLE_DOCS` | A YAML stream may include multiple documents. If yours does, you'll need to use `parseAllDocuments()` to work with it. | | `MULTIPLE_TAGS` | A node is only allowed to have one tag. | | `NON_STRING_KEY` | With the `stringKeys` option, all mapping keys must be strings | | `TAB_AS_INDENT` | Only spaces are allowed as indentation. | | `TAG_RESOLVE_FAILED` | Something went wrong when resolving a node's tag with the current schema. | | `UNEXPECTED_TOKEN` | A token was encountered in a place where it wasn't expected. | ## Silencing Errors and Warnings Some of the errors encountered during parsing are required by the spec, but are caused by content that may be parsed unambiguously. To ignore these errors, use the `strict: false` option: - `MULTILINE_IMPLICIT_KEY`: Implicit keys of flow sequence pairs need to be on a single line - `KEY_OVER_1024_CHARS`: The : indicator must be at most 1024 chars after the start of an implicit block mapping key For additional control, set the `logLevel` option to `'error'` (default: `'warn'`) to silence all warnings. Setting `logLevel: 'silent'` will ignore parsing errors completely, resulting in output that may well be rather broken. eemeli-yaml-086fa6b/docs/09_cli.md000066400000000000000000000020611511277410200166600ustar00rootroot00000000000000# Command-line Tool ```sh npx yaml valid < file.yaml ``` Available as `npx yaml` or `npm exec yaml`: 
yaml: A command-line YAML processor and inspector

Reads stdin and writes output to stdout and errors & warnings to stderr.

Usage:
  yaml          Process a YAML stream, outputting it as YAML
  yaml cst      Parse the CST of a YAML stream
  yaml lex      Parse the lexical tokens of a YAML stream
  yaml valid    Validate a YAML stream, returning 0 on success

Options:
  --help, -h    Show this message.
  --json, -j    Output JSON.
  --indent 2    Output pretty-printed data, indented by the given number of spaces.
  --merge, -m   Enable support for "<<" merge keys.

Additional options for bare "yaml" command:
  --doc, -d     Output pretty-printed JS Document objects.
  --single, -1  Require the input to consist of a single YAML document.
  --strict, -s  Stop on errors.
  --visit, -v   Apply a visitor to each document (requires a path to import)
  --yaml 1.1    Set the YAML version. (default: 1.2)
eemeli-yaml-086fa6b/docs/10_yaml_syntax.md000066400000000000000000000135751511277410200204650ustar00rootroot00000000000000# YAML Syntax A YAML _schema_ is a combination of a set of tags and a mechanism for resolving non-specific tags, i.e. values that do not have an explicit tag such as `!!int`. The [default schema](#data-schemas) is the `'core'` schema, which is the recommended one for YAML 1.2. For YAML 1.1 documents the default is `'yaml-1.1'`. ## Tags ```js YAML.parse('"42"') // '42' YAML.parse('!!int "42"') // 42 YAML.parse(` %TAG ! tag:example.com,2018:app/ --- !foo 42 `) // YAMLWarning: // The tag tag:example.com,2018:app/foo is unavailable, // falling back to tag:yaml.org,2002:str // '42' ``` The default prefix for YAML tags is `tag:yaml.org,2002:`, for which the shorthand `!!` is used when stringified. Shorthands for other prefixes may also be defined by document-specific directives, e.g. `!e!` or just `!` for `tag:example.com,2018:app/`, but this is not required to use a tag with a different prefix. During parsing, unresolved tags should not result in errors (though they will be noted as `warnings`), with the tagged value being parsed according to the data type that it would have under automatic tag resolution rules. This should not result in any data loss, allowing such tags to be handled by the calling app. In order to have `yaml` provide you with automatic parsing and stringification of non-standard data types, it will need to be configured with a suitable tag object. For more information, see [Custom Tags](#custom-tags). The YAML 1.0 tag specification is [slightly different](#changes-from-yaml-1-0-to-1-1) from that used in later versions, and implements prefixing shorthands rather differently. ## Version Differences This library's parser is based on the 1.2 version of the [YAML spec](http://yaml.org/spec/1.2/spec.html), which is almost completely backwards-compatible with [YAML 1.1](http://yaml.org/spec/1.1/) as well as [YAML 1.0](http://yaml.org/spec/1.0/). Some specific relaxations have been added for backwards compatibility, but if you encounter an issue please [report it](https://github.com/eemeli/yaml/issues). ### Changes from YAML 1.1 to 1.2 ```yaml %YAML 1.1 --- true: Yes octal: 014 sexagesimal: 3:25:45 picture: !!binary | R0lGODlhDAAMAIQAAP//9/X 17unp5WZmZgAAAOfn515eXv Pz7Y6OjuDg4J+fn5OTk6enp 56enmleECcgggoBADs= ``` ```js { true: true, octal: 12, sexagesimal: 12345, picture: Buffer [Uint8Array] [ 71, 73, 70, 56, 57, 97, 12, 0, 12, 0, 132, 0, 0, 255, 255, 247, 245, 245, 238, 233, 233, 229, 102, 102, 102, 0, 0, 0, 231, 231, 231, 94, 94, 94, 243, 243, 237, 142, 142, 142, 224, 224, 224, 159, 159, 159, 147, 147, 147, 167, 167, 167, 158, 158, 158, 105, 94, 16, 39, 32, 130, 10, 1, 0, 59 ] } ``` The most significant difference between YAML 1.1 and YAML 1.2 is the introduction of the core data schema as the recommended default, replacing the YAML 1.1 type library: - Only `true` and `false` strings are parsed as booleans (including `True` and `TRUE`); `y`, `yes`, `on`, and their negative counterparts are parsed as strings. - Underlines `_` cannot be used within numerical values. - Octal values need a `0o` prefix; e.g. `010` is now parsed with the value 10 rather than 8. - The binary and sexagesimal integer formats have been dropped. - The `!!pairs`, `!!omap`, `!!set`, `!!timestamp` and `!!binary` types have been dropped. - The merge `<<` and value `=` special mapping keys have been removed. The other major change has been to make sure that YAML 1.2 is a valid superset of JSON. Additionally there are some minor differences between the parsing rules: - The next-line `\x85`, line-separator `\u2028` and paragraph-separator `\u2029` characters are no longer considered line-break characters. Within scalar values, this means that next-line characters will not be included in the white-space normalisation. Using any of these outside scalar values is likely to result in errors during parsing. For a relatively robust solution, try replacing `\x85` and `\u2028` with `\n` and `\u2029` with `\n\n`. - Tag shorthands can no longer include any of the characters `,[]{}`, but can include `#`. To work around this, either fix your tag names or use verbatim tags. - Anchors can no longer include any of the characters `,[]{}`. - Inside double-quoted strings `\/` is now a valid escape for the `/` character. - Quoted content can include practically all Unicode characters. - Documents in streams are now independent of each other, and no longer inherit preceding document directives if they do not define their own. ### Changes from YAML 1.0 to 1.1 ```text %YAML:1.0 --- date: 2001-01-23 number: !int '123' string: !str 123 pool: !!ball { number: 8 } invoice: !domain.tld,2002/^invoice customers: !seq - !^customer given : Chris family : Dumars ``` The most significant difference between these versions is the complete refactoring of the tag syntax: - The `%TAG` directive has been added, along with the `!foo!` tag prefix shorthand notation. - The `^` character no longer enables tag prefixing. - The private vs. default scoping of `!` and `!!` tag prefixes has been switched around; `!!str` is now a default tag while `!bar` is an application-specific tag. - Verbatim `!` tag notation has been added. - The formal `tag:domain,date/path` format for tag names has been dropped as a requirement. Additionally, the formal description of the language describing the document structure has been completely refactored between these versions, but the described intent has not changed. Other changes include: - A `\` escape has been added for the tab character, in addition to the pre-existing `\t` - The `\^` escape has been removed - Directives now use a blank space `' '` rather than `:` as the separator between the name and its parameter/value. `yaml@1` supports parsing and stringifying YAML 1.0 documents, but does not expand tags using the `^` notation. As there is no indication that _anyone_ is still using YAML 1.0, explicit support has been dropped in `yaml@2`. eemeli-yaml-086fa6b/docs/CONTRIBUTING.md000066400000000000000000000106711511277410200175160ustar00rootroot00000000000000# Contributing to `yaml` The YAML spec is somewhat complicated, and `yaml` tries its best to make it as easy as possible to work with it. The primary goal of this project is to make YAML as safe and pleasant as possible to work with. To that end, the order of priorities is: 1. **Be safe**. Be gracious with bad input, and make dangerous things at least difficult if not impossible. Don't allow resource exhaustion attacks. Reading or writing external files or URLs is rather explicitly left out of the core functionality for security reasons. 2. **Maintain compatibility**. There exists a number of YAML libraries written in and for various languages, based on various versions of the specification. This library currently passes more of the [YAML Test Matrix](https://matrix.yaml.io/) than any other, and it should be kept that way. 3. **Support all YAML features**. Everything that you might want to do with YAML should be possible with `yaml`. In a somewhat perverse way, this means that we need to break the spec a bit in order to allow working with comments. This also means that we want to simultaneously maintain compatibility with multiple versions of the spec, in particular YAML 1.1 and YAML 1.2. 4. **Keep it simple**. Extending the library needs to be done carefully, and keep in mind all of its users. Different applications have different needs and so are provided with different APIs. In particular, custom tags are supported, but aren't part of the built-in schemas. ## Getting Started To start hacking `yaml`, this should get you set up: ```sh git clone https://github.com/eemeli/yaml.git # or your own fork cd yaml git submodule update --init # required by tests; also fetches the docs & playground npm install # npm v7 or later is required npm test # just to be sure ``` ## Repository Directory & File Structure - **`browser/`** - Browser-optimised ES build of the library, which should work in modern browsers. Used automatically by e.g. Webpack & Rollup via the `"browser"` value in `package.json`. - **`config/`** - Some of the build & test configuration files, so they don't pollute the root of the repo. - **`dist/`** - Node-optimised build of the library, which should work in Node.js 10.0 and later without polyfills. - **`docs/`** - Sources for the library's [documentation site](https://eemeli.org/yaml). - **`docs-slate/`** - Compiler for the library's [documentation site](https://eemeli.org/yaml). Maintained as a git submodule to allow merges from its upstream source, [Slate](https://github.com/slatedocs/slate). See its [`README`](./docs-slate/README.md) for installation instructions. Note that the build target is the `gh-pages` branch of _this_ repo. - **`playground/`** - Source files for a browser-based [playground](https://eemeli.org/yaml-playground/) using this library. Also contains the Selenium browser tests for the library. Maintained as a git submodule to allow for easier publication. - **`src/`** - Source files for the library: - **`src/compose/`** - The AST composer. Consumes CST, produces documents while validating its inputs. - **`src/parse/`** - The lexer and CST parser. Does not depend on other parts of the library. - **`src/schema/`** - Implementations of the standard schemas - **`tests/`** - Tests for the library: - **`tests/artifacts/`** - YAML files used by some of the tests - **`tests/doc/`** - Tests for the AST level of the library - **`tests/json-test-suite/`** - Git submodule of the [JSON Test Suite](https://github.com/nst/JSONTestSuite) - **`tests/yaml-test-suite/`** - Git submodule of a custom fork of the [YAML Test Suite](https://github.com/yaml/yaml-test-suite) ## Contributing Code First of all, make sure that all the tests pass, and that you've added test cases covering your changes. Our set of test suites is rather extensive, and is a significant help in making sure no regressions are introduced. Note that the CI environment runs tests in both Node.js and browsers, so using new language features may require polyfilling. If you're intending to contribute to the upstream repo, please make sure that your code style matches the Prettier and ESLint rules. The easiest way to do that is to configure your editor to do that for you, but `lint` and `prettier` npm scripts are also provided. If you use an LLM when writing pull requests, this must be explicitly declared in the pull request. If there is indication of undeclared LLM assistance, the pull request will be declined. eemeli-yaml-086fa6b/docs/README.md000066400000000000000000000020241511277410200165350ustar00rootroot00000000000000## YAML Docs These documentation source files are compiled into [eemeli.org/yaml](https://eemeli.org/yaml) using a [Slate](https://github.com/slatedocs/slate) instance that's a git submodule of this repo at `docs-slate/`. ### How to Preview Changes 1. Modify these source files, noting that sections are defined in `index.html.md` 2. Make sure that the Slate submodule is properly initialised. If you've just cloned the repo, the command you'll want is `git submodule update --init` 3. Note that `docs-slate/source` contains symlinks to this folder, which may need extra configuration to work in Windows environments 4. See [docs-slate/README.md](../docs-slate/README.md) for its install instructions 5. Use `npm run docs` from this repo's root to preview the site at http://localhost:4567 ### How to Publish Changes In addition to the preview steps: 1. Add this repo as the "yaml" remote for the `docs-slate` submodule repo: `git remote add yaml git@github.com:eemeli/yaml.git` 2. Run the `deploy.sh` script from the `docs-slate` folder eemeli-yaml-086fa6b/docs/SECURITY.md000066400000000000000000000007061511277410200170540ustar00rootroot00000000000000# Security Policy Security updates will be provided for the most recent minor v1 and v2 releases of `yaml`. No updates are provided for earlier releases. To report a suspected security vulnerability, please do so on GitHub via this form: https://github.com/eemeli/yaml/security/advisories/new You may expect a response within 48 hours. For extended support or a stronger guarantee, please reach out to the maintainer to discuss a support agreement. eemeli-yaml-086fa6b/docs/index.html.md000066400000000000000000000007601511277410200176570ustar00rootroot00000000000000--- title: YAML toc_footers: - Version 2.x.y (changelog) - github.com/eemeli/yaml - npm install yaml includes: - 01_intro - 02_parse_stringify - 03_options - 04_documents - 05_content_nodes - 06_custom_tags - 07_parsing_yaml - 08_errors - 09_cli - 10_yaml_syntax search: true --- eemeli-yaml-086fa6b/docs/prepare-docs.mjs000077500000000000000000000025651511277410200203720ustar00rootroot00000000000000#!/usr/bin/env node import { lstat, mkdir, readdir, readFile, symlink, rm, writeFile } from 'node:fs/promises' import { resolve } from 'node:path' import { help } from '../dist/cli.mjs' import { parseAllDocuments } from '../dist/index.js' const source = 'docs' const target = 'docs-slate/source' // Update CLI help const cli = resolve(source, '09_cli.md') const docs = await readFile(cli, 'utf-8') const update = docs.replace( /(
).*?(<\/pre>)/s,
  '$1\n' + help + '\n$2'
)
if (update !== docs) await writeFile(cli, update)

// Create symlink for index.html.md
const indexSource = resolve(source, 'index.html.md')
const indexTarget = resolve(target, 'index.html.md')
try {
  const prevIndex = await lstat(indexTarget)
  if (prevIndex.isSymbolicLink()) await rm(indexTarget)
} catch {}
await symlink(indexSource, indexTarget, 'file')

// Create symlinks for included sections
const includesDir = resolve(target, 'includes')
try {
  await mkdir(includesDir)
} catch {
  for (const ent of await readdir(includesDir, { withFileTypes: true })) {
    if (ent.isSymbolicLink()) await rm(resolve(includesDir, ent.name))
  }
}
const [indexDoc] = parseAllDocuments(await readFile(indexSource, 'utf-8'))
for (const { value } of indexDoc.get('includes').items) {
  const name = `${value}.md`
  await symlink(resolve(source, name), resolve(includesDir, name), 'file')
}
eemeli-yaml-086fa6b/eslint.config.mjs000066400000000000000000000051121511277410200176040ustar00rootroot00000000000000import eslint from '@eslint/js'
import prettierConfig from 'eslint-config-prettier/flat'
import typescript from 'typescript-eslint'

export default [
  {
    ignores: [
      'browser/',
      'dist/',
      'docs/',
      'docs-slate/',
      'lib/',
      'package-lock.json',
      'playground/dist/',
      'tests/artifacts/',
      'tests/json-test-suite/',
      'tests/yaml-test-suite/'
    ]
  },
  eslint.configs.recommended,
  ...typescript.configs.recommendedTypeChecked,
  prettierConfig,
  {
    languageOptions: {
      parserOptions: {
        projectService: {
          allowDefaultProject: ['*js', 'config/*js'],
          defaultProject: 'tsconfig.json'
        }
      }
    },

    rules: {
      'array-callback-return': 'error',
      camelcase: 'error',
      eqeqeq: ['error', 'always', { null: 'ignore' }],
      'no-constant-condition': ['error', { checkLoops: false }],
      'no-control-regex': 'off',
      'no-fallthrough': ['error', { commentPattern: 'fallthrough' }],
      'no-implicit-globals': 'error',
      'no-restricted-imports': [
        'error',
        {
          patterns: [
            {
              regex: '^\\..*(?= 14.6"
      },
      "funding": {
        "url": "https://github.com/sponsors/eemeli"
      }
    },
    "node_modules/@babel/code-frame": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-validator-identifier": "^7.27.1",
        "js-tokens": "^4.0.0",
        "picocolors": "^1.1.1"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/compat-data": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.5.tgz",
      "integrity": "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/core": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
      "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@babel/code-frame": "^7.27.1",
        "@babel/generator": "^7.28.5",
        "@babel/helper-compilation-targets": "^7.27.2",
        "@babel/helper-module-transforms": "^7.28.3",
        "@babel/helpers": "^7.28.4",
        "@babel/parser": "^7.28.5",
        "@babel/template": "^7.27.2",
        "@babel/traverse": "^7.28.5",
        "@babel/types": "^7.28.5",
        "@jridgewell/remapping": "^2.3.5",
        "convert-source-map": "^2.0.0",
        "debug": "^4.1.0",
        "gensync": "^1.0.0-beta.2",
        "json5": "^2.2.3",
        "semver": "^6.3.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/babel"
      }
    },
    "node_modules/@babel/generator": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.5.tgz",
      "integrity": "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/parser": "^7.28.5",
        "@babel/types": "^7.28.5",
        "@jridgewell/gen-mapping": "^0.3.12",
        "@jridgewell/trace-mapping": "^0.3.28",
        "jsesc": "^3.0.2"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-annotate-as-pure": {
      "version": "7.27.3",
      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz",
      "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/types": "^7.27.3"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-compilation-targets": {
      "version": "7.27.2",
      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
      "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/compat-data": "^7.27.2",
        "@babel/helper-validator-option": "^7.27.1",
        "browserslist": "^4.24.0",
        "lru-cache": "^5.1.1",
        "semver": "^6.3.1"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-create-class-features-plugin": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.5.tgz",
      "integrity": "sha512-q3WC4JfdODypvxArsJQROfupPBq9+lMwjKq7C33GhbFYJsufD0yd/ziwD+hJucLeWsnFPWZjsU2DNFqBPE7jwQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-annotate-as-pure": "^7.27.3",
        "@babel/helper-member-expression-to-functions": "^7.28.5",
        "@babel/helper-optimise-call-expression": "^7.27.1",
        "@babel/helper-replace-supers": "^7.27.1",
        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
        "@babel/traverse": "^7.28.5",
        "semver": "^6.3.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/helper-create-regexp-features-plugin": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.28.5.tgz",
      "integrity": "sha512-N1EhvLtHzOvj7QQOUCCS3NrPJP8c5W6ZXCHDn7Yialuy1iu4r5EmIYkXlKNqT99Ciw+W0mDqWoR6HWMZlFP3hw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-annotate-as-pure": "^7.27.3",
        "regexpu-core": "^6.3.1",
        "semver": "^6.3.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/helper-define-polyfill-provider": {
      "version": "0.6.5",
      "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.5.tgz",
      "integrity": "sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-compilation-targets": "^7.27.2",
        "@babel/helper-plugin-utils": "^7.27.1",
        "debug": "^4.4.1",
        "lodash.debounce": "^4.0.8",
        "resolve": "^1.22.10"
      },
      "peerDependencies": {
        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
      }
    },
    "node_modules/@babel/helper-globals": {
      "version": "7.28.0",
      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-member-expression-to-functions": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.28.5.tgz",
      "integrity": "sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/traverse": "^7.28.5",
        "@babel/types": "^7.28.5"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-module-imports": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
      "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/traverse": "^7.27.1",
        "@babel/types": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-module-transforms": {
      "version": "7.28.3",
      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz",
      "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-module-imports": "^7.27.1",
        "@babel/helper-validator-identifier": "^7.27.1",
        "@babel/traverse": "^7.28.3"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/helper-optimise-call-expression": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz",
      "integrity": "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/types": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-plugin-utils": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
      "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-remap-async-to-generator": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz",
      "integrity": "sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-annotate-as-pure": "^7.27.1",
        "@babel/helper-wrap-function": "^7.27.1",
        "@babel/traverse": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/helper-replace-supers": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.27.1.tgz",
      "integrity": "sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-member-expression-to-functions": "^7.27.1",
        "@babel/helper-optimise-call-expression": "^7.27.1",
        "@babel/traverse": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/helper-skip-transparent-expression-wrappers": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz",
      "integrity": "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/traverse": "^7.27.1",
        "@babel/types": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-string-parser": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-validator-identifier": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-validator-option": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helper-wrap-function": {
      "version": "7.28.3",
      "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.28.3.tgz",
      "integrity": "sha512-zdf983tNfLZFletc0RRXYrHrucBEg95NIFMkn6K9dbeMYnsgHaSBGcQqdsCSStG2PYwRre0Qc2NNSCXbG+xc6g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/template": "^7.27.2",
        "@babel/traverse": "^7.28.3",
        "@babel/types": "^7.28.2"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/helpers": {
      "version": "7.28.4",
      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz",
      "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/template": "^7.27.2",
        "@babel/types": "^7.28.4"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/parser": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",
      "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/types": "^7.28.5"
      },
      "bin": {
        "parser": "bin/babel-parser.js"
      },
      "engines": {
        "node": ">=6.0.0"
      }
    },
    "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.28.5.tgz",
      "integrity": "sha512-87GDMS3tsmMSi/3bWOte1UblL+YUTFMV8SZPZ2eSEL17s74Cw/l63rR6NmGVKMYW2GYi85nE+/d6Hw5N0bEk2Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/traverse": "^7.28.5"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz",
      "integrity": "sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz",
      "integrity": "sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz",
      "integrity": "sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
        "@babel/plugin-transform-optional-chaining": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.13.0"
      }
    },
    "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": {
      "version": "7.28.3",
      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.3.tgz",
      "integrity": "sha512-b6YTX108evsvE4YgWyQ921ZAFFQm3Bn+CA3+ZXlNVnPhx+UfsVURoPjfGAPCjBgrqo30yX/C2nZGX96DxvR9Iw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/traverse": "^7.28.3"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/plugin-proposal-private-property-in-object": {
      "version": "7.21.0-placeholder-for-preset-env.2",
      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz",
      "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-async-generators": {
      "version": "7.8.4",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz",
      "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.8.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-bigint": {
      "version": "7.8.3",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz",
      "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.8.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-class-properties": {
      "version": "7.12.13",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz",
      "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.12.13"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-class-static-block": {
      "version": "7.14.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz",
      "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.14.5"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-import-assertions": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.27.1.tgz",
      "integrity": "sha512-UT/Jrhw57xg4ILHLFnzFpPDlMbcdEicaAtjPQpbj9wa8T4r5KVWCimHcL/460g8Ht0DMxDyjsLgiWSkVjnwPFg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-import-attributes": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.27.1.tgz",
      "integrity": "sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-import-meta": {
      "version": "7.10.4",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz",
      "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.10.4"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-json-strings": {
      "version": "7.8.3",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz",
      "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.8.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-jsx": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz",
      "integrity": "sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-logical-assignment-operators": {
      "version": "7.10.4",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz",
      "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.10.4"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": {
      "version": "7.8.3",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz",
      "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.8.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-numeric-separator": {
      "version": "7.10.4",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz",
      "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.10.4"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-object-rest-spread": {
      "version": "7.8.3",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz",
      "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.8.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-optional-catch-binding": {
      "version": "7.8.3",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz",
      "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.8.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-optional-chaining": {
      "version": "7.8.3",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz",
      "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.8.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-private-property-in-object": {
      "version": "7.14.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz",
      "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.14.5"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-top-level-await": {
      "version": "7.14.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz",
      "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.14.5"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-typescript": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz",
      "integrity": "sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-syntax-unicode-sets-regex": {
      "version": "7.18.6",
      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz",
      "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-regexp-features-plugin": "^7.18.6",
        "@babel/helper-plugin-utils": "^7.18.6"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/plugin-transform-arrow-functions": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz",
      "integrity": "sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-async-generator-functions": {
      "version": "7.28.0",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.28.0.tgz",
      "integrity": "sha512-BEOdvX4+M765icNPZeidyADIvQ1m1gmunXufXxvRESy/jNNyfovIqUyE7MVgGBjWktCoJlzvFA1To2O4ymIO3Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-remap-async-to-generator": "^7.27.1",
        "@babel/traverse": "^7.28.0"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-async-to-generator": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.27.1.tgz",
      "integrity": "sha512-NREkZsZVJS4xmTr8qzE5y8AfIPqsdQfRuUiLRTEzb7Qii8iFWCyDKaUV2c0rCuh4ljDZ98ALHP/PetiBV2nddA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-module-imports": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-remap-async-to-generator": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-block-scoped-functions": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz",
      "integrity": "sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-block-scoping": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.5.tgz",
      "integrity": "sha512-45DmULpySVvmq9Pj3X9B+62Xe+DJGov27QravQJU1LLcapR6/10i+gYVAucGGJpHBp5mYxIMK4nDAT/QDLr47g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-class-properties": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.27.1.tgz",
      "integrity": "sha512-D0VcalChDMtuRvJIu3U/fwWjf8ZMykz5iZsg77Nuj821vCKI3zCyRLwRdWbsuJ/uRwZhZ002QtCqIkwC/ZkvbA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-class-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-class-static-block": {
      "version": "7.28.3",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.3.tgz",
      "integrity": "sha512-LtPXlBbRoc4Njl/oh1CeD/3jC+atytbnf/UqLoqTDcEYGUPj022+rvfkbDYieUrSj3CaV4yHDByPE+T2HwfsJg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-class-features-plugin": "^7.28.3",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.12.0"
      }
    },
    "node_modules/@babel/plugin-transform-classes": {
      "version": "7.28.4",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.4.tgz",
      "integrity": "sha512-cFOlhIYPBv/iBoc+KS3M6et2XPtbT2HiCRfBXWtfpc9OAyostldxIf9YAYB6ypURBBbx+Qv6nyrLzASfJe+hBA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-annotate-as-pure": "^7.27.3",
        "@babel/helper-compilation-targets": "^7.27.2",
        "@babel/helper-globals": "^7.28.0",
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-replace-supers": "^7.27.1",
        "@babel/traverse": "^7.28.4"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-computed-properties": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.27.1.tgz",
      "integrity": "sha512-lj9PGWvMTVksbWiDT2tW68zGS/cyo4AkZ/QTp0sQT0mjPopCmrSkzxeXkznjqBxzDI6TclZhOJbBmbBLjuOZUw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/template": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-destructuring": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.5.tgz",
      "integrity": "sha512-Kl9Bc6D0zTUcFUvkNuQh4eGXPKKNDOJQXVyyM4ZAQPMveniJdxi8XMJwLo+xSoW3MIq81bD33lcUe9kZpl0MCw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/traverse": "^7.28.5"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-dotall-regex": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.27.1.tgz",
      "integrity": "sha512-gEbkDVGRvjj7+T1ivxrfgygpT7GUd4vmODtYpbs0gZATdkX8/iSnOtZSxiZnsgm1YjTgjI6VKBGSJJevkrclzw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-duplicate-keys": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz",
      "integrity": "sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.27.1.tgz",
      "integrity": "sha512-hkGcueTEzuhB30B3eJCbCYeCaaEQOmQR0AdvzpD4LoN0GXMWzzGSuRrxR2xTnCrvNbVwK9N6/jQ92GSLfiZWoQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/plugin-transform-dynamic-import": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz",
      "integrity": "sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-explicit-resource-management": {
      "version": "7.28.0",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.0.tgz",
      "integrity": "sha512-K8nhUcn3f6iB+P3gwCv/no7OdzOZQcKchW6N389V6PD8NUWKZHzndOd9sPDVbMoBsbmjMqlB4L9fm+fEFNVlwQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/plugin-transform-destructuring": "^7.28.0"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-exponentiation-operator": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.5.tgz",
      "integrity": "sha512-D4WIMaFtwa2NizOp+dnoFjRez/ClKiC2BqqImwKd1X28nqBtZEyCYJ2ozQrrzlxAFrcrjxo39S6khe9RNDlGzw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-export-namespace-from": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz",
      "integrity": "sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-for-of": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz",
      "integrity": "sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-function-name": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz",
      "integrity": "sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-compilation-targets": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/traverse": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-json-strings": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.27.1.tgz",
      "integrity": "sha512-6WVLVJiTjqcQauBhn1LkICsR2H+zm62I3h9faTDKt1qP4jn2o72tSvqMwtGFKGTpojce0gJs+76eZ2uCHRZh0Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-literals": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz",
      "integrity": "sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-logical-assignment-operators": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.5.tgz",
      "integrity": "sha512-axUuqnUTBuXyHGcJEVVh9pORaN6wC5bYfE7FGzPiaWa3syib9m7g+/IT/4VgCOe2Upef43PHzeAvcrVek6QuuA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-member-expression-literals": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz",
      "integrity": "sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-modules-amd": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz",
      "integrity": "sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-module-transforms": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-modules-commonjs": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.27.1.tgz",
      "integrity": "sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-module-transforms": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-modules-systemjs": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.28.5.tgz",
      "integrity": "sha512-vn5Jma98LCOeBy/KpeQhXcV2WZgaRUtjwQmjoBuLNlOmkg0fB5pdvYVeWRYI69wWKwK2cD1QbMiUQnoujWvrew==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-module-transforms": "^7.28.3",
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-validator-identifier": "^7.28.5",
        "@babel/traverse": "^7.28.5"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-modules-umd": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz",
      "integrity": "sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-module-transforms": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-named-capturing-groups-regex": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.27.1.tgz",
      "integrity": "sha512-SstR5JYy8ddZvD6MhV0tM/j16Qds4mIpJTOd1Yu9J9pJjH93bxHECF7pgtc28XvkzTD6Pxcm/0Z73Hvk7kb3Ng==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/plugin-transform-new-target": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz",
      "integrity": "sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-nullish-coalescing-operator": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.27.1.tgz",
      "integrity": "sha512-aGZh6xMo6q9vq1JGcw58lZ1Z0+i0xB2x0XaauNIUXd6O1xXc3RwoWEBlsTQrY4KQ9Jf0s5rgD6SiNkaUdJegTA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-numeric-separator": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.27.1.tgz",
      "integrity": "sha512-fdPKAcujuvEChxDBJ5c+0BTaS6revLV7CJL08e4m3de8qJfNIuCc2nc7XJYOjBoTMJeqSmwXJ0ypE14RCjLwaw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-object-rest-spread": {
      "version": "7.28.4",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.4.tgz",
      "integrity": "sha512-373KA2HQzKhQCYiRVIRr+3MjpCObqzDlyrM6u4I201wL8Mp2wHf7uB8GhDwis03k2ti8Zr65Zyyqs1xOxUF/Ew==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-compilation-targets": "^7.27.2",
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/plugin-transform-destructuring": "^7.28.0",
        "@babel/plugin-transform-parameters": "^7.27.7",
        "@babel/traverse": "^7.28.4"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-object-super": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz",
      "integrity": "sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-replace-supers": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-optional-catch-binding": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.27.1.tgz",
      "integrity": "sha512-txEAEKzYrHEX4xSZN4kJ+OfKXFVSWKB2ZxM9dpcE3wT7smwkNmXo5ORRlVzMVdJbD+Q8ILTgSD7959uj+3Dm3Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-optional-chaining": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.5.tgz",
      "integrity": "sha512-N6fut9IZlPnjPwgiQkXNhb+cT8wQKFlJNqcZkWlcTqkcqx6/kU4ynGmLFoa4LViBSirn05YAwk+sQBbPfxtYzQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-parameters": {
      "version": "7.27.7",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz",
      "integrity": "sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-private-methods": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.27.1.tgz",
      "integrity": "sha512-10FVt+X55AjRAYI9BrdISN9/AQWHqldOeZDUoLyif1Kn05a56xVBXb8ZouL8pZ9jem8QpXaOt8TS7RHUIS+GPA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-class-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-private-property-in-object": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.27.1.tgz",
      "integrity": "sha512-5J+IhqTi1XPa0DXF83jYOaARrX+41gOewWbkPyjMNRDqgOCqdffGh8L3f/Ek5utaEBZExjSAzcyjmV9SSAWObQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-annotate-as-pure": "^7.27.1",
        "@babel/helper-create-class-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-property-literals": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz",
      "integrity": "sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-regenerator": {
      "version": "7.28.4",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.28.4.tgz",
      "integrity": "sha512-+ZEdQlBoRg9m2NnzvEeLgtvBMO4tkFBw5SQIUgLICgTrumLoU7lr+Oghi6km2PFj+dbUt2u1oby2w3BDO9YQnA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-regexp-modifiers": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.27.1.tgz",
      "integrity": "sha512-TtEciroaiODtXvLZv4rmfMhkCv8jx3wgKpL68PuiPh2M4fvz5jhsA7697N1gMvkvr/JTF13DrFYyEbY9U7cVPA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/plugin-transform-reserved-words": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz",
      "integrity": "sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-shorthand-properties": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz",
      "integrity": "sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-spread": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.27.1.tgz",
      "integrity": "sha512-kpb3HUqaILBJcRFVhFUs6Trdd4mkrzcGXss+6/mxUd273PfbWqSDHRzMT2234gIg2QYfAjvXLSquP1xECSg09Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-sticky-regex": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz",
      "integrity": "sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-template-literals": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz",
      "integrity": "sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-typeof-symbol": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz",
      "integrity": "sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-typescript": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.5.tgz",
      "integrity": "sha512-x2Qa+v/CuEoX7Dr31iAfr0IhInrVOWZU/2vJMJ00FOR/2nM0BcBEclpaf9sWCDc+v5e9dMrhSH8/atq/kX7+bA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-annotate-as-pure": "^7.27.3",
        "@babel/helper-create-class-features-plugin": "^7.28.5",
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
        "@babel/plugin-syntax-typescript": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-unicode-escapes": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz",
      "integrity": "sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-unicode-property-regex": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.27.1.tgz",
      "integrity": "sha512-uW20S39PnaTImxp39O5qFlHLS9LJEmANjMG7SxIhap8rCHqu0Ik+tLEPX5DKmHn6CsWQ7j3lix2tFOa5YtL12Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-unicode-regex": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz",
      "integrity": "sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/plugin-transform-unicode-sets-regex": {
      "version": "7.27.1",
      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.27.1.tgz",
      "integrity": "sha512-EtkOujbc4cgvb0mlpQefi4NTPBzhSIevblFevACNLUspmrALgmEBdL/XfnyyITfd8fKBZrZys92zOWcik7j9Tw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
        "@babel/helper-plugin-utils": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/@babel/preset-env": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.28.5.tgz",
      "integrity": "sha512-S36mOoi1Sb6Fz98fBfE+UZSpYw5mJm0NUHtIKrOuNcqeFauy1J6dIvXm2KRVKobOSaGq4t/hBXdN4HGU3wL9Wg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/compat-data": "^7.28.5",
        "@babel/helper-compilation-targets": "^7.27.2",
        "@babel/helper-plugin-utils": "^7.27.1",
        "@babel/helper-validator-option": "^7.27.1",
        "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.28.5",
        "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.27.1",
        "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.27.1",
        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.27.1",
        "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.28.3",
        "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2",
        "@babel/plugin-syntax-import-assertions": "^7.27.1",
        "@babel/plugin-syntax-import-attributes": "^7.27.1",
        "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6",
        "@babel/plugin-transform-arrow-functions": "^7.27.1",
        "@babel/plugin-transform-async-generator-functions": "^7.28.0",
        "@babel/plugin-transform-async-to-generator": "^7.27.1",
        "@babel/plugin-transform-block-scoped-functions": "^7.27.1",
        "@babel/plugin-transform-block-scoping": "^7.28.5",
        "@babel/plugin-transform-class-properties": "^7.27.1",
        "@babel/plugin-transform-class-static-block": "^7.28.3",
        "@babel/plugin-transform-classes": "^7.28.4",
        "@babel/plugin-transform-computed-properties": "^7.27.1",
        "@babel/plugin-transform-destructuring": "^7.28.5",
        "@babel/plugin-transform-dotall-regex": "^7.27.1",
        "@babel/plugin-transform-duplicate-keys": "^7.27.1",
        "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.27.1",
        "@babel/plugin-transform-dynamic-import": "^7.27.1",
        "@babel/plugin-transform-explicit-resource-management": "^7.28.0",
        "@babel/plugin-transform-exponentiation-operator": "^7.28.5",
        "@babel/plugin-transform-export-namespace-from": "^7.27.1",
        "@babel/plugin-transform-for-of": "^7.27.1",
        "@babel/plugin-transform-function-name": "^7.27.1",
        "@babel/plugin-transform-json-strings": "^7.27.1",
        "@babel/plugin-transform-literals": "^7.27.1",
        "@babel/plugin-transform-logical-assignment-operators": "^7.28.5",
        "@babel/plugin-transform-member-expression-literals": "^7.27.1",
        "@babel/plugin-transform-modules-amd": "^7.27.1",
        "@babel/plugin-transform-modules-commonjs": "^7.27.1",
        "@babel/plugin-transform-modules-systemjs": "^7.28.5",
        "@babel/plugin-transform-modules-umd": "^7.27.1",
        "@babel/plugin-transform-named-capturing-groups-regex": "^7.27.1",
        "@babel/plugin-transform-new-target": "^7.27.1",
        "@babel/plugin-transform-nullish-coalescing-operator": "^7.27.1",
        "@babel/plugin-transform-numeric-separator": "^7.27.1",
        "@babel/plugin-transform-object-rest-spread": "^7.28.4",
        "@babel/plugin-transform-object-super": "^7.27.1",
        "@babel/plugin-transform-optional-catch-binding": "^7.27.1",
        "@babel/plugin-transform-optional-chaining": "^7.28.5",
        "@babel/plugin-transform-parameters": "^7.27.7",
        "@babel/plugin-transform-private-methods": "^7.27.1",
        "@babel/plugin-transform-private-property-in-object": "^7.27.1",
        "@babel/plugin-transform-property-literals": "^7.27.1",
        "@babel/plugin-transform-regenerator": "^7.28.4",
        "@babel/plugin-transform-regexp-modifiers": "^7.27.1",
        "@babel/plugin-transform-reserved-words": "^7.27.1",
        "@babel/plugin-transform-shorthand-properties": "^7.27.1",
        "@babel/plugin-transform-spread": "^7.27.1",
        "@babel/plugin-transform-sticky-regex": "^7.27.1",
        "@babel/plugin-transform-template-literals": "^7.27.1",
        "@babel/plugin-transform-typeof-symbol": "^7.27.1",
        "@babel/plugin-transform-unicode-escapes": "^7.27.1",
        "@babel/plugin-transform-unicode-property-regex": "^7.27.1",
        "@babel/plugin-transform-unicode-regex": "^7.27.1",
        "@babel/plugin-transform-unicode-sets-regex": "^7.27.1",
        "@babel/preset-modules": "0.1.6-no-external-plugins",
        "babel-plugin-polyfill-corejs2": "^0.4.14",
        "babel-plugin-polyfill-corejs3": "^0.13.0",
        "babel-plugin-polyfill-regenerator": "^0.6.5",
        "core-js-compat": "^3.43.0",
        "semver": "^6.3.1"
      },
      "engines": {
        "node": ">=6.9.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0"
      }
    },
    "node_modules/@babel/preset-modules": {
      "version": "0.1.6-no-external-plugins",
      "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz",
      "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.0.0",
        "@babel/types": "^7.4.4",
        "esutils": "^2.0.2"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0"
      }
    },
    "node_modules/@babel/template": {
      "version": "7.27.2",
      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
      "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/code-frame": "^7.27.1",
        "@babel/parser": "^7.27.2",
        "@babel/types": "^7.27.1"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/traverse": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.5.tgz",
      "integrity": "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/code-frame": "^7.27.1",
        "@babel/generator": "^7.28.5",
        "@babel/helper-globals": "^7.28.0",
        "@babel/parser": "^7.28.5",
        "@babel/template": "^7.27.2",
        "@babel/types": "^7.28.5",
        "debug": "^4.3.1"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@babel/types": {
      "version": "7.28.5",
      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",
      "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-string-parser": "^7.27.1",
        "@babel/helper-validator-identifier": "^7.28.5"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/@bcoe/v8-coverage": {
      "version": "0.2.3",
      "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz",
      "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@eslint-community/eslint-utils": {
      "version": "4.9.0",
      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz",
      "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "eslint-visitor-keys": "^3.4.3"
      },
      "engines": {
        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
      },
      "funding": {
        "url": "https://opencollective.com/eslint"
      },
      "peerDependencies": {
        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
      }
    },
    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
      "version": "3.4.3",
      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
      "dev": true,
      "license": "Apache-2.0",
      "engines": {
        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
      },
      "funding": {
        "url": "https://opencollective.com/eslint"
      }
    },
    "node_modules/@eslint-community/regexpp": {
      "version": "4.12.2",
      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
      }
    },
    "node_modules/@eslint/config-array": {
      "version": "0.21.1",
      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz",
      "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==",
      "dev": true,
      "license": "Apache-2.0",
      "dependencies": {
        "@eslint/object-schema": "^2.1.7",
        "debug": "^4.3.1",
        "minimatch": "^3.1.2"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      }
    },
    "node_modules/@eslint/config-helpers": {
      "version": "0.4.2",
      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
      "dev": true,
      "license": "Apache-2.0",
      "dependencies": {
        "@eslint/core": "^0.17.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      }
    },
    "node_modules/@eslint/core": {
      "version": "0.17.0",
      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
      "dev": true,
      "license": "Apache-2.0",
      "dependencies": {
        "@types/json-schema": "^7.0.15"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      }
    },
    "node_modules/@eslint/eslintrc": {
      "version": "3.3.3",
      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz",
      "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "ajv": "^6.12.4",
        "debug": "^4.3.2",
        "espree": "^10.0.1",
        "globals": "^14.0.0",
        "ignore": "^5.2.0",
        "import-fresh": "^3.2.1",
        "js-yaml": "^4.1.1",
        "minimatch": "^3.1.2",
        "strip-json-comments": "^3.1.1"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/eslint"
      }
    },
    "node_modules/@eslint/eslintrc/node_modules/argparse": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
      "dev": true,
      "license": "Python-2.0"
    },
    "node_modules/@eslint/eslintrc/node_modules/js-yaml": {
      "version": "4.1.1",
      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "argparse": "^2.0.1"
      },
      "bin": {
        "js-yaml": "bin/js-yaml.js"
      }
    },
    "node_modules/@eslint/js": {
      "version": "9.39.1",
      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.1.tgz",
      "integrity": "sha512-S26Stp4zCy88tH94QbBv3XCuzRQiZ9yXofEILmglYTh/Ug/a9/umqvgFtYBAo3Lp0nsI/5/qH1CCrbdK3AP1Tw==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "url": "https://eslint.org/donate"
      }
    },
    "node_modules/@eslint/object-schema": {
      "version": "2.1.7",
      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
      "dev": true,
      "license": "Apache-2.0",
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      }
    },
    "node_modules/@eslint/plugin-kit": {
      "version": "0.4.1",
      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
      "dev": true,
      "license": "Apache-2.0",
      "dependencies": {
        "@eslint/core": "^0.17.0",
        "levn": "^0.4.1"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      }
    },
    "node_modules/@humanfs/core": {
      "version": "0.19.1",
      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
      "dev": true,
      "license": "Apache-2.0",
      "engines": {
        "node": ">=18.18.0"
      }
    },
    "node_modules/@humanfs/node": {
      "version": "0.16.7",
      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
      "dev": true,
      "license": "Apache-2.0",
      "dependencies": {
        "@humanfs/core": "^0.19.1",
        "@humanwhocodes/retry": "^0.4.0"
      },
      "engines": {
        "node": ">=18.18.0"
      }
    },
    "node_modules/@humanwhocodes/module-importer": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
      "dev": true,
      "license": "Apache-2.0",
      "engines": {
        "node": ">=12.22"
      },
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/nzakas"
      }
    },
    "node_modules/@humanwhocodes/retry": {
      "version": "0.4.3",
      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
      "dev": true,
      "license": "Apache-2.0",
      "engines": {
        "node": ">=18.18"
      },
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/nzakas"
      }
    },
    "node_modules/@istanbuljs/load-nyc-config": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz",
      "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "camelcase": "^5.3.1",
        "find-up": "^4.1.0",
        "get-package-type": "^0.1.0",
        "js-yaml": "^3.13.1",
        "resolve-from": "^5.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/@istanbuljs/schema": {
      "version": "0.1.3",
      "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz",
      "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/@jest/console": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/console/-/console-29.7.0.tgz",
      "integrity": "sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "chalk": "^4.0.0",
        "jest-message-util": "^29.7.0",
        "jest-util": "^29.7.0",
        "slash": "^3.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/core": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/core/-/core-29.7.0.tgz",
      "integrity": "sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/console": "^29.7.0",
        "@jest/reporters": "^29.7.0",
        "@jest/test-result": "^29.7.0",
        "@jest/transform": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "ansi-escapes": "^4.2.1",
        "chalk": "^4.0.0",
        "ci-info": "^3.2.0",
        "exit": "^0.1.2",
        "graceful-fs": "^4.2.9",
        "jest-changed-files": "^29.7.0",
        "jest-config": "^29.7.0",
        "jest-haste-map": "^29.7.0",
        "jest-message-util": "^29.7.0",
        "jest-regex-util": "^29.6.3",
        "jest-resolve": "^29.7.0",
        "jest-resolve-dependencies": "^29.7.0",
        "jest-runner": "^29.7.0",
        "jest-runtime": "^29.7.0",
        "jest-snapshot": "^29.7.0",
        "jest-util": "^29.7.0",
        "jest-validate": "^29.7.0",
        "jest-watcher": "^29.7.0",
        "micromatch": "^4.0.4",
        "pretty-format": "^29.7.0",
        "slash": "^3.0.0",
        "strip-ansi": "^6.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      },
      "peerDependencies": {
        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
      },
      "peerDependenciesMeta": {
        "node-notifier": {
          "optional": true
        }
      }
    },
    "node_modules/@jest/environment": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-29.7.0.tgz",
      "integrity": "sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/fake-timers": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "jest-mock": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/expect": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-29.7.0.tgz",
      "integrity": "sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "expect": "^29.7.0",
        "jest-snapshot": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/expect-utils": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.7.0.tgz",
      "integrity": "sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "jest-get-type": "^29.6.3"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/fake-timers": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-29.7.0.tgz",
      "integrity": "sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/types": "^29.6.3",
        "@sinonjs/fake-timers": "^10.0.2",
        "@types/node": "*",
        "jest-message-util": "^29.7.0",
        "jest-mock": "^29.7.0",
        "jest-util": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/globals": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-29.7.0.tgz",
      "integrity": "sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/environment": "^29.7.0",
        "@jest/expect": "^29.7.0",
        "@jest/types": "^29.6.3",
        "jest-mock": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/reporters": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-29.7.0.tgz",
      "integrity": "sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@bcoe/v8-coverage": "^0.2.3",
        "@jest/console": "^29.7.0",
        "@jest/test-result": "^29.7.0",
        "@jest/transform": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@jridgewell/trace-mapping": "^0.3.18",
        "@types/node": "*",
        "chalk": "^4.0.0",
        "collect-v8-coverage": "^1.0.0",
        "exit": "^0.1.2",
        "glob": "^7.1.3",
        "graceful-fs": "^4.2.9",
        "istanbul-lib-coverage": "^3.0.0",
        "istanbul-lib-instrument": "^6.0.0",
        "istanbul-lib-report": "^3.0.0",
        "istanbul-lib-source-maps": "^4.0.0",
        "istanbul-reports": "^3.1.3",
        "jest-message-util": "^29.7.0",
        "jest-util": "^29.7.0",
        "jest-worker": "^29.7.0",
        "slash": "^3.0.0",
        "string-length": "^4.0.1",
        "strip-ansi": "^6.0.0",
        "v8-to-istanbul": "^9.0.1"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      },
      "peerDependencies": {
        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
      },
      "peerDependenciesMeta": {
        "node-notifier": {
          "optional": true
        }
      }
    },
    "node_modules/@jest/reporters/node_modules/istanbul-lib-instrument": {
      "version": "6.0.3",
      "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.3.tgz",
      "integrity": "sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "@babel/core": "^7.23.9",
        "@babel/parser": "^7.23.9",
        "@istanbuljs/schema": "^0.1.3",
        "istanbul-lib-coverage": "^3.2.0",
        "semver": "^7.5.4"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/@jest/reporters/node_modules/semver": {
      "version": "7.7.3",
      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
      "dev": true,
      "license": "ISC",
      "bin": {
        "semver": "bin/semver.js"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/@jest/schemas": {
      "version": "29.6.3",
      "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz",
      "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@sinclair/typebox": "^0.27.8"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/source-map": {
      "version": "29.6.3",
      "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-29.6.3.tgz",
      "integrity": "sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jridgewell/trace-mapping": "^0.3.18",
        "callsites": "^3.0.0",
        "graceful-fs": "^4.2.9"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/test-result": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-29.7.0.tgz",
      "integrity": "sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/console": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@types/istanbul-lib-coverage": "^2.0.0",
        "collect-v8-coverage": "^1.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/test-sequencer": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-29.7.0.tgz",
      "integrity": "sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/test-result": "^29.7.0",
        "graceful-fs": "^4.2.9",
        "jest-haste-map": "^29.7.0",
        "slash": "^3.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/transform": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-29.7.0.tgz",
      "integrity": "sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/core": "^7.11.6",
        "@jest/types": "^29.6.3",
        "@jridgewell/trace-mapping": "^0.3.18",
        "babel-plugin-istanbul": "^6.1.1",
        "chalk": "^4.0.0",
        "convert-source-map": "^2.0.0",
        "fast-json-stable-stringify": "^2.1.0",
        "graceful-fs": "^4.2.9",
        "jest-haste-map": "^29.7.0",
        "jest-regex-util": "^29.6.3",
        "jest-util": "^29.7.0",
        "micromatch": "^4.0.4",
        "pirates": "^4.0.4",
        "slash": "^3.0.0",
        "write-file-atomic": "^4.0.2"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jest/types": {
      "version": "29.6.3",
      "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz",
      "integrity": "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/schemas": "^29.6.3",
        "@types/istanbul-lib-coverage": "^2.0.0",
        "@types/istanbul-reports": "^3.0.0",
        "@types/node": "*",
        "@types/yargs": "^17.0.8",
        "chalk": "^4.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/@jridgewell/gen-mapping": {
      "version": "0.3.13",
      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jridgewell/sourcemap-codec": "^1.5.0",
        "@jridgewell/trace-mapping": "^0.3.24"
      }
    },
    "node_modules/@jridgewell/remapping": {
      "version": "2.3.5",
      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jridgewell/gen-mapping": "^0.3.5",
        "@jridgewell/trace-mapping": "^0.3.24"
      }
    },
    "node_modules/@jridgewell/resolve-uri": {
      "version": "3.1.2",
      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.0.0"
      }
    },
    "node_modules/@jridgewell/sourcemap-codec": {
      "version": "1.5.5",
      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@jridgewell/trace-mapping": {
      "version": "0.3.31",
      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jridgewell/resolve-uri": "^3.1.0",
        "@jridgewell/sourcemap-codec": "^1.4.14"
      }
    },
    "node_modules/@rollup/plugin-babel": {
      "version": "6.1.0",
      "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-6.1.0.tgz",
      "integrity": "sha512-dFZNuFD2YRcoomP4oYf+DvQNSUA9ih+A3vUqopQx5EdtPGo3WBnQcI/S8pwpz91UsGfL0HsMSOlaMld8HrbubA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-module-imports": "^7.18.6",
        "@rollup/pluginutils": "^5.0.1"
      },
      "engines": {
        "node": ">=14.0.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0",
        "@types/babel__core": "^7.1.9",
        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
      },
      "peerDependenciesMeta": {
        "@types/babel__core": {
          "optional": true
        },
        "rollup": {
          "optional": true
        }
      }
    },
    "node_modules/@rollup/plugin-replace": {
      "version": "6.0.3",
      "resolved": "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-6.0.3.tgz",
      "integrity": "sha512-J4RZarRvQAm5IF0/LwUUg+obsm+xZhYnbMXmXROyoSE1ATJe3oXSb9L5MMppdxP2ylNSjv6zFBwKYjcKMucVfA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@rollup/pluginutils": "^5.0.1",
        "magic-string": "^0.30.3"
      },
      "engines": {
        "node": ">=14.0.0"
      },
      "peerDependencies": {
        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
      },
      "peerDependenciesMeta": {
        "rollup": {
          "optional": true
        }
      }
    },
    "node_modules/@rollup/plugin-typescript": {
      "version": "12.3.0",
      "resolved": "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-12.3.0.tgz",
      "integrity": "sha512-7DP0/p7y3t67+NabT9f8oTBFE6gGkto4SA6Np2oudYmZE/m1dt8RB0SjL1msMxFpLo631qjRCcBlAbq1ml/Big==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@rollup/pluginutils": "^5.1.0",
        "resolve": "^1.22.1"
      },
      "engines": {
        "node": ">=14.0.0"
      },
      "peerDependencies": {
        "rollup": "^2.14.0||^3.0.0||^4.0.0",
        "tslib": "*",
        "typescript": ">=3.7.0"
      },
      "peerDependenciesMeta": {
        "rollup": {
          "optional": true
        },
        "tslib": {
          "optional": true
        }
      }
    },
    "node_modules/@rollup/pluginutils": {
      "version": "5.3.0",
      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.3.0.tgz",
      "integrity": "sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@types/estree": "^1.0.0",
        "estree-walker": "^2.0.2",
        "picomatch": "^4.0.2"
      },
      "engines": {
        "node": ">=14.0.0"
      },
      "peerDependencies": {
        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
      },
      "peerDependenciesMeta": {
        "rollup": {
          "optional": true
        }
      }
    },
    "node_modules/@rollup/rollup-android-arm-eabi": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.53.3.tgz",
      "integrity": "sha512-mRSi+4cBjrRLoaal2PnqH82Wqyb+d3HsPUN/W+WslCXsZsyHa9ZeQQX/pQsZaVIWDkPcpV6jJ+3KLbTbgnwv8w==",
      "cpu": [
        "arm"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "android"
      ]
    },
    "node_modules/@rollup/rollup-android-arm64": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.53.3.tgz",
      "integrity": "sha512-CbDGaMpdE9sh7sCmTrTUyllhrg65t6SwhjlMJsLr+J8YjFuPmCEjbBSx4Z/e4SmDyH3aB5hGaJUP2ltV/vcs4w==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "android"
      ]
    },
    "node_modules/@rollup/rollup-darwin-arm64": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.53.3.tgz",
      "integrity": "sha512-Nr7SlQeqIBpOV6BHHGZgYBuSdanCXuw09hon14MGOLGmXAFYjx1wNvquVPmpZnl0tLjg25dEdr4IQ6GgyToCUA==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "darwin"
      ]
    },
    "node_modules/@rollup/rollup-darwin-x64": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.53.3.tgz",
      "integrity": "sha512-DZ8N4CSNfl965CmPktJ8oBnfYr3F8dTTNBQkRlffnUarJ2ohudQD17sZBa097J8xhQ26AwhHJ5mvUyQW8ddTsQ==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "darwin"
      ]
    },
    "node_modules/@rollup/rollup-freebsd-arm64": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.53.3.tgz",
      "integrity": "sha512-yMTrCrK92aGyi7GuDNtGn2sNW+Gdb4vErx4t3Gv/Tr+1zRb8ax4z8GWVRfr3Jw8zJWvpGHNpss3vVlbF58DZ4w==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "freebsd"
      ]
    },
    "node_modules/@rollup/rollup-freebsd-x64": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.53.3.tgz",
      "integrity": "sha512-lMfF8X7QhdQzseM6XaX0vbno2m3hlyZFhwcndRMw8fbAGUGL3WFMBdK0hbUBIUYcEcMhVLr1SIamDeuLBnXS+Q==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "freebsd"
      ]
    },
    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.53.3.tgz",
      "integrity": "sha512-k9oD15soC/Ln6d2Wv/JOFPzZXIAIFLp6B+i14KhxAfnq76ajt0EhYc5YPeX6W1xJkAdItcVT+JhKl1QZh44/qw==",
      "cpu": [
        "arm"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.53.3.tgz",
      "integrity": "sha512-vTNlKq+N6CK/8UktsrFuc+/7NlEYVxgaEgRXVUVK258Z5ymho29skzW1sutgYjqNnquGwVUObAaxae8rZ6YMhg==",
      "cpu": [
        "arm"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-arm64-gnu": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.53.3.tgz",
      "integrity": "sha512-RGrFLWgMhSxRs/EWJMIFM1O5Mzuz3Xy3/mnxJp/5cVhZ2XoCAxJnmNsEyeMJtpK+wu0FJFWz+QF4mjCA7AUQ3w==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-arm64-musl": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.53.3.tgz",
      "integrity": "sha512-kASyvfBEWYPEwe0Qv4nfu6pNkITLTb32p4yTgzFCocHnJLAHs+9LjUu9ONIhvfT/5lv4YS5muBHyuV84epBo/A==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-loong64-gnu": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.53.3.tgz",
      "integrity": "sha512-JiuKcp2teLJwQ7vkJ95EwESWkNRFJD7TQgYmCnrPtlu50b4XvT5MOmurWNrCj3IFdyjBQ5p9vnrX4JM6I8OE7g==",
      "cpu": [
        "loong64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.53.3.tgz",
      "integrity": "sha512-EoGSa8nd6d3T7zLuqdojxC20oBfNT8nexBbB/rkxgKj5T5vhpAQKKnD+h3UkoMuTyXkP5jTjK/ccNRmQrPNDuw==",
      "cpu": [
        "ppc64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.53.3.tgz",
      "integrity": "sha512-4s+Wped2IHXHPnAEbIB0YWBv7SDohqxobiiPA1FIWZpX+w9o2i4LezzH/NkFUl8LRci/8udci6cLq+jJQlh+0g==",
      "cpu": [
        "riscv64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-riscv64-musl": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.53.3.tgz",
      "integrity": "sha512-68k2g7+0vs2u9CxDt5ktXTngsxOQkSEV/xBbwlqYcUrAVh6P9EgMZvFsnHy4SEiUl46Xf0IObWVbMvPrr2gw8A==",
      "cpu": [
        "riscv64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-s390x-gnu": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.53.3.tgz",
      "integrity": "sha512-VYsFMpULAz87ZW6BVYw3I6sWesGpsP9OPcyKe8ofdg9LHxSbRMd7zrVrr5xi/3kMZtpWL/wC+UIJWJYVX5uTKg==",
      "cpu": [
        "s390x"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-x64-gnu": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.53.3.tgz",
      "integrity": "sha512-3EhFi1FU6YL8HTUJZ51imGJWEX//ajQPfqWLI3BQq4TlvHy4X0MOr5q3D2Zof/ka0d5FNdPwZXm3Yyib/UEd+w==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-linux-x64-musl": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.53.3.tgz",
      "integrity": "sha512-eoROhjcc6HbZCJr+tvVT8X4fW3/5g/WkGvvmwz/88sDtSJzO7r/blvoBDgISDiCjDRZmHpwud7h+6Q9JxFwq1Q==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ]
    },
    "node_modules/@rollup/rollup-openharmony-arm64": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.53.3.tgz",
      "integrity": "sha512-OueLAWgrNSPGAdUdIjSWXw+u/02BRTcnfw9PN41D2vq/JSEPnJnVuBgw18VkN8wcd4fjUs+jFHVM4t9+kBSNLw==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "openharmony"
      ]
    },
    "node_modules/@rollup/rollup-win32-arm64-msvc": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.53.3.tgz",
      "integrity": "sha512-GOFuKpsxR/whszbF/bzydebLiXIHSgsEUp6M0JI8dWvi+fFa1TD6YQa4aSZHtpmh2/uAlj/Dy+nmby3TJ3pkTw==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "win32"
      ]
    },
    "node_modules/@rollup/rollup-win32-ia32-msvc": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.53.3.tgz",
      "integrity": "sha512-iah+THLcBJdpfZ1TstDFbKNznlzoxa8fmnFYK4V67HvmuNYkVdAywJSoteUszvBQ9/HqN2+9AZghbajMsFT+oA==",
      "cpu": [
        "ia32"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "win32"
      ]
    },
    "node_modules/@rollup/rollup-win32-x64-gnu": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.53.3.tgz",
      "integrity": "sha512-J9QDiOIZlZLdcot5NXEepDkstocktoVjkaKUtqzgzpt2yWjGlbYiKyp05rWwk4nypbYUNoFAztEgixoLaSETkg==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "win32"
      ]
    },
    "node_modules/@rollup/rollup-win32-x64-msvc": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.53.3.tgz",
      "integrity": "sha512-UhTd8u31dXadv0MopwGgNOBpUVROFKWVQgAg5N1ESyCz8AuBcMqm4AuTjrwgQKGDfoFuz02EuMRHQIw/frmYKQ==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "win32"
      ]
    },
    "node_modules/@sinclair/typebox": {
      "version": "0.27.8",
      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
      "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@sinonjs/commons": {
      "version": "3.0.1",
      "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-3.0.1.tgz",
      "integrity": "sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "type-detect": "4.0.8"
      }
    },
    "node_modules/@sinonjs/fake-timers": {
      "version": "10.3.0",
      "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz",
      "integrity": "sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "@sinonjs/commons": "^3.0.0"
      }
    },
    "node_modules/@types/babel__core": {
      "version": "7.20.5",
      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@babel/parser": "^7.20.7",
        "@babel/types": "^7.20.7",
        "@types/babel__generator": "*",
        "@types/babel__template": "*",
        "@types/babel__traverse": "*"
      }
    },
    "node_modules/@types/babel__generator": {
      "version": "7.27.0",
      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/types": "^7.0.0"
      }
    },
    "node_modules/@types/babel__template": {
      "version": "7.4.4",
      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/parser": "^7.1.0",
        "@babel/types": "^7.0.0"
      }
    },
    "node_modules/@types/babel__traverse": {
      "version": "7.28.0",
      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/types": "^7.28.2"
      }
    },
    "node_modules/@types/estree": {
      "version": "1.0.8",
      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@types/graceful-fs": {
      "version": "4.1.9",
      "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.9.tgz",
      "integrity": "sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@types/node": "*"
      }
    },
    "node_modules/@types/istanbul-lib-coverage": {
      "version": "2.0.6",
      "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
      "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@types/istanbul-lib-report": {
      "version": "3.0.3",
      "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz",
      "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@types/istanbul-lib-coverage": "*"
      }
    },
    "node_modules/@types/istanbul-reports": {
      "version": "3.0.4",
      "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz",
      "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@types/istanbul-lib-report": "*"
      }
    },
    "node_modules/@types/jest": {
      "version": "29.5.14",
      "resolved": "https://registry.npmjs.org/@types/jest/-/jest-29.5.14.tgz",
      "integrity": "sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "expect": "^29.0.0",
        "pretty-format": "^29.0.0"
      }
    },
    "node_modules/@types/json-schema": {
      "version": "7.0.15",
      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@types/node": {
      "version": "20.19.25",
      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.25.tgz",
      "integrity": "sha512-ZsJzA5thDQMSQO788d7IocwwQbI8B5OPzmqNvpf3NY/+MHDAS759Wo0gd2WQeXYt5AAAQjzcrTVC6SKCuYgoCQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "undici-types": "~6.21.0"
      }
    },
    "node_modules/@types/stack-utils": {
      "version": "2.0.3",
      "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.3.tgz",
      "integrity": "sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@types/yargs": {
      "version": "17.0.35",
      "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.35.tgz",
      "integrity": "sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@types/yargs-parser": "*"
      }
    },
    "node_modules/@types/yargs-parser": {
      "version": "21.0.3",
      "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
      "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@typescript-eslint/eslint-plugin": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.48.0.tgz",
      "integrity": "sha512-XxXP5tL1txl13YFtrECECQYeZjBZad4fyd3cFV4a19LkAY/bIp9fev3US4S5fDVV2JaYFiKAZ/GRTOLer+mbyQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@eslint-community/regexpp": "^4.10.0",
        "@typescript-eslint/scope-manager": "8.48.0",
        "@typescript-eslint/type-utils": "8.48.0",
        "@typescript-eslint/utils": "8.48.0",
        "@typescript-eslint/visitor-keys": "8.48.0",
        "graphemer": "^1.4.0",
        "ignore": "^7.0.0",
        "natural-compare": "^1.4.0",
        "ts-api-utils": "^2.1.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      },
      "peerDependencies": {
        "@typescript-eslint/parser": "^8.48.0",
        "eslint": "^8.57.0 || ^9.0.0",
        "typescript": ">=4.8.4 <6.0.0"
      }
    },
    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
      "version": "7.0.5",
      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">= 4"
      }
    },
    "node_modules/@typescript-eslint/parser": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.48.0.tgz",
      "integrity": "sha512-jCzKdm/QK0Kg4V4IK/oMlRZlY+QOcdjv89U2NgKHZk1CYTj82/RVSx1mV/0gqCVMJ/DA+Zf/S4NBWNF8GQ+eqQ==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@typescript-eslint/scope-manager": "8.48.0",
        "@typescript-eslint/types": "8.48.0",
        "@typescript-eslint/typescript-estree": "8.48.0",
        "@typescript-eslint/visitor-keys": "8.48.0",
        "debug": "^4.3.4"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      },
      "peerDependencies": {
        "eslint": "^8.57.0 || ^9.0.0",
        "typescript": ">=4.8.4 <6.0.0"
      }
    },
    "node_modules/@typescript-eslint/project-service": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.48.0.tgz",
      "integrity": "sha512-Ne4CTZyRh1BecBf84siv42wv5vQvVmgtk8AuiEffKTUo3DrBaGYZueJSxxBZ8fjk/N3DrgChH4TOdIOwOwiqqw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@typescript-eslint/tsconfig-utils": "^8.48.0",
        "@typescript-eslint/types": "^8.48.0",
        "debug": "^4.3.4"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      },
      "peerDependencies": {
        "typescript": ">=4.8.4 <6.0.0"
      }
    },
    "node_modules/@typescript-eslint/scope-manager": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.48.0.tgz",
      "integrity": "sha512-uGSSsbrtJrLduti0Q1Q9+BF1/iFKaxGoQwjWOIVNJv0o6omrdyR8ct37m4xIl5Zzpkp69Kkmvom7QFTtue89YQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@typescript-eslint/types": "8.48.0",
        "@typescript-eslint/visitor-keys": "8.48.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      }
    },
    "node_modules/@typescript-eslint/tsconfig-utils": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.48.0.tgz",
      "integrity": "sha512-WNebjBdFdyu10sR1M4OXTt2OkMd5KWIL+LLfeH9KhgP+jzfDV/LI3eXzwJ1s9+Yc0Kzo2fQCdY/OpdusCMmh6w==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      },
      "peerDependencies": {
        "typescript": ">=4.8.4 <6.0.0"
      }
    },
    "node_modules/@typescript-eslint/type-utils": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.48.0.tgz",
      "integrity": "sha512-zbeVaVqeXhhab6QNEKfK96Xyc7UQuoFWERhEnj3mLVnUWrQnv15cJNseUni7f3g557gm0e46LZ6IJ4NJVOgOpw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@typescript-eslint/types": "8.48.0",
        "@typescript-eslint/typescript-estree": "8.48.0",
        "@typescript-eslint/utils": "8.48.0",
        "debug": "^4.3.4",
        "ts-api-utils": "^2.1.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      },
      "peerDependencies": {
        "eslint": "^8.57.0 || ^9.0.0",
        "typescript": ">=4.8.4 <6.0.0"
      }
    },
    "node_modules/@typescript-eslint/types": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.48.0.tgz",
      "integrity": "sha512-cQMcGQQH7kwKoVswD1xdOytxQR60MWKM1di26xSUtxehaDs/32Zpqsu5WJlXTtTTqyAVK8R7hvsUnIXRS+bjvA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      }
    },
    "node_modules/@typescript-eslint/typescript-estree": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.48.0.tgz",
      "integrity": "sha512-ljHab1CSO4rGrQIAyizUS6UGHHCiAYhbfcIZ1zVJr5nMryxlXMVWS3duFPSKvSUbFPwkXMFk1k0EMIjub4sRRQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@typescript-eslint/project-service": "8.48.0",
        "@typescript-eslint/tsconfig-utils": "8.48.0",
        "@typescript-eslint/types": "8.48.0",
        "@typescript-eslint/visitor-keys": "8.48.0",
        "debug": "^4.3.4",
        "minimatch": "^9.0.4",
        "semver": "^7.6.0",
        "tinyglobby": "^0.2.15",
        "ts-api-utils": "^2.1.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      },
      "peerDependencies": {
        "typescript": ">=4.8.4 <6.0.0"
      }
    },
    "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "balanced-match": "^1.0.0"
      }
    },
    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
      "version": "9.0.5",
      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "brace-expansion": "^2.0.1"
      },
      "engines": {
        "node": ">=16 || 14 >=14.17"
      },
      "funding": {
        "url": "https://github.com/sponsors/isaacs"
      }
    },
    "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": {
      "version": "7.7.3",
      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
      "dev": true,
      "license": "ISC",
      "bin": {
        "semver": "bin/semver.js"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/@typescript-eslint/utils": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.48.0.tgz",
      "integrity": "sha512-yTJO1XuGxCsSfIVt1+1UrLHtue8xz16V8apzPYI06W0HbEbEWHxHXgZaAgavIkoh+GeV6hKKd5jm0sS6OYxWXQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@eslint-community/eslint-utils": "^4.7.0",
        "@typescript-eslint/scope-manager": "8.48.0",
        "@typescript-eslint/types": "8.48.0",
        "@typescript-eslint/typescript-estree": "8.48.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      },
      "peerDependencies": {
        "eslint": "^8.57.0 || ^9.0.0",
        "typescript": ">=4.8.4 <6.0.0"
      }
    },
    "node_modules/@typescript-eslint/visitor-keys": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.48.0.tgz",
      "integrity": "sha512-T0XJMaRPOH3+LBbAfzR2jalckP1MSG/L9eUtY0DEzUyVaXJ/t6zN0nR7co5kz0Jko/nkSYCBRkz1djvjajVTTg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@typescript-eslint/types": "8.48.0",
        "eslint-visitor-keys": "^4.2.1"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      }
    },
    "node_modules/acorn": {
      "version": "8.15.0",
      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "bin": {
        "acorn": "bin/acorn"
      },
      "engines": {
        "node": ">=0.4.0"
      }
    },
    "node_modules/acorn-jsx": {
      "version": "5.3.2",
      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
      "dev": true,
      "license": "MIT",
      "peerDependencies": {
        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
      }
    },
    "node_modules/ajv": {
      "version": "6.12.6",
      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "fast-deep-equal": "^3.1.1",
        "fast-json-stable-stringify": "^2.0.0",
        "json-schema-traverse": "^0.4.1",
        "uri-js": "^4.2.2"
      },
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/epoberezkin"
      }
    },
    "node_modules/ansi-escapes": {
      "version": "4.3.2",
      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "type-fest": "^0.21.3"
      },
      "engines": {
        "node": ">=8"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/ansi-regex": {
      "version": "5.0.1",
      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/ansi-styles": {
      "version": "4.3.0",
      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "color-convert": "^2.0.1"
      },
      "engines": {
        "node": ">=8"
      },
      "funding": {
        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
      }
    },
    "node_modules/anymatch": {
      "version": "3.1.3",
      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "normalize-path": "^3.0.0",
        "picomatch": "^2.0.4"
      },
      "engines": {
        "node": ">= 8"
      }
    },
    "node_modules/anymatch/node_modules/picomatch": {
      "version": "2.3.1",
      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8.6"
      },
      "funding": {
        "url": "https://github.com/sponsors/jonschlinkert"
      }
    },
    "node_modules/argparse": {
      "version": "1.0.10",
      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "sprintf-js": "~1.0.2"
      }
    },
    "node_modules/babel-jest": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-29.7.0.tgz",
      "integrity": "sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/transform": "^29.7.0",
        "@types/babel__core": "^7.1.14",
        "babel-plugin-istanbul": "^6.1.1",
        "babel-preset-jest": "^29.6.3",
        "chalk": "^4.0.0",
        "graceful-fs": "^4.2.9",
        "slash": "^3.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.8.0"
      }
    },
    "node_modules/babel-plugin-istanbul": {
      "version": "6.1.1",
      "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz",
      "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "@babel/helper-plugin-utils": "^7.0.0",
        "@istanbuljs/load-nyc-config": "^1.0.0",
        "@istanbuljs/schema": "^0.1.2",
        "istanbul-lib-instrument": "^5.0.4",
        "test-exclude": "^6.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/babel-plugin-jest-hoist": {
      "version": "29.6.3",
      "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.6.3.tgz",
      "integrity": "sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/template": "^7.3.3",
        "@babel/types": "^7.3.3",
        "@types/babel__core": "^7.1.14",
        "@types/babel__traverse": "^7.0.6"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/babel-plugin-polyfill-corejs2": {
      "version": "0.4.14",
      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.14.tgz",
      "integrity": "sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/compat-data": "^7.27.7",
        "@babel/helper-define-polyfill-provider": "^0.6.5",
        "semver": "^6.3.1"
      },
      "peerDependencies": {
        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
      }
    },
    "node_modules/babel-plugin-polyfill-corejs3": {
      "version": "0.13.0",
      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.13.0.tgz",
      "integrity": "sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-define-polyfill-provider": "^0.6.5",
        "core-js-compat": "^3.43.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
      }
    },
    "node_modules/babel-plugin-polyfill-regenerator": {
      "version": "0.6.5",
      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.5.tgz",
      "integrity": "sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/helper-define-polyfill-provider": "^0.6.5"
      },
      "peerDependencies": {
        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
      }
    },
    "node_modules/babel-preset-current-node-syntax": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.2.0.tgz",
      "integrity": "sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/plugin-syntax-async-generators": "^7.8.4",
        "@babel/plugin-syntax-bigint": "^7.8.3",
        "@babel/plugin-syntax-class-properties": "^7.12.13",
        "@babel/plugin-syntax-class-static-block": "^7.14.5",
        "@babel/plugin-syntax-import-attributes": "^7.24.7",
        "@babel/plugin-syntax-import-meta": "^7.10.4",
        "@babel/plugin-syntax-json-strings": "^7.8.3",
        "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4",
        "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3",
        "@babel/plugin-syntax-numeric-separator": "^7.10.4",
        "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
        "@babel/plugin-syntax-optional-catch-binding": "^7.8.3",
        "@babel/plugin-syntax-optional-chaining": "^7.8.3",
        "@babel/plugin-syntax-private-property-in-object": "^7.14.5",
        "@babel/plugin-syntax-top-level-await": "^7.14.5"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0 || ^8.0.0-0"
      }
    },
    "node_modules/babel-preset-jest": {
      "version": "29.6.3",
      "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.6.3.tgz",
      "integrity": "sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "babel-plugin-jest-hoist": "^29.6.3",
        "babel-preset-current-node-syntax": "^1.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      },
      "peerDependencies": {
        "@babel/core": "^7.0.0"
      }
    },
    "node_modules/balanced-match": {
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/baseline-browser-mapping": {
      "version": "2.8.32",
      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.32.tgz",
      "integrity": "sha512-OPz5aBThlyLFgxyhdwf/s2+8ab3OvT7AdTNvKHBwpXomIYeXqpUUuT8LrdtxZSsWJ4R4CU1un4XGh5Ez3nlTpw==",
      "dev": true,
      "license": "Apache-2.0",
      "bin": {
        "baseline-browser-mapping": "dist/cli.js"
      }
    },
    "node_modules/brace-expansion": {
      "version": "1.1.12",
      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "balanced-match": "^1.0.0",
        "concat-map": "0.0.1"
      }
    },
    "node_modules/braces": {
      "version": "3.0.3",
      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "fill-range": "^7.1.1"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/browserslist": {
      "version": "4.28.0",
      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.0.tgz",
      "integrity": "sha512-tbydkR/CxfMwelN0vwdP/pLkDwyAASZ+VfWm4EOwlB6SWhx1sYnWLqo8N5j0rAzPfzfRaxt0mM/4wPU/Su84RQ==",
      "dev": true,
      "funding": [
        {
          "type": "opencollective",
          "url": "https://opencollective.com/browserslist"
        },
        {
          "type": "tidelift",
          "url": "https://tidelift.com/funding/github/npm/browserslist"
        },
        {
          "type": "github",
          "url": "https://github.com/sponsors/ai"
        }
      ],
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "baseline-browser-mapping": "^2.8.25",
        "caniuse-lite": "^1.0.30001754",
        "electron-to-chromium": "^1.5.249",
        "node-releases": "^2.0.27",
        "update-browserslist-db": "^1.1.4"
      },
      "bin": {
        "browserslist": "cli.js"
      },
      "engines": {
        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
      }
    },
    "node_modules/bser": {
      "version": "2.1.1",
      "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz",
      "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==",
      "dev": true,
      "license": "Apache-2.0",
      "dependencies": {
        "node-int64": "^0.4.0"
      }
    },
    "node_modules/buffer-from": {
      "version": "1.1.2",
      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/callsites": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/camelcase": {
      "version": "5.3.1",
      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/caniuse-lite": {
      "version": "1.0.30001757",
      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001757.tgz",
      "integrity": "sha512-r0nnL/I28Zi/yjk1el6ilj27tKcdjLsNqAOZr0yVjWPrSQyHgKI2INaEWw21bAQSv2LXRt1XuCS/GomNpWOxsQ==",
      "dev": true,
      "funding": [
        {
          "type": "opencollective",
          "url": "https://opencollective.com/browserslist"
        },
        {
          "type": "tidelift",
          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
        },
        {
          "type": "github",
          "url": "https://github.com/sponsors/ai"
        }
      ],
      "license": "CC-BY-4.0"
    },
    "node_modules/chalk": {
      "version": "4.1.2",
      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "ansi-styles": "^4.1.0",
        "supports-color": "^7.1.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/chalk/chalk?sponsor=1"
      }
    },
    "node_modules/char-regex": {
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz",
      "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/ci-info": {
      "version": "3.9.0",
      "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz",
      "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==",
      "dev": true,
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/sibiraj-s"
        }
      ],
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/cjs-module-lexer": {
      "version": "1.4.3",
      "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz",
      "integrity": "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/cliui": {
      "version": "8.0.1",
      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "string-width": "^4.2.0",
        "strip-ansi": "^6.0.1",
        "wrap-ansi": "^7.0.0"
      },
      "engines": {
        "node": ">=12"
      }
    },
    "node_modules/co": {
      "version": "4.6.0",
      "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz",
      "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "iojs": ">= 1.0.0",
        "node": ">= 0.12.0"
      }
    },
    "node_modules/collect-v8-coverage": {
      "version": "1.0.3",
      "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.3.tgz",
      "integrity": "sha512-1L5aqIkwPfiodaMgQunkF1zRhNqifHBmtbbbxcr6yVxxBnliw4TDOW6NxpO8DJLgJ16OT+Y4ztZqP6p/FtXnAw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/color-convert": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "color-name": "~1.1.4"
      },
      "engines": {
        "node": ">=7.0.0"
      }
    },
    "node_modules/color-name": {
      "version": "1.1.4",
      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/concat-map": {
      "version": "0.0.1",
      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/convert-source-map": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/core-js-compat": {
      "version": "3.47.0",
      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.47.0.tgz",
      "integrity": "sha512-IGfuznZ/n7Kp9+nypamBhvwdwLsW6KC8IOaURw2doAK5e98AG3acVLdh0woOnEqCfUtS+Vu882JE4k/DAm3ItQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "browserslist": "^4.28.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/core-js"
      }
    },
    "node_modules/create-jest": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/create-jest/-/create-jest-29.7.0.tgz",
      "integrity": "sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/types": "^29.6.3",
        "chalk": "^4.0.0",
        "exit": "^0.1.2",
        "graceful-fs": "^4.2.9",
        "jest-config": "^29.7.0",
        "jest-util": "^29.7.0",
        "prompts": "^2.0.1"
      },
      "bin": {
        "create-jest": "bin/create-jest.js"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/cross-spawn": {
      "version": "7.0.6",
      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "path-key": "^3.1.0",
        "shebang-command": "^2.0.0",
        "which": "^2.0.1"
      },
      "engines": {
        "node": ">= 8"
      }
    },
    "node_modules/debug": {
      "version": "4.4.3",
      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "ms": "^2.1.3"
      },
      "engines": {
        "node": ">=6.0"
      },
      "peerDependenciesMeta": {
        "supports-color": {
          "optional": true
        }
      }
    },
    "node_modules/dedent": {
      "version": "1.7.0",
      "resolved": "https://registry.npmjs.org/dedent/-/dedent-1.7.0.tgz",
      "integrity": "sha512-HGFtf8yhuhGhqO07SV79tRp+br4MnbdjeVxotpn1QBl30pcLLCQjX5b2295ll0fv8RKDKsmWYrl05usHM9CewQ==",
      "dev": true,
      "license": "MIT",
      "peerDependencies": {
        "babel-plugin-macros": "^3.1.0"
      },
      "peerDependenciesMeta": {
        "babel-plugin-macros": {
          "optional": true
        }
      }
    },
    "node_modules/deep-is": {
      "version": "0.1.4",
      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/deepmerge": {
      "version": "4.3.1",
      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/detect-newline": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz",
      "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/diff-sequences": {
      "version": "29.6.3",
      "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz",
      "integrity": "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/electron-to-chromium": {
      "version": "1.5.262",
      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.262.tgz",
      "integrity": "sha512-NlAsMteRHek05jRUxUR0a5jpjYq9ykk6+kO0yRaMi5moe7u0fVIOeQ3Y30A8dIiWFBNUoQGi1ljb1i5VtS9WQQ==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/emittery": {
      "version": "0.13.1",
      "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz",
      "integrity": "sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=12"
      },
      "funding": {
        "url": "https://github.com/sindresorhus/emittery?sponsor=1"
      }
    },
    "node_modules/emoji-regex": {
      "version": "8.0.0",
      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/error-ex": {
      "version": "1.3.4",
      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz",
      "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "is-arrayish": "^0.2.1"
      }
    },
    "node_modules/escalade": {
      "version": "3.2.0",
      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/escape-string-regexp": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/eslint": {
      "version": "9.39.1",
      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.1.tgz",
      "integrity": "sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@eslint-community/eslint-utils": "^4.8.0",
        "@eslint-community/regexpp": "^4.12.1",
        "@eslint/config-array": "^0.21.1",
        "@eslint/config-helpers": "^0.4.2",
        "@eslint/core": "^0.17.0",
        "@eslint/eslintrc": "^3.3.1",
        "@eslint/js": "9.39.1",
        "@eslint/plugin-kit": "^0.4.1",
        "@humanfs/node": "^0.16.6",
        "@humanwhocodes/module-importer": "^1.0.1",
        "@humanwhocodes/retry": "^0.4.2",
        "@types/estree": "^1.0.6",
        "ajv": "^6.12.4",
        "chalk": "^4.0.0",
        "cross-spawn": "^7.0.6",
        "debug": "^4.3.2",
        "escape-string-regexp": "^4.0.0",
        "eslint-scope": "^8.4.0",
        "eslint-visitor-keys": "^4.2.1",
        "espree": "^10.4.0",
        "esquery": "^1.5.0",
        "esutils": "^2.0.2",
        "fast-deep-equal": "^3.1.3",
        "file-entry-cache": "^8.0.0",
        "find-up": "^5.0.0",
        "glob-parent": "^6.0.2",
        "ignore": "^5.2.0",
        "imurmurhash": "^0.1.4",
        "is-glob": "^4.0.0",
        "json-stable-stringify-without-jsonify": "^1.0.1",
        "lodash.merge": "^4.6.2",
        "minimatch": "^3.1.2",
        "natural-compare": "^1.4.0",
        "optionator": "^0.9.3"
      },
      "bin": {
        "eslint": "bin/eslint.js"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "url": "https://eslint.org/donate"
      },
      "peerDependencies": {
        "jiti": "*"
      },
      "peerDependenciesMeta": {
        "jiti": {
          "optional": true
        }
      }
    },
    "node_modules/eslint-config-prettier": {
      "version": "10.1.8",
      "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.8.tgz",
      "integrity": "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==",
      "dev": true,
      "license": "MIT",
      "bin": {
        "eslint-config-prettier": "bin/cli.js"
      },
      "funding": {
        "url": "https://opencollective.com/eslint-config-prettier"
      },
      "peerDependencies": {
        "eslint": ">=7.0.0"
      }
    },
    "node_modules/eslint-scope": {
      "version": "8.4.0",
      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
      "dev": true,
      "license": "BSD-2-Clause",
      "dependencies": {
        "esrecurse": "^4.3.0",
        "estraverse": "^5.2.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/eslint"
      }
    },
    "node_modules/eslint-visitor-keys": {
      "version": "4.2.1",
      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
      "dev": true,
      "license": "Apache-2.0",
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/eslint"
      }
    },
    "node_modules/eslint/node_modules/find-up": {
      "version": "5.0.0",
      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "locate-path": "^6.0.0",
        "path-exists": "^4.0.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/eslint/node_modules/locate-path": {
      "version": "6.0.0",
      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "p-locate": "^5.0.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/eslint/node_modules/p-locate": {
      "version": "5.0.0",
      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "p-limit": "^3.0.2"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/espree": {
      "version": "10.4.0",
      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
      "dev": true,
      "license": "BSD-2-Clause",
      "dependencies": {
        "acorn": "^8.15.0",
        "acorn-jsx": "^5.3.2",
        "eslint-visitor-keys": "^4.2.1"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "url": "https://opencollective.com/eslint"
      }
    },
    "node_modules/esprima": {
      "version": "4.0.1",
      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
      "dev": true,
      "license": "BSD-2-Clause",
      "bin": {
        "esparse": "bin/esparse.js",
        "esvalidate": "bin/esvalidate.js"
      },
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/esquery": {
      "version": "1.6.0",
      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "estraverse": "^5.1.0"
      },
      "engines": {
        "node": ">=0.10"
      }
    },
    "node_modules/esrecurse": {
      "version": "4.3.0",
      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
      "dev": true,
      "license": "BSD-2-Clause",
      "dependencies": {
        "estraverse": "^5.2.0"
      },
      "engines": {
        "node": ">=4.0"
      }
    },
    "node_modules/estraverse": {
      "version": "5.3.0",
      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
      "dev": true,
      "license": "BSD-2-Clause",
      "engines": {
        "node": ">=4.0"
      }
    },
    "node_modules/estree-walker": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/esutils": {
      "version": "2.0.3",
      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
      "dev": true,
      "license": "BSD-2-Clause",
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/execa": {
      "version": "5.1.1",
      "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz",
      "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "cross-spawn": "^7.0.3",
        "get-stream": "^6.0.0",
        "human-signals": "^2.1.0",
        "is-stream": "^2.0.0",
        "merge-stream": "^2.0.0",
        "npm-run-path": "^4.0.1",
        "onetime": "^5.1.2",
        "signal-exit": "^3.0.3",
        "strip-final-newline": "^2.0.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sindresorhus/execa?sponsor=1"
      }
    },
    "node_modules/exit": {
      "version": "0.1.2",
      "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz",
      "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==",
      "dev": true,
      "engines": {
        "node": ">= 0.8.0"
      }
    },
    "node_modules/expect": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/expect/-/expect-29.7.0.tgz",
      "integrity": "sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/expect-utils": "^29.7.0",
        "jest-get-type": "^29.6.3",
        "jest-matcher-utils": "^29.7.0",
        "jest-message-util": "^29.7.0",
        "jest-util": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/fast-check": {
      "version": "2.25.0",
      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-2.25.0.tgz",
      "integrity": "sha512-wRUT2KD2lAmT75WNIJIHECawoUUMHM0I5jrlLXGtGeqmPL8jl/EldUDjY1VCp6fDY8yflyfUeIOsOBrIbIiArg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "pure-rand": "^5.0.1"
      },
      "engines": {
        "node": ">=8.0.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/fast-check"
      }
    },
    "node_modules/fast-deep-equal": {
      "version": "3.1.3",
      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/fast-json-stable-stringify": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/fast-levenshtein": {
      "version": "2.0.6",
      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/fb-watchman": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz",
      "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==",
      "dev": true,
      "license": "Apache-2.0",
      "dependencies": {
        "bser": "2.1.1"
      }
    },
    "node_modules/fdir": {
      "version": "6.5.0",
      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=12.0.0"
      },
      "peerDependencies": {
        "picomatch": "^3 || ^4"
      },
      "peerDependenciesMeta": {
        "picomatch": {
          "optional": true
        }
      }
    },
    "node_modules/file-entry-cache": {
      "version": "8.0.0",
      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "flat-cache": "^4.0.0"
      },
      "engines": {
        "node": ">=16.0.0"
      }
    },
    "node_modules/fill-range": {
      "version": "7.1.1",
      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "to-regex-range": "^5.0.1"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/find-up": {
      "version": "4.1.0",
      "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "locate-path": "^5.0.0",
        "path-exists": "^4.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/flat-cache": {
      "version": "4.0.1",
      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "flatted": "^3.2.9",
        "keyv": "^4.5.4"
      },
      "engines": {
        "node": ">=16"
      }
    },
    "node_modules/flatted": {
      "version": "3.3.3",
      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/fs.realpath": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/fsevents": {
      "version": "2.3.3",
      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
      "dev": true,
      "hasInstallScript": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "darwin"
      ],
      "engines": {
        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
      }
    },
    "node_modules/function-bind": {
      "version": "1.1.2",
      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
      "dev": true,
      "license": "MIT",
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/gensync": {
      "version": "1.0.0-beta.2",
      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/get-caller-file": {
      "version": "2.0.5",
      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
      "dev": true,
      "license": "ISC",
      "engines": {
        "node": "6.* || 8.* || >= 10.*"
      }
    },
    "node_modules/get-package-type": {
      "version": "0.1.0",
      "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz",
      "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8.0.0"
      }
    },
    "node_modules/get-stream": {
      "version": "6.0.1",
      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
      "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/glob": {
      "version": "7.2.3",
      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
      "deprecated": "Glob versions prior to v9 are no longer supported",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "fs.realpath": "^1.0.0",
        "inflight": "^1.0.4",
        "inherits": "2",
        "minimatch": "^3.1.1",
        "once": "^1.3.0",
        "path-is-absolute": "^1.0.0"
      },
      "engines": {
        "node": "*"
      },
      "funding": {
        "url": "https://github.com/sponsors/isaacs"
      }
    },
    "node_modules/glob-parent": {
      "version": "6.0.2",
      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "is-glob": "^4.0.3"
      },
      "engines": {
        "node": ">=10.13.0"
      }
    },
    "node_modules/globals": {
      "version": "14.0.0",
      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=18"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/graceful-fs": {
      "version": "4.2.11",
      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/graphemer": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/has-flag": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/hasown": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "function-bind": "^1.1.2"
      },
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/html-escaper": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/human-signals": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz",
      "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==",
      "dev": true,
      "license": "Apache-2.0",
      "engines": {
        "node": ">=10.17.0"
      }
    },
    "node_modules/ignore": {
      "version": "5.3.2",
      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">= 4"
      }
    },
    "node_modules/import-fresh": {
      "version": "3.3.1",
      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "parent-module": "^1.0.0",
        "resolve-from": "^4.0.0"
      },
      "engines": {
        "node": ">=6"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/import-fresh/node_modules/resolve-from": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/import-local": {
      "version": "3.2.0",
      "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.2.0.tgz",
      "integrity": "sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "pkg-dir": "^4.2.0",
        "resolve-cwd": "^3.0.0"
      },
      "bin": {
        "import-local-fixture": "fixtures/cli.js"
      },
      "engines": {
        "node": ">=8"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/imurmurhash": {
      "version": "0.1.4",
      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.8.19"
      }
    },
    "node_modules/inflight": {
      "version": "1.0.6",
      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "once": "^1.3.0",
        "wrappy": "1"
      }
    },
    "node_modules/inherits": {
      "version": "2.0.4",
      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/is-arrayish": {
      "version": "0.2.1",
      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/is-core-module": {
      "version": "2.16.1",
      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "hasown": "^2.0.2"
      },
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/is-extglob": {
      "version": "2.1.1",
      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/is-fullwidth-code-point": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/is-generator-fn": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz",
      "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/is-glob": {
      "version": "4.0.3",
      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "is-extglob": "^2.1.1"
      },
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/is-number": {
      "version": "7.0.0",
      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.12.0"
      }
    },
    "node_modules/is-stream": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/isexe": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/istanbul-lib-coverage": {
      "version": "3.2.2",
      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
      "dev": true,
      "license": "BSD-3-Clause",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/istanbul-lib-instrument": {
      "version": "5.2.1",
      "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz",
      "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "@babel/core": "^7.12.3",
        "@babel/parser": "^7.14.7",
        "@istanbuljs/schema": "^0.1.2",
        "istanbul-lib-coverage": "^3.2.0",
        "semver": "^6.3.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/istanbul-lib-report": {
      "version": "3.0.1",
      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "istanbul-lib-coverage": "^3.0.0",
        "make-dir": "^4.0.0",
        "supports-color": "^7.1.0"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/istanbul-lib-source-maps": {
      "version": "4.0.1",
      "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz",
      "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "debug": "^4.1.1",
        "istanbul-lib-coverage": "^3.0.0",
        "source-map": "^0.6.1"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/istanbul-reports": {
      "version": "3.2.0",
      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "html-escaper": "^2.0.0",
        "istanbul-lib-report": "^3.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/jest": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest/-/jest-29.7.0.tgz",
      "integrity": "sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/core": "^29.7.0",
        "@jest/types": "^29.6.3",
        "import-local": "^3.0.2",
        "jest-cli": "^29.7.0"
      },
      "bin": {
        "jest": "bin/jest.js"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      },
      "peerDependencies": {
        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
      },
      "peerDependenciesMeta": {
        "node-notifier": {
          "optional": true
        }
      }
    },
    "node_modules/jest-changed-files": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.7.0.tgz",
      "integrity": "sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "execa": "^5.0.0",
        "jest-util": "^29.7.0",
        "p-limit": "^3.1.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-circus": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-29.7.0.tgz",
      "integrity": "sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/environment": "^29.7.0",
        "@jest/expect": "^29.7.0",
        "@jest/test-result": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "chalk": "^4.0.0",
        "co": "^4.6.0",
        "dedent": "^1.0.0",
        "is-generator-fn": "^2.0.0",
        "jest-each": "^29.7.0",
        "jest-matcher-utils": "^29.7.0",
        "jest-message-util": "^29.7.0",
        "jest-runtime": "^29.7.0",
        "jest-snapshot": "^29.7.0",
        "jest-util": "^29.7.0",
        "p-limit": "^3.1.0",
        "pretty-format": "^29.7.0",
        "pure-rand": "^6.0.0",
        "slash": "^3.0.0",
        "stack-utils": "^2.0.3"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-circus/node_modules/pure-rand": {
      "version": "6.1.0",
      "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.1.0.tgz",
      "integrity": "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==",
      "dev": true,
      "funding": [
        {
          "type": "individual",
          "url": "https://github.com/sponsors/dubzzz"
        },
        {
          "type": "opencollective",
          "url": "https://opencollective.com/fast-check"
        }
      ],
      "license": "MIT"
    },
    "node_modules/jest-cli": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-29.7.0.tgz",
      "integrity": "sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/core": "^29.7.0",
        "@jest/test-result": "^29.7.0",
        "@jest/types": "^29.6.3",
        "chalk": "^4.0.0",
        "create-jest": "^29.7.0",
        "exit": "^0.1.2",
        "import-local": "^3.0.2",
        "jest-config": "^29.7.0",
        "jest-util": "^29.7.0",
        "jest-validate": "^29.7.0",
        "yargs": "^17.3.1"
      },
      "bin": {
        "jest": "bin/jest.js"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      },
      "peerDependencies": {
        "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
      },
      "peerDependenciesMeta": {
        "node-notifier": {
          "optional": true
        }
      }
    },
    "node_modules/jest-config": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-29.7.0.tgz",
      "integrity": "sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/core": "^7.11.6",
        "@jest/test-sequencer": "^29.7.0",
        "@jest/types": "^29.6.3",
        "babel-jest": "^29.7.0",
        "chalk": "^4.0.0",
        "ci-info": "^3.2.0",
        "deepmerge": "^4.2.2",
        "glob": "^7.1.3",
        "graceful-fs": "^4.2.9",
        "jest-circus": "^29.7.0",
        "jest-environment-node": "^29.7.0",
        "jest-get-type": "^29.6.3",
        "jest-regex-util": "^29.6.3",
        "jest-resolve": "^29.7.0",
        "jest-runner": "^29.7.0",
        "jest-util": "^29.7.0",
        "jest-validate": "^29.7.0",
        "micromatch": "^4.0.4",
        "parse-json": "^5.2.0",
        "pretty-format": "^29.7.0",
        "slash": "^3.0.0",
        "strip-json-comments": "^3.1.1"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      },
      "peerDependencies": {
        "@types/node": "*",
        "ts-node": ">=9.0.0"
      },
      "peerDependenciesMeta": {
        "@types/node": {
          "optional": true
        },
        "ts-node": {
          "optional": true
        }
      }
    },
    "node_modules/jest-diff": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-29.7.0.tgz",
      "integrity": "sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "chalk": "^4.0.0",
        "diff-sequences": "^29.6.3",
        "jest-get-type": "^29.6.3",
        "pretty-format": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-docblock": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.7.0.tgz",
      "integrity": "sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "detect-newline": "^3.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-each": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-29.7.0.tgz",
      "integrity": "sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/types": "^29.6.3",
        "chalk": "^4.0.0",
        "jest-get-type": "^29.6.3",
        "jest-util": "^29.7.0",
        "pretty-format": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-environment-node": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-29.7.0.tgz",
      "integrity": "sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/environment": "^29.7.0",
        "@jest/fake-timers": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "jest-mock": "^29.7.0",
        "jest-util": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-get-type": {
      "version": "29.6.3",
      "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.6.3.tgz",
      "integrity": "sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-haste-map": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-29.7.0.tgz",
      "integrity": "sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/types": "^29.6.3",
        "@types/graceful-fs": "^4.1.3",
        "@types/node": "*",
        "anymatch": "^3.0.3",
        "fb-watchman": "^2.0.0",
        "graceful-fs": "^4.2.9",
        "jest-regex-util": "^29.6.3",
        "jest-util": "^29.7.0",
        "jest-worker": "^29.7.0",
        "micromatch": "^4.0.4",
        "walker": "^1.0.8"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      },
      "optionalDependencies": {
        "fsevents": "^2.3.2"
      }
    },
    "node_modules/jest-leak-detector": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-29.7.0.tgz",
      "integrity": "sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "jest-get-type": "^29.6.3",
        "pretty-format": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-matcher-utils": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.7.0.tgz",
      "integrity": "sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "chalk": "^4.0.0",
        "jest-diff": "^29.7.0",
        "jest-get-type": "^29.6.3",
        "pretty-format": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-message-util": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.7.0.tgz",
      "integrity": "sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/code-frame": "^7.12.13",
        "@jest/types": "^29.6.3",
        "@types/stack-utils": "^2.0.0",
        "chalk": "^4.0.0",
        "graceful-fs": "^4.2.9",
        "micromatch": "^4.0.4",
        "pretty-format": "^29.7.0",
        "slash": "^3.0.0",
        "stack-utils": "^2.0.3"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-mock": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-29.7.0.tgz",
      "integrity": "sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "jest-util": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-pnp-resolver": {
      "version": "1.2.3",
      "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz",
      "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      },
      "peerDependencies": {
        "jest-resolve": "*"
      },
      "peerDependenciesMeta": {
        "jest-resolve": {
          "optional": true
        }
      }
    },
    "node_modules/jest-regex-util": {
      "version": "29.6.3",
      "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.6.3.tgz",
      "integrity": "sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-resolve": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-29.7.0.tgz",
      "integrity": "sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "chalk": "^4.0.0",
        "graceful-fs": "^4.2.9",
        "jest-haste-map": "^29.7.0",
        "jest-pnp-resolver": "^1.2.2",
        "jest-util": "^29.7.0",
        "jest-validate": "^29.7.0",
        "resolve": "^1.20.0",
        "resolve.exports": "^2.0.0",
        "slash": "^3.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-resolve-dependencies": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-29.7.0.tgz",
      "integrity": "sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "jest-regex-util": "^29.6.3",
        "jest-snapshot": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-runner": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-29.7.0.tgz",
      "integrity": "sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/console": "^29.7.0",
        "@jest/environment": "^29.7.0",
        "@jest/test-result": "^29.7.0",
        "@jest/transform": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "chalk": "^4.0.0",
        "emittery": "^0.13.1",
        "graceful-fs": "^4.2.9",
        "jest-docblock": "^29.7.0",
        "jest-environment-node": "^29.7.0",
        "jest-haste-map": "^29.7.0",
        "jest-leak-detector": "^29.7.0",
        "jest-message-util": "^29.7.0",
        "jest-resolve": "^29.7.0",
        "jest-runtime": "^29.7.0",
        "jest-util": "^29.7.0",
        "jest-watcher": "^29.7.0",
        "jest-worker": "^29.7.0",
        "p-limit": "^3.1.0",
        "source-map-support": "0.5.13"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-runtime": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-29.7.0.tgz",
      "integrity": "sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/environment": "^29.7.0",
        "@jest/fake-timers": "^29.7.0",
        "@jest/globals": "^29.7.0",
        "@jest/source-map": "^29.6.3",
        "@jest/test-result": "^29.7.0",
        "@jest/transform": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "chalk": "^4.0.0",
        "cjs-module-lexer": "^1.0.0",
        "collect-v8-coverage": "^1.0.0",
        "glob": "^7.1.3",
        "graceful-fs": "^4.2.9",
        "jest-haste-map": "^29.7.0",
        "jest-message-util": "^29.7.0",
        "jest-mock": "^29.7.0",
        "jest-regex-util": "^29.6.3",
        "jest-resolve": "^29.7.0",
        "jest-snapshot": "^29.7.0",
        "jest-util": "^29.7.0",
        "slash": "^3.0.0",
        "strip-bom": "^4.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-snapshot": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-29.7.0.tgz",
      "integrity": "sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/core": "^7.11.6",
        "@babel/generator": "^7.7.2",
        "@babel/plugin-syntax-jsx": "^7.7.2",
        "@babel/plugin-syntax-typescript": "^7.7.2",
        "@babel/types": "^7.3.3",
        "@jest/expect-utils": "^29.7.0",
        "@jest/transform": "^29.7.0",
        "@jest/types": "^29.6.3",
        "babel-preset-current-node-syntax": "^1.0.0",
        "chalk": "^4.0.0",
        "expect": "^29.7.0",
        "graceful-fs": "^4.2.9",
        "jest-diff": "^29.7.0",
        "jest-get-type": "^29.6.3",
        "jest-matcher-utils": "^29.7.0",
        "jest-message-util": "^29.7.0",
        "jest-util": "^29.7.0",
        "natural-compare": "^1.4.0",
        "pretty-format": "^29.7.0",
        "semver": "^7.5.3"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-snapshot/node_modules/semver": {
      "version": "7.7.3",
      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
      "dev": true,
      "license": "ISC",
      "bin": {
        "semver": "bin/semver.js"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/jest-ts-webcompat-resolver": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/jest-ts-webcompat-resolver/-/jest-ts-webcompat-resolver-1.0.1.tgz",
      "integrity": "sha512-6rz4gejsOd0SYq5F/DmVGvJlFPmiCqkoXhkNKhyL1Uaqz4GyFMBbGUoBK+koXHThQdq97Ev7XJiyZ8iusMpWgQ==",
      "dev": true,
      "license": "MIT",
      "peerDependencies": {
        "jest-resolve": "*"
      }
    },
    "node_modules/jest-util": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz",
      "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "chalk": "^4.0.0",
        "ci-info": "^3.2.0",
        "graceful-fs": "^4.2.9",
        "picomatch": "^2.2.3"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-util/node_modules/picomatch": {
      "version": "2.3.1",
      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8.6"
      },
      "funding": {
        "url": "https://github.com/sponsors/jonschlinkert"
      }
    },
    "node_modules/jest-validate": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-29.7.0.tgz",
      "integrity": "sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/types": "^29.6.3",
        "camelcase": "^6.2.0",
        "chalk": "^4.0.0",
        "jest-get-type": "^29.6.3",
        "leven": "^3.1.0",
        "pretty-format": "^29.7.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-validate/node_modules/camelcase": {
      "version": "6.3.0",
      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/jest-watcher": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-29.7.0.tgz",
      "integrity": "sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/test-result": "^29.7.0",
        "@jest/types": "^29.6.3",
        "@types/node": "*",
        "ansi-escapes": "^4.2.1",
        "chalk": "^4.0.0",
        "emittery": "^0.13.1",
        "jest-util": "^29.7.0",
        "string-length": "^4.0.1"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-worker": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz",
      "integrity": "sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@types/node": "*",
        "jest-util": "^29.7.0",
        "merge-stream": "^2.0.0",
        "supports-color": "^8.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/jest-worker/node_modules/supports-color": {
      "version": "8.1.1",
      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "has-flag": "^4.0.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/chalk/supports-color?sponsor=1"
      }
    },
    "node_modules/js-tokens": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/js-yaml": {
      "version": "3.14.2",
      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz",
      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "argparse": "^1.0.7",
        "esprima": "^4.0.0"
      },
      "bin": {
        "js-yaml": "bin/js-yaml.js"
      }
    },
    "node_modules/jsesc": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
      "dev": true,
      "license": "MIT",
      "bin": {
        "jsesc": "bin/jsesc"
      },
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/json-buffer": {
      "version": "3.0.1",
      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/json-parse-even-better-errors": {
      "version": "2.3.1",
      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/json-schema-traverse": {
      "version": "0.4.1",
      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/json-stable-stringify-without-jsonify": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/json5": {
      "version": "2.2.3",
      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
      "dev": true,
      "license": "MIT",
      "bin": {
        "json5": "lib/cli.js"
      },
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/keyv": {
      "version": "4.5.4",
      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "json-buffer": "3.0.1"
      }
    },
    "node_modules/kleur": {
      "version": "3.0.3",
      "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
      "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/leven": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
      "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/levn": {
      "version": "0.4.1",
      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "prelude-ls": "^1.2.1",
        "type-check": "~0.4.0"
      },
      "engines": {
        "node": ">= 0.8.0"
      }
    },
    "node_modules/lines-and-columns": {
      "version": "1.2.4",
      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/locate-path": {
      "version": "5.0.0",
      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "p-locate": "^4.1.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/lodash.debounce": {
      "version": "4.0.8",
      "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz",
      "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/lodash.merge": {
      "version": "4.6.2",
      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/lru-cache": {
      "version": "5.1.1",
      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "yallist": "^3.0.2"
      }
    },
    "node_modules/magic-string": {
      "version": "0.30.21",
      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jridgewell/sourcemap-codec": "^1.5.5"
      }
    },
    "node_modules/make-dir": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
      "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "semver": "^7.5.3"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/make-dir/node_modules/semver": {
      "version": "7.7.3",
      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
      "dev": true,
      "license": "ISC",
      "bin": {
        "semver": "bin/semver.js"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/makeerror": {
      "version": "1.0.12",
      "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz",
      "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==",
      "dev": true,
      "license": "BSD-3-Clause",
      "dependencies": {
        "tmpl": "1.0.5"
      }
    },
    "node_modules/merge-stream": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/micromatch": {
      "version": "4.0.8",
      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "braces": "^3.0.3",
        "picomatch": "^2.3.1"
      },
      "engines": {
        "node": ">=8.6"
      }
    },
    "node_modules/micromatch/node_modules/picomatch": {
      "version": "2.3.1",
      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8.6"
      },
      "funding": {
        "url": "https://github.com/sponsors/jonschlinkert"
      }
    },
    "node_modules/mimic-fn": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/minimatch": {
      "version": "3.1.2",
      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "brace-expansion": "^1.1.7"
      },
      "engines": {
        "node": "*"
      }
    },
    "node_modules/ms": {
      "version": "2.1.3",
      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/natural-compare": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/node-int64": {
      "version": "0.4.0",
      "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",
      "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/node-releases": {
      "version": "2.0.27",
      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/normalize-path": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/npm-run-path": {
      "version": "4.0.1",
      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
      "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "path-key": "^3.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/once": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "wrappy": "1"
      }
    },
    "node_modules/onetime": {
      "version": "5.1.2",
      "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
      "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "mimic-fn": "^2.1.0"
      },
      "engines": {
        "node": ">=6"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/optionator": {
      "version": "0.9.4",
      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "deep-is": "^0.1.3",
        "fast-levenshtein": "^2.0.6",
        "levn": "^0.4.1",
        "prelude-ls": "^1.2.1",
        "type-check": "^0.4.0",
        "word-wrap": "^1.2.5"
      },
      "engines": {
        "node": ">= 0.8.0"
      }
    },
    "node_modules/p-limit": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "yocto-queue": "^0.1.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/p-locate": {
      "version": "4.1.0",
      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "p-limit": "^2.2.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/p-locate/node_modules/p-limit": {
      "version": "2.3.0",
      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "p-try": "^2.0.0"
      },
      "engines": {
        "node": ">=6"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/p-try": {
      "version": "2.2.0",
      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/parent-module": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "callsites": "^3.0.0"
      },
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/parse-json": {
      "version": "5.2.0",
      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@babel/code-frame": "^7.0.0",
        "error-ex": "^1.3.1",
        "json-parse-even-better-errors": "^2.3.0",
        "lines-and-columns": "^1.1.6"
      },
      "engines": {
        "node": ">=8"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/path-exists": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/path-is-absolute": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/path-key": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/path-parse": {
      "version": "1.0.7",
      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/picocolors": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/picomatch": {
      "version": "4.0.3",
      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=12"
      },
      "funding": {
        "url": "https://github.com/sponsors/jonschlinkert"
      }
    },
    "node_modules/pirates": {
      "version": "4.0.7",
      "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
      "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">= 6"
      }
    },
    "node_modules/pkg-dir": {
      "version": "4.2.0",
      "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz",
      "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "find-up": "^4.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/prelude-ls": {
      "version": "1.2.1",
      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">= 0.8.0"
      }
    },
    "node_modules/prettier": {
      "version": "3.7.3",
      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.7.3.tgz",
      "integrity": "sha512-QgODejq9K3OzoBbuyobZlUhznP5SKwPqp+6Q6xw6o8gnhr4O85L2U915iM2IDcfF2NPXVaM9zlo9tdwipnYwzg==",
      "dev": true,
      "license": "MIT",
      "bin": {
        "prettier": "bin/prettier.cjs"
      },
      "engines": {
        "node": ">=14"
      },
      "funding": {
        "url": "https://github.com/prettier/prettier?sponsor=1"
      }
    },
    "node_modules/pretty-format": {
      "version": "29.7.0",
      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz",
      "integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@jest/schemas": "^29.6.3",
        "ansi-styles": "^5.0.0",
        "react-is": "^18.0.0"
      },
      "engines": {
        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
      }
    },
    "node_modules/pretty-format/node_modules/ansi-styles": {
      "version": "5.2.0",
      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
      }
    },
    "node_modules/prompts": {
      "version": "2.4.2",
      "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz",
      "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "kleur": "^3.0.3",
        "sisteransi": "^1.0.5"
      },
      "engines": {
        "node": ">= 6"
      }
    },
    "node_modules/punycode": {
      "version": "2.3.1",
      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/pure-rand": {
      "version": "5.0.5",
      "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-5.0.5.tgz",
      "integrity": "sha512-BwQpbqxSCBJVpamI6ydzcKqyFmnd5msMWUGvzXLm1aXvusbbgkbOto/EUPM00hjveJEaJtdbhUjKSzWRhQVkaw==",
      "dev": true,
      "funding": [
        {
          "type": "individual",
          "url": "https://github.com/sponsors/dubzzz"
        },
        {
          "type": "opencollective",
          "url": "https://opencollective.com/fast-check"
        }
      ],
      "license": "MIT"
    },
    "node_modules/react-is": {
      "version": "18.3.1",
      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/regenerate": {
      "version": "1.4.2",
      "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz",
      "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/regenerate-unicode-properties": {
      "version": "10.2.2",
      "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz",
      "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "regenerate": "^1.4.2"
      },
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/regexpu-core": {
      "version": "6.4.0",
      "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.4.0.tgz",
      "integrity": "sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "regenerate": "^1.4.2",
        "regenerate-unicode-properties": "^10.2.2",
        "regjsgen": "^0.8.0",
        "regjsparser": "^0.13.0",
        "unicode-match-property-ecmascript": "^2.0.0",
        "unicode-match-property-value-ecmascript": "^2.2.1"
      },
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/regjsgen": {
      "version": "0.8.0",
      "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz",
      "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/regjsparser": {
      "version": "0.13.0",
      "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.0.tgz",
      "integrity": "sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==",
      "dev": true,
      "license": "BSD-2-Clause",
      "dependencies": {
        "jsesc": "~3.1.0"
      },
      "bin": {
        "regjsparser": "bin/parser"
      }
    },
    "node_modules/require-directory": {
      "version": "2.1.1",
      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/resolve": {
      "version": "1.22.11",
      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
      "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "is-core-module": "^2.16.1",
        "path-parse": "^1.0.7",
        "supports-preserve-symlinks-flag": "^1.0.0"
      },
      "bin": {
        "resolve": "bin/resolve"
      },
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/resolve-cwd": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz",
      "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "resolve-from": "^5.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/resolve-from": {
      "version": "5.0.0",
      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
      "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/resolve.exports": {
      "version": "2.0.3",
      "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.3.tgz",
      "integrity": "sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/rollup": {
      "version": "4.53.3",
      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.53.3.tgz",
      "integrity": "sha512-w8GmOxZfBmKknvdXU1sdM9NHcoQejwF/4mNgj2JuEEdRaHwwF12K7e9eXn1nLZ07ad+du76mkVsyeb2rKGllsA==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@types/estree": "1.0.8"
      },
      "bin": {
        "rollup": "dist/bin/rollup"
      },
      "engines": {
        "node": ">=18.0.0",
        "npm": ">=8.0.0"
      },
      "optionalDependencies": {
        "@rollup/rollup-android-arm-eabi": "4.53.3",
        "@rollup/rollup-android-arm64": "4.53.3",
        "@rollup/rollup-darwin-arm64": "4.53.3",
        "@rollup/rollup-darwin-x64": "4.53.3",
        "@rollup/rollup-freebsd-arm64": "4.53.3",
        "@rollup/rollup-freebsd-x64": "4.53.3",
        "@rollup/rollup-linux-arm-gnueabihf": "4.53.3",
        "@rollup/rollup-linux-arm-musleabihf": "4.53.3",
        "@rollup/rollup-linux-arm64-gnu": "4.53.3",
        "@rollup/rollup-linux-arm64-musl": "4.53.3",
        "@rollup/rollup-linux-loong64-gnu": "4.53.3",
        "@rollup/rollup-linux-ppc64-gnu": "4.53.3",
        "@rollup/rollup-linux-riscv64-gnu": "4.53.3",
        "@rollup/rollup-linux-riscv64-musl": "4.53.3",
        "@rollup/rollup-linux-s390x-gnu": "4.53.3",
        "@rollup/rollup-linux-x64-gnu": "4.53.3",
        "@rollup/rollup-linux-x64-musl": "4.53.3",
        "@rollup/rollup-openharmony-arm64": "4.53.3",
        "@rollup/rollup-win32-arm64-msvc": "4.53.3",
        "@rollup/rollup-win32-ia32-msvc": "4.53.3",
        "@rollup/rollup-win32-x64-gnu": "4.53.3",
        "@rollup/rollup-win32-x64-msvc": "4.53.3",
        "fsevents": "~2.3.2"
      }
    },
    "node_modules/semver": {
      "version": "6.3.1",
      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
      "dev": true,
      "license": "ISC",
      "bin": {
        "semver": "bin/semver.js"
      }
    },
    "node_modules/shebang-command": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "shebang-regex": "^3.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/shebang-regex": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/signal-exit": {
      "version": "3.0.7",
      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/sisteransi": {
      "version": "1.0.5",
      "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz",
      "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/slash": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/source-map": {
      "version": "0.6.1",
      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
      "dev": true,
      "license": "BSD-3-Clause",
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/source-map-support": {
      "version": "0.5.13",
      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz",
      "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "buffer-from": "^1.0.0",
        "source-map": "^0.6.0"
      }
    },
    "node_modules/sprintf-js": {
      "version": "1.0.3",
      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
      "dev": true,
      "license": "BSD-3-Clause"
    },
    "node_modules/stack-utils": {
      "version": "2.0.6",
      "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
      "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "escape-string-regexp": "^2.0.0"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/stack-utils/node_modules/escape-string-regexp": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
      "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/string-length": {
      "version": "4.0.2",
      "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz",
      "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "char-regex": "^1.0.2",
        "strip-ansi": "^6.0.0"
      },
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/string-width": {
      "version": "4.2.3",
      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "emoji-regex": "^8.0.0",
        "is-fullwidth-code-point": "^3.0.0",
        "strip-ansi": "^6.0.1"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/strip-ansi": {
      "version": "6.0.1",
      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "ansi-regex": "^5.0.1"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/strip-bom": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz",
      "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/strip-final-newline": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
      "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/strip-json-comments": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=8"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/supports-color": {
      "version": "7.2.0",
      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "has-flag": "^4.0.0"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/supports-preserve-symlinks-flag": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">= 0.4"
      },
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/test-exclude": {
      "version": "6.0.0",
      "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz",
      "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "@istanbuljs/schema": "^0.1.2",
        "glob": "^7.1.4",
        "minimatch": "^3.0.4"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/tinyglobby": {
      "version": "0.2.15",
      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "fdir": "^6.5.0",
        "picomatch": "^4.0.3"
      },
      "engines": {
        "node": ">=12.0.0"
      },
      "funding": {
        "url": "https://github.com/sponsors/SuperchupuDev"
      }
    },
    "node_modules/tmpl": {
      "version": "1.0.5",
      "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz",
      "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==",
      "dev": true,
      "license": "BSD-3-Clause"
    },
    "node_modules/to-regex-range": {
      "version": "5.0.1",
      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "is-number": "^7.0.0"
      },
      "engines": {
        "node": ">=8.0"
      }
    },
    "node_modules/ts-api-utils": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.1.0.tgz",
      "integrity": "sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=18.12"
      },
      "peerDependencies": {
        "typescript": ">=4.8.4"
      }
    },
    "node_modules/tslib": {
      "version": "2.8.1",
      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
      "dev": true,
      "license": "0BSD",
      "peer": true
    },
    "node_modules/type-check": {
      "version": "0.4.0",
      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "prelude-ls": "^1.2.1"
      },
      "engines": {
        "node": ">= 0.8.0"
      }
    },
    "node_modules/type-detect": {
      "version": "4.0.8",
      "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
      "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/type-fest": {
      "version": "0.21.3",
      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
      "dev": true,
      "license": "(MIT OR CC0-1.0)",
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/typescript": {
      "version": "5.9.3",
      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
      "dev": true,
      "license": "Apache-2.0",
      "peer": true,
      "bin": {
        "tsc": "bin/tsc",
        "tsserver": "bin/tsserver"
      },
      "engines": {
        "node": ">=14.17"
      }
    },
    "node_modules/typescript-eslint": {
      "version": "8.48.0",
      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.48.0.tgz",
      "integrity": "sha512-fcKOvQD9GUn3Xw63EgiDqhvWJ5jsyZUaekl3KVpGsDJnN46WJTe3jWxtQP9lMZm1LJNkFLlTaWAxK2vUQR+cqw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@typescript-eslint/eslint-plugin": "8.48.0",
        "@typescript-eslint/parser": "8.48.0",
        "@typescript-eslint/typescript-estree": "8.48.0",
        "@typescript-eslint/utils": "8.48.0"
      },
      "engines": {
        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
      },
      "funding": {
        "type": "opencollective",
        "url": "https://opencollective.com/typescript-eslint"
      },
      "peerDependencies": {
        "eslint": "^8.57.0 || ^9.0.0",
        "typescript": ">=4.8.4 <6.0.0"
      }
    },
    "node_modules/undici-types": {
      "version": "6.21.0",
      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/unicode-canonical-property-names-ecmascript": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz",
      "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/unicode-match-property-ecmascript": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz",
      "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "unicode-canonical-property-names-ecmascript": "^2.0.0",
        "unicode-property-aliases-ecmascript": "^2.0.0"
      },
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/unicode-match-property-value-ecmascript": {
      "version": "2.2.1",
      "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz",
      "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/unicode-property-aliases-ecmascript": {
      "version": "2.2.0",
      "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz",
      "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/update-browserslist-db": {
      "version": "1.1.4",
      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.4.tgz",
      "integrity": "sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==",
      "dev": true,
      "funding": [
        {
          "type": "opencollective",
          "url": "https://opencollective.com/browserslist"
        },
        {
          "type": "tidelift",
          "url": "https://tidelift.com/funding/github/npm/browserslist"
        },
        {
          "type": "github",
          "url": "https://github.com/sponsors/ai"
        }
      ],
      "license": "MIT",
      "dependencies": {
        "escalade": "^3.2.0",
        "picocolors": "^1.1.1"
      },
      "bin": {
        "update-browserslist-db": "cli.js"
      },
      "peerDependencies": {
        "browserslist": ">= 4.21.0"
      }
    },
    "node_modules/uri-js": {
      "version": "4.4.1",
      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
      "dev": true,
      "license": "BSD-2-Clause",
      "dependencies": {
        "punycode": "^2.1.0"
      }
    },
    "node_modules/v8-to-istanbul": {
      "version": "9.3.0",
      "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz",
      "integrity": "sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "@jridgewell/trace-mapping": "^0.3.12",
        "@types/istanbul-lib-coverage": "^2.0.1",
        "convert-source-map": "^2.0.0"
      },
      "engines": {
        "node": ">=10.12.0"
      }
    },
    "node_modules/walker": {
      "version": "1.0.8",
      "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz",
      "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==",
      "dev": true,
      "license": "Apache-2.0",
      "dependencies": {
        "makeerror": "1.0.12"
      }
    },
    "node_modules/which": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "isexe": "^2.0.0"
      },
      "bin": {
        "node-which": "bin/node-which"
      },
      "engines": {
        "node": ">= 8"
      }
    },
    "node_modules/word-wrap": {
      "version": "1.2.5",
      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/wrap-ansi": {
      "version": "7.0.0",
      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "ansi-styles": "^4.0.0",
        "string-width": "^4.1.0",
        "strip-ansi": "^6.0.0"
      },
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
      }
    },
    "node_modules/wrappy": {
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/write-file-atomic": {
      "version": "4.0.2",
      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz",
      "integrity": "sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==",
      "dev": true,
      "license": "ISC",
      "dependencies": {
        "imurmurhash": "^0.1.4",
        "signal-exit": "^3.0.7"
      },
      "engines": {
        "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
      }
    },
    "node_modules/y18n": {
      "version": "5.0.8",
      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
      "dev": true,
      "license": "ISC",
      "engines": {
        "node": ">=10"
      }
    },
    "node_modules/yallist": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
      "dev": true,
      "license": "ISC"
    },
    "node_modules/yargs": {
      "version": "17.7.2",
      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "cliui": "^8.0.1",
        "escalade": "^3.1.1",
        "get-caller-file": "^2.0.5",
        "require-directory": "^2.1.1",
        "string-width": "^4.2.3",
        "y18n": "^5.0.5",
        "yargs-parser": "^21.1.1"
      },
      "engines": {
        "node": ">=12"
      }
    },
    "node_modules/yargs-parser": {
      "version": "21.1.1",
      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
      "dev": true,
      "license": "ISC",
      "engines": {
        "node": ">=12"
      }
    },
    "node_modules/yocto-queue": {
      "version": "0.1.0",
      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=10"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    }
  }
}
eemeli-yaml-086fa6b/package.json000066400000000000000000000062661511277410200166300ustar00rootroot00000000000000{
  "name": "yaml",
  "version": "2.8.2",
  "license": "ISC",
  "author": "Eemeli Aro ",
  "funding": "https://github.com/sponsors/eemeli",
  "repository": "github:eemeli/yaml",
  "description": "JavaScript parser and stringifier for YAML",
  "keywords": [
    "YAML",
    "parser",
    "stringifier"
  ],
  "homepage": "https://eemeli.org/yaml/",
  "files": [
    "browser/",
    "dist/",
    "util.js"
  ],
  "type": "commonjs",
  "main": "./dist/index.js",
  "bin": "./bin.mjs",
  "browser": {
    "./dist/index.js": "./browser/index.js",
    "./dist/util.js": "./browser/dist/util.js",
    "./util.js": "./browser/dist/util.js"
  },
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "node": "./dist/index.js",
      "default": "./browser/index.js"
    },
    "./package.json": "./package.json",
    "./util": {
      "types": "./dist/util.d.ts",
      "node": "./dist/util.js",
      "default": "./browser/dist/util.js"
    }
  },
  "scripts": {
    "build": "npm run build:node && npm run build:browser",
    "build:browser": "rollup -c config/rollup.browser-config.mjs",
    "build:node": "rollup -c config/rollup.node-config.mjs",
    "clean": "git clean -fdxe node_modules",
    "lint": "eslint config/ src/",
    "prettier": "prettier --write .",
    "prestart": "rollup --sourcemap -c config/rollup.node-config.mjs",
    "start": "node --enable-source-maps -i -e 'YAML=require(\"./dist/index.js\");const{parse,parseDocument,parseAllDocuments}=YAML'",
    "test": "jest --config config/jest.config.js",
    "test:all": "npm test && npm run test:types && npm run test:dist && npm run test:dist:types",
    "test:browsers": "cd playground && npm test",
    "test:dist": "npm run build:node && jest --config config/jest.config.js",
    "test:dist:types": "tsc --allowJs --moduleResolution node --noEmit --target es5 dist/index.js",
    "test:types": "tsc --noEmit && tsc --noEmit -p tests/tsconfig.json",
    "docs:install": "cd docs-slate && bundle install",
    "predocs:deploy": "node docs/prepare-docs.mjs",
    "docs:deploy": "cd docs-slate && ./deploy.sh",
    "predocs": "node docs/prepare-docs.mjs",
    "docs": "cd docs-slate && bundle exec middleman server",
    "preversion": "npm test && npm run build",
    "prepublishOnly": "npm run clean && npm test && npm run build"
  },
  "browserslist": "defaults, not ie 11",
  "prettier": {
    "arrowParens": "avoid",
    "semi": false,
    "singleQuote": true,
    "trailingComma": "none"
  },
  "devDependencies": {
    "@babel/core": "^7.12.10",
    "@babel/plugin-transform-typescript": "^7.12.17",
    "@babel/preset-env": "^7.12.11",
    "@eslint/js": "^9.9.1",
    "@rollup/plugin-babel": "^6.0.3",
    "@rollup/plugin-replace": "^6.0.3",
    "@rollup/plugin-typescript": "^12.1.1",
    "@types/jest": "^29.2.4",
    "@types/node": "^20.11.20",
    "babel-jest": "^29.0.1",
    "eslint": "^9.9.1",
    "eslint-config-prettier": "^10.1.8",
    "fast-check": "^2.12.0",
    "jest": "^29.0.1",
    "jest-resolve": "^29.7.0",
    "jest-ts-webcompat-resolver": "^1.0.0",
    "prettier": "^3.0.2",
    "rollup": "^4.12.0",
    "tslib": "^2.8.1",
    "typescript": "^5.7.2",
    "typescript-eslint": "^8.4.0"
  },
  "engines": {
    "node": ">= 14.6"
  }
}
eemeli-yaml-086fa6b/playground/000077500000000000000000000000001511277410200165145ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/000077500000000000000000000000001511277410200151175ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/cli.ts000066400000000000000000000146141511277410200162440ustar00rootroot00000000000000import { resolve } from 'node:path'
import { parseArgs } from 'node:util'

import type { Token } from './parse/cst.ts'
import { prettyToken } from './parse/cst.ts'
import { Lexer } from './parse/lexer.ts'
import { Parser } from './parse/parser.ts'
import { Composer } from './compose/composer.ts'
import { LineCounter } from './parse/line-counter.ts'
import type { Document } from './doc/Document.ts'
import { prettifyError } from './errors.ts'
import type { visitor } from './visit.ts'
import { visit } from './visit.ts'

export const help = `\
yaml: A command-line YAML processor and inspector

Reads stdin and writes output to stdout and errors & warnings to stderr.

Usage:
  yaml          Process a YAML stream, outputting it as YAML
  yaml cst      Parse the CST of a YAML stream
  yaml lex      Parse the lexical tokens of a YAML stream
  yaml valid    Validate a YAML stream, returning 0 on success

Options:
  --help, -h    Show this message.
  --json, -j    Output JSON.
  --indent 2    Output pretty-printed data, indented by the given number of spaces.
  --merge, -m   Enable support for "<<" merge keys.

Additional options for bare "yaml" command:
  --doc, -d     Output pretty-printed JS Document objects.
  --single, -1  Require the input to consist of a single YAML document.
  --strict, -s  Stop on errors.
  --visit, -v   Apply a visitor to each document (requires a path to import)
  --yaml 1.1    Set the YAML version. (default: 1.2)`

export class UserError extends Error {
  static ARGS = 2
  static SINGLE = 3
  code: number
  constructor(code: number, message: string) {
    super(`Error: ${message}`)
    this.code = code
  }
}

export async function cli(
  stdin: NodeJS.ReadableStream,
  done: (error?: Error) => void,
  argv?: string[]
) {
  let args
  try {
    args = parseArgs({
      args: argv,
      allowPositionals: true,
      options: {
        doc: { type: 'boolean', short: 'd' },
        help: { type: 'boolean', short: 'h' },
        indent: { type: 'string', short: 'i' },
        merge: { type: 'boolean', short: 'm' },
        json: { type: 'boolean', short: 'j' },
        single: { type: 'boolean', short: '1' },
        strict: { type: 'boolean', short: 's' },
        visit: { type: 'string', short: 'v' },
        yaml: { type: 'string', default: '1.2' }
      }
    })
  } catch (error) {
    return done(new UserError(UserError.ARGS, (error as Error).message))
  }

  const {
    positionals: [mode],
    values: opt
  } = args

  let indent = Number(opt.indent)

  stdin.setEncoding('utf-8')

  // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
  switch (opt.help || mode) {
    /* istanbul ignore next */
    case true: // --help
      console.log(help)
      break

    case 'lex': {
      const lexer = new Lexer()
      const data: string[] = []
      const add = (tok: string) => {
        if (opt.json) data.push(tok)
        else console.log(prettyToken(tok))
      }
      stdin.on('data', (chunk: string) => {
        for (const tok of lexer.lex(chunk, true)) add(tok)
      })
      stdin.on('end', () => {
        for (const tok of lexer.lex('', false)) add(tok)
        if (opt.json) console.log(JSON.stringify(data, null, indent))
        done()
      })
      break
    }

    case 'cst': {
      const parser = new Parser()
      const data: Token[] = []
      const add = (tok: Token) => {
        if (opt.json) data.push(tok)
        else console.dir(tok, { depth: null })
      }
      stdin.on('data', (chunk: string) => {
        for (const tok of parser.parse(chunk, true)) add(tok)
      })
      stdin.on('end', () => {
        for (const tok of parser.parse('', false)) add(tok)
        if (opt.json) console.log(JSON.stringify(data, null, indent))
        done()
      })
      break
    }

    case undefined:
    case 'valid': {
      const lineCounter = new LineCounter()
      const parser = new Parser(lineCounter.addNewLine)
      // @ts-expect-error Version is validated at runtime
      const composer = new Composer({ version: opt.yaml, merge: opt.merge })
      const visitor: visitor | null = opt.visit
        ? (await import(resolve(opt.visit))).default
        : null
      let source = ''
      let hasDoc = false
      let reqDocEnd = false
      const data: Document[] = []
      const add = (doc: Document) => {
        if (hasDoc && opt.single) {
          return done(
            new UserError(
              UserError.SINGLE,
              'Input stream contains multiple documents'
            )
          )
        }
        for (const error of doc.errors) {
          prettifyError(source, lineCounter)(error)
          if (opt.strict || mode === 'valid') return done(error)
          console.error(error)
        }
        for (const warning of doc.warnings) {
          prettifyError(source, lineCounter)(warning)
          console.error(warning)
        }
        if (visitor) visit(doc, visitor)
        if (mode === 'valid') doc.toJS()
        else if (opt.json) data.push(doc)
        else if (opt.doc) {
          Object.defineProperties(doc, {
            options: { enumerable: false },
            schema: { enumerable: false }
          })
          console.dir(doc, { depth: null })
        } else {
          if (reqDocEnd) console.log('...')
          try {
            indent ||= 2
            const str = doc.toString({ indent })
            console.log(str.endsWith('\n') ? str.slice(0, -1) : str)
          } catch (error) {
            done(error as Error)
          }
        }
        hasDoc = true
        reqDocEnd = !doc.directives?.docEnd
      }
      stdin.on('data', (chunk: string) => {
        source += chunk
        for (const tok of parser.parse(chunk, true)) {
          for (const doc of composer.next(tok)) add(doc)
        }
      })
      stdin.on('end', () => {
        for (const tok of parser.parse('', false)) {
          for (const doc of composer.next(tok)) add(doc)
        }
        for (const doc of composer.end(false)) add(doc)
        if (opt.single && !hasDoc) {
          return done(
            new UserError(
              UserError.SINGLE,
              'Input stream contained no documents'
            )
          )
        }
        if (mode !== 'valid' && opt.json) {
          console.log(JSON.stringify(opt.single ? data[0] : data, null, indent))
        }
        done()
      })
      break
    }

    default:
      done(
        new UserError(
          UserError.ARGS,
          `Unknown command: ${JSON.stringify(mode)}`
        )
      )
  }
}
eemeli-yaml-086fa6b/src/compose/000077500000000000000000000000001511277410200165645ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/compose/compose-collection.ts000066400000000000000000000101221511277410200227260ustar00rootroot00000000000000import { isNode } from '../nodes/identity.ts'
import type { ParsedNode } from '../nodes/Node.ts'
import { Scalar } from '../nodes/Scalar.ts'
import { YAMLMap } from '../nodes/YAMLMap.ts'
import { YAMLSeq } from '../nodes/YAMLSeq.ts'
import type {
  BlockMap,
  BlockSequence,
  FlowCollection,
  SourceToken
} from '../parse/cst.ts'
import type { CollectionTag } from '../schema/types.ts'
import type { ComposeContext, ComposeNode } from './compose-node.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { resolveBlockMap } from './resolve-block-map.ts'
import { resolveBlockSeq } from './resolve-block-seq.ts'
import { resolveFlowCollection } from './resolve-flow-collection.ts'

function resolveCollection(
  CN: ComposeNode,
  ctx: ComposeContext,
  token: BlockMap | BlockSequence | FlowCollection,
  onError: ComposeErrorHandler,
  tagName: string | null,
  tag?: CollectionTag
) {
  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 as typeof YAMLMap | typeof YAMLSeq

  // 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
}

interface Props {
  anchor: SourceToken | null
  tag: SourceToken | null
  newlineAfterProp: SourceToken | null
}

export function composeCollection(
  CN: ComposeNode,
  ctx: ComposeContext,
  token: BlockMap | BlockSequence | FlowCollection,
  props: Props,
  onError: ComposeErrorHandler
) {
  const tagToken = props.tag
  const tagName: string | null = !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: 'map' | 'seq' =
    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
  ) as CollectionTag | undefined

  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 as ParsedNode)
    : (new Scalar(res) as Scalar.Parsed)
  node.range = coll.range
  node.tag = tagName
  if (tag?.format) (node as Scalar).format = tag.format
  return node
}
eemeli-yaml-086fa6b/src/compose/compose-doc.ts000066400000000000000000000037321511277410200213510ustar00rootroot00000000000000import type { Directives } from '../doc/directives.ts'
import { Document } from '../doc/Document.ts'
import type { ParsedNode } from '../nodes/Node.ts'
import type {
  DocumentOptions,
  ParseOptions,
  SchemaOptions
} from '../options.ts'
import type * as CST from '../parse/cst.ts'
import {
  type ComposeContext,
  composeEmptyNode,
  composeNode
} from './compose-node.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { resolveEnd } from './resolve-end.ts'
import { resolveProps } from './resolve-props.ts'

export function composeDoc<
  Contents extends ParsedNode = ParsedNode,
  Strict extends boolean = true
>(
  options: ParseOptions & DocumentOptions & SchemaOptions,
  directives: Directives,
  { offset, start, value, end }: CST.Document,
  onError: ComposeErrorHandler
) {
  const opts = Object.assign({ _directives: directives }, options)
  const doc = new Document(undefined, opts) as Document.Parsed
  const ctx: ComposeContext = {
    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
}
eemeli-yaml-086fa6b/src/compose/compose-node.ts000066400000000000000000000106211511277410200215240ustar00rootroot00000000000000import type { Directives } from '../doc/directives.ts'
import { Alias } from '../nodes/Alias.ts'
import { isScalar } from '../nodes/identity.ts'
import type { ParsedNode } from '../nodes/Node.ts'
import type { ParseOptions } from '../options.ts'
import type { FlowScalar, SourceToken, Token } from '../parse/cst.ts'
import type { Schema } from '../schema/Schema.ts'
import { composeCollection } from './compose-collection.ts'
import { composeScalar } from './compose-scalar.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { resolveEnd } from './resolve-end.ts'
import { emptyScalarPosition } from './util-empty-scalar-position.ts'

export interface ComposeContext {
  atKey: boolean
  atRoot: boolean
  directives: Directives
  options: Readonly>>
  schema: Readonly
}

interface Props {
  spaceBefore: boolean
  comment: string
  anchor: SourceToken | null
  tag: SourceToken | null
  newlineAfterProp: SourceToken | null
  end: number
}

const CN = { composeNode, composeEmptyNode }
export type ComposeNode = typeof CN

export function composeNode(
  ctx: ComposeContext,
  token: Token,
  props: Props,
  onError: ComposeErrorHandler
) {
  const atKey = ctx.atKey
  const { spaceBefore, comment, anchor, tag } = props
  let node: ParsedNode
  let isSrcToken = true
  switch (token.type) {
    case 'alias':
      node = composeAlias(ctx, token, onError)
      if (anchor || tag)
        onError(
          token,
          'ALIAS_PROPS',
          'An alias node must not specify any properties'
        )
      break
    case 'scalar':
    case 'single-quoted-scalar':
    case 'double-quoted-scalar':
    case 'block-scalar':
      node = composeScalar(ctx, token, tag, onError)
      if (anchor) node.anchor = anchor.source.substring(1)
      break
    case 'block-map':
    case 'block-seq':
    case 'flow-collection':
      node = composeCollection(CN, ctx, token, props, onError)
      if (anchor) node.anchor = anchor.source.substring(1)
      break
    default: {
      const message =
        token.type === 'error'
          ? token.message
          : `Unsupported token (type: ${token.type})`
      onError(token, 'UNEXPECTED_TOKEN', message)
      node = composeEmptyNode(
        ctx,
        token.offset,
        undefined,
        null,
        props,
        onError
      )
      isSrcToken = false
    }
  }
  if (anchor && node.anchor === '')
    onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string')
  if (
    atKey &&
    ctx.options.stringKeys &&
    (!isScalar(node) ||
      typeof node.value !== 'string' ||
      (node.tag && node.tag !== 'tag:yaml.org,2002:str'))
  ) {
    const msg = 'With stringKeys, all keys must be strings'
    onError(tag ?? token, 'NON_STRING_KEY', msg)
  }
  if (spaceBefore) node.spaceBefore = true
  if (comment) {
    if (token.type === 'scalar' && token.source === '') node.comment = comment
    else node.commentBefore = comment
  }
  // @ts-expect-error Type checking misses meaning of isSrcToken
  if (ctx.options.keepSourceTokens && isSrcToken) node.srcToken = token
  return node
}

export function composeEmptyNode(
  ctx: ComposeContext,
  offset: number,
  before: Token[] | undefined,
  pos: number | null,
  { spaceBefore, comment, anchor, tag, end }: Props,
  onError: ComposeErrorHandler
) {
  const token: FlowScalar = {
    type: 'scalar',
    offset: emptyScalarPosition(offset, before, pos),
    indent: -1,
    source: ''
  }
  const node = composeScalar(ctx, token, tag, onError)
  if (anchor) {
    node.anchor = anchor.source.substring(1)
    if (node.anchor === '')
      onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string')
  }
  if (spaceBefore) node.spaceBefore = true
  if (comment) {
    node.comment = comment
    node.range[2] = end
  }
  return node
}

function composeAlias(
  { options }: ComposeContext,
  { offset, source, end }: FlowScalar,
  onError: ComposeErrorHandler
) {
  const alias = new Alias(source.substring(1))
  if (alias.source === '')
    onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string')
  if (alias.source.endsWith(':'))
    onError(
      offset + source.length - 1,
      'BAD_ALIAS',
      'Alias ending in : is ambiguous',
      true
    )
  const valueEnd = offset + source.length
  const re = resolveEnd(end, valueEnd, options.strict, onError)
  alias.range = [offset, valueEnd, re.offset]
  if (re.comment) alias.comment = re.comment
  return alias as Alias.Parsed
}
eemeli-yaml-086fa6b/src/compose/compose-scalar.ts000066400000000000000000000071001511277410200220420ustar00rootroot00000000000000import { isScalar, SCALAR } from '../nodes/identity.ts'
import { Scalar } from '../nodes/Scalar.ts'
import type { BlockScalar, FlowScalar, SourceToken } from '../parse/cst.ts'
import type { Schema } from '../schema/Schema.ts'
import type { ScalarTag } from '../schema/types.ts'
import type { ComposeContext } from './compose-node.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { resolveBlockScalar } from './resolve-block-scalar.ts'
import { resolveFlowScalar } from './resolve-flow-scalar.ts'

export function composeScalar(
  ctx: ComposeContext,
  token: FlowScalar | BlockScalar,
  tagToken: SourceToken | null,
  onError: ComposeErrorHandler
) {
  const { value, type, comment, range } =
    token.type === 'block-scalar'
      ? resolveBlockScalar(ctx, token, onError)
      : resolveFlowScalar(token, ctx.options.strict, onError)

  const tagName = tagToken
    ? ctx.directives.tagName(tagToken.source, msg =>
        onError(tagToken, 'TAG_RESOLVE_FAILED', msg)
      )
    : null

  let tag: ScalarTag
  if (ctx.options.stringKeys && ctx.atKey) {
    tag = ctx.schema[SCALAR]
  } else if (tagName)
    tag = findScalarTagByName(ctx.schema, value, tagName, tagToken!, onError)
  else if (token.type === 'scalar')
    tag = findScalarTagByTest(ctx, value, token, onError)
  else tag = ctx.schema[SCALAR]

  let scalar: Scalar
  try {
    const res = tag.resolve(
      value,
      msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg),
      ctx.options
    )
    scalar = isScalar(res) ? res : new Scalar(res)
  } catch (error) {
    const msg = error instanceof Error ? error.message : String(error)
    onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg)
    scalar = new Scalar(value)
  }
  scalar.range = range
  scalar.source = value
  if (type) scalar.type = type
  if (tagName) scalar.tag = tagName
  if (tag.format) scalar.format = tag.format
  if (comment) scalar.comment = comment

  return scalar as Scalar.Parsed
}

function findScalarTagByName(
  schema: Schema,
  value: string,
  tagName: string,
  tagToken: SourceToken,
  onError: ComposeErrorHandler
) {
  if (tagName === '!') return schema[SCALAR] // non-specific tag
  const matchWithTest: ScalarTag[] = []
  for (const tag of schema.tags) {
    if (!tag.collection && tag.tag === tagName) {
      if (tag.default && tag.test) matchWithTest.push(tag)
      else return tag
    }
  }
  for (const tag of matchWithTest) if (tag.test?.test(value)) return tag
  const kt = schema.knownTags[tagName]
  if (kt && !kt.collection) {
    // Ensure that the known tag is available for stringifying,
    // but does not get used by default.
    schema.tags.push(Object.assign({}, kt, { default: false, test: undefined }))
    return kt
  }
  onError(
    tagToken,
    'TAG_RESOLVE_FAILED',
    `Unresolved tag: ${tagName}`,
    tagName !== 'tag:yaml.org,2002:str'
  )
  return schema[SCALAR]
}

function findScalarTagByTest(
  { atKey, directives, schema }: ComposeContext,
  value: string,
  token: FlowScalar,
  onError: ComposeErrorHandler
) {
  const tag =
    (schema.tags.find(
      tag =>
        (tag.default === true || (atKey && tag.default === 'key')) &&
        tag.test?.test(value)
    ) as ScalarTag) || schema[SCALAR]

  if (schema.compat) {
    const compat =
      schema.compat.find(tag => tag.default && tag.test?.test(value)) ??
      schema[SCALAR]
    if (tag.tag !== compat.tag) {
      const ts = directives.tagString(tag.tag)
      const cs = directives.tagString(compat.tag)
      const msg = `Value may be parsed as either ${ts} or ${cs}`
      onError(token, 'TAG_RESOLVE_FAILED', msg, true)
    }
  }

  return tag
}
eemeli-yaml-086fa6b/src/compose/composer.ts000066400000000000000000000211711511277410200207650ustar00rootroot00000000000000import { env } from 'node:process'
import { Directives } from '../doc/directives.ts'
import { Document } from '../doc/Document.ts'
import type { ErrorCode } from '../errors.ts'
import { YAMLParseError, YAMLWarning } from '../errors.ts'
import { isCollection, isPair } from '../nodes/identity.ts'
import type { ParsedNode, Range } from '../nodes/Node.ts'
import type {
  DocumentOptions,
  ParseOptions,
  SchemaOptions
} from '../options.ts'
import type { Token } from '../parse/cst.ts'
import { composeDoc } from './compose-doc.ts'
import { resolveEnd } from './resolve-end.ts'

type ErrorSource =
  | number
  | [number, number]
  | Range
  | { offset: number; source?: string }

export type ComposeErrorHandler = (
  source: ErrorSource,
  code: ErrorCode,
  message: string,
  warning?: boolean
) => void

function getErrorPos(src: ErrorSource): [number, number] {
  if (typeof src === 'number') return [src, src + 1]
  if (Array.isArray(src)) return src.length === 2 ? src : [src[0], src[1]]
  const { offset, source } = src
  return [offset, offset + (typeof source === 'string' ? source.length : 1)]
}

function parsePrelude(prelude: string[]) {
  let comment = ''
  let atComment = false
  let afterEmptyLine = false
  for (let i = 0; i < prelude.length; ++i) {
    const source = prelude[i]
    switch (source[0]) {
      case '#':
        comment +=
          (comment === '' ? '' : afterEmptyLine ? '\n\n' : '\n') +
          (source.substring(1) || ' ')
        atComment = true
        afterEmptyLine = false
        break
      case '%':
        if (prelude[i + 1]?.[0] !== '#') i += 1
        atComment = false
        break
      default:
        // This may be wrong after doc-end, but in that case it doesn't matter
        if (!atComment) afterEmptyLine = true
        atComment = false
    }
  }
  return { comment, afterEmptyLine }
}

/**
 * Compose a stream of CST nodes into a stream of YAML Documents.
 *
 * ```ts
 * import { Composer, Parser } from 'yaml'
 *
 * const src: string = ...
 * const tokens = new Parser().parse(src)
 * const docs = new Composer().compose(tokens)
 * ```
 */
export class Composer<
  Contents extends ParsedNode = ParsedNode,
  Strict extends boolean = true
> {
  private directives: Directives
  private doc: Document.Parsed | null = null
  private options: ParseOptions & DocumentOptions & SchemaOptions
  private atDirectives = false
  private prelude: string[] = []
  private errors: YAMLParseError[] = []
  private warnings: YAMLWarning[] = []

  constructor(options: ParseOptions & DocumentOptions & SchemaOptions = {}) {
    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
    this.directives = new Directives({ version: options.version || '1.2' })
    this.options = options
  }

  private onError: ComposeErrorHandler = (source, code, message, warning) => {
    const pos = getErrorPos(source)
    if (warning) this.warnings.push(new YAMLWarning(pos, code, message))
    else this.errors.push(new YAMLParseError(pos, code, message))
  }

  private decorate(doc: Document.Parsed, afterDoc: boolean) {
    const { comment, afterEmptyLine } = parsePrelude(this.prelude)
    //console.log({ dc: doc.comment, prelude, comment })
    if (comment) {
      const dc = doc.contents
      if (afterDoc) {
        doc.comment = doc.comment ? `${doc.comment}\n${comment}` : comment
      } else if (afterEmptyLine || doc.directives.docStart || !dc) {
        doc.commentBefore = comment
      } else if (isCollection(dc) && !dc.flow && dc.items.length > 0) {
        let it = dc.items[0]
        if (isPair(it)) it = it.key
        const cb = it.commentBefore
        it.commentBefore = cb ? `${comment}\n${cb}` : comment
      } else {
        const cb = dc.commentBefore
        dc.commentBefore = cb ? `${comment}\n${cb}` : comment
      }
    }

    if (afterDoc) {
      Array.prototype.push.apply(doc.errors, this.errors)
      Array.prototype.push.apply(doc.warnings, this.warnings)
    } else {
      doc.errors = this.errors
      doc.warnings = this.warnings
    }

    this.prelude = []
    this.errors = []
    this.warnings = []
  }

  /**
   * Current stream status information.
   *
   * Mostly useful at the end of input for an empty stream.
   */
  streamInfo(): {
    comment: string
    directives: Directives
    errors: YAMLParseError[]
    warnings: YAMLWarning[]
  } {
    return {
      comment: parsePrelude(this.prelude).comment,
      directives: this.directives,
      errors: this.errors,
      warnings: this.warnings
    }
  }

  /**
   * Compose tokens into documents.
   *
   * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
   * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
   */
  *compose(
    tokens: Iterable,
    forceDoc = false,
    endOffset = -1
  ): Generator, void, unknown> {
    for (const token of tokens) yield* this.next(token)
    yield* this.end(forceDoc, endOffset)
  }

  /** Advance the composer by one CST token. */
  *next(
    token: Token
  ): Generator, void, unknown> {
    if (env.LOG_STREAM) console.dir(token, { depth: null })
    switch (token.type) {
      case 'directive':
        this.directives.add(token.source, (offset, message, warning) => {
          const pos = getErrorPos(token)
          pos[0] += offset
          this.onError(pos, 'BAD_DIRECTIVE', message, warning)
        })
        this.prelude.push(token.source)
        this.atDirectives = true
        break
      case 'document': {
        const doc = composeDoc(
          this.options,
          this.directives,
          token,
          this.onError
        )
        if (this.atDirectives && !doc.directives.docStart)
          this.onError(
            token,
            'MISSING_CHAR',
            'Missing directives-end/doc-start indicator line'
          )
        this.decorate(doc, false)
        if (this.doc) yield this.doc
        this.doc = doc
        this.atDirectives = false
        break
      }
      case 'byte-order-mark':
      case 'space':
        break
      case 'comment':
      case 'newline':
        this.prelude.push(token.source)
        break
      case 'error': {
        const msg = token.source
          ? `${token.message}: ${JSON.stringify(token.source)}`
          : token.message
        const error = new YAMLParseError(
          getErrorPos(token),
          'UNEXPECTED_TOKEN',
          msg
        )
        if (this.atDirectives || !this.doc) this.errors.push(error)
        else this.doc.errors.push(error)
        break
      }
      case 'doc-end': {
        if (!this.doc) {
          const msg = 'Unexpected doc-end without preceding document'
          this.errors.push(
            new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg)
          )
          break
        }
        this.doc.directives.docEnd = true
        const end = resolveEnd(
          token.end,
          token.offset + token.source.length,
          this.doc.options.strict,
          this.onError
        )
        this.decorate(this.doc, true)
        if (end.comment) {
          const dc = this.doc.comment
          this.doc.comment = dc ? `${dc}\n${end.comment}` : end.comment
        }
        this.doc.range[2] = end.offset
        break
      }
      default:
        this.errors.push(
          new YAMLParseError(
            getErrorPos(token),
            'UNEXPECTED_TOKEN',
            `Unsupported token ${token.type}`
          )
        )
    }
  }

  /**
   * Call at end of input to yield any remaining document.
   *
   * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
   * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
   */
  *end(
    forceDoc = false,
    endOffset = -1
  ): Generator, void, unknown> {
    if (this.doc) {
      this.decorate(this.doc, true)
      yield this.doc
      this.doc = null
    } else if (forceDoc) {
      const opts = Object.assign({ _directives: this.directives }, this.options)
      const doc = new Document(undefined, opts) as Document.Parsed<
        Contents,
        Strict
      >
      if (this.atDirectives)
        this.onError(
          endOffset,
          'MISSING_CHAR',
          'Missing directives-end indicator line'
        )
      doc.range = [0, endOffset, endOffset]
      this.decorate(doc, false)
      yield doc
    }
  }
}
eemeli-yaml-086fa6b/src/compose/resolve-block-map.ts000066400000000000000000000114061511277410200224600ustar00rootroot00000000000000import type { ParsedNode } from '../nodes/Node.ts'
import { Pair } from '../nodes/Pair.ts'
import { YAMLMap } from '../nodes/YAMLMap.ts'
import type { BlockMap } from '../parse/cst.ts'
import type { CollectionTag } from '../schema/types.ts'
import type { ComposeContext, ComposeNode } from './compose-node.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { resolveProps } from './resolve-props.ts'
import { containsNewline } from './util-contains-newline.ts'
import { flowIndentCheck } from './util-flow-indent-check.ts'
import { mapIncludes } from './util-map-includes.ts'

const startColMsg = 'All mapping items must start at the same column'

export function resolveBlockMap(
  { composeNode, composeEmptyNode }: ComposeNode,
  ctx: ComposeContext,
  bm: BlockMap,
  onError: ComposeErrorHandler,
  tag?: CollectionTag
) {
  const NodeClass = tag?.nodeClass ?? YAMLMap
  const map = new NodeClass(ctx.schema) as YAMLMap

  if (ctx.atRoot) ctx.atRoot = false
  let offset = bm.offset
  let commentEnd: number | null = null
  for (const collItem of bm.items) {
    const { start, key, sep, value } = collItem

    // key properties
    const keyProps = resolveProps(start, {
      indicator: 'explicit-key-ind',
      next: key ?? sep?.[0],
      offset,
      onError,
      parentIndent: bm.indent,
      startOnNewline: true
    })
    const implicitKey = !keyProps.found
    if (implicitKey) {
      if (key) {
        if (key.type === 'block-seq')
          onError(
            offset,
            'BLOCK_AS_IMPLICIT_KEY',
            'A block sequence may not be used as an implicit map key'
          )
        else if ('indent' in key && key.indent !== bm.indent)
          onError(offset, 'BAD_INDENT', startColMsg)
      }
      if (!keyProps.anchor && !keyProps.tag && !sep) {
        commentEnd = keyProps.end
        if (keyProps.comment) {
          if (map.comment) map.comment += '\n' + keyProps.comment
          else map.comment = keyProps.comment
        }
        continue
      }
      if (keyProps.newlineAfterProp || containsNewline(key)) {
        onError(
          key ?? start[start.length - 1],
          'MULTILINE_IMPLICIT_KEY',
          'Implicit keys need to be on a single line'
        )
      }
    } else if (keyProps.found?.indent !== bm.indent) {
      onError(offset, 'BAD_INDENT', startColMsg)
    }

    // key value
    ctx.atKey = true
    const keyStart = keyProps.end
    const keyNode = key
      ? composeNode(ctx, key, keyProps, onError)
      : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError)
    if (ctx.schema.compat) flowIndentCheck(bm.indent, key, onError)
    ctx.atKey = false

    if (mapIncludes(ctx, map.items, keyNode))
      onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique')

    // value properties
    const valueProps = resolveProps(sep ?? [], {
      indicator: 'map-value-ind',
      next: value,
      offset: keyNode.range[2],
      onError,
      parentIndent: bm.indent,
      startOnNewline: !key || key.type === 'block-scalar'
    })
    offset = valueProps.end

    if (valueProps.found) {
      if (implicitKey) {
        if (value?.type === 'block-map' && !valueProps.hasNewline)
          onError(
            offset,
            'BLOCK_AS_IMPLICIT_KEY',
            'Nested mappings are not allowed in compact mappings'
          )
        if (
          ctx.options.strict &&
          keyProps.start < valueProps.found.offset - 1024
        )
          onError(
            keyNode.range,
            'KEY_OVER_1024_CHARS',
            'The : indicator must be at most 1024 chars after the start of an implicit block mapping key'
          )
      }
      // value value
      const valueNode = value
        ? composeNode(ctx, value, valueProps, onError)
        : composeEmptyNode(ctx, offset, sep, null, valueProps, onError)
      if (ctx.schema.compat) flowIndentCheck(bm.indent, value, onError)
      offset = valueNode.range[2]
      const pair = new Pair(keyNode, valueNode)
      if (ctx.options.keepSourceTokens) pair.srcToken = collItem
      map.items.push(pair)
    } else {
      // key with no value
      if (implicitKey)
        onError(
          keyNode.range,
          'MISSING_CHAR',
          'Implicit map keys need to be followed by map values'
        )
      if (valueProps.comment) {
        if (keyNode.comment) keyNode.comment += '\n' + valueProps.comment
        else keyNode.comment = valueProps.comment
      }
      const pair: Pair = new Pair(keyNode)
      if (ctx.options.keepSourceTokens) pair.srcToken = collItem
      map.items.push(pair)
    }
  }

  if (commentEnd && commentEnd < offset)
    onError(commentEnd, 'IMPOSSIBLE', 'Map comment with trailing content')
  map.range = [bm.offset, offset, commentEnd ?? offset]
  return map as YAMLMap.Parsed
}
eemeli-yaml-086fa6b/src/compose/resolve-block-scalar.ts000066400000000000000000000153371511277410200231570ustar00rootroot00000000000000import type { Range } from '../nodes/Node.ts'
import { Scalar } from '../nodes/Scalar.ts'
import type { BlockScalar } from '../parse/cst.ts'
import type { ComposeContext } from './compose-node.ts'
import type { ComposeErrorHandler } from './composer.ts'

export function resolveBlockScalar(
  ctx: ComposeContext,
  scalar: BlockScalar,
  onError: ComposeErrorHandler
): {
  value: string
  type: Scalar.BLOCK_FOLDED | Scalar.BLOCK_LITERAL | null
  comment: string
  range: Range
} {
  const start = scalar.offset
  const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError)
  if (!header)
    return { value: '', type: null, comment: '', range: [start, start, start] }
  const type = header.mode === '>' ? Scalar.BLOCK_FOLDED : Scalar.BLOCK_LITERAL
  const lines = scalar.source ? splitLines(scalar.source) : []

  // determine the end of content & start of chomping
  let chompStart = lines.length
  for (let i = lines.length - 1; i >= 0; --i) {
    const content = lines[i][1]
    if (content === '' || content === '\r') chompStart = i
    else break
  }

  // shortcut for empty contents
  if (chompStart === 0) {
    const value =
      header.chomp === '+' && lines.length > 0
        ? '\n'.repeat(Math.max(1, lines.length - 1))
        : ''
    let end = start + header.length
    if (scalar.source) end += scalar.source.length
    return { value, type, comment: header.comment, range: [start, end, end] }
  }

  // find the indentation level to trim from start
  let trimIndent = scalar.indent + header.indent
  let offset = scalar.offset + header.length
  let contentStart = 0
  for (let i = 0; i < chompStart; ++i) {
    const [indent, content] = lines[i]
    if (content === '' || content === '\r') {
      if (header.indent === 0 && indent.length > trimIndent)
        trimIndent = indent.length
    } else {
      if (indent.length < trimIndent) {
        const message =
          'Block scalars with more-indented leading empty lines must use an explicit indentation indicator'
        onError(offset + indent.length, 'MISSING_CHAR', message)
      }
      if (header.indent === 0) trimIndent = indent.length
      contentStart = i
      if (trimIndent === 0 && !ctx.atRoot) {
        const message = 'Block scalar values in collections must be indented'
        onError(offset, 'BAD_INDENT', message)
      }
      break
    }
    offset += indent.length + content.length + 1
  }

  // include trailing more-indented empty lines in content
  for (let i = lines.length - 1; i >= chompStart; --i) {
    if (lines[i][0].length > trimIndent) chompStart = i + 1
  }

  let value = ''
  let sep = ''
  let prevMoreIndented = false

  // leading whitespace is kept intact
  for (let i = 0; i < contentStart; ++i)
    value += lines[i][0].slice(trimIndent) + '\n'

  for (let i = contentStart; i < chompStart; ++i) {
    let [indent, content] = lines[i]
    offset += indent.length + content.length + 1
    const crlf = content[content.length - 1] === '\r'
    if (crlf) content = content.slice(0, -1)

    /* istanbul ignore if already caught in lexer */
    if (content && indent.length < trimIndent) {
      const src = header.indent
        ? 'explicit indentation indicator'
        : 'first line'
      const message = `Block scalar lines must not be less indented than their ${src}`
      onError(offset - content.length - (crlf ? 2 : 1), 'BAD_INDENT', message)
      indent = ''
    }

    if (type === Scalar.BLOCK_LITERAL) {
      value += sep + indent.slice(trimIndent) + content
      sep = '\n'
    } else if (indent.length > trimIndent || content[0] === '\t') {
      // more-indented content within a folded block
      if (sep === ' ') sep = '\n'
      else if (!prevMoreIndented && sep === '\n') sep = '\n\n'
      value += sep + indent.slice(trimIndent) + content
      sep = '\n'
      prevMoreIndented = true
    } else if (content === '') {
      // empty line
      if (sep === '\n') value += '\n'
      else sep = '\n'
    } else {
      value += sep + content
      sep = ' '
      prevMoreIndented = false
    }
  }

  switch (header.chomp) {
    case '-':
      break
    case '+':
      for (let i = chompStart; i < lines.length; ++i)
        value += '\n' + lines[i][0].slice(trimIndent)
      if (value[value.length - 1] !== '\n') value += '\n'
      break
    default:
      value += '\n'
  }

  const end = start + header.length + scalar.source.length
  return { value, type, comment: header.comment, range: [start, end, end] }
}

function parseBlockScalarHeader(
  { offset, props }: BlockScalar,
  strict: boolean,
  onError: ComposeErrorHandler
) {
  /* istanbul ignore if should not happen */
  if (props[0].type !== 'block-scalar-header') {
    onError(props[0], 'IMPOSSIBLE', 'Block scalar header not found')
    return null
  }
  const { source } = props[0]
  const mode = source[0] as '>' | '|'
  let indent = 0
  let chomp: '' | '-' | '+' = ''
  let error = -1
  for (let i = 1; i < source.length; ++i) {
    const ch = source[i]
    if (!chomp && (ch === '-' || ch === '+')) chomp = ch
    else {
      const n = Number(ch)
      if (!indent && n) indent = n
      else if (error === -1) error = offset + i
    }
  }
  if (error !== -1)
    onError(
      error,
      'UNEXPECTED_TOKEN',
      `Block scalar header includes extra characters: ${source}`
    )
  let hasSpace = false
  let comment = ''
  let length = source.length
  for (let i = 1; i < props.length; ++i) {
    const token = props[i]
    switch (token.type) {
      case 'space':
        hasSpace = true
      // fallthrough
      case 'newline':
        length += token.source.length
        break
      case 'comment':
        if (strict && !hasSpace) {
          const message =
            'Comments must be separated from other tokens by white space characters'
          onError(token, 'MISSING_CHAR', message)
        }
        length += token.source.length
        comment = token.source.substring(1)
        break
      case 'error':
        onError(token, 'UNEXPECTED_TOKEN', token.message)
        length += token.source.length
        break
      /* istanbul ignore next should not happen */
      default: {
        const message = `Unexpected token in block scalar header: ${token.type}`
        onError(token, 'UNEXPECTED_TOKEN', message)
        const ts = (token as any).source
        if (ts && typeof ts === 'string') length += ts.length
      }
    }
  }
  return { mode, indent, chomp, comment, length }
}

/** @returns Array of lines split up as `[indent, content]` */
function splitLines(source: string) {
  const split = source.split(/\n( *)/)
  const first = split[0]
  const m = first.match(/^( *)/)
  const line0: [string, string] = m?.[1]
    ? [m[1], first.slice(m[1].length)]
    : ['', first]
  const lines = [line0]
  for (let i = 1; i < split.length; i += 2) lines.push([split[i], split[i + 1]])
  return lines
}
eemeli-yaml-086fa6b/src/compose/resolve-block-seq.ts000066400000000000000000000035301511277410200224720ustar00rootroot00000000000000import { YAMLSeq } from '../nodes/YAMLSeq.ts'
import type { BlockSequence } from '../parse/cst.ts'
import type { CollectionTag } from '../schema/types.ts'
import type { ComposeContext, ComposeNode } from './compose-node.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { resolveProps } from './resolve-props.ts'
import { flowIndentCheck } from './util-flow-indent-check.ts'

export function resolveBlockSeq(
  { composeNode, composeEmptyNode }: ComposeNode,
  ctx: ComposeContext,
  bs: BlockSequence,
  onError: ComposeErrorHandler,
  tag?: CollectionTag
) {
  const NodeClass = tag?.nodeClass ?? YAMLSeq
  const seq = new NodeClass(ctx.schema) as YAMLSeq

  if (ctx.atRoot) ctx.atRoot = false
  if (ctx.atKey) ctx.atKey = false
  let offset = bs.offset
  let commentEnd: number | null = null
  for (const { start, value } of bs.items) {
    const props = resolveProps(start, {
      indicator: 'seq-item-ind',
      next: value,
      offset,
      onError,
      parentIndent: bs.indent,
      startOnNewline: true
    })
    if (!props.found) {
      if (props.anchor || props.tag || value) {
        if (value?.type === 'block-seq')
          onError(
            props.end,
            'BAD_INDENT',
            'All sequence items must start at the same column'
          )
        else
          onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator')
      } else {
        commentEnd = props.end
        if (props.comment) seq.comment = props.comment
        continue
      }
    }
    const node = value
      ? composeNode(ctx, value, props, onError)
      : composeEmptyNode(ctx, props.end, start, null, props, onError)
    if (ctx.schema.compat) flowIndentCheck(bs.indent, value, onError)
    offset = node.range[2]
    seq.items.push(node)
  }
  seq.range = [bs.offset, offset, commentEnd ?? offset]
  return seq as YAMLSeq.Parsed
}
eemeli-yaml-086fa6b/src/compose/resolve-end.ts000066400000000000000000000022001511277410200213510ustar00rootroot00000000000000import type { SourceToken } from '../parse/cst.ts'
import type { ComposeErrorHandler } from './composer.ts'

export function resolveEnd(
  end: SourceToken[] | undefined,
  offset: number,
  reqSpace: boolean,
  onError: ComposeErrorHandler
) {
  let comment = ''
  if (end) {
    let hasSpace = false
    let sep = ''
    for (const token of end) {
      const { source, type } = token
      switch (type) {
        case 'space':
          hasSpace = true
          break
        case 'comment': {
          if (reqSpace && !hasSpace)
            onError(
              token,
              'MISSING_CHAR',
              'Comments must be separated from other tokens by white space characters'
            )
          const cb = source.substring(1) || ' '
          if (!comment) comment = cb
          else comment += sep + cb
          sep = ''
          break
        }
        case 'newline':
          if (comment) sep += source
          hasSpace = true
          break
        default:
          onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${type} at node end`)
      }
      offset += source.length
    }
  }
  return { comment, offset }
}
eemeli-yaml-086fa6b/src/compose/resolve-flow-collection.ts000066400000000000000000000175751511277410200237300ustar00rootroot00000000000000import { isPair } from '../nodes/identity.ts'
import { Pair } from '../nodes/Pair.ts'
import { YAMLMap } from '../nodes/YAMLMap.ts'
import { YAMLSeq } from '../nodes/YAMLSeq.ts'
import type { FlowCollection, Token } from '../parse/cst.ts'
import type { Schema } from '../schema/Schema.ts'
import type { CollectionTag } from '../schema/types.ts'
import type { ComposeContext, ComposeNode } from './compose-node.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { resolveEnd } from './resolve-end.ts'
import { resolveProps } from './resolve-props.ts'
import { containsNewline } from './util-contains-newline.ts'
import { mapIncludes } from './util-map-includes.ts'

const blockMsg = 'Block collections are not allowed within flow collections'
const isBlock = (token: Token | null | undefined) =>
  token && (token.type === 'block-map' || token.type === 'block-seq')

export function resolveFlowCollection(
  { composeNode, composeEmptyNode }: ComposeNode,
  ctx: ComposeContext,
  fc: FlowCollection,
  onError: ComposeErrorHandler,
  tag?: CollectionTag
) {
  const isMap = fc.start.source === '{'
  const fcName = isMap ? 'flow map' : 'flow sequence'
  const NodeClass = (tag?.nodeClass ?? (isMap ? YAMLMap : YAMLSeq)) as {
    new (schema: Schema): YAMLMap.Parsed | YAMLSeq.Parsed
  }
  const coll = new NodeClass(ctx.schema)
  coll.flow = true
  const atRoot = ctx.atRoot
  if (atRoot) ctx.atRoot = false
  if (ctx.atKey) ctx.atKey = false

  let offset = fc.offset + fc.start.source.length
  for (let i = 0; i < fc.items.length; ++i) {
    const collItem = fc.items[i]
    const { start, key, sep, value } = collItem

    const props = resolveProps(start, {
      flow: fcName,
      indicator: 'explicit-key-ind',
      next: key ?? sep?.[0],
      offset,
      onError,
      parentIndent: fc.indent,
      startOnNewline: false
    })
    if (!props.found) {
      if (!props.anchor && !props.tag && !sep && !value) {
        if (i === 0 && props.comma)
          onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`)
        else if (i < fc.items.length - 1)
          onError(
            props.start,
            'UNEXPECTED_TOKEN',
            `Unexpected empty item in ${fcName}`
          )
        if (props.comment) {
          if (coll.comment) coll.comment += '\n' + props.comment
          else coll.comment = props.comment
        }
        offset = props.end
        continue
      }
      if (!isMap && ctx.options.strict && containsNewline(key))
        onError(
          key as Token, // checked by containsNewline()
          'MULTILINE_IMPLICIT_KEY',
          'Implicit keys of flow sequence pairs need to be on a single line'
        )
    }
    if (i === 0) {
      if (props.comma)
        onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`)
    } else {
      if (!props.comma)
        onError(
          props.start,
          'MISSING_CHAR',
          `Missing , between ${fcName} items`
        )
      if (props.comment) {
        let prevItemComment = ''
        loop: for (const st of start) {
          switch (st.type) {
            case 'comma':
            case 'space':
              break
            case 'comment':
              prevItemComment = st.source.substring(1)
              break loop
            default:
              break loop
          }
        }
        if (prevItemComment) {
          let prev = coll.items[coll.items.length - 1]
          if (isPair(prev)) prev = prev.value ?? prev.key
          if (prev.comment) prev.comment += '\n' + prevItemComment
          else prev.comment = prevItemComment
          props.comment = props.comment.substring(prevItemComment.length + 1)
        }
      }
    }

    if (!isMap && !sep && !props.found) {
      // item is a value in a seq
      // → key & sep are empty, start does not include ? or :
      const valueNode = value
        ? composeNode(ctx, value, props, onError)
        : composeEmptyNode(ctx, props.end, sep, null, props, onError)
      ;(coll as YAMLSeq).items.push(valueNode)
      offset = valueNode.range[2]
      if (isBlock(value)) onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg)
    } else {
      // item is a key+value pair

      // key value
      ctx.atKey = true
      const keyStart = props.end
      const keyNode = key
        ? composeNode(ctx, key, props, onError)
        : composeEmptyNode(ctx, keyStart, start, null, props, onError)
      if (isBlock(key)) onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg)
      ctx.atKey = false

      // value properties
      const valueProps = resolveProps(sep ?? [], {
        flow: fcName,
        indicator: 'map-value-ind',
        next: value,
        offset: keyNode.range[2],
        onError,
        parentIndent: fc.indent,
        startOnNewline: false
      })

      if (valueProps.found) {
        if (!isMap && !props.found && ctx.options.strict) {
          if (sep)
            for (const st of sep) {
              if (st === valueProps.found) break
              if (st.type === 'newline') {
                onError(
                  st,
                  'MULTILINE_IMPLICIT_KEY',
                  'Implicit keys of flow sequence pairs need to be on a single line'
                )
                break
              }
            }
          if (props.start < valueProps.found.offset - 1024)
            onError(
              valueProps.found,
              'KEY_OVER_1024_CHARS',
              'The : indicator must be at most 1024 chars after the start of an implicit flow sequence key'
            )
        }
      } else if (value) {
        if ('source' in value && value.source?.[0] === ':')
          onError(value, 'MISSING_CHAR', `Missing space after : in ${fcName}`)
        else
          onError(
            valueProps.start,
            'MISSING_CHAR',
            `Missing , or : between ${fcName} items`
          )
      }

      // value value
      const valueNode = value
        ? composeNode(ctx, value, valueProps, onError)
        : valueProps.found
          ? composeEmptyNode(
              ctx,
              valueProps.end,
              sep,
              null,
              valueProps,
              onError
            )
          : null
      if (valueNode) {
        if (isBlock(value)) onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg)
      } else if (valueProps.comment) {
        if (keyNode.comment) keyNode.comment += '\n' + valueProps.comment
        else keyNode.comment = valueProps.comment
      }

      const pair = new Pair(keyNode, valueNode)
      if (ctx.options.keepSourceTokens) pair.srcToken = collItem
      if (isMap) {
        const map = coll as YAMLMap.Parsed
        if (mapIncludes(ctx, map.items, keyNode))
          onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique')
        map.items.push(pair)
      } else {
        const map = new YAMLMap(ctx.schema)
        map.flow = true
        map.items.push(pair)
        const endRange = (valueNode ?? keyNode).range
        map.range = [keyNode.range[0], endRange[1], endRange[2]]
        ;(coll as YAMLSeq).items.push(map)
      }
      offset = valueNode ? valueNode.range[2] : valueProps.end
    }
  }

  const expectedEnd = isMap ? '}' : ']'
  const [ce, ...ee] = fc.end
  let cePos = offset
  if (ce?.source === expectedEnd) cePos = ce.offset + ce.source.length
  else {
    const name = fcName[0].toUpperCase() + fcName.substring(1)
    const msg = atRoot
      ? `${name} must end with a ${expectedEnd}`
      : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`
    onError(offset, atRoot ? 'MISSING_CHAR' : 'BAD_INDENT', msg)
    if (ce && ce.source.length !== 1) ee.unshift(ce)
  }
  if (ee.length > 0) {
    const end = resolveEnd(ee, cePos, ctx.options.strict, onError)
    if (end.comment) {
      if (coll.comment) coll.comment += '\n' + end.comment
      else coll.comment = end.comment
    }
    coll.range = [fc.offset, cePos, end.offset]
  } else {
    coll.range = [fc.offset, cePos, cePos]
  }

  return coll
}
eemeli-yaml-086fa6b/src/compose/resolve-flow-scalar.ts000066400000000000000000000156271511277410200230360ustar00rootroot00000000000000import type { ErrorCode } from '../errors.ts'
import type { Range } from '../nodes/Node.ts'
import { Scalar } from '../nodes/Scalar.ts'
import type { FlowScalar } from '../parse/cst.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { resolveEnd } from './resolve-end.ts'

type FlowScalarErrorHandler = (
  offset: number,
  code: ErrorCode,
  message: string
) => void

export function resolveFlowScalar(
  scalar: FlowScalar,
  strict: boolean,
  onError: ComposeErrorHandler
): {
  value: string
  type: Scalar.PLAIN | Scalar.QUOTE_DOUBLE | Scalar.QUOTE_SINGLE | null
  comment: string
  range: Range
} {
  const { offset, type, source, end } = scalar
  let _type: Scalar.PLAIN | Scalar.QUOTE_DOUBLE | Scalar.QUOTE_SINGLE
  let value: string
  const _onError: FlowScalarErrorHandler = (rel, code, msg) =>
    onError(offset + rel, code, msg)
  switch (type) {
    case 'scalar':
      _type = Scalar.PLAIN
      value = plainValue(source, _onError)
      break

    case 'single-quoted-scalar':
      _type = Scalar.QUOTE_SINGLE
      value = singleQuotedValue(source, _onError)
      break

    case 'double-quoted-scalar':
      _type = Scalar.QUOTE_DOUBLE
      value = doubleQuotedValue(source, _onError)
      break

    /* istanbul ignore next should not happen */
    default:
      onError(
        scalar,
        'UNEXPECTED_TOKEN',
        `Expected a flow scalar value, but found: ${type}`
      )
      return {
        value: '',
        type: null,
        comment: '',
        range: [offset, offset + source.length, offset + source.length]
      }
  }

  const valueEnd = offset + source.length
  const re = resolveEnd(end, valueEnd, strict, onError)
  return {
    value,
    type: _type,
    comment: re.comment,
    range: [offset, valueEnd, re.offset]
  }
}

function plainValue(source: string, onError: FlowScalarErrorHandler) {
  let badChar = ''
  switch (source[0]) {
    /* istanbul ignore next should not happen */
    case '\t':
      badChar = 'a tab character'
      break
    case ',':
      badChar = 'flow indicator character ,'
      break
    case '%':
      badChar = 'directive indicator character %'
      break
    case '|':
    case '>': {
      badChar = `block scalar indicator ${source[0]}`
      break
    }
    case '@':
    case '`': {
      badChar = `reserved character ${source[0]}`
      break
    }
  }
  if (badChar)
    onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`)
  return foldLines(source)
}

function singleQuotedValue(source: string, onError: FlowScalarErrorHandler) {
  if (source[source.length - 1] !== "'" || source.length === 1)
    onError(source.length, 'MISSING_CHAR', "Missing closing 'quote")
  return foldLines(source.slice(1, -1)).replace(/''/g, "'")
}

function foldLines(source: string) {
  /**
   * The negative lookbehind here and in the `re` RegExp is to
   * prevent causing a polynomial search time in certain cases.
   *
   * The try-catch is for Safari, which doesn't support this yet:
   * https://caniuse.com/js-regexp-lookbehind
   */
  let first: RegExp, line: RegExp
  try {
    first = new RegExp('(.*?)(? wsStart ? source.slice(wsStart, i + 1) : ch
    } else {
      res += ch
    }
  }
  if (source[source.length - 1] !== '"' || source.length === 1)
    onError(source.length, 'MISSING_CHAR', 'Missing closing "quote')
  return res
}

/**
 * Fold a single newline into a space, multiple newlines to N - 1 newlines.
 * Presumes `source[offset] === '\n'`
 */
function foldNewline(source: string, offset: number) {
  let fold = ''
  let ch = source[offset + 1]
  while (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
    if (ch === '\r' && source[offset + 2] !== '\n') break
    if (ch === '\n') fold += '\n'
    offset += 1
    ch = source[offset + 1]
  }
  if (!fold) fold = ' '
  return { fold, offset }
}

const escapeCodes: Record = {
  '0': '\0', // null character
  a: '\x07', // bell character
  b: '\b', // backspace
  e: '\x1b', // escape character
  f: '\f', // form feed
  n: '\n', // line feed
  r: '\r', // carriage return
  t: '\t', // horizontal tab
  v: '\v', // vertical tab
  N: '\u0085', // Unicode next line
  _: '\u00a0', // Unicode non-breaking space
  L: '\u2028', // Unicode line separator
  P: '\u2029', // Unicode paragraph separator
  ' ': ' ',
  '"': '"',
  '/': '/',
  '\\': '\\',
  '\t': '\t'
}

function parseCharCode(
  source: string,
  offset: number,
  length: number,
  onError: FlowScalarErrorHandler
) {
  const cc = source.substr(offset, length)
  const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc)
  const code = ok ? parseInt(cc, 16) : NaN
  if (isNaN(code)) {
    const raw = source.substr(offset - 2, length + 2)
    onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`)
    return raw
  }
  return String.fromCodePoint(code)
}
eemeli-yaml-086fa6b/src/compose/resolve-props.ts000066400000000000000000000124631511277410200217620ustar00rootroot00000000000000import type { SourceToken, Token } from '../parse/cst.ts'
import type { ComposeErrorHandler } from './composer.ts'

export interface ResolvePropsArg {
  flow?: 'flow map' | 'flow sequence'
  indicator: 'doc-start' | 'explicit-key-ind' | 'map-value-ind' | 'seq-item-ind'
  next: Token | null | undefined
  offset: number
  onError: ComposeErrorHandler
  parentIndent: number
  startOnNewline: boolean
}

export function resolveProps(
  tokens: SourceToken[],
  {
    flow,
    indicator,
    next,
    offset,
    onError,
    parentIndent,
    startOnNewline
  }: ResolvePropsArg
) {
  let spaceBefore = false
  let atNewline = startOnNewline
  let hasSpace = startOnNewline
  let comment = ''
  let commentSep = ''
  let hasNewline = false
  let reqSpace = false
  let tab: SourceToken | null = null
  let anchor: SourceToken | null = null
  let tag: SourceToken | null = null
  let newlineAfterProp: SourceToken | null = null
  let comma: SourceToken | null = null
  let found: SourceToken | null = null
  let start: number | null = null
  for (const token of tokens) {
    if (reqSpace) {
      if (
        token.type !== 'space' &&
        token.type !== 'newline' &&
        token.type !== 'comma'
      )
        onError(
          token.offset,
          'MISSING_CHAR',
          'Tags and anchors must be separated from the next token by white space'
        )
      reqSpace = false
    }
    if (tab) {
      if (atNewline && token.type !== 'comment' && token.type !== 'newline') {
        onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation')
      }
      tab = null
    }
    switch (token.type) {
      case 'space':
        // At the doc level, tabs at line start may be parsed
        // as leading white space rather than indentation.
        // In a flow collection, only the parser handles indent.
        if (
          !flow &&
          (indicator !== 'doc-start' || next?.type !== 'flow-collection') &&
          token.source.includes('\t')
        ) {
          tab = token
        }
        hasSpace = true
        break
      case 'comment': {
        if (!hasSpace)
          onError(
            token,
            'MISSING_CHAR',
            'Comments must be separated from other tokens by white space characters'
          )
        const cb = token.source.substring(1) || ' '
        if (!comment) comment = cb
        else comment += commentSep + cb
        commentSep = ''
        atNewline = false
        break
      }
      case 'newline':
        if (atNewline) {
          if (comment) comment += token.source
          else if (!found || indicator !== 'seq-item-ind') spaceBefore = true
        } else commentSep += token.source
        atNewline = true
        hasNewline = true
        if (anchor || tag) newlineAfterProp = token
        hasSpace = true
        break
      case 'anchor':
        if (anchor)
          onError(
            token,
            'MULTIPLE_ANCHORS',
            'A node can have at most one anchor'
          )
        if (token.source.endsWith(':'))
          onError(
            token.offset + token.source.length - 1,
            'BAD_ALIAS',
            'Anchor ending in : is ambiguous',
            true
          )
        anchor = token
        start ??= token.offset
        atNewline = false
        hasSpace = false
        reqSpace = true
        break
      case 'tag': {
        if (tag)
          onError(token, 'MULTIPLE_TAGS', 'A node can have at most one tag')
        tag = token
        start ??= token.offset
        atNewline = false
        hasSpace = false
        reqSpace = true
        break
      }
      case indicator:
        // Could here handle preceding comments differently
        if (anchor || tag)
          onError(
            token,
            'BAD_PROP_ORDER',
            `Anchors and tags must be after the ${token.source} indicator`
          )
        if (found)
          onError(
            token,
            'UNEXPECTED_TOKEN',
            `Unexpected ${token.source} in ${flow ?? 'collection'}`
          )
        found = token
        atNewline =
          indicator === 'seq-item-ind' || indicator === 'explicit-key-ind'
        hasSpace = false
        break
      case 'comma':
        if (flow) {
          if (comma)
            onError(token, 'UNEXPECTED_TOKEN', `Unexpected , in ${flow}`)
          comma = token
          atNewline = false
          hasSpace = false
          break
        }
      // else fallthrough
      default:
        onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.type} token`)
        atNewline = false
        hasSpace = false
    }
  }
  const last = tokens[tokens.length - 1]
  const end = last ? last.offset + last.source.length : offset
  if (
    reqSpace &&
    next &&
    next.type !== 'space' &&
    next.type !== 'newline' &&
    next.type !== 'comma' &&
    (next.type !== 'scalar' || next.source !== '')
  ) {
    onError(
      next.offset,
      'MISSING_CHAR',
      'Tags and anchors must be separated from the next token by white space'
    )
  }
  if (
    tab &&
    ((atNewline && tab.indent <= parentIndent) ||
      next?.type === 'block-map' ||
      next?.type === 'block-seq')
  )
    onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation')
  return {
    comma,
    found,
    spaceBefore,
    comment,
    hasNewline,
    anchor,
    tag,
    newlineAfterProp,
    end,
    start: start ?? end
  }
}
eemeli-yaml-086fa6b/src/compose/util-contains-newline.ts000066400000000000000000000014321511277410200233640ustar00rootroot00000000000000import type { Token } from '../parse/cst.ts'

export function containsNewline(key: Token | null | undefined) {
  if (!key) return null
  switch (key.type) {
    case 'alias':
    case 'scalar':
    case 'double-quoted-scalar':
    case 'single-quoted-scalar':
      if (key.source.includes('\n')) return true
      if (key.end)
        for (const st of key.end) if (st.type === 'newline') return true
      return false
    case 'flow-collection':
      for (const it of key.items) {
        for (const st of it.start) if (st.type === 'newline') return true
        if (it.sep)
          for (const st of it.sep) if (st.type === 'newline') return true
        if (containsNewline(it.key) || containsNewline(it.value)) return true
      }
      return false
    default:
      return true
  }
}
eemeli-yaml-086fa6b/src/compose/util-empty-scalar-position.ts000066400000000000000000000013451511277410200243550ustar00rootroot00000000000000import type { Token } from '../parse/cst.ts'

export function emptyScalarPosition(
  offset: number,
  before: Token[] | undefined,
  pos: number | null
) {
  if (before) {
    pos ??= before.length
    for (let i = pos - 1; i >= 0; --i) {
      let st = before[i]
      switch (st.type) {
        case 'space':
        case 'comment':
        case 'newline':
          offset -= st.source.length
          continue
      }

      // Technically, an empty scalar is immediately after the last non-empty
      // node, but it's more useful to place it after any whitespace.
      st = before[++i]
      while (st?.type === 'space') {
        offset += st.source.length
        st = before[++i]
      }
      break
    }
  }
  return offset
}
eemeli-yaml-086fa6b/src/compose/util-flow-indent-check.ts000066400000000000000000000011351511277410200234100ustar00rootroot00000000000000import type { Token } from '../parse/cst.ts'
import type { ComposeErrorHandler } from './composer.ts'
import { containsNewline } from './util-contains-newline.ts'

export function flowIndentCheck(
  indent: number,
  fc: Token | null | undefined,
  onError: ComposeErrorHandler
) {
  if (fc?.type === 'flow-collection') {
    const end = fc.end[0]
    if (
      end.indent === indent &&
      (end.source === ']' || end.source === '}') &&
      containsNewline(fc)
    ) {
      const msg = 'Flow end indicator should be more indented than parent'
      onError(end, 'BAD_INDENT', msg, true)
    }
  }
}
eemeli-yaml-086fa6b/src/compose/util-map-includes.ts000066400000000000000000000011671511277410200224750ustar00rootroot00000000000000import { isScalar } from '../nodes/identity.ts'
import type { ParsedNode } from '../nodes/Node.ts'
import type { Pair } from '../nodes/Pair.ts'
import type { ComposeContext } from './compose-node.ts'

export function mapIncludes(
  ctx: ComposeContext,
  items: Pair[],
  search: ParsedNode
) {
  const { uniqueKeys } = ctx.options
  if (uniqueKeys === false) return false
  const isEqual =
    typeof uniqueKeys === 'function'
      ? uniqueKeys
      : (a: ParsedNode, b: ParsedNode) =>
          a === b || (isScalar(a) && isScalar(b) && a.value === b.value)
  return items.some(pair => isEqual(pair.key, search))
}
eemeli-yaml-086fa6b/src/doc/000077500000000000000000000000001511277410200156645ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/doc/Document.ts000066400000000000000000000361631511277410200200230ustar00rootroot00000000000000import type { YAMLError, YAMLWarning } from '../errors.ts'
import { Alias } from '../nodes/Alias.ts'
import { collectionFromPath, isEmptyPath } from '../nodes/Collection.ts'
import {
  DOC,
  isCollection,
  isNode,
  isScalar,
  NODE_TYPE
} from '../nodes/identity.ts'
import type { Node, NodeType, ParsedNode, Range } from '../nodes/Node.ts'
import { Pair } from '../nodes/Pair.ts'
import type { Scalar } from '../nodes/Scalar.ts'
import type { ToJSContext } from '../nodes/toJS.ts'
import { toJS } from '../nodes/toJS.ts'
import type { YAMLMap } from '../nodes/YAMLMap.ts'
import type { YAMLSeq } from '../nodes/YAMLSeq.ts'
import type {
  CreateNodeOptions,
  DocumentOptions,
  ParseOptions,
  SchemaOptions,
  ToJSOptions,
  ToStringOptions
} from '../options.ts'
import { Schema } from '../schema/Schema.ts'
import { stringifyDocument } from '../stringify/stringifyDocument.ts'
import { anchorNames, createNodeAnchors, findNewAnchor } from './anchors.ts'
import { applyReviver } from './applyReviver.ts'
import type { CreateNodeContext } from './createNode.ts'
import { createNode } from './createNode.ts'
import { Directives } from './directives.ts'

export type Replacer = any[] | ((key: any, value: any) => unknown)

export declare namespace Document {
  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
  /** @ts-ignore The typing of directives fails in TS <= 4.2 */
  interface Parsed<
    Contents extends ParsedNode = ParsedNode,
    Strict extends boolean = true
  > extends Document {
    directives: Directives
    range: Range
  }
}

export class Document<
  Contents extends Node = Node,
  Strict extends boolean = true
> {
  declare readonly [NODE_TYPE]: symbol

  /** A comment before this Document */
  commentBefore: string | null = null

  /** A comment immediately after this Document */
  comment: string | null = null

  /** The document contents. */
  contents: Strict extends true ? Contents | null : Contents

  directives: Strict extends true ? Directives | undefined : Directives

  /** Errors encountered during parsing. */
  errors: YAMLError[] = []

  options: Required<
    Omit<
      ParseOptions & DocumentOptions,
      '_directives' | 'lineCounter' | 'version'
    >
  >

  /**
   * The `[start, value-end, node-end]` character offsets for the part of the
   * source parsed into this document (undefined if not parsed). The `value-end`
   * and `node-end` positions are themselves not included in their respective
   * ranges.
   */
  declare range?: Range

  // TS can't figure out that setSchema() will set this, or throw
  /** The schema used with the document. Use `setSchema()` to change. */
  declare schema: Schema

  /** Warnings encountered during parsing. */
  warnings: YAMLWarning[] = []

  /**
   * @param value - The initial value for the document, which will be wrapped
   *   in a Node container.
   */
  constructor(
    value?: any,
    options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions
  )
  constructor(
    value: any,
    replacer: null | Replacer,
    options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions
  )
  constructor(
    value?: unknown,
    replacer?:
      | Replacer
      | (DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions)
      | null,
    options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions
  ) {
    Object.defineProperty(this, NODE_TYPE, { value: DOC })
    let _replacer: Replacer | null = null
    if (typeof replacer === 'function' || Array.isArray(replacer)) {
      _replacer = replacer
    } else if (options === undefined && replacer) {
      options = replacer
      replacer = undefined
    }

    const opt = Object.assign(
      {
        intAsBigInt: false,
        keepSourceTokens: false,
        logLevel: 'warn',
        prettyErrors: true,
        strict: true,
        stringKeys: false,
        uniqueKeys: true,
        version: '1.2'
      },
      options
    )
    this.options = opt
    let { version } = opt
    if (options?._directives) {
      this.directives = options._directives.atDocument()
      if (this.directives.yaml.explicit) version = this.directives.yaml.version
    } else this.directives = new Directives({ version })
    this.setSchema(version, options)

    // @ts-expect-error We can't really know that this matches Contents.
    this.contents =
      value === undefined ? null : this.createNode(value, _replacer, options)
  }

  /**
   * Create a deep copy of this Document and its contents.
   *
   * Custom Node values that inherit from `Object` still refer to their original instances.
   */
  clone(): Document {
    const copy: Document = Object.create(Document.prototype, {
      [NODE_TYPE]: { value: DOC }
    })
    copy.commentBefore = this.commentBefore
    copy.comment = this.comment
    copy.errors = this.errors.slice()
    copy.warnings = this.warnings.slice()
    copy.options = Object.assign({}, this.options)
    if (this.directives) copy.directives = this.directives.clone()
    copy.schema = this.schema.clone()
    // @ts-expect-error We can't really know that this matches Contents.
    copy.contents = isNode(this.contents)
      ? this.contents.clone(copy.schema)
      : this.contents
    if (this.range) copy.range = this.range.slice() as Document['range']
    return copy
  }

  /** Adds a value to the document. */
  add(value: any) {
    if (assertCollection(this.contents)) this.contents.add(value)
  }

  /** Adds a value to the document. */
  addIn(path: Iterable, value: unknown) {
    if (assertCollection(this.contents)) this.contents.addIn(path, value)
  }

  /**
   * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
   *
   * If `node` already has an anchor, `name` is ignored.
   * Otherwise, the `node.anchor` value will be set to `name`,
   * or if an anchor with that name is already present in the document,
   * `name` will be used as a prefix for a new unique anchor.
   * If `name` is undefined, the generated anchor will use 'a' as a prefix.
   */
  createAlias(
    node: Strict extends true ? Scalar | YAMLMap | YAMLSeq : Node,
    name?: string
  ): Alias {
    if (!node.anchor) {
      const prev = anchorNames(this)
      node.anchor =
        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
        !name || prev.has(name) ? findNewAnchor(name || 'a', prev) : name
    }
    return new Alias(node.anchor)
  }

  /**
   * Convert any value into a `Node` using the current schema, recursively
   * turning objects into collections.
   */
  createNode(value: T, options?: CreateNodeOptions): NodeType
  createNode(
    value: T,
    replacer: Replacer | CreateNodeOptions | null,
    options?: CreateNodeOptions
  ): NodeType
  createNode(
    value: unknown,
    replacer?: Replacer | CreateNodeOptions | null,
    options?: CreateNodeOptions
  ): Node {
    let _replacer: Replacer | undefined = undefined
    if (typeof replacer === 'function') {
      value = replacer.call({ '': value }, '', value)
      _replacer = replacer
    } else if (Array.isArray(replacer)) {
      const keyToStr = (v: unknown) =>
        typeof v === 'number' || v instanceof String || v instanceof Number
      const asStr = replacer.filter(keyToStr).map(String)
      if (asStr.length > 0) replacer = replacer.concat(asStr)
      _replacer = replacer
    } else if (options === undefined && replacer) {
      options = replacer
      replacer = undefined
    }

    const {
      aliasDuplicateObjects,
      anchorPrefix,
      flow,
      keepUndefined,
      onTagObj,
      tag
    } = options ?? {}
    const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(
      this,
      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
      anchorPrefix || 'a'
    )
    const ctx: CreateNodeContext = {
      aliasDuplicateObjects: aliasDuplicateObjects ?? true,
      keepUndefined: keepUndefined ?? false,
      onAnchor,
      onTagObj,
      replacer: _replacer,
      schema: this.schema,
      sourceObjects
    }
    const node = createNode(value, tag, ctx)
    if (flow && isCollection(node)) node.flow = true
    setAnchors()
    return node
  }

  /**
   * Convert a key and a value into a `Pair` using the current schema,
   * recursively wrapping all values as `Scalar` or `Collection` nodes.
   */
  createPair(
    key: unknown,
    value: unknown,
    options: CreateNodeOptions = {}
  ): Pair {
    const k = this.createNode(key, null, options) as K
    const v = this.createNode(value, null, options) as V
    return new Pair(k, v)
  }

  /**
   * Removes a value from the document.
   * @returns `true` if the item was found and removed.
   */
  delete(key: unknown): boolean {
    return assertCollection(this.contents) ? this.contents.delete(key) : false
  }

  /**
   * Removes a value from the document.
   * @returns `true` if the item was found and removed.
   */
  deleteIn(path: Iterable | null): boolean {
    if (isEmptyPath(path)) {
      if (this.contents == null) return false
      // @ts-expect-error Presumed impossible if Strict extends false
      this.contents = null
      return true
    }
    return assertCollection(this.contents)
      ? this.contents.deleteIn(path)
      : false
  }

  /**
   * Returns item at `key`, or `undefined` if not found. By default unwraps
   * scalar values from their surrounding node; to disable set `keepScalar` to
   * `true` (collections are always returned intact).
   */
  get(key: unknown, keepScalar?: boolean): Strict extends true ? unknown : any {
    return isCollection(this.contents)
      ? this.contents.get(key, keepScalar)
      : undefined
  }

  /**
   * Returns item at `path`, or `undefined` if not found. By default unwraps
   * scalar values from their surrounding node; to disable set `keepScalar` to
   * `true` (collections are always returned intact).
   */
  getIn(
    path: Iterable | null,
    keepScalar?: boolean
  ): Strict extends true ? unknown : any {
    if (isEmptyPath(path))
      return !keepScalar && isScalar(this.contents)
        ? this.contents.value
        : this.contents
    return isCollection(this.contents)
      ? this.contents.getIn(path, keepScalar)
      : undefined
  }

  /**
   * Checks if the document includes a value with the key `key`.
   */
  has(key: unknown): boolean {
    return isCollection(this.contents) ? this.contents.has(key) : false
  }

  /**
   * Checks if the document includes a value at `path`.
   */
  hasIn(path: Iterable | null): boolean {
    if (isEmptyPath(path)) return this.contents !== undefined
    return isCollection(this.contents) ? this.contents.hasIn(path) : false
  }

  /**
   * Sets a value in this document. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   */
  set(key: any, value: unknown): void {
    if (this.contents == null) {
      // @ts-expect-error We can't really know that this matches Contents.
      this.contents = collectionFromPath(this.schema, [key], value)
    } else if (assertCollection(this.contents)) {
      this.contents.set(key, value)
    }
  }

  /**
   * Sets a value in this document. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   */
  setIn(path: Iterable | null, value: unknown): void {
    if (isEmptyPath(path)) {
      // @ts-expect-error We can't really know that this matches Contents.
      this.contents = value
    } else if (this.contents == null) {
      // @ts-expect-error We can't really know that this matches Contents.
      this.contents = collectionFromPath(this.schema, Array.from(path), value)
    } else if (assertCollection(this.contents)) {
      this.contents.setIn(path, value)
    }
  }

  /**
   * Change the YAML version and schema used by the document.
   * A `null` version disables support for directives, explicit tags, anchors, and aliases.
   * It also requires the `schema` option to be given as a `Schema` instance value.
   *
   * Overrides all previously set schema options.
   */
  setSchema(
    version: '1.1' | '1.2' | 'next' | null,
    options: SchemaOptions = {}
  ) {
    if (typeof version === 'number') version = String(version) as '1.1' | '1.2'

    let opt: (SchemaOptions & { schema: string }) | null
    switch (version) {
      case '1.1':
        if (this.directives) this.directives.yaml.version = '1.1'
        else this.directives = new Directives({ version: '1.1' })
        opt = { resolveKnownTags: false, schema: 'yaml-1.1' }
        break
      case '1.2':
      case 'next':
        if (this.directives) this.directives.yaml.version = version
        else this.directives = new Directives({ version })
        opt = { resolveKnownTags: true, schema: 'core' }
        break
      case null:
        if (this.directives) delete this.directives
        opt = null
        break
      default: {
        const sv = JSON.stringify(version)
        throw new Error(
          `Expected '1.1', '1.2' or null as first argument, but found: ${sv}`
        )
      }
    }

    // Not using `instanceof Schema` to allow for duck typing
    if (options.schema instanceof Object) this.schema = options.schema
    else if (opt) this.schema = new Schema(Object.assign(opt, options))
    else
      throw new Error(
        `With a null YAML version, the { schema: Schema } option is required`
      )
  }

  /** A plain JavaScript representation of the document `contents`. */
  toJS(opt?: ToJSOptions & { [ignored: string]: unknown }): any

  // json & jsonArg are only used from toJSON()
  toJS({
    json,
    jsonArg,
    mapAsMap,
    maxAliasCount,
    onAnchor,
    reviver
  }: ToJSOptions & { json?: boolean; jsonArg?: string | null } = {}): any {
    const ctx: ToJSContext = {
      anchors: new Map(),
      doc: this,
      keep: !json,
      mapAsMap: mapAsMap === true,
      mapKeyWarned: false,
      maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
    }
    const res = toJS(this.contents, jsonArg ?? '', ctx)
    if (typeof onAnchor === 'function')
      for (const { count, res } of ctx.anchors.values()) onAnchor(res, count)
    return typeof reviver === 'function'
      ? applyReviver(reviver, { '': res }, '', res)
      : res
  }

  /**
   * A JSON representation of the document `contents`.
   *
   * @param jsonArg Used by `JSON.stringify` to indicate the array index or
   *   property name.
   */
  toJSON(jsonArg?: string | null, onAnchor?: ToJSOptions['onAnchor']): any {
    return this.toJS({ json: true, jsonArg, mapAsMap: false, onAnchor })
  }

  /** A YAML representation of the document. */
  toString(options: ToStringOptions = {}): string {
    if (this.errors.length > 0)
      throw new Error('Document with errors cannot be stringified')
    if (
      'indent' in options &&
      (!Number.isInteger(options.indent) || Number(options.indent) <= 0)
    ) {
      const s = JSON.stringify(options.indent)
      throw new Error(`"indent" option must be a positive integer, not ${s}`)
    }
    return stringifyDocument(this, options)
  }
}

function assertCollection(contents: unknown): contents is YAMLMap | YAMLSeq {
  if (isCollection(contents)) return true
  throw new Error('Expected a YAML collection as document contents')
}
eemeli-yaml-086fa6b/src/doc/anchors.ts000066400000000000000000000047241511277410200177000ustar00rootroot00000000000000import { isCollection, isScalar } from '../nodes/identity.ts'
import type { Node } from '../nodes/Node.ts'
import type { Scalar } from '../nodes/Scalar.ts'
import type { YAMLMap } from '../nodes/YAMLMap.ts'
import type { YAMLSeq } from '../nodes/YAMLSeq.ts'
import { visit } from '../visit.ts'
import type { CreateNodeContext } from './createNode.ts'
import type { Document } from './Document.ts'

/**
 * Verify that the input string is a valid anchor.
 *
 * Will throw on errors.
 */
export function anchorIsValid(anchor: string): true {
  if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
    const sa = JSON.stringify(anchor)
    const msg = `Anchor must not contain whitespace or control characters: ${sa}`
    throw new Error(msg)
  }
  return true
}

export function anchorNames(root: Document | Node) {
  const anchors = new Set()
  visit(root, {
    Value(_key: unknown, node: Scalar | YAMLMap | YAMLSeq) {
      if (node.anchor) anchors.add(node.anchor)
    }
  })
  return anchors
}

/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
export function findNewAnchor(prefix: string, exclude: Set) {
  for (let i = 1; true; ++i) {
    const name = `${prefix}${i}`
    if (!exclude.has(name)) return name
  }
}

export function createNodeAnchors(
  doc: Document,
  prefix: string
) {
  const aliasObjects: unknown[] = []
  const sourceObjects: CreateNodeContext['sourceObjects'] = new Map()
  let prevAnchors: Set | null = null

  return {
    onAnchor: (source: unknown) => {
      aliasObjects.push(source)
      prevAnchors ??= anchorNames(doc)
      const anchor = findNewAnchor(prefix, prevAnchors)
      prevAnchors.add(anchor)
      return anchor
    },

    /**
     * With circular references, the source node is only resolved after all
     * of its child nodes are. This is why anchors are set only after all of
     * the nodes have been created.
     */
    setAnchors: () => {
      for (const source of aliasObjects) {
        const ref = sourceObjects.get(source)
        if (
          typeof ref === 'object' &&
          ref.anchor &&
          (isScalar(ref.node) || isCollection(ref.node))
        ) {
          ref.node.anchor = ref.anchor
        } else {
          const error = new Error(
            'Failed to resolve repeated object (this should not happen)'
          ) as Error & { source: unknown }
          error.source = source
          throw error
        }
      }
    },

    sourceObjects
  }
}
eemeli-yaml-086fa6b/src/doc/applyReviver.ts000066400000000000000000000031111511277410200207200ustar00rootroot00000000000000export type Reviver = (key: unknown, value: unknown) => unknown

/**
 * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
 * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
 * 2021 edition: https://tc39.es/ecma262/#sec-json.parse
 *
 * Includes extensions for handling Map and Set objects.
 */
export function applyReviver(
  reviver: Reviver,
  obj: unknown,
  key: unknown,
  val: any
) {
  if (val && typeof val === 'object') {
    if (Array.isArray(val)) {
      for (let i = 0, len = val.length; i < len; ++i) {
        const v0 = val[i]
        const v1 = applyReviver(reviver, val, String(i), v0)
        // eslint-disable-next-line @typescript-eslint/no-array-delete
        if (v1 === undefined) delete val[i]
        else if (v1 !== v0) val[i] = v1
      }
    } else if (val instanceof Map) {
      for (const k of Array.from(val.keys())) {
        const v0 = val.get(k)
        const v1 = applyReviver(reviver, val, k, v0)
        if (v1 === undefined) val.delete(k)
        else if (v1 !== v0) val.set(k, v1)
      }
    } else if (val instanceof Set) {
      for (const v0 of Array.from(val)) {
        const v1 = applyReviver(reviver, val, v0, v0)
        if (v1 === undefined) val.delete(v0)
        else if (v1 !== v0) {
          val.delete(v0)
          val.add(v1)
        }
      }
    } else {
      for (const [k, v0] of Object.entries(val)) {
        const v1 = applyReviver(reviver, val, k, v0)
        if (v1 === undefined) delete val[k]
        else if (v1 !== v0) val[k] = v1
      }
    }
  }
  return reviver.call(obj, key, val)
}
eemeli-yaml-086fa6b/src/doc/createNode.ts000066400000000000000000000065761511277410200203230ustar00rootroot00000000000000import { Alias } from '../nodes/Alias.ts'
import { isDocument, isNode, isPair, MAP, SEQ } from '../nodes/identity.ts'
import type { Node } from '../nodes/Node.ts'
import { Scalar } from '../nodes/Scalar.ts'
import type { YAMLMap } from '../nodes/YAMLMap.ts'
import type { Schema } from '../schema/Schema.ts'
import type { CollectionTag, ScalarTag } from '../schema/types.ts'
import type { Replacer } from './Document.ts'

const defaultTagPrefix = 'tag:yaml.org,2002:'

export interface CreateNodeContext {
  aliasDuplicateObjects: boolean
  keepUndefined: boolean
  onAnchor: (source: unknown) => string
  onTagObj?: (tagObj: ScalarTag | CollectionTag) => void
  sourceObjects: Map
  replacer?: Replacer
  schema: Schema
}

function findTagObject(
  value: unknown,
  tagName: string | undefined,
  tags: Array
) {
  if (tagName) {
    const match = tags.filter(t => t.tag === tagName)
    const tagObj = match.find(t => !t.format) ?? match[0]
    if (!tagObj) throw new Error(`Tag ${tagName} not found`)
    return tagObj
  }
  return tags.find(t => t.identify?.(value) && !t.format)
}

export function createNode(
  value: unknown,
  tagName: string | undefined,
  ctx: CreateNodeContext
): Node {
  if (isDocument(value)) value = value.contents
  if (isNode(value)) return value
  if (isPair(value)) {
    const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx) as YAMLMap
    map.items.push(value)
    return map
  }
  if (
    value instanceof String ||
    value instanceof Number ||
    value instanceof Boolean ||
    (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere
  ) {
    // https://tc39.es/ecma262/#sec-serializejsonproperty
    value = value.valueOf()
  }

  const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } =
    ctx

  // Detect duplicate references to the same object & use Alias nodes for all
  // after first. The `ref` wrapper allows for circular references to resolve.
  let ref: { anchor: string | null; node: Node | null } | undefined = undefined
  if (aliasDuplicateObjects && value && typeof value === 'object') {
    ref = sourceObjects.get(value)
    if (ref) {
      ref.anchor ??= onAnchor(value)
      return new Alias(ref.anchor)
    } else {
      ref = { anchor: null, node: null }
      sourceObjects.set(value, ref)
    }
  }

  if (tagName?.startsWith('!!')) tagName = defaultTagPrefix + tagName.slice(2)

  let tagObj = findTagObject(value, tagName, schema.tags)
  if (!tagObj) {
    if (value && typeof (value as any).toJSON === 'function') {
      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
      value = (value as any).toJSON()
    }
    if (!value || typeof value !== 'object') {
      const node = new Scalar(value)
      if (ref) ref.node = node
      return node
    }
    tagObj =
      value instanceof Map
        ? schema[MAP]
        : Symbol.iterator in Object(value)
          ? schema[SEQ]
          : schema[MAP]
  }
  if (onTagObj) {
    onTagObj(tagObj)
    delete ctx.onTagObj
  }

  const node = tagObj?.createNode
    ? tagObj.createNode(ctx.schema, value, ctx)
    : typeof tagObj?.nodeClass?.from === 'function'
      ? tagObj.nodeClass.from(ctx.schema, value, ctx)
      : new Scalar(value)
  if (tagName) node.tag = tagName
  else if (!tagObj.default) node.tag = tagObj.tag

  if (ref) ref.node = node
  return node
}
eemeli-yaml-086fa6b/src/doc/directives.ts000066400000000000000000000135541511277410200204050ustar00rootroot00000000000000import { isNode } from '../nodes/identity.ts'
import { visit } from '../visit.ts'
import type { Document } from './Document.ts'

const escapeChars: Record = {
  '!': '%21',
  ',': '%2C',
  '[': '%5B',
  ']': '%5D',
  '{': '%7B',
  '}': '%7D'
}

const escapeTagName = (tn: string) =>
  tn.replace(/[!,[\]{}]/g, ch => escapeChars[ch])

export class Directives {
  static defaultYaml: Directives['yaml'] = { explicit: false, version: '1.2' }
  static defaultTags: Directives['tags'] = { '!!': 'tag:yaml.org,2002:' }

  yaml: { version: '1.1' | '1.2' | 'next'; explicit?: boolean }
  tags: Record

  /**
   * The directives-end/doc-start marker `---`. If `null`, a marker may still be
   * included in the document's stringified representation.
   */
  docStart: true | null = null

  /** The doc-end marker `...`.  */
  docEnd = false

  /**
   * Used when parsing YAML 1.1, where:
   * > If the document specifies no directives, it is parsed using the same
   * > settings as the previous document. If the document does specify any
   * > directives, all directives of previous documents, if any, are ignored.
   */
  private atNextDocument?: boolean

  constructor(yaml?: Directives['yaml'], tags?: Directives['tags']) {
    this.yaml = Object.assign({}, Directives.defaultYaml, yaml)
    this.tags = Object.assign({}, Directives.defaultTags, tags)
  }

  clone(): Directives {
    const copy = new Directives(this.yaml, this.tags)
    copy.docStart = this.docStart
    return copy
  }

  /**
   * During parsing, get a Directives instance for the current document and
   * update the stream state according to the current version's spec.
   */
  atDocument(): Directives {
    const res = new Directives(this.yaml, this.tags)
    switch (this.yaml.version) {
      case '1.1':
        this.atNextDocument = true
        break
      case '1.2':
        this.atNextDocument = false
        this.yaml = {
          explicit: Directives.defaultYaml.explicit,
          version: '1.2'
        }
        this.tags = Object.assign({}, Directives.defaultTags)
        break
    }
    return res
  }

  /**
   * @param onError - May be called even if the action was successful
   * @returns `true` on success
   */
  add(
    line: string,
    onError: (offset: number, message: string, warning?: boolean) => void
  ): boolean {
    if (this.atNextDocument) {
      this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' }
      this.tags = Object.assign({}, Directives.defaultTags)
      this.atNextDocument = false
    }
    const parts = line.trim().split(/[ \t]+/)
    const name = parts.shift()
    switch (name) {
      case '%TAG': {
        if (parts.length !== 2) {
          onError(0, '%TAG directive should contain exactly two parts')
          if (parts.length < 2) return false
        }
        const [handle, prefix] = parts
        this.tags[handle] = prefix
        return true
      }
      case '%YAML': {
        this.yaml.explicit = true
        if (parts.length !== 1) {
          onError(0, '%YAML directive should contain exactly one part')
          return false
        }
        const [version] = parts
        if (version === '1.1' || version === '1.2') {
          this.yaml.version = version
          return true
        } else {
          const isValid = /^\d+\.\d+$/.test(version)
          onError(6, `Unsupported YAML version ${version}`, isValid)
          return false
        }
      }
      default:
        onError(0, `Unknown directive ${name}`, true)
        return false
    }
  }

  /**
   * Resolves a tag, matching handles to those defined in %TAG directives.
   *
   * @returns Resolved tag, which may also be the non-specific tag `'!'` or a
   *   `'!local'` tag, or `null` if unresolvable.
   */
  tagName(source: string, onError: (message: string) => void): string | null {
    if (source === '!') return '!' // non-specific tag

    if (source[0] !== '!') {
      onError(`Not a valid tag: ${source}`)
      return null
    }

    if (source[1] === '<') {
      const verbatim = source.slice(2, -1)
      if (verbatim === '!' || verbatim === '!!') {
        onError(`Verbatim tags aren't resolved, so ${source} is invalid.`)
        return null
      }
      if (source[source.length - 1] !== '>')
        onError('Verbatim tags must end with a >')
      return verbatim
    }

    const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s) as string[]
    if (!suffix) onError(`The ${source} tag has no suffix`)
    const prefix = this.tags[handle]
    if (prefix) {
      try {
        return prefix + decodeURIComponent(suffix)
      } catch (error) {
        onError(String(error))
        return null
      }
    }
    if (handle === '!') return source // local tag

    onError(`Could not resolve tag: ${source}`)
    return null
  }

  /**
   * Given a fully resolved tag, returns its printable string form,
   * taking into account current tag prefixes and defaults.
   */
  tagString(tag: string): string {
    for (const [handle, prefix] of Object.entries(this.tags)) {
      if (tag.startsWith(prefix))
        return handle + escapeTagName(tag.substring(prefix.length))
    }
    return tag[0] === '!' ? tag : `!<${tag}>`
  }

  toString(doc?: Document): string {
    const lines = this.yaml.explicit
      ? [`%YAML ${this.yaml.version || '1.2'}`]
      : []

    const tagEntries = Object.entries(this.tags)

    let tagNames: string[]
    if (doc && tagEntries.length > 0 && isNode(doc.contents)) {
      const tags: Record = {}
      visit(doc.contents, (_key, node) => {
        if (isNode(node) && node.tag) tags[node.tag] = true
      })
      tagNames = Object.keys(tags)
    } else tagNames = []

    for (const [handle, prefix] of tagEntries) {
      if (handle === '!!' && prefix === 'tag:yaml.org,2002:') continue
      if (!doc || tagNames.some(tn => tn.startsWith(prefix)))
        lines.push(`%TAG ${handle} ${prefix}`)
    }
    return lines.join('\n')
  }
}
eemeli-yaml-086fa6b/src/errors.ts000066400000000000000000000054441511277410200170120ustar00rootroot00000000000000import type { LineCounter } from './parse/line-counter.ts'

export type ErrorCode =
  | 'ALIAS_PROPS'
  | 'BAD_ALIAS'
  | 'BAD_DIRECTIVE'
  | 'BAD_DQ_ESCAPE'
  | 'BAD_INDENT'
  | 'BAD_PROP_ORDER'
  | 'BAD_SCALAR_START'
  | 'BLOCK_AS_IMPLICIT_KEY'
  | 'BLOCK_IN_FLOW'
  | 'DUPLICATE_KEY'
  | 'IMPOSSIBLE'
  | 'KEY_OVER_1024_CHARS'
  | 'MISSING_CHAR'
  | 'MULTILINE_IMPLICIT_KEY'
  | 'MULTIPLE_ANCHORS'
  | 'MULTIPLE_DOCS'
  | 'MULTIPLE_TAGS'
  | 'NON_STRING_KEY'
  | 'TAB_AS_INDENT'
  | 'TAG_RESOLVE_FAILED'
  | 'UNEXPECTED_TOKEN'
  | 'BAD_COLLECTION_TYPE'

export type LinePos = { line: number; col: number }

export class YAMLError extends Error {
  name: 'YAMLParseError' | 'YAMLWarning'
  code: ErrorCode
  message: string
  pos: [number, number]
  linePos?: [LinePos] | [LinePos, LinePos]

  constructor(
    name: YAMLError['name'],
    pos: [number, number],
    code: ErrorCode,
    message: string
  ) {
    super()
    this.name = name
    this.code = code
    this.message = message
    this.pos = pos
  }
}

export class YAMLParseError extends YAMLError {
  constructor(pos: [number, number], code: ErrorCode, message: string) {
    super('YAMLParseError', pos, code, message)
  }
}

export class YAMLWarning extends YAMLError {
  constructor(pos: [number, number], code: ErrorCode, message: string) {
    super('YAMLWarning', pos, code, message)
  }
}

export const prettifyError =
  (src: string, lc: LineCounter) => (error: YAMLError) => {
    if (error.pos[0] === -1) return
    error.linePos = error.pos.map(pos => lc.linePos(pos)) as
      | [LinePos]
      | [LinePos, LinePos]
    const { line, col } = error.linePos[0]
    error.message += ` at line ${line}, column ${col}`

    let ci = col - 1
    let lineStr = src
      .substring(lc.lineStarts[line - 1], lc.lineStarts[line])
      .replace(/[\n\r]+$/, '')

    // Trim to max 80 chars, keeping col position near the middle
    if (ci >= 60 && lineStr.length > 80) {
      const trimStart = Math.min(ci - 39, lineStr.length - 79)
      lineStr = '…' + lineStr.substring(trimStart)
      ci -= trimStart - 1
    }
    if (lineStr.length > 80) lineStr = lineStr.substring(0, 79) + '…'

    // Include previous line in context if pointing at line start
    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
      // Regexp won't match if start is trimmed
      let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1])
      if (prev.length > 80) prev = prev.substring(0, 79) + '…\n'
      lineStr = prev + lineStr
    }

    if (/[^ ]/.test(lineStr)) {
      let count = 1
      const end = error.linePos[1]
      if (end?.line === line && end.col > col) {
        count = Math.max(1, Math.min(end.col - col, 80 - ci))
      }
      const pointer = ' '.repeat(ci) + '^'.repeat(count)
      error.message += `:\n\n${lineStr}\n${pointer}\n`
    }
  }
eemeli-yaml-086fa6b/src/index.ts000066400000000000000000000027301511277410200166000ustar00rootroot00000000000000export { Composer } from './compose/composer.ts'

export { Document } from './doc/Document.ts'
export { Schema } from './schema/Schema.ts'

export type { ErrorCode } from './errors.ts'
export { YAMLError, YAMLParseError, YAMLWarning } from './errors.ts'

export { Alias } from './nodes/Alias.ts'
export {
  isAlias,
  isCollection,
  isDocument,
  isMap,
  isNode,
  isPair,
  isScalar,
  isSeq
} from './nodes/identity.ts'
export type { Node, ParsedNode, Range } from './nodes/Node.ts'
export { Pair } from './nodes/Pair.ts'
export { Scalar } from './nodes/Scalar.ts'
export { YAMLMap } from './nodes/YAMLMap.ts'
export { YAMLSeq } from './nodes/YAMLSeq.ts'

export type {
  CreateNodeOptions,
  DocumentOptions,
  ParseOptions,
  SchemaOptions,
  ToJSOptions,
  ToStringOptions
} from './options.ts'

export * as CST from './parse/cst.ts'
export { Lexer } from './parse/lexer.ts'
export { LineCounter } from './parse/line-counter.ts'
export { Parser } from './parse/parser.ts'

export type { EmptyStream } from './public-api.ts'
export {
  parse,
  parseAllDocuments,
  parseDocument,
  stringify
} from './public-api.ts'

export type { TagId, Tags } from './schema/tags.ts'
export type { CollectionTag, ScalarTag } from './schema/types.ts'
export type { YAMLOMap } from './schema/yaml-1.1/omap.ts'
export type { YAMLSet } from './schema/yaml-1.1/set.ts'

export type {
  asyncVisitor,
  asyncVisitorFn,
  visitor,
  visitorFn
} from './visit.ts'
export { visit, visitAsync } from './visit.ts'
eemeli-yaml-086fa6b/src/log.ts000066400000000000000000000007061511277410200162530ustar00rootroot00000000000000import { emitWarning } from 'node:process'

export type LogLevelId = 'silent' | 'error' | 'warn' | 'debug'

export function debug(logLevel: LogLevelId, ...messages: any[]) {
  if (logLevel === 'debug') console.log(...messages)
}

export function warn(logLevel: LogLevelId, warning: string | Error) {
  if (logLevel === 'debug' || logLevel === 'warn') {
    if (typeof emitWarning === 'function') emitWarning(warning)
    else console.warn(warning)
  }
}
eemeli-yaml-086fa6b/src/nodes/000077500000000000000000000000001511277410200162275ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/nodes/Alias.ts000066400000000000000000000076671511277410200176500ustar00rootroot00000000000000import { anchorIsValid } from '../doc/anchors.ts'
import type { Document } from '../doc/Document.ts'
import type { FlowScalar } from '../parse/cst.ts'
import type { StringifyContext } from '../stringify/stringify.ts'
import { visit } from '../visit.ts'
import { ALIAS, hasAnchor, isAlias, isCollection, isPair } from './identity.ts'
import type { Node, Range } from './Node.ts'
import { NodeBase } from './Node.ts'
import type { Scalar } from './Scalar.ts'
import type { ToJSContext } from './toJS.ts'
import { toJS } from './toJS.ts'
import type { YAMLMap } from './YAMLMap.ts'
import type { YAMLSeq } from './YAMLSeq.ts'

export declare namespace Alias {
  interface Parsed extends Alias {
    range: Range
    srcToken?: FlowScalar & { type: 'alias' }
  }
}

export class Alias extends NodeBase {
  source: string

  declare anchor?: never

  constructor(source: string) {
    super(ALIAS)
    this.source = source
    Object.defineProperty(this, 'tag', {
      set() {
        throw new Error('Alias nodes cannot have tags')
      }
    })
  }

  /**
   * Resolve the value of this alias within `doc`, finding the last
   * instance of the `source` anchor before this node.
   */
  resolve(
    doc: Document,
    ctx?: ToJSContext
  ): Scalar | YAMLMap | YAMLSeq | undefined {
    let nodes: Node[]
    if (ctx?.aliasResolveCache) {
      nodes = ctx.aliasResolveCache
    } else {
      nodes = []
      visit(doc, {
        Node: (_key: unknown, node: Node) => {
          if (isAlias(node) || hasAnchor(node)) nodes.push(node)
        }
      })
      if (ctx) ctx.aliasResolveCache = nodes
    }

    let found: Scalar | YAMLMap | YAMLSeq | undefined = undefined
    for (const node of nodes) {
      if (node === this) break
      if (node.anchor === this.source) found = node
    }

    return found
  }

  toJSON(_arg?: unknown, ctx?: ToJSContext): unknown {
    if (!ctx) return { source: this.source }
    const { anchors, doc, maxAliasCount } = ctx
    const source = this.resolve(doc, ctx)
    if (!source) {
      const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`
      throw new ReferenceError(msg)
    }
    let data = anchors.get(source)
    if (!data) {
      // Resolve anchors for Node.prototype.toJS()
      toJS(source, null, ctx)
      data = anchors.get(source)
    }
    /* istanbul ignore if */
    if (data?.res === undefined) {
      const msg = 'This should not happen: Alias anchor was not resolved?'
      throw new ReferenceError(msg)
    }
    if (maxAliasCount >= 0) {
      data.count += 1
      if (data.aliasCount === 0)
        data.aliasCount = getAliasCount(doc, source, anchors)
      if (data.count * data.aliasCount > maxAliasCount) {
        const msg =
          'Excessive alias count indicates a resource exhaustion attack'
        throw new ReferenceError(msg)
      }
    }
    return data.res
  }

  toString(
    ctx?: StringifyContext,
    _onComment?: () => void,
    _onChompKeep?: () => void
  ): string {
    const src = `*${this.source}`
    if (ctx) {
      anchorIsValid(this.source)
      if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
        const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`
        throw new Error(msg)
      }
      if (ctx.implicitKey) return `${src} `
    }
    return src
  }
}

function getAliasCount(
  doc: Document,
  node: unknown,
  anchors: ToJSContext['anchors']
): number {
  if (isAlias(node)) {
    const source = node.resolve(doc)
    const anchor = anchors && source && anchors.get(source)
    return anchor ? anchor.count * anchor.aliasCount : 0
  } else if (isCollection(node)) {
    let count = 0
    for (const item of node.items) {
      const c = getAliasCount(doc, item, anchors)
      if (c > count) count = c
    }
    return count
  } else if (isPair(node)) {
    const kc = getAliasCount(doc, node.key, anchors)
    const vc = getAliasCount(doc, node.value, anchors)
    return Math.max(kc, vc)
  }
  return 1
}
eemeli-yaml-086fa6b/src/nodes/Collection.ts000066400000000000000000000136361511277410200207030ustar00rootroot00000000000000import { createNode } from '../doc/createNode.ts'
import type { Schema } from '../schema/Schema.ts'
import {
  isCollection,
  isNode,
  isPair,
  isScalar,
  NODE_TYPE
} from './identity.ts'
import { NodeBase } from './Node.ts'

export function collectionFromPath(
  schema: Schema,
  path: unknown[],
  value: unknown
) {
  let v = value
  for (let i = path.length - 1; i >= 0; --i) {
    const k = path[i]
    if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {
      const a: unknown[] = []
      a[k] = v
      v = a
    } else {
      v = new Map([[k, v]])
    }
  }
  return createNode(v, undefined, {
    aliasDuplicateObjects: false,
    keepUndefined: false,
    onAnchor: () => {
      throw new Error('This should not happen, please report a bug.')
    },
    schema,
    sourceObjects: new Map()
  })
}

// Type guard is intentionally a little wrong so as to be more useful,
// as it does not cover untypable empty non-string iterables (e.g. []).
export const isEmptyPath = (
  path: Iterable | null | undefined
): path is null | undefined =>
  path == null ||
  (typeof path === 'object' && !!path[Symbol.iterator]().next().done)

export abstract class Collection extends NodeBase {
  schema: Schema | undefined;

  declare [NODE_TYPE]: symbol

  declare items: unknown[]

  /** An optional anchor on this node. Used by alias nodes. */
  declare anchor?: string

  /**
   * If true, stringify this and all child nodes using flow rather than
   * block styles.
   */
  declare flow?: boolean

  constructor(type: symbol, schema?: Schema) {
    super(type)
    Object.defineProperty(this, 'schema', {
      value: schema,
      configurable: true,
      enumerable: false,
      writable: true
    })
  }

  /**
   * Create a copy of this collection.
   *
   * @param schema - If defined, overwrites the original's schema
   */
  clone(schema?: Schema): Collection {
    const copy: Collection = Object.create(
      Object.getPrototypeOf(this),
      Object.getOwnPropertyDescriptors(this)
    )
    if (schema) copy.schema = schema
    copy.items = copy.items.map(it =>
      isNode(it) || isPair(it) ? it.clone(schema) : it
    )
    if (this.range) copy.range = this.range.slice() as NodeBase['range']
    return copy
  }

  /** Adds a value to the collection. */
  abstract add(value: unknown): void

  /**
   * Removes a value from the collection.
   * @returns `true` if the item was found and removed.
   */
  abstract delete(key: unknown): boolean

  /**
   * Returns item at `key`, or `undefined` if not found. By default unwraps
   * scalar values from their surrounding node; to disable set `keepScalar` to
   * `true` (collections are always returned intact).
   */
  abstract get(key: unknown, keepScalar?: boolean): unknown

  /**
   * Checks if the collection includes a value with the key `key`.
   */
  abstract has(key: unknown): boolean

  /**
   * Sets a value in this collection. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   */
  abstract set(key: unknown, value: unknown): void

  /**
   * Adds a value to the collection. For `!!map` and `!!omap` the value must
   * be a Pair instance or a `{ key, value }` object, which may not have a key
   * that already exists in the map.
   */
  addIn(path: Iterable, value: unknown) {
    if (isEmptyPath(path)) this.add(value)
    else {
      const [key, ...rest] = path
      const node = this.get(key, true)
      if (isCollection(node)) node.addIn(rest, value)
      else if (node === undefined && this.schema)
        this.set(key, collectionFromPath(this.schema, rest, value))
      else
        throw new Error(
          `Expected YAML collection at ${key}. Remaining path: ${rest}`
        )
    }
  }

  /**
   * Removes a value from the collection.
   * @returns `true` if the item was found and removed.
   */
  deleteIn(path: Iterable): boolean {
    const [key, ...rest] = path
    if (rest.length === 0) return this.delete(key)
    const node = this.get(key, true)
    if (isCollection(node)) return node.deleteIn(rest)
    else
      throw new Error(
        `Expected YAML collection at ${key}. Remaining path: ${rest}`
      )
  }

  /**
   * Returns item at `key`, or `undefined` if not found. By default unwraps
   * scalar values from their surrounding node; to disable set `keepScalar` to
   * `true` (collections are always returned intact).
   */
  getIn(path: Iterable, keepScalar?: boolean): unknown {
    const [key, ...rest] = path
    const node = this.get(key, true)
    if (rest.length === 0)
      return !keepScalar && isScalar(node) ? node.value : node
    else return isCollection(node) ? node.getIn(rest, keepScalar) : undefined
  }

  hasAllNullValues(allowScalar?: boolean): boolean {
    return this.items.every(node => {
      if (!isPair(node)) return false
      const n = node.value
      return (
        n == null ||
        (allowScalar &&
          isScalar(n) &&
          n.value == null &&
          !n.commentBefore &&
          !n.comment &&
          !n.tag)
      )
    })
  }

  /**
   * Checks if the collection includes a value with the key `key`.
   */
  hasIn(path: Iterable): boolean {
    const [key, ...rest] = path
    if (rest.length === 0) return this.has(key)
    const node = this.get(key, true)
    return isCollection(node) ? node.hasIn(rest) : false
  }

  /**
   * Sets a value in this collection. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   */
  setIn(path: Iterable, value: unknown) {
    const [key, ...rest] = path
    if (rest.length === 0) {
      this.set(key, value)
    } else {
      const node = this.get(key, true)
      if (isCollection(node)) node.setIn(rest, value)
      else if (node === undefined && this.schema)
        this.set(key, collectionFromPath(this.schema, rest, value))
      else
        throw new Error(
          `Expected YAML collection at ${key}. Remaining path: ${rest}`
        )
    }
  }
}
eemeli-yaml-086fa6b/src/nodes/Node.ts000066400000000000000000000071721511277410200174730ustar00rootroot00000000000000import { applyReviver } from '../doc/applyReviver.ts'
import type { Document } from '../doc/Document.ts'
import type { ToJSOptions } from '../options.ts'
import type { Token } from '../parse/cst.ts'
import type { StringifyContext } from '../stringify/stringify.ts'
import type { Alias } from './Alias.ts'
import { isDocument, NODE_TYPE } from './identity.ts'
import type { Scalar } from './Scalar.ts'
import type { ToJSContext } from './toJS.ts'
import { toJS } from './toJS.ts'
import type { MapLike, YAMLMap } from './YAMLMap.ts'
import type { YAMLSeq } from './YAMLSeq.ts'

export type Node =
  | Alias
  | Scalar
  | YAMLMap
  | YAMLSeq

/** Utility type mapper */
export type NodeType = T extends
  | string
  | number
  | bigint
  | boolean
  | null
  | undefined
  ? Scalar
  : T extends Date
    ? Scalar
    : T extends Array
      ? YAMLSeq>
      : T extends { [key: string]: any }
        ? YAMLMap, NodeType>
        : T extends { [key: number]: any } // Merge with previous once supported in all TS versions
          ? YAMLMap, NodeType>
          : Node

export type ParsedNode =
  | Alias.Parsed
  | Scalar.Parsed
  | YAMLMap.Parsed
  | YAMLSeq.Parsed

/** `[start, value-end, node-end]` */
export type Range = [number, number, number]

export abstract class NodeBase {
  declare readonly [NODE_TYPE]: symbol

  /** A comment on or immediately after this */
  declare comment?: string | null

  /** A comment before this */
  declare commentBefore?: string | null

  /**
   * The `[start, value-end, node-end]` character offsets for the part of the
   * source parsed into this node (undefined if not parsed). The `value-end`
   * and `node-end` positions are themselves not included in their respective
   * ranges.
   */
  declare range?: Range | null

  /** A blank line before this node and its commentBefore */
  declare spaceBefore?: boolean

  /** The CST token that was composed into this node.  */
  declare srcToken?: Token

  /** A fully qualified tag, if required */
  declare tag?: string

  /**
   * Customize the way that a key-value pair is resolved.
   * Used for YAML 1.1 !!merge << handling.
   */
  declare addToJSMap?: (
    ctx: ToJSContext | undefined,
    map: MapLike,
    value: unknown
  ) => void

  /** A plain JS representation of this node */
  abstract toJSON(): any

  abstract toString(
    ctx?: StringifyContext,
    onComment?: () => void,
    onChompKeep?: () => void
  ): string

  constructor(type: symbol) {
    Object.defineProperty(this, NODE_TYPE, { value: type })
  }

  /** Create a copy of this node.  */
  clone(): NodeBase {
    const copy: NodeBase = Object.create(
      Object.getPrototypeOf(this),
      Object.getOwnPropertyDescriptors(this)
    )
    if (this.range) copy.range = this.range.slice() as NodeBase['range']
    return copy
  }

  /** A plain JavaScript representation of this node. */
  toJS(
    doc: Document,
    { mapAsMap, maxAliasCount, onAnchor, reviver }: ToJSOptions = {}
  ): any {
    if (!isDocument(doc)) throw new TypeError('A document argument is required')
    const ctx: ToJSContext = {
      anchors: new Map(),
      doc,
      keep: true,
      mapAsMap: mapAsMap === true,
      mapKeyWarned: false,
      maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
    }
    const res = toJS(this, '', ctx)
    if (typeof onAnchor === 'function')
      for (const { count, res } of ctx.anchors.values()) onAnchor(res, count)
    return typeof reviver === 'function'
      ? applyReviver(reviver, { '': res }, '', res)
      : res
  }
}
eemeli-yaml-086fa6b/src/nodes/Pair.ts000066400000000000000000000035531511277410200175000ustar00rootroot00000000000000import type { CreateNodeContext } from '../doc/createNode.ts'
import { createNode } from '../doc/createNode.ts'
import type { CollectionItem } from '../parse/cst.ts'
import type { Schema } from '../schema/Schema.ts'
import type { StringifyContext } from '../stringify/stringify.ts'
import { stringifyPair } from '../stringify/stringifyPair.ts'
import { addPairToJSMap } from './addPairToJSMap.ts'
import { isNode, NODE_TYPE, PAIR } from './identity.ts'
import type { Node } from './Node.ts'
import type { ToJSContext } from './toJS.ts'

export function createPair(
  key: unknown,
  value: unknown,
  ctx: CreateNodeContext
): Pair {
  const k = createNode(key, undefined, ctx)
  const v = createNode(value, undefined, ctx)
  return new Pair(k, v)
}

export class Pair {
  declare readonly [NODE_TYPE]: symbol

  /** Always Node or null when parsed, but can be set to anything. */
  key: K

  /** Always Node or null when parsed, but can be set to anything. */
  value: V | null

  /** The CST token that was composed into this pair.  */
  declare srcToken?: CollectionItem

  constructor(key: K, value: V | null = null) {
    Object.defineProperty(this, NODE_TYPE, { value: PAIR })
    this.key = key
    this.value = value
  }

  clone(schema?: Schema): Pair {
    let { key, value } = this
    if (isNode(key)) key = key.clone(schema) as unknown as K
    if (isNode(value)) value = value.clone(schema) as unknown as V
    return new Pair(key, value)
  }

  toJSON(_?: unknown, ctx?: ToJSContext): ReturnType {
    const pair = ctx?.mapAsMap ? new Map() : {}
    return addPairToJSMap(ctx, pair, this)
  }

  toString(
    ctx?: StringifyContext,
    onComment?: () => void,
    onChompKeep?: () => void
  ): string {
    return ctx?.doc
      ? stringifyPair(this, ctx, onComment, onChompKeep)
      : JSON.stringify(this)
  }
}
eemeli-yaml-086fa6b/src/nodes/Scalar.ts000066400000000000000000000036051511277410200200100ustar00rootroot00000000000000import type { BlockScalar, FlowScalar } from '../parse/cst.ts'
import { SCALAR } from './identity.ts'
import type { Range } from './Node.ts'
import { NodeBase } from './Node.ts'
import type { ToJSContext } from './toJS.ts'
import { toJS } from './toJS.ts'

export const isScalarValue = (value: unknown) =>
  !value || (typeof value !== 'function' && typeof value !== 'object')

export declare namespace Scalar {
  interface Parsed extends Scalar {
    range: Range
    source: string
    srcToken?: FlowScalar | BlockScalar
  }

  type BLOCK_FOLDED = 'BLOCK_FOLDED'
  type BLOCK_LITERAL = 'BLOCK_LITERAL'
  type PLAIN = 'PLAIN'
  type QUOTE_DOUBLE = 'QUOTE_DOUBLE'
  type QUOTE_SINGLE = 'QUOTE_SINGLE'

  type Type = BLOCK_FOLDED | BLOCK_LITERAL | PLAIN | QUOTE_DOUBLE | QUOTE_SINGLE
}

export class Scalar extends NodeBase {
  static readonly BLOCK_FOLDED = 'BLOCK_FOLDED'
  static readonly BLOCK_LITERAL = 'BLOCK_LITERAL'
  static readonly PLAIN = 'PLAIN'
  static readonly QUOTE_DOUBLE = 'QUOTE_DOUBLE'
  static readonly QUOTE_SINGLE = 'QUOTE_SINGLE'

  value: T

  /** An optional anchor on this node. Used by alias nodes. */
  declare anchor?: string

  /**
   * By default (undefined), numbers use decimal notation.
   * The YAML 1.2 core schema only supports 'HEX' and 'OCT'.
   * The YAML 1.1 schema also supports 'BIN' and 'TIME'
   */
  declare format?: string

  /** If `value` is a number, use this value when stringifying this node. */
  declare minFractionDigits?: number

  /** Set during parsing to the source string value */
  declare source?: string

  /** The scalar style used for the node's string representation */
  declare type?: Scalar.Type

  constructor(value: T) {
    super(SCALAR)
    this.value = value
  }

  toJSON(arg?: any, ctx?: ToJSContext): any {
    return ctx?.keep ? this.value : toJS(this.value, arg, ctx)
  }

  toString(): string {
    return String(this.value)
  }
}
eemeli-yaml-086fa6b/src/nodes/YAMLMap.ts000066400000000000000000000131521511277410200200010ustar00rootroot00000000000000import type { BlockMap, FlowCollection } from '../parse/cst.ts'
import type { Schema } from '../schema/Schema.ts'
import type { StringifyContext } from '../stringify/stringify.ts'
import { stringifyCollection } from '../stringify/stringifyCollection.ts'
import type { CreateNodeContext } from '../util.ts'
import { addPairToJSMap } from './addPairToJSMap.ts'
import { Collection } from './Collection.ts'
import { isPair, isScalar, MAP } from './identity.ts'
import type { ParsedNode, Range } from './Node.ts'
import { createPair, Pair } from './Pair.ts'
import type { Scalar } from './Scalar.ts'
import { isScalarValue } from './Scalar.ts'
import type { ToJSContext } from './toJS.ts'

export type MapLike =
  | Map
  | Set
  | Record

export function findPair(
  items: Iterable>,
  key: unknown
): Pair | undefined {
  const k = isScalar(key) ? key.value : key
  for (const it of items) {
    if (isPair(it)) {
      if (it.key === key || it.key === k) return it
      if (isScalar(it.key) && it.key.value === k) return it
    }
  }
  return undefined
}

export declare namespace YAMLMap {
  interface Parsed<
    K extends ParsedNode = ParsedNode,
    V extends ParsedNode | null = ParsedNode | null
  > extends YAMLMap {
    items: Pair[]
    range: Range
    srcToken?: BlockMap | FlowCollection
  }
}

export class YAMLMap extends Collection {
  static get tagName(): 'tag:yaml.org,2002:map' {
    return 'tag:yaml.org,2002:map'
  }

  items: Pair[] = []

  constructor(schema?: Schema) {
    super(MAP, schema)
  }

  /**
   * A generic collection parsing method that can be extended
   * to other node classes that inherit from YAMLMap
   */
  static from(schema: Schema, obj: unknown, ctx: CreateNodeContext): YAMLMap {
    const { keepUndefined, replacer } = ctx
    const map = new this(schema)
    const add = (key: unknown, value: unknown) => {
      if (typeof replacer === 'function') value = replacer.call(obj, key, value)
      else if (Array.isArray(replacer) && !replacer.includes(key)) return
      if (value !== undefined || keepUndefined)
        map.items.push(createPair(key, value, ctx))
    }
    if (obj instanceof Map) {
      for (const [key, value] of obj) add(key, value)
    } else if (obj && typeof obj === 'object') {
      for (const key of Object.keys(obj)) add(key, (obj as any)[key])
    }
    if (typeof schema.sortMapEntries === 'function') {
      map.items.sort(schema.sortMapEntries)
    }
    return map
  }

  /**
   * Adds a value to the collection.
   *
   * @param overwrite - If not set `true`, using a key that is already in the
   *   collection will throw. Otherwise, overwrites the previous value.
   */
  add(pair: Pair | { key: K; value: V }, overwrite?: boolean): void {
    let _pair: Pair
    if (isPair(pair)) _pair = pair
    else if (!pair || typeof pair !== 'object' || !('key' in pair)) {
      // In TypeScript, this never happens.
      _pair = new Pair(pair as any, (pair as any)?.value)
    } else _pair = new Pair(pair.key, pair.value)

    const prev = findPair(this.items, _pair.key)
    const sortEntries = this.schema?.sortMapEntries
    if (prev) {
      if (!overwrite) throw new Error(`Key ${_pair.key} already set`)
      // For scalars, keep the old node & its comments and anchors
      if (isScalar(prev.value) && isScalarValue(_pair.value))
        prev.value.value = _pair.value
      else prev.value = _pair.value
    } else if (sortEntries) {
      const i = this.items.findIndex(item => sortEntries(_pair, item) < 0)
      if (i === -1) this.items.push(_pair)
      else this.items.splice(i, 0, _pair)
    } else {
      this.items.push(_pair)
    }
  }

  delete(key: unknown): boolean {
    const it = findPair(this.items, key)
    if (!it) return false
    const del = this.items.splice(this.items.indexOf(it), 1)
    return del.length > 0
  }

  get(key: unknown, keepScalar: true): Scalar | undefined
  get(key: unknown, keepScalar?: false): V | undefined
  get(key: unknown, keepScalar?: boolean): V | Scalar | undefined
  get(key: unknown, keepScalar?: boolean): V | Scalar | undefined {
    const it = findPair(this.items, key)
    const node = it?.value
    return (!keepScalar && isScalar(node) ? node.value : node) ?? undefined
  }

  has(key: unknown): boolean {
    return !!findPair(this.items, key)
  }

  set(key: K, value: V): void {
    this.add(new Pair(key, value), true)
  }

  /**
   * @param ctx - Conversion context, originally set in Document#toJS()
   * @param {Class} Type - If set, forces the returned collection type
   * @returns Instance of Type, Map, or Object
   */
  toJSON>(
    _?: unknown,
    ctx?: ToJSContext,
    Type?: { new (): T }
  ): any {
    const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {}
    if (ctx?.onCreate) ctx.onCreate(map)
    for (const item of this.items) addPairToJSMap(ctx, map, item)
    return map
  }

  toString(
    ctx?: StringifyContext,
    onComment?: () => void,
    onChompKeep?: () => void
  ): string {
    if (!ctx) return JSON.stringify(this)
    for (const item of this.items) {
      if (!isPair(item))
        throw new Error(
          `Map items must all be pairs; found ${JSON.stringify(item)} instead`
        )
    }
    if (!ctx.allNullValues && this.hasAllNullValues(false))
      ctx = Object.assign({}, ctx, { allNullValues: true })
    return stringifyCollection(this, ctx, {
      blockItemPrefix: '',
      flowChars: { start: '{', end: '}' },
      itemIndent: ctx.indent || '',
      onChompKeep,
      onComment
    })
  }
}
eemeli-yaml-086fa6b/src/nodes/YAMLSeq.ts000066400000000000000000000110711511277410200200120ustar00rootroot00000000000000import type { CreateNodeContext } from '../doc/createNode.ts'
import { createNode } from '../doc/createNode.ts'
import type { BlockSequence, FlowCollection } from '../parse/cst.ts'
import type { Schema } from '../schema/Schema.ts'
import type { StringifyContext } from '../stringify/stringify.ts'
import { stringifyCollection } from '../stringify/stringifyCollection.ts'
import { Collection } from './Collection.ts'
import { isScalar, SEQ } from './identity.ts'
import type { ParsedNode, Range } from './Node.ts'
import type { Pair } from './Pair.ts'
import type { Scalar } from './Scalar.ts'
import { isScalarValue } from './Scalar.ts'
import type { ToJSContext } from './toJS.ts'
import { toJS } from './toJS.ts'

export declare namespace YAMLSeq {
  interface Parsed<
    T extends ParsedNode | Pair = ParsedNode
  > extends YAMLSeq {
    items: T[]
    range: Range
    srcToken?: BlockSequence | FlowCollection
  }
}

export class YAMLSeq extends Collection {
  static get tagName(): 'tag:yaml.org,2002:seq' {
    return 'tag:yaml.org,2002:seq'
  }

  items: T[] = []

  constructor(schema?: Schema) {
    super(SEQ, schema)
  }

  add(value: T): void {
    this.items.push(value)
  }

  /**
   * Removes a value from the collection.
   *
   * `key` must contain a representation of an integer for this to succeed.
   * It may be wrapped in a `Scalar`.
   *
   * @returns `true` if the item was found and removed.
   */
  delete(key: unknown): boolean {
    const idx = asItemIndex(key)
    if (typeof idx !== 'number') return false
    const del = this.items.splice(idx, 1)
    return del.length > 0
  }

  /**
   * Returns item at `key`, or `undefined` if not found. By default unwraps
   * scalar values from their surrounding node; to disable set `keepScalar` to
   * `true` (collections are always returned intact).
   *
   * `key` must contain a representation of an integer for this to succeed.
   * It may be wrapped in a `Scalar`.
   */
  get(key: unknown, keepScalar: true): Scalar | undefined
  get(key: unknown, keepScalar?: false): T | undefined
  get(key: unknown, keepScalar?: boolean): T | Scalar | undefined
  get(key: unknown, keepScalar?: boolean): T | Scalar | undefined {
    const idx = asItemIndex(key)
    if (typeof idx !== 'number') return undefined
    const it = this.items[idx]
    return !keepScalar && isScalar(it) ? it.value : it
  }

  /**
   * Checks if the collection includes a value with the key `key`.
   *
   * `key` must contain a representation of an integer for this to succeed.
   * It may be wrapped in a `Scalar`.
   */
  has(key: unknown): boolean {
    const idx = asItemIndex(key)
    return typeof idx === 'number' && idx < this.items.length
  }

  /**
   * Sets a value in this collection. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   *
   * If `key` does not contain a representation of an integer, this will throw.
   * It may be wrapped in a `Scalar`.
   */
  set(key: unknown, value: T): void {
    const idx = asItemIndex(key)
    if (typeof idx !== 'number')
      throw new Error(`Expected a valid index, not ${key}.`)
    const prev = this.items[idx]
    if (isScalar(prev) && isScalarValue(value)) prev.value = value
    else this.items[idx] = value
  }

  toJSON(_?: unknown, ctx?: ToJSContext): unknown[] {
    const seq: unknown[] = []
    if (ctx?.onCreate) ctx.onCreate(seq)
    let i = 0
    for (const item of this.items) seq.push(toJS(item, String(i++), ctx))
    return seq
  }

  toString(
    ctx?: StringifyContext,
    onComment?: () => void,
    onChompKeep?: () => void
  ): string {
    if (!ctx) return JSON.stringify(this)
    return stringifyCollection(this, ctx, {
      blockItemPrefix: '- ',
      flowChars: { start: '[', end: ']' },
      itemIndent: (ctx.indent || '') + '  ',
      onChompKeep,
      onComment
    })
  }

  static from(schema: Schema, obj: unknown, ctx: CreateNodeContext): YAMLSeq {
    const { replacer } = ctx
    const seq = new this(schema)
    if (obj && Symbol.iterator in Object(obj)) {
      let i = 0
      for (let it of obj as Iterable) {
        if (typeof replacer === 'function') {
          const key = obj instanceof Set ? it : String(i++)
          it = replacer.call(obj, key, it)
        }
        seq.items.push(createNode(it, undefined, ctx))
      }
    }
    return seq
  }
}

function asItemIndex(key: unknown): number | null {
  let idx = isScalar(key) ? key.value : key
  if (idx && typeof idx === 'string') idx = Number(idx)
  return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0
    ? idx
    : null
}
eemeli-yaml-086fa6b/src/nodes/addPairToJSMap.ts000066400000000000000000000042651511277410200213500ustar00rootroot00000000000000import { warn } from '../log.ts'
import { addMergeToJSMap, isMergeKey } from '../schema/yaml-1.1/merge.ts'
import { createStringifyContext } from '../stringify/stringify.ts'
import { isNode } from './identity.ts'
import type { Pair } from './Pair.ts'
import type { ToJSContext } from './toJS.ts'
import { toJS } from './toJS.ts'
import type { MapLike } from './YAMLMap.ts'

export function addPairToJSMap(
  ctx: ToJSContext | undefined,
  map: MapLike,
  { key, value }: Pair
): MapLike {
  if (isNode(key) && key.addToJSMap) key.addToJSMap(ctx, map, value)
  // TODO: Should drop this special case for bare << handling
  else if (isMergeKey(ctx, key)) addMergeToJSMap(ctx, map, value)
  else {
    const jsKey = toJS(key, '', ctx)
    if (map instanceof Map) {
      map.set(jsKey, toJS(value, jsKey, ctx))
    } else if (map instanceof Set) {
      map.add(jsKey)
    } else {
      const stringKey = stringifyKey(key, jsKey, ctx)
      const jsValue = toJS(value, stringKey, ctx)
      if (stringKey in map)
        Object.defineProperty(map, stringKey, {
          value: jsValue,
          writable: true,
          enumerable: true,
          configurable: true
        })
      else map[stringKey] = jsValue
    }
  }
  return map
}

function stringifyKey(
  key: unknown,
  jsKey: unknown,
  ctx: ToJSContext | undefined
) {
  if (jsKey === null) return ''
  // eslint-disable-next-line @typescript-eslint/no-base-to-string
  if (typeof jsKey !== 'object') return String(jsKey)
  if (isNode(key) && ctx?.doc) {
    const strCtx = createStringifyContext(ctx.doc, {})
    strCtx.anchors = new Set()
    for (const node of ctx.anchors.keys())
      strCtx.anchors.add(node.anchor as 'string')
    strCtx.inFlow = true
    strCtx.inStringifyKey = true
    const strKey = key.toString(strCtx)
    if (!ctx.mapKeyWarned) {
      let jsonStr = JSON.stringify(strKey)
      if (jsonStr.length > 40) jsonStr = jsonStr.substring(0, 36) + '..."'
      warn(
        ctx.doc.options.logLevel,
        `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`
      )
      ctx.mapKeyWarned = true
    }
    return strKey
  }
  return JSON.stringify(jsKey)
}
eemeli-yaml-086fa6b/src/nodes/identity.ts000066400000000000000000000041611511277410200204320ustar00rootroot00000000000000import type { Document } from '../doc/Document.ts'
import type { Alias } from './Alias.ts'
import type { Node } from './Node.ts'
import type { Pair } from './Pair.ts'
import type { Scalar } from './Scalar.ts'
import type { YAMLMap } from './YAMLMap.ts'
import type { YAMLSeq } from './YAMLSeq.ts'

export const ALIAS = Symbol.for('yaml.alias')
export const DOC = Symbol.for('yaml.document')
export const MAP = Symbol.for('yaml.map')
export const PAIR = Symbol.for('yaml.pair')
export const SCALAR = Symbol.for('yaml.scalar')
export const SEQ = Symbol.for('yaml.seq')
export const NODE_TYPE = Symbol.for('yaml.node.type')

export const isAlias = (node: any): node is Alias =>
  !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS

export const isDocument = (
  node: any
): node is Document =>
  !!node && typeof node === 'object' && node[NODE_TYPE] === DOC

export const isMap = (
  node: any
): node is YAMLMap =>
  !!node && typeof node === 'object' && node[NODE_TYPE] === MAP

export const isPair = (
  node: any
): node is Pair =>
  !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR

export const isScalar = (node: any): node is Scalar =>
  !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR

export const isSeq = (node: any): node is YAMLSeq =>
  !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ

export function isCollection(
  node: any
): node is YAMLMap | YAMLSeq {
  if (node && typeof node === 'object')
    switch (node[NODE_TYPE]) {
      case MAP:
      case SEQ:
        return true
    }
  return false
}

export function isNode(node: any): node is Node {
  if (node && typeof node === 'object')
    switch (node[NODE_TYPE]) {
      case ALIAS:
      case MAP:
      case SCALAR:
      case SEQ:
        return true
    }
  return false
}

export const hasAnchor = (
  node: unknown
): node is Scalar | YAMLMap | YAMLSeq =>
  (isScalar(node) || isCollection(node)) && !!node.anchor
eemeli-yaml-086fa6b/src/nodes/toJS.ts000066400000000000000000000032351511277410200174610ustar00rootroot00000000000000import type { Document } from '../doc/Document.ts'
import { hasAnchor } from './identity.ts'
import type { Node } from './Node.ts'

export interface AnchorData {
  aliasCount: number
  count: number
  res: unknown
}

export interface ToJSContext {
  anchors: Map
  /** Cached anchor and alias nodes in the order they occur in the document */
  aliasResolveCache?: Node[]
  doc: Document
  keep: boolean
  mapAsMap: boolean
  mapKeyWarned: boolean
  maxAliasCount: number
  onCreate?: (res: unknown) => void
}

/**
 * Recursively convert any node or its contents to native JavaScript
 *
 * @param value - The input value
 * @param arg - If `value` defines a `toJSON()` method, use this
 *   as its first argument
 * @param ctx - Conversion context, originally set in Document#toJS(). If
 *   `{ keep: true }` is not set, output should be suitable for JSON
 *   stringification.
 */
export function toJS(value: any, arg: string | null, ctx?: ToJSContext): any {
  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
  if (Array.isArray(value)) return value.map((v, i) => toJS(v, String(i), ctx))
  if (value && typeof value.toJSON === 'function') {
    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
    if (!ctx || !hasAnchor(value)) return value.toJSON(arg, ctx)
    const data: AnchorData = { aliasCount: 0, count: 1, res: undefined }
    ctx.anchors.set(value, data)
    ctx.onCreate = res => {
      data.res = res
      delete ctx.onCreate
    }
    const res = value.toJSON(arg, ctx)
    if (ctx.onCreate) ctx.onCreate(res)
    return res
  }
  if (typeof value === 'bigint' && !ctx?.keep) return Number(value)
  return value
}
eemeli-yaml-086fa6b/src/options.ts000066400000000000000000000241721511277410200171700ustar00rootroot00000000000000import type { Reviver } from './doc/applyReviver.ts'
import type { Directives } from './doc/directives.ts'
import type { LogLevelId } from './log.ts'
import type { ParsedNode } from './nodes/Node.ts'
import type { Pair } from './nodes/Pair.ts'
import type { Scalar } from './nodes/Scalar.ts'
import type { LineCounter } from './parse/line-counter.ts'
import type { Schema } from './schema/Schema.ts'
import type { Tags } from './schema/tags.ts'
import type { CollectionTag, ScalarTag } from './schema/types.ts'

export type ParseOptions = {
  /**
   * Whether integers should be parsed into BigInt rather than number values.
   *
   * Default: `false`
   *
   * https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/BigInt
   */
  intAsBigInt?: boolean

  /**
   * Include a `srcToken` value on each parsed `Node`, containing the CST token
   * that was composed into this node.
   *
   * Default: `false`
   */
  keepSourceTokens?: boolean

  /**
   * If set, newlines will be tracked, to allow for `lineCounter.linePos(offset)`
   * to provide the `{ line, col }` positions within the input.
   */
  lineCounter?: LineCounter

  /**
   * Include line/col position & node type directly in parse errors.
   *
   * Default: `true`
   */
  prettyErrors?: boolean

  /**
   * Detect and report errors that are required by the YAML 1.2 spec,
   * but are caused by unambiguous content.
   *
   * Default: `true`
   */
  strict?: boolean

  /**
   * Parse all mapping keys as strings. Treat all non-scalar keys as errors.
   *
   * Default: `false`
   */
  stringKeys?: boolean

  /**
   * YAML requires map keys to be unique. By default, this is checked by
   * comparing scalar values with `===`; deep equality is not checked for
   * aliases or collections. If merge keys are enabled by the schema,
   * multiple `<<` keys are allowed.
   *
   * Set `false` to disable, or provide your own comparator function to
   * customise. The comparator will be passed two `ParsedNode` values, and
   * is expected to return a `boolean` indicating their equality.
   *
   * Default: `true`
   */
  uniqueKeys?: boolean | ((a: ParsedNode, b: ParsedNode) => boolean)
}

export type DocumentOptions = {
  /**
   * @internal
   * Used internally by Composer. If set and includes an explicit version,
   * that overrides the `version` option.
   */
  _directives?: Directives

  /**
   * Control the logging level during parsing
   *
   * Default: `'warn'`
   */
  logLevel?: LogLevelId

  /**
   * The YAML version used by documents without a `%YAML` directive.
   *
   * Default: `"1.2"`
   */
  version?: '1.1' | '1.2' | 'next'
}

export type SchemaOptions = {
  /**
   * When parsing, warn about compatibility issues with the given schema.
   * When stringifying, use scalar styles that are parsed correctly
   * by the `compat` schema as well as the actual schema.
   *
   * Default: `null`
   */
  compat?: string | Tags | null

  /**
   * Array of additional tags to include in the schema, or a function that may
   * modify the schema's base tag array.
   */
  customTags?: Tags | ((tags: Tags) => Tags) | null

  /**
   * Enable support for `<<` merge keys.
   *
   * Default: `false` for YAML 1.2, `true` for earlier versions
   */
  merge?: boolean

  /**
   * When using the `'core'` schema, support parsing values with these
   * explicit YAML 1.1 tags:
   *
   * `!!binary`, `!!omap`, `!!pairs`, `!!set`, `!!timestamp`.
   *
   * Default `true`
   */
  resolveKnownTags?: boolean

  /**
   * The base schema to use.
   *
   * The core library has built-in support for the following:
   * - `'failsafe'`: A minimal schema that parses all scalars as strings
   * - `'core'`: The YAML 1.2 core schema
   * - `'json'`: The YAML 1.2 JSON schema, with minimal rules for JSON compatibility
   * - `'yaml-1.1'`: The YAML 1.1 schema
   *
   * If using another (custom) schema, the `customTags` array needs to
   * fully define the schema's tags.
   *
   * Default: `'core'` for YAML 1.2, `'yaml-1.1'` for earlier versions
   */
  schema?: string | Schema

  /**
   * When adding to or stringifying a map, sort the entries.
   * If `true`, sort by comparing key values with `<`.
   * Does not affect item order when parsing.
   *
   * Default: `false`
   */
  sortMapEntries?: boolean | ((a: Pair, b: Pair) => number)

  /**
   * Override default values for `toString()` options.
   */
  toStringDefaults?: ToStringOptions
}

export type CreateNodeOptions = {
  /**
   * During node construction, use anchors and aliases to keep strictly equal
   * non-null objects as equivalent in YAML.
   *
   * Default: `true`
   */
  aliasDuplicateObjects?: boolean

  /**
   * Default prefix for anchors.
   *
   * Default: `'a'`, resulting in anchors `a1`, `a2`, etc.
   */
  anchorPrefix?: string

  /** Force the top-level collection node to use flow style. */
  flow?: boolean

  /**
   * Keep `undefined` object values when creating mappings, rather than
   * discarding them.
   *
   * Default: `false`
   */
  keepUndefined?: boolean | null

  onTagObj?: (tagObj: ScalarTag | CollectionTag) => void

  /**
   * Specify the top-level collection type, e.g. `"!!omap"`. Note that this
   * requires the corresponding tag to be available in this document's schema.
   */
  tag?: string
}

export type ToJSOptions = {
  /**
   * Use Map rather than Object to represent mappings.
   *
   * Default: `false`
   */
  mapAsMap?: boolean

  /**
   * Prevent exponential entity expansion attacks by limiting data aliasing count;
   * set to `-1` to disable checks; `0` disallows all alias nodes.
   *
   * Default: `100`
   */
  maxAliasCount?: number

  /**
   * If defined, called with the resolved `value` and reference `count` for
   * each anchor in the document.
   */
  onAnchor?: (value: unknown, count: number) => void

  /**
   * Optional function that may filter or modify the output JS value
   *
   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#using_the_reviver_parameter
   */
  reviver?: Reviver
}

export type ToStringOptions = {
  /**
   * Use block quote styles for scalar values where applicable.
   * Set to `false` to disable block quotes completely.
   *
   * Default: `true`
   */
  blockQuote?: boolean | 'folded' | 'literal'

  /**
   * Enforce `'block'` or `'flow'` style on maps and sequences.
   * Empty collections will always be stringified as `{}` or `[]`.
   *
   * Default: `'any'`, allowing each node to set its style separately
   * with its `flow: boolean` (default `false`) property.
   */
  collectionStyle?: 'any' | 'block' | 'flow'

  /**
   * Comment stringifier.
   * Output should be valid for the current schema.
   *
   * By default, empty comment lines are left empty,
   * lines consisting of a single space are replaced by `#`,
   * and all other lines are prefixed with a `#`.
   */
  commentString?: (comment: string) => string

  /**
   * The default type of string literal used to stringify implicit key values.
   * Output may use other types if required to fully represent the value.
   *
   * If `null`, the value of `defaultStringType` is used.
   *
   * Default: `null`
   */
  defaultKeyType?: Scalar.Type | null

  /**
   * The default type of string literal used to stringify values in general.
   * Output may use other types if required to fully represent the value.
   *
   * Default: `'PLAIN'`
   */
  defaultStringType?: Scalar.Type

  /**
   * Include directives in the output.
   *
   * - If `true`, at least the document-start marker `---` is always included.
   *   This does not force the `%YAML` directive to be included. To do that,
   *   set `doc.directives.yaml.explicit = true`.
   * - If `false`, no directives or marker is ever included. If using the `%TAG`
   *   directive, you are expected to include it manually in the stream before
   *   its use.
   * - If `null`, directives and marker may be included if required.
   *
   * Default: `null`
   */
  directives?: boolean | null

  /**
   * Restrict double-quoted strings to use JSON-compatible syntax.
   *
   * Default: `false`
   */
  doubleQuotedAsJSON?: boolean

  /**
   * Minimum length for double-quoted strings to use multiple lines to
   * represent the value. Ignored if `doubleQuotedAsJSON` is set.
   *
   * Default: `40`
   */
  doubleQuotedMinMultiLineLength?: number

  /**
   * String representation for `false`.
   * With the core schema, use `'false'`, `'False'`, or `'FALSE'`.
   *
   * Default: `'false'`
   */
  falseStr?: string

  /**
   * When true, a single space of padding will be added inside the delimiters
   * of non-empty single-line flow collections.
   *
   * Default: `true`
   */
  flowCollectionPadding?: boolean

  /**
   * The number of spaces to use when indenting code.
   *
   * Default: `2`
   */
  indent?: number

  /**
   * Whether block sequences should be indented.
   *
   * Default: `true`
   */
  indentSeq?: boolean

  /**
   * Maximum line width (set to `0` to disable folding).
   *
   * This is a soft limit, as only double-quoted semantics allow for inserting
   * a line break in the middle of a word, as well as being influenced by the
   * `minContentWidth` option.
   *
   * Default: `80`
   */
  lineWidth?: number

  /**
   * Minimum line width for highly-indented content (set to `0` to disable).
   *
   * Default: `20`
   */
  minContentWidth?: number

  /**
   * String representation for `null`.
   * With the core schema, use `'null'`, `'Null'`, `'NULL'`, `'~'`, or an empty
   * string `''`.
   *
   * Default: `'null'`
   */
  nullStr?: string

  /**
   * Require keys to be scalars and to use implicit rather than explicit notation.
   *
   * Default: `false`
   */
  simpleKeys?: boolean

  /**
   * Use 'single quote' rather than "double quote" where applicable.
   * Set to `false` to disable single quotes completely.
   *
   * Default: `null`
   */
  singleQuote?: boolean | null

  /**
   * String representation for `true`.
   * With the core schema, use `'true'`, `'True'`, or `'TRUE'`.
   *
   * Default: `'true'`
   */
  trueStr?: string

  /**
   * The anchor used by an alias must be defined before the alias node. As it's
   * possible for the document to be modified manually, the order may be
   * verified during stringification.
   *
   * Default: `'true'`
   */
  verifyAliasOrder?: boolean
}
eemeli-yaml-086fa6b/src/parse/000077500000000000000000000000001511277410200162315ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/parse/cst-scalar.ts000066400000000000000000000237361511277410200206500ustar00rootroot00000000000000import type { ComposeContext } from '../compose/compose-node.ts'
import type { ComposeErrorHandler } from '../compose/composer.ts'
import { resolveBlockScalar } from '../compose/resolve-block-scalar.ts'
import { resolveFlowScalar } from '../compose/resolve-flow-scalar.ts'
import type { ErrorCode } from '../errors.ts'
import { YAMLParseError } from '../errors.ts'
import type { Range } from '../nodes/Node.ts'
import type { Scalar } from '../nodes/Scalar.ts'
import type { StringifyContext } from '../stringify/stringify.ts'
import { stringifyString } from '../stringify/stringifyString.ts'
import type { BlockScalar, FlowScalar, SourceToken, Token } from './cst.ts'

/**
 * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
 * Otherwise, return `null`.
 */
export function resolveAsScalar(
  token: FlowScalar | BlockScalar,
  strict?: boolean,
  onError?: (offset: number, code: ErrorCode, message: string) => void
): {
  value: string
  type: Scalar.Type | null
  comment: string
  range: Range
}
export function resolveAsScalar(
  token: Token | null | undefined,
  strict?: boolean,
  onError?: (offset: number, code: ErrorCode, message: string) => void
): {
  value: string
  type: Scalar.Type | null
  comment: string
  range: Range
} | null
export function resolveAsScalar(
  token: Token | null | undefined,
  strict = true,
  onError?: (offset: number, code: ErrorCode, message: string) => void
): {
  value: string
  type: Scalar.Type | null
  comment: string
  range: Range
} | null {
  if (token) {
    const _onError: ComposeErrorHandler = (pos, code, message) => {
      const offset =
        typeof pos === 'number' ? pos : Array.isArray(pos) ? pos[0] : pos.offset
      if (onError) onError(offset, code, message)
      else throw new YAMLParseError([offset, offset + 1], code, message)
    }
    switch (token.type) {
      case 'scalar':
      case 'single-quoted-scalar':
      case 'double-quoted-scalar':
        return resolveFlowScalar(token, strict, _onError)
      case 'block-scalar':
        return resolveBlockScalar(
          { options: { strict } } as ComposeContext,
          token,
          _onError
        )
    }
  }
  return null
}

/**
 * Create a new scalar token with `value`
 *
 * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
 * as this function does not support any schema operations and won't check for such conflicts.
 *
 * @param value The string representation of the value, which will have its content properly indented.
 * @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
 * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
 * @param context.indent The indent level of the token.
 * @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
 * @param context.offset The offset position of the token.
 * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
 */
export function createScalarToken(
  value: string,
  context: {
    end?: SourceToken[]
    implicitKey?: boolean
    indent: number
    inFlow?: boolean
    offset?: number
    type?: Scalar.Type
  }
): BlockScalar | FlowScalar {
  const {
    implicitKey = false,
    indent,
    inFlow = false,
    offset = -1,
    type = 'PLAIN'
  } = context
  const source = stringifyString(
    { type, value } as Scalar,
    {
      implicitKey,
      indent: indent > 0 ? ' '.repeat(indent) : '',
      inFlow,
      options: { blockQuote: true, lineWidth: -1 }
    } as StringifyContext
  )
  const end = context.end ?? [
    { type: 'newline', offset: -1, indent, source: '\n' }
  ]
  switch (source[0]) {
    case '|':
    case '>': {
      const he = source.indexOf('\n')
      const head = source.substring(0, he)
      const body = source.substring(he + 1) + '\n'
      const props: Token[] = [
        { type: 'block-scalar-header', offset, indent, source: head }
      ]
      if (!addEndtoBlockProps(props, end))
        props.push({ type: 'newline', offset: -1, indent, source: '\n' })
      return { type: 'block-scalar', offset, indent, props, source: body }
    }
    case '"':
      return { type: 'double-quoted-scalar', offset, indent, source, end }
    case "'":
      return { type: 'single-quoted-scalar', offset, indent, source, end }
    default:
      return { type: 'scalar', offset, indent, source, end }
  }
}

/**
 * Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have.
 *
 * Best efforts are made to retain any comments previously associated with the `token`,
 * though all contents within a collection's `items` will be overwritten.
 *
 * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
 * as this function does not support any schema operations and won't check for such conflicts.
 *
 * @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
 * @param value The string representation of the value, which will have its content properly indented.
 * @param context.afterKey In most cases, values after a key should have an additional level of indentation.
 * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
 * @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
 * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
 */
export function setScalarValue(
  token: Token,
  value: string,
  context: {
    afterKey?: boolean
    implicitKey?: boolean
    inFlow?: boolean
    type?: Scalar.Type
  } = {}
) {
  let { afterKey = false, implicitKey = false, inFlow = false, type } = context
  let indent = 'indent' in token ? token.indent : null
  if (afterKey && typeof indent === 'number') indent += 2
  if (!type)
    switch (token.type) {
      case 'single-quoted-scalar':
        type = 'QUOTE_SINGLE'
        break
      case 'double-quoted-scalar':
        type = 'QUOTE_DOUBLE'
        break
      case 'block-scalar': {
        const header = token.props[0]
        if (header.type !== 'block-scalar-header')
          throw new Error('Invalid block scalar header')
        type = header.source[0] === '>' ? 'BLOCK_FOLDED' : 'BLOCK_LITERAL'
        break
      }
      default:
        type = 'PLAIN'
    }
  const source = stringifyString(
    { type, value } as Scalar,
    {
      implicitKey: implicitKey || indent === null,
      indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
      inFlow,
      options: { blockQuote: true, lineWidth: -1 }
    } as StringifyContext
  )
  switch (source[0]) {
    case '|':
    case '>':
      setBlockScalarValue(token, source)
      break
    case '"':
      setFlowScalarValue(token, source, 'double-quoted-scalar')
      break
    case "'":
      setFlowScalarValue(token, source, 'single-quoted-scalar')
      break
    default:
      setFlowScalarValue(token, source, 'scalar')
  }
}

function setBlockScalarValue(token: Token, source: string) {
  const he = source.indexOf('\n')
  const head = source.substring(0, he)
  const body = source.substring(he + 1) + '\n'
  if (token.type === 'block-scalar') {
    const header = token.props[0]
    if (header.type !== 'block-scalar-header')
      throw new Error('Invalid block scalar header')
    header.source = head
    token.source = body
  } else {
    const { offset } = token
    const indent = 'indent' in token ? token.indent : -1
    const props: Token[] = [
      { type: 'block-scalar-header', offset, indent, source: head }
    ]
    if (!addEndtoBlockProps(props, 'end' in token ? token.end : undefined))
      props.push({ type: 'newline', offset: -1, indent, source: '\n' })

    for (const key of Object.keys(token))
      if (key !== 'type' && key !== 'offset') delete (token as any)[key]
    Object.assign(token, { type: 'block-scalar', indent, props, source: body })
  }
}

/** @returns `true` if last token is a newline */
function addEndtoBlockProps(props: Token[], end?: SourceToken[]) {
  if (end)
    for (const st of end)
      switch (st.type) {
        case 'space':
        case 'comment':
          props.push(st)
          break
        case 'newline':
          props.push(st)
          return true
      }
  return false
}

function setFlowScalarValue(
  token: Token,
  source: string,
  type: 'scalar' | 'double-quoted-scalar' | 'single-quoted-scalar'
) {
  switch (token.type) {
    case 'scalar':
    case 'double-quoted-scalar':
    case 'single-quoted-scalar':
      token.type = type
      token.source = source
      break
    case 'block-scalar': {
      const end = token.props.slice(1)
      let oa = source.length
      if (token.props[0].type === 'block-scalar-header')
        oa -= token.props[0].source.length
      for (const tok of end) tok.offset += oa
      delete (token as any).props
      Object.assign(token, { type, source, end })
      break
    }
    case 'block-map':
    case 'block-seq': {
      const offset = token.offset + source.length
      const nl = { type: 'newline', offset, indent: token.indent, source: '\n' }
      delete (token as any).items
      Object.assign(token, { type, source, end: [nl] })
      break
    }
    default: {
      const indent = 'indent' in token ? token.indent : -1
      const end =
        'end' in token && Array.isArray(token.end)
          ? token.end.filter(
              st =>
                st.type === 'space' ||
                st.type === 'comment' ||
                st.type === 'newline'
            )
          : []
      for (const key of Object.keys(token))
        if (key !== 'type' && key !== 'offset') delete (token as any)[key]
      Object.assign(token, { type, indent, source, end })
    }
  }
}
eemeli-yaml-086fa6b/src/parse/cst-stringify.ts000066400000000000000000000030021511277410200214010ustar00rootroot00000000000000import type { CollectionItem, Token } from './cst.ts'

/**
 * Stringify a CST document, token, or collection item
 *
 * Fair warning: This applies no validation whatsoever, and
 * simply concatenates the sources in their logical order.
 */
export const stringify = (cst: Token | CollectionItem): string =>
  'type' in cst ? stringifyToken(cst) : stringifyItem(cst)

function stringifyToken(token: Token): string {
  switch (token.type) {
    case 'block-scalar': {
      let res = ''
      for (const tok of token.props) res += stringifyToken(tok)
      return res + token.source
    }
    case 'block-map':
    case 'block-seq': {
      let res = ''
      for (const item of token.items) res += stringifyItem(item)
      return res
    }
    case 'flow-collection': {
      let res = token.start.source
      for (const item of token.items) res += stringifyItem(item)
      for (const st of token.end) res += st.source
      return res
    }
    case 'document': {
      let res = stringifyItem(token)
      if (token.end) for (const st of token.end) res += st.source
      return res
    }
    default: {
      let res = token.source
      if ('end' in token && token.end)
        for (const st of token.end) res += st.source
      return res
    }
  }
}

function stringifyItem({ start, key, sep, value }: CollectionItem): string {
  let res = ''
  for (const st of start) res += st.source
  if (key) res += stringifyToken(key)
  if (sep) for (const st of sep) res += st.source
  if (value) res += stringifyToken(value)
  return res
}
eemeli-yaml-086fa6b/src/parse/cst-visit.ts000066400000000000000000000103721511277410200205310ustar00rootroot00000000000000import type {
  BlockMap,
  BlockSequence,
  CollectionItem,
  Document,
  FlowCollection
} from './cst.ts'

const BREAK = Symbol('break visit')
const SKIP = Symbol('skip children')
const REMOVE = Symbol('remove item')

export type VisitPath = readonly ['key' | 'value', number][]

export type Visitor = (
  item: CollectionItem,
  path: VisitPath
) => number | symbol | Visitor | void

/**
 * Apply a visitor to a CST document or item.
 *
 * Walks through the tree (depth-first) starting from the root, calling a
 * `visitor` function with two arguments when entering each item:
 *   - `item`: The current item, which included the following members:
 *     - `start: SourceToken[]` – Source tokens before the key or value,
 *       possibly including its anchor or tag.
 *     - `key?: Token | null` – Set for pair values. May then be `null`, if
 *       the key before the `:` separator is empty.
 *     - `sep?: SourceToken[]` – Source tokens between the key and the value,
 *       which should include the `:` map value indicator if `value` is set.
 *     - `value?: Token` – The value of a sequence item, or of a map pair.
 *   - `path`: The steps from the root to the current node, as an array of
 *     `['key' | 'value', number]` tuples.
 *
 * The return value of the visitor may be used to control the traversal:
 *   - `undefined` (default): Do nothing and continue
 *   - `visit.SKIP`: Do not visit the children of this token, continue with
 *      next sibling
 *   - `visit.BREAK`: Terminate traversal completely
 *   - `visit.REMOVE`: Remove the current item, then continue with the next one
 *   - `number`: Set the index of the next step. This is useful especially if
 *     the index of the current token has changed.
 *   - `function`: Define the next visitor for this item. After the original
 *     visitor is called on item entry, next visitors are called after handling
 *     a non-empty `key` and when exiting the item.
 */
export function visit(cst: Document | CollectionItem, visitor: Visitor): void {
  if ('type' in cst && cst.type === 'document')
    cst = { start: cst.start, value: cst.value }
  _visit(Object.freeze([]), cst, visitor)
}

// Without the `as symbol` casts, TS declares these in the `visit`
// namespace using `var`, but then complains about that because
// `unique symbol` must be `const`.

/** Terminate visit traversal completely */
visit.BREAK = BREAK as symbol

/** Do not visit the children of the current item */
visit.SKIP = SKIP as symbol

/** Remove the current item */
visit.REMOVE = REMOVE as symbol

/** Find the item at `path` from `cst` as the root */
visit.itemAtPath = (
  cst: Document | CollectionItem,
  path: VisitPath
): CollectionItem | undefined => {
  let item: CollectionItem = cst
  for (const [field, index] of path) {
    const tok = item?.[field]
    if (tok && 'items' in tok) {
      item = tok.items[index]
    } else return undefined
  }
  return item
}

/**
 * Get the immediate parent collection of the item at `path` from `cst` as the root.
 *
 * Throws an error if the collection is not found, which should never happen if the item itself exists.
 */
visit.parentCollection = (
  cst: Document | CollectionItem,
  path: VisitPath
): BlockMap | BlockSequence | FlowCollection => {
  const parent = visit.itemAtPath(cst, path.slice(0, -1))
  const field = path[path.length - 1][0]
  const coll = parent?.[field]
  if (coll && 'items' in coll) return coll
  throw new Error('Parent collection not found')
}

function _visit(
  path: VisitPath,
  item: CollectionItem,
  visitor: Visitor
): number | symbol | Visitor | void {
  let ctrl = visitor(item, path)
  if (typeof ctrl === 'symbol') return ctrl
  for (const field of ['key', 'value'] as const) {
    const token = item[field]
    if (token && 'items' in token) {
      for (let i = 0; i < token.items.length; ++i) {
        const ci = _visit(
          Object.freeze(path.concat([[field, i]])),
          token.items[i],
          visitor
        )
        if (typeof ci === 'number') i = ci - 1
        else if (ci === BREAK) return BREAK
        else if (ci === REMOVE) {
          token.items.splice(i, 1)
          i -= 1
        }
      }
      if (typeof ctrl === 'function' && field === 'key') ctrl = ctrl(item, path)
    }
  }
  return typeof ctrl === 'function' ? ctrl(item, path) : ctrl
}
eemeli-yaml-086fa6b/src/parse/cst.ts000066400000000000000000000117111511277410200173730ustar00rootroot00000000000000export {
  createScalarToken,
  resolveAsScalar,
  setScalarValue
} from './cst-scalar.ts'
export { stringify } from './cst-stringify.ts'
export type { Visitor, VisitPath } from './cst-visit.ts'
export { visit } from './cst-visit.ts'

export interface SourceToken {
  type:
    | 'byte-order-mark'
    | 'doc-mode'
    | 'doc-start'
    | 'space'
    | 'comment'
    | 'newline'
    | 'directive-line'
    | 'anchor'
    | 'tag'
    | 'seq-item-ind'
    | 'explicit-key-ind'
    | 'map-value-ind'
    | 'flow-map-start'
    | 'flow-map-end'
    | 'flow-seq-start'
    | 'flow-seq-end'
    | 'flow-error-end'
    | 'comma'
    | 'block-scalar-header'
  offset: number
  indent: number
  source: string
}

export interface ErrorToken {
  type: 'error'
  offset: number
  source: string
  message: string
}

export interface Directive {
  type: 'directive'
  offset: number
  source: string
}

export interface Document {
  type: 'document'
  offset: number
  start: SourceToken[]
  value?: Token
  end?: SourceToken[]
}

export interface DocumentEnd {
  type: 'doc-end'
  offset: number
  source: string
  end?: SourceToken[]
}

export interface FlowScalar {
  type: 'alias' | 'scalar' | 'single-quoted-scalar' | 'double-quoted-scalar'
  offset: number
  indent: number
  source: string
  end?: SourceToken[]
}

export interface BlockScalar {
  type: 'block-scalar'
  offset: number
  indent: number
  props: Token[]
  source: string
}

export interface BlockMap {
  type: 'block-map'
  offset: number
  indent: number
  items: Array<
    | {
        start: SourceToken[]
        explicitKey?: true
        key?: never
        sep?: never
        value?: never
      }
    | {
        start: SourceToken[]
        explicitKey?: true
        key: Token | null
        sep: SourceToken[]
        value?: Token
      }
  >
}

export interface BlockSequence {
  type: 'block-seq'
  offset: number
  indent: number
  items: Array<{
    start: SourceToken[]
    key?: never
    sep?: never
    value?: Token
  }>
}

export type CollectionItem = {
  start: SourceToken[]
  key?: Token | null
  sep?: SourceToken[]
  value?: Token
}

export interface FlowCollection {
  type: 'flow-collection'
  offset: number
  indent: number
  start: SourceToken
  items: CollectionItem[]
  end: SourceToken[]
}

export type Token =
  | SourceToken
  | ErrorToken
  | Directive
  | Document
  | DocumentEnd
  | FlowScalar
  | BlockScalar
  | BlockMap
  | BlockSequence
  | FlowCollection

export type TokenType =
  | SourceToken['type']
  | DocumentEnd['type']
  | FlowScalar['type']

/** The byte order mark */
export const BOM = '\u{FEFF}'

/** Start of doc-mode */
export const DOCUMENT = '\x02' // C0: Start of Text

/** Unexpected end of flow-mode */
export const FLOW_END = '\x18' // C0: Cancel

/** Next token is a scalar value */
export const SCALAR = '\x1f' // C0: Unit Separator

/** @returns `true` if `token` is a flow or block collection */
export const isCollection = (
  token: Token | null | undefined
): token is BlockMap | BlockSequence | FlowCollection =>
  !!token && 'items' in token

/** @returns `true` if `token` is a flow or block scalar; not an alias */
export const isScalar = (
  token: Token | null | undefined
): token is FlowScalar | BlockScalar =>
  !!token &&
  (token.type === 'scalar' ||
    token.type === 'single-quoted-scalar' ||
    token.type === 'double-quoted-scalar' ||
    token.type === 'block-scalar')

/* istanbul ignore next */
/** Get a printable representation of a lexer token */
export function prettyToken(token: string): string {
  switch (token) {
    case BOM:
      return ''
    case DOCUMENT:
      return ''
    case FLOW_END:
      return ''
    case SCALAR:
      return ''
    default:
      return JSON.stringify(token)
  }
}

/** Identify the type of a lexer token. May return `null` for unknown tokens. */
export function tokenType(source: string): TokenType | null {
  switch (source) {
    case BOM:
      return 'byte-order-mark'
    case DOCUMENT:
      return 'doc-mode'
    case FLOW_END:
      return 'flow-error-end'
    case SCALAR:
      return 'scalar'
    case '---':
      return 'doc-start'
    case '...':
      return 'doc-end'
    case '':
    case '\n':
    case '\r\n':
      return 'newline'
    case '-':
      return 'seq-item-ind'
    case '?':
      return 'explicit-key-ind'
    case ':':
      return 'map-value-ind'
    case '{':
      return 'flow-map-start'
    case '}':
      return 'flow-map-end'
    case '[':
      return 'flow-seq-start'
    case ']':
      return 'flow-seq-end'
    case ',':
      return 'comma'
  }
  switch (source[0]) {
    case ' ':
    case '\t':
      return 'space'
    case '#':
      return 'comment'
    case '%':
      return 'directive-line'
    case '*':
      return 'alias'
    case '&':
      return 'anchor'
    case '!':
      return 'tag'
    case "'":
      return 'single-quoted-scalar'
    case '"':
      return 'double-quoted-scalar'
    case '|':
    case '>':
      return 'block-scalar-header'
  }
  return null
}
eemeli-yaml-086fa6b/src/parse/lexer.ts000066400000000000000000000476401511277410200177330ustar00rootroot00000000000000/*
START -> stream

stream
  directive -> line-end -> stream
  indent + line-end -> stream
  [else] -> line-start

line-end
  comment -> line-end
  newline -> .
  input-end -> END

line-start
  doc-start -> doc
  doc-end -> stream
  [else] -> indent -> block-start

block-start
  seq-item-start -> block-start
  explicit-key-start -> block-start
  map-value-start -> block-start
  [else] -> doc

doc
  line-end -> line-start
  spaces -> doc
  anchor -> doc
  tag -> doc
  flow-start -> flow -> doc
  flow-end -> error -> doc
  seq-item-start -> error -> doc
  explicit-key-start -> error -> doc
  map-value-start -> doc
  alias -> doc
  quote-start -> quoted-scalar -> doc
  block-scalar-header -> line-end -> block-scalar(min) -> line-start
  [else] -> plain-scalar(false, min) -> doc

flow
  line-end -> flow
  spaces -> flow
  anchor -> flow
  tag -> flow
  flow-start -> flow -> flow
  flow-end -> .
  seq-item-start -> error -> flow
  explicit-key-start -> flow
  map-value-start -> flow
  alias -> flow
  quote-start -> quoted-scalar -> flow
  comma -> flow
  [else] -> plain-scalar(true, 0) -> flow

quoted-scalar
  quote-end -> .
  [else] -> quoted-scalar

block-scalar(min)
  newline + peek(indent < min) -> .
  [else] -> block-scalar(min)

plain-scalar(is-flow, min)
  scalar-end(is-flow) -> .
  peek(newline + (indent < min)) -> .
  [else] -> plain-scalar(min)
*/

import { BOM, DOCUMENT, FLOW_END, SCALAR } from './cst.ts'

type State =
  | 'stream'
  | 'line-start'
  | 'block-start'
  | 'doc'
  | 'flow'
  | 'quoted-scalar'
  | 'block-scalar'
  | 'plain-scalar'

function isEmpty(ch: string) {
  switch (ch) {
    case undefined:
    case ' ':
    case '\n':
    case '\r':
    case '\t':
      return true
    default:
      return false
  }
}

const hexDigits = new Set('0123456789ABCDEFabcdef')
const tagChars = new Set(
  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()"
)
const flowIndicatorChars = new Set(',[]{}')
const invalidAnchorChars = new Set(' ,[]{}\n\r\t')
const isNotAnchorChar = (ch: string) => !ch || invalidAnchorChars.has(ch)

/**
 * Splits an input string into lexical tokens, i.e. smaller strings that are
 * easily identifiable by `tokens.tokenType()`.
 *
 * Lexing starts always in a "stream" context. Incomplete input may be buffered
 * until a complete token can be emitted.
 *
 * In addition to slices of the original input, the following control characters
 * may also be emitted:
 *
 * - `\x02` (Start of Text): A document starts with the next token
 * - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
 * - `\x1f` (Unit Separator): Next token is a scalar value
 * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
 */
export class Lexer {
  /**
   * Flag indicating whether the end of the current buffer marks the end of
   * all input
   */
  private atEnd = false

  /**
   * Explicit indent set in block scalar header, as an offset from the current
   * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not
   * explicitly set.
   */
  private blockScalarIndent = -1

  /**
   * Block scalars that include a + (keep) chomping indicator in their header
   * include trailing empty lines, which are otherwise excluded from the
   * scalar's contents.
   */
  private blockScalarKeep = false

  /** Current input */
  private buffer = ''

  /**
   * Flag noting whether the map value indicator : can immediately follow this
   * node within a flow context.
   */
  private flowKey = false

  /** Count of surrounding flow collection levels. */
  private flowLevel = 0

  /**
   * Minimum level of indentation required for next lines to be parsed as a
   * part of the current scalar value.
   */
  private indentNext = 0

  /** Indentation level of the current line. */
  private indentValue = 0

  /** Position of the next \n character. */
  private lineEndPos: number | null = null

  /** Stores the state of the lexer if reaching the end of incpomplete input */
  private next: State | null = null

  /** A pointer to `buffer`; the current position of the lexer. */
  private pos = 0;

  /**
   * Generate YAML tokens from the `source` string. If `incomplete`,
   * a part of the last line may be left as a buffer for the next call.
   *
   * @returns A generator of lexical tokens
   */
  *lex(source: string, incomplete = false): Generator {
    if (source) {
      if (typeof source !== 'string') throw TypeError('source is not a string')
      this.buffer = this.buffer ? this.buffer + source : source
      this.lineEndPos = null
    }
    this.atEnd = !incomplete
    let next: State | null = this.next ?? 'stream'
    while (next && (incomplete || this.hasChars(1)))
      next = yield* this.parseNext(next)
  }

  private atLineEnd() {
    let i = this.pos
    let ch = this.buffer[i]
    while (ch === ' ' || ch === '\t') ch = this.buffer[++i]
    if (!ch || ch === '#' || ch === '\n') return true
    if (ch === '\r') return this.buffer[i + 1] === '\n'
    return false
  }

  private charAt(n: number) {
    return this.buffer[this.pos + n]
  }

  private continueScalar(offset: number) {
    let ch = this.buffer[offset]
    if (this.indentNext > 0) {
      let indent = 0
      while (ch === ' ') ch = this.buffer[++indent + offset]
      if (ch === '\r') {
        const next = this.buffer[indent + offset + 1]
        if (next === '\n' || (!next && !this.atEnd)) return offset + indent + 1
      }
      return ch === '\n' || indent >= this.indentNext || (!ch && !this.atEnd)
        ? offset + indent
        : -1
    }
    if (ch === '-' || ch === '.') {
      const dt = this.buffer.substr(offset, 3)
      if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3]))
        return -1
    }
    return offset
  }

  private getLine(): string | null {
    let end = this.lineEndPos
    if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {
      end = this.buffer.indexOf('\n', this.pos)
      this.lineEndPos = end
    }
    if (end === -1) return this.atEnd ? this.buffer.substring(this.pos) : null
    if (this.buffer[end - 1] === '\r') end -= 1
    return this.buffer.substring(this.pos, end)
  }

  private hasChars(n: number) {
    return this.pos + n <= this.buffer.length
  }

  private setNext(state: State) {
    this.buffer = this.buffer.substring(this.pos)
    this.pos = 0
    this.lineEndPos = null
    this.next = state
    return null
  }

  private peek(n: number) {
    return this.buffer.substr(this.pos, n)
  }

  private *parseNext(next: State) {
    switch (next) {
      case 'stream':
        return yield* this.parseStream()
      case 'line-start':
        return yield* this.parseLineStart()
      case 'block-start':
        return yield* this.parseBlockStart()
      case 'doc':
        return yield* this.parseDocument()
      case 'flow':
        return yield* this.parseFlowCollection()
      case 'quoted-scalar':
        return yield* this.parseQuotedScalar()
      case 'block-scalar':
        return yield* this.parseBlockScalar()
      case 'plain-scalar':
        return yield* this.parsePlainScalar()
    }
  }

  private *parseStream() {
    let line = this.getLine()
    if (line === null) return this.setNext('stream')
    if (line[0] === BOM) {
      yield* this.pushCount(1)
      line = line.substring(1)
    }
    if (line[0] === '%') {
      let dirEnd = line.length
      let cs = line.indexOf('#')
      while (cs !== -1) {
        const ch = line[cs - 1]
        if (ch === ' ' || ch === '\t') {
          dirEnd = cs - 1
          break
        } else {
          cs = line.indexOf('#', cs + 1)
        }
      }
      while (true) {
        const ch = line[dirEnd - 1]
        if (ch === ' ' || ch === '\t') dirEnd -= 1
        else break
      }
      const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true))
      yield* this.pushCount(line.length - n) // possible comment
      this.pushNewline()
      return 'stream'
    }
    if (this.atLineEnd()) {
      const sp = yield* this.pushSpaces(true)
      yield* this.pushCount(line.length - sp)
      yield* this.pushNewline()
      return 'stream'
    }
    yield DOCUMENT
    return yield* this.parseLineStart()
  }

  private *parseLineStart() {
    const ch = this.charAt(0)
    if (!ch && !this.atEnd) return this.setNext('line-start')
    if (ch === '-' || ch === '.') {
      if (!this.atEnd && !this.hasChars(4)) return this.setNext('line-start')
      const s = this.peek(3)
      if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {
        yield* this.pushCount(3)
        this.indentValue = 0
        this.indentNext = 0
        return s === '---' ? 'doc' : 'stream'
      }
    }
    this.indentValue = yield* this.pushSpaces(false)
    if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))
      this.indentNext = this.indentValue
    return yield* this.parseBlockStart()
  }

  private *parseBlockStart(): Generator {
    const [ch0, ch1] = this.peek(2)
    if (!ch1 && !this.atEnd) return this.setNext('block-start')
    if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) {
      const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true))
      this.indentNext = this.indentValue + 1
      this.indentValue += n
      return yield* this.parseBlockStart()
    }
    return 'doc'
  }

  private *parseDocument() {
    yield* this.pushSpaces(true)
    const line = this.getLine()
    if (line === null) return this.setNext('doc')
    let n = yield* this.pushIndicators()
    switch (line[n]) {
      case '#':
        yield* this.pushCount(line.length - n)
      // fallthrough
      case undefined:
        yield* this.pushNewline()
        return yield* this.parseLineStart()
      case '{':
      case '[':
        yield* this.pushCount(1)
        this.flowKey = false
        this.flowLevel = 1
        return 'flow'
      case '}':
      case ']':
        // this is an error
        yield* this.pushCount(1)
        return 'doc'
      case '*':
        yield* this.pushUntil(isNotAnchorChar)
        return 'doc'
      case '"':
      case "'":
        return yield* this.parseQuotedScalar()
      case '|':
      case '>':
        n += yield* this.parseBlockScalarHeader()
        n += yield* this.pushSpaces(true)
        yield* this.pushCount(line.length - n)
        yield* this.pushNewline()
        return yield* this.parseBlockScalar()
      default:
        return yield* this.parsePlainScalar()
    }
  }

  private *parseFlowCollection() {
    let nl: number, sp: number
    let indent = -1
    do {
      nl = yield* this.pushNewline()
      if (nl > 0) {
        sp = yield* this.pushSpaces(false)
        this.indentValue = indent = sp
      } else {
        sp = 0
      }
      sp += yield* this.pushSpaces(true)
    } while (nl + sp > 0)
    const line = this.getLine()
    if (line === null) return this.setNext('flow')
    if (
      (indent !== -1 && indent < this.indentNext && line[0] !== '#') ||
      (indent === 0 &&
        (line.startsWith('---') || line.startsWith('...')) &&
        isEmpty(line[3]))
    ) {
      // Allowing for the terminal ] or } at the same (rather than greater)
      // indent level as the initial [ or { is technically invalid, but
      // failing here would be surprising to users.
      const atFlowEndMarker =
        indent === this.indentNext - 1 &&
        this.flowLevel === 1 &&
        (line[0] === ']' || line[0] === '}')
      if (!atFlowEndMarker) {
        // this is an error
        this.flowLevel = 0
        yield FLOW_END
        return yield* this.parseLineStart()
      }
    }
    let n = 0
    while (line[n] === ',') {
      n += yield* this.pushCount(1)
      n += yield* this.pushSpaces(true)
      this.flowKey = false
    }
    n += yield* this.pushIndicators()
    switch (line[n]) {
      case undefined:
        return 'flow'
      case '#':
        yield* this.pushCount(line.length - n)
        return 'flow'
      case '{':
      case '[':
        yield* this.pushCount(1)
        this.flowKey = false
        this.flowLevel += 1
        return 'flow'
      case '}':
      case ']':
        yield* this.pushCount(1)
        this.flowKey = true
        this.flowLevel -= 1
        return this.flowLevel ? 'flow' : 'doc'
      case '*':
        yield* this.pushUntil(isNotAnchorChar)
        return 'flow'
      case '"':
      case "'":
        this.flowKey = true
        return yield* this.parseQuotedScalar()
      case ':': {
        const next = this.charAt(1)
        if (this.flowKey || isEmpty(next) || next === ',') {
          this.flowKey = false
          yield* this.pushCount(1)
          yield* this.pushSpaces(true)
          return 'flow'
        }
      }
      // fallthrough
      default:
        this.flowKey = false
        return yield* this.parsePlainScalar()
    }
  }

  private *parseQuotedScalar() {
    const quote = this.charAt(0)
    let end = this.buffer.indexOf(quote, this.pos + 1)
    if (quote === "'") {
      while (end !== -1 && this.buffer[end + 1] === "'")
        end = this.buffer.indexOf("'", end + 2)
    } else {
      // double-quote
      while (end !== -1) {
        let n = 0
        while (this.buffer[end - 1 - n] === '\\') n += 1
        if (n % 2 === 0) break
        end = this.buffer.indexOf('"', end + 1)
      }
    }
    // Only looking for newlines within the quotes
    const qb = this.buffer.substring(0, end)
    let nl = qb.indexOf('\n', this.pos)
    if (nl !== -1) {
      while (nl !== -1) {
        const cs = this.continueScalar(nl + 1)
        if (cs === -1) break
        nl = qb.indexOf('\n', cs)
      }
      if (nl !== -1) {
        // this is an error caused by an unexpected unindent
        end = nl - (qb[nl - 1] === '\r' ? 2 : 1)
      }
    }
    if (end === -1) {
      if (!this.atEnd) return this.setNext('quoted-scalar')
      end = this.buffer.length
    }
    yield* this.pushToIndex(end + 1, false)
    return this.flowLevel ? 'flow' : 'doc'
  }

  private *parseBlockScalarHeader() {
    this.blockScalarIndent = -1
    this.blockScalarKeep = false
    let i = this.pos
    while (true) {
      const ch = this.buffer[++i]
      if (ch === '+') this.blockScalarKeep = true
      else if (ch > '0' && ch <= '9') this.blockScalarIndent = Number(ch) - 1
      else if (ch !== '-') break
    }
    return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#')
  }

  private *parseBlockScalar() {
    let nl = this.pos - 1 // may be -1 if this.pos === 0
    let indent = 0
    let ch: string
    loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) {
      switch (ch) {
        case ' ':
          indent += 1
          break
        case '\n':
          nl = i
          indent = 0
          break
        case '\r': {
          const next = this.buffer[i + 1]
          if (!next && !this.atEnd) return this.setNext('block-scalar')
          if (next === '\n') break
        } // fallthrough
        default:
          break loop
      }
    }
    if (!ch && !this.atEnd) return this.setNext('block-scalar')
    if (indent >= this.indentNext) {
      if (this.blockScalarIndent === -1) this.indentNext = indent
      else {
        this.indentNext =
          this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext)
      }
      do {
        const cs = this.continueScalar(nl + 1)
        if (cs === -1) break
        nl = this.buffer.indexOf('\n', cs)
      } while (nl !== -1)
      if (nl === -1) {
        if (!this.atEnd) return this.setNext('block-scalar')
        nl = this.buffer.length
      }
    }

    // Trailing insufficiently indented tabs are invalid.
    // To catch that during parsing, we include them in the block scalar value.
    let i = nl + 1
    ch = this.buffer[i]
    while (ch === ' ') ch = this.buffer[++i]
    if (ch === '\t') {
      while (ch === '\t' || ch === ' ' || ch === '\r' || ch === '\n')
        ch = this.buffer[++i]
      nl = i - 1
    } else if (!this.blockScalarKeep) {
      do {
        let i = nl - 1
        let ch = this.buffer[i]
        if (ch === '\r') ch = this.buffer[--i]
        const lastChar = i // Drop the line if last char not more indented
        while (ch === ' ') ch = this.buffer[--i]
        if (ch === '\n' && i >= this.pos && i + 1 + indent > lastChar) nl = i
        else break
      } while (true)
    }
    yield SCALAR
    yield* this.pushToIndex(nl + 1, true)
    return yield* this.parseLineStart()
  }

  private *parsePlainScalar() {
    const inFlow = this.flowLevel > 0
    let end = this.pos - 1
    let i = this.pos - 1
    let ch: string
    while ((ch = this.buffer[++i])) {
      if (ch === ':') {
        const next = this.buffer[i + 1]
        if (isEmpty(next) || (inFlow && flowIndicatorChars.has(next))) break
        end = i
      } else if (isEmpty(ch)) {
        let next = this.buffer[i + 1]
        if (ch === '\r') {
          if (next === '\n') {
            i += 1
            ch = '\n'
            next = this.buffer[i + 1]
          } else end = i
        }
        if (next === '#' || (inFlow && flowIndicatorChars.has(next))) break
        if (ch === '\n') {
          const cs = this.continueScalar(i + 1)
          if (cs === -1) break
          i = Math.max(i, cs - 2) // to advance, but still account for ' #'
        }
      } else {
        if (inFlow && flowIndicatorChars.has(ch)) break
        end = i
      }
    }
    if (!ch && !this.atEnd) return this.setNext('plain-scalar')
    yield SCALAR
    yield* this.pushToIndex(end + 1, true)
    return inFlow ? 'flow' : 'doc'
  }

  private *pushCount(n: number) {
    if (n > 0) {
      yield this.buffer.substr(this.pos, n)
      this.pos += n
      return n
    }
    return 0
  }

  private *pushToIndex(i: number, allowEmpty: boolean) {
    const s = this.buffer.slice(this.pos, i)
    if (s) {
      yield s
      this.pos += s.length
      return s.length
    } else if (allowEmpty) yield ''
    return 0
  }

  private *pushIndicators(): Generator {
    switch (this.charAt(0)) {
      case '!':
        return (
          (yield* this.pushTag()) +
          (yield* this.pushSpaces(true)) +
          (yield* this.pushIndicators())
        )
      case '&':
        return (
          (yield* this.pushUntil(isNotAnchorChar)) +
          (yield* this.pushSpaces(true)) +
          (yield* this.pushIndicators())
        )
      case '-': // this is an error
      case '?': // this is an error outside flow collections
      case ':': {
        const inFlow = this.flowLevel > 0
        const ch1 = this.charAt(1)
        if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {
          if (!inFlow) this.indentNext = this.indentValue + 1
          else if (this.flowKey) this.flowKey = false
          return (
            (yield* this.pushCount(1)) +
            (yield* this.pushSpaces(true)) +
            (yield* this.pushIndicators())
          )
        }
      }
    }
    return 0
  }

  private *pushTag() {
    if (this.charAt(1) === '<') {
      let i = this.pos + 2
      let ch = this.buffer[i]
      while (!isEmpty(ch) && ch !== '>') ch = this.buffer[++i]
      return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false)
    } else {
      let i = this.pos + 1
      let ch = this.buffer[i]
      while (ch) {
        if (tagChars.has(ch)) ch = this.buffer[++i]
        else if (
          ch === '%' &&
          hexDigits.has(this.buffer[i + 1]) &&
          hexDigits.has(this.buffer[i + 2])
        ) {
          ch = this.buffer[(i += 3)]
        } else break
      }
      return yield* this.pushToIndex(i, false)
    }
  }

  private *pushNewline() {
    const ch = this.buffer[this.pos]
    if (ch === '\n') return yield* this.pushCount(1)
    else if (ch === '\r' && this.charAt(1) === '\n')
      return yield* this.pushCount(2)
    else return 0
  }

  private *pushSpaces(allowTabs: boolean) {
    let i = this.pos - 1
    let ch: string
    do {
      ch = this.buffer[++i]
    } while (ch === ' ' || (allowTabs && ch === '\t'))
    const n = i - this.pos
    if (n > 0) {
      yield this.buffer.substr(this.pos, n)
      this.pos = i
    }
    return n
  }

  private *pushUntil(test: (ch: string) => boolean) {
    let i = this.pos
    let ch = this.buffer[i]
    while (!test(ch)) ch = this.buffer[++i]
    return yield* this.pushToIndex(i, false)
  }
}
eemeli-yaml-086fa6b/src/parse/line-counter.ts000066400000000000000000000022231511277410200212040ustar00rootroot00000000000000/**
 * Tracks newlines during parsing in order to provide an efficient API for
 * determining the one-indexed `{ line, col }` position for any offset
 * within the input.
 */
export class LineCounter {
  lineStarts: number[] = []

  /**
   * Should be called in ascending order. Otherwise, call
   * `lineCounter.lineStarts.sort()` before calling `linePos()`.
   */
  addNewLine = (offset: number): number => this.lineStarts.push(offset)

  /**
   * Performs a binary search and returns the 1-indexed { line, col }
   * position of `offset`. If `line === 0`, `addNewLine` has never been
   * called or `offset` is before the first known newline.
   */
  linePos = (offset: number): { line: number; col: number } => {
    let low = 0
    let high = this.lineStarts.length
    while (low < high) {
      const mid = (low + high) >> 1 // Math.floor((low + high) / 2)
      if (this.lineStarts[mid] < offset) low = mid + 1
      else high = mid
    }
    if (this.lineStarts[low] === offset) return { line: low + 1, col: 1 }
    if (low === 0) return { line: 0, col: offset }
    const start = this.lineStarts[low - 1]
    return { line: low, col: offset - start + 1 }
  }
}
eemeli-yaml-086fa6b/src/parse/parser.ts000066400000000000000000000671051511277410200201060ustar00rootroot00000000000000import { env } from 'node:process'
import type {
  SourceToken,
  Token,
  FlowScalar,
  FlowCollection,
  Document,
  BlockMap,
  BlockScalar,
  BlockSequence,
  DocumentEnd,
  TokenType
} from './cst.ts'
import { prettyToken, tokenType } from './cst.ts'
import { Lexer } from './lexer.ts'

function includesToken(list: SourceToken[], type: SourceToken['type']) {
  for (let i = 0; i < list.length; ++i) if (list[i].type === type) return true
  return false
}

function findNonEmptyIndex(list: SourceToken[]) {
  for (let i = 0; i < list.length; ++i) {
    switch (list[i].type) {
      case 'space':
      case 'comment':
      case 'newline':
        break
      default:
        return i
    }
  }
  return -1
}

function isFlowToken(
  token: Token | null | undefined
): token is FlowScalar | FlowCollection {
  switch (token?.type) {
    case 'alias':
    case 'scalar':
    case 'single-quoted-scalar':
    case 'double-quoted-scalar':
    case 'flow-collection':
      return true
    default:
      return false
  }
}

function getPrevProps(parent: Token) {
  switch (parent.type) {
    case 'document':
      return parent.start
    case 'block-map': {
      const it = parent.items[parent.items.length - 1]
      return it.sep ?? it.start
    }
    case 'block-seq':
      return parent.items[parent.items.length - 1].start
    /* istanbul ignore next should not happen */
    default:
      return []
  }
}

/** Note: May modify input array */
function getFirstKeyStartProps(prev: SourceToken[]) {
  if (prev.length === 0) return []

  let i = prev.length
  loop: while (--i >= 0) {
    switch (prev[i].type) {
      case 'doc-start':
      case 'explicit-key-ind':
      case 'map-value-ind':
      case 'seq-item-ind':
      case 'newline':
        break loop
    }
  }
  while (prev[++i]?.type === 'space') {
    /* loop */
  }
  return prev.splice(i, prev.length)
}

function fixFlowSeqItems(fc: FlowCollection) {
  if (fc.start.type === 'flow-seq-start') {
    for (const it of fc.items) {
      if (
        it.sep &&
        !it.value &&
        !includesToken(it.start, 'explicit-key-ind') &&
        !includesToken(it.sep, 'map-value-ind')
      ) {
        if (it.key) it.value = it.key
        delete it.key
        if (isFlowToken(it.value)) {
          if (it.value.end) Array.prototype.push.apply(it.value.end, it.sep)
          else it.value.end = it.sep
        } else Array.prototype.push.apply(it.start, it.sep)
        delete it.sep
      }
    }
  }
}

/**
 * A YAML concrete syntax tree (CST) parser
 *
 * ```ts
 * const src: string = ...
 * for (const token of new Parser().parse(src)) {
 *   // token: Token
 * }
 * ```
 *
 * To use the parser with a user-provided lexer:
 *
 * ```ts
 * function* parse(source: string, lexer: Lexer) {
 *   const parser = new Parser()
 *   for (const lexeme of lexer.lex(source))
 *     yield* parser.next(lexeme)
 *   yield* parser.end()
 * }
 *
 * const src: string = ...
 * const lexer = new Lexer()
 * for (const token of parse(src, lexer)) {
 *   // token: Token
 * }
 * ```
 */
export class Parser {
  private onNewLine?: (offset: number) => void

  /** If true, space and sequence indicators count as indentation */
  private atNewLine = true

  /** If true, next token is a scalar value */
  private atScalar = false

  /** Current indentation level */
  private indent = 0

  /** Current offset since the start of parsing */
  offset = 0

  /** On the same line with a block map key */
  private onKeyLine = false

  /** Top indicates the node that's currently being built */
  stack: Token[] = []

  /** The source of the current token, set in parse() */
  private source = ''

  /** The type of the current token, set in parse() */
  private type = '' as TokenType

  /**
   * @param onNewLine - If defined, called separately with the start position of
   *   each new line (in `parse()`, including the start of input).
   */
  constructor(onNewLine?: (offset: number) => void) {
    this.onNewLine = onNewLine
  }

  /**
   * Parse `source` as a YAML stream.
   * If `incomplete`, a part of the last line may be left as a buffer for the next call.
   *
   * Errors are not thrown, but yielded as `{ type: 'error', message }` tokens.
   *
   * @returns A generator of tokens representing each directive, document, and other structure.
   */
  *parse(source: string, incomplete = false): Generator {
    if (this.onNewLine && this.offset === 0) this.onNewLine(0)
    for (const lexeme of this.lexer.lex(source, incomplete))
      yield* this.next(lexeme)
    if (!incomplete) yield* this.end()
  }

  /**
   * Advance the parser by the `source` of one lexical token.
   */
  *next(source: string): Generator {
    this.source = source
    if (env.LOG_TOKENS) console.log('|', prettyToken(source))

    if (this.atScalar) {
      this.atScalar = false
      yield* this.step()
      this.offset += source.length
      return
    }

    const type = tokenType(source)
    if (!type) {
      const message = `Not a YAML token: ${source}`
      yield* this.pop({ type: 'error', offset: this.offset, message, source })
      this.offset += source.length
    } else if (type === 'scalar') {
      this.atNewLine = false
      this.atScalar = true
      this.type = 'scalar'
    } else {
      this.type = type
      yield* this.step()
      switch (type) {
        case 'newline':
          this.atNewLine = true
          this.indent = 0
          if (this.onNewLine) this.onNewLine(this.offset + source.length)
          break
        case 'space':
          if (this.atNewLine && source[0] === ' ') this.indent += source.length
          break
        case 'explicit-key-ind':
        case 'map-value-ind':
        case 'seq-item-ind':
          if (this.atNewLine) this.indent += source.length
          break
        case 'doc-mode':
        case 'flow-error-end':
          return
        default:
          this.atNewLine = false
      }
      this.offset += source.length
    }
  }

  // Must be defined after `next()`
  private lexer = new Lexer();

  /** Call at end of input to push out any remaining constructions */
  *end(): Generator {
    while (this.stack.length > 0) yield* this.pop()
  }

  private get sourceToken() {
    const st: SourceToken = {
      type: this.type as SourceToken['type'],
      offset: this.offset,
      indent: this.indent,
      source: this.source
    }
    return st
  }

  private *step(): Generator {
    const top = this.peek(1)
    if (this.type === 'doc-end' && top?.type !== 'doc-end') {
      while (this.stack.length > 0) yield* this.pop()
      this.stack.push({
        type: 'doc-end',
        offset: this.offset,
        source: this.source
      })
      return
    }
    if (!top) return yield* this.stream()
    switch (top.type) {
      case 'document':
        return yield* this.document(top)
      case 'alias':
      case 'scalar':
      case 'single-quoted-scalar':
      case 'double-quoted-scalar':
        return yield* this.scalar(top)
      case 'block-scalar':
        return yield* this.blockScalar(top)
      case 'block-map':
        return yield* this.blockMap(top)
      case 'block-seq':
        return yield* this.blockSequence(top)
      case 'flow-collection':
        return yield* this.flowCollection(top)
      case 'doc-end':
        return yield* this.documentEnd(top)
    }
    /* istanbul ignore next should not happen */
    yield* this.pop()
  }

  private peek(n: number) {
    return this.stack[this.stack.length - n]
  }

  private *pop(error?: Token): Generator {
    const token = error ?? this.stack.pop()
    /* istanbul ignore if should not happen */
    if (!token) {
      const message = 'Tried to pop an empty stack'
      yield { type: 'error', offset: this.offset, source: '', message }
    } else if (this.stack.length === 0) {
      yield token
    } else {
      const top = this.peek(1)
      if (token.type === 'block-scalar') {
        // Block scalars use their parent rather than header indent
        token.indent = 'indent' in top ? top.indent : 0
      } else if (token.type === 'flow-collection' && top.type === 'document') {
        // Ignore all indent for top-level flow collections
        token.indent = 0
      }
      if (token.type === 'flow-collection') fixFlowSeqItems(token)
      switch (top.type) {
        case 'document':
          top.value = token
          break
        case 'block-scalar':
          top.props.push(token) // error
          break
        case 'block-map': {
          const it = top.items[top.items.length - 1]
          if (it.value) {
            top.items.push({ start: [], key: token, sep: [] })
            this.onKeyLine = true
            return
          } else if (it.sep) {
            it.value = token
          } else {
            Object.assign(it, { key: token, sep: [] })
            this.onKeyLine = !it.explicitKey
            return
          }
          break
        }
        case 'block-seq': {
          const it = top.items[top.items.length - 1]
          if (it.value) top.items.push({ start: [], value: token })
          else it.value = token
          break
        }
        case 'flow-collection': {
          const it = top.items[top.items.length - 1]
          if (!it || it.value)
            top.items.push({ start: [], key: token, sep: [] })
          else if (it.sep) it.value = token
          else Object.assign(it, { key: token, sep: [] })
          return
        }
        /* istanbul ignore next should not happen */
        default:
          yield* this.pop()
          yield* this.pop(token)
      }

      if (
        (top.type === 'document' ||
          top.type === 'block-map' ||
          top.type === 'block-seq') &&
        (token.type === 'block-map' || token.type === 'block-seq')
      ) {
        const last = token.items[token.items.length - 1]
        if (
          last &&
          !last.sep &&
          !last.value &&
          last.start.length > 0 &&
          findNonEmptyIndex(last.start) === -1 &&
          (token.indent === 0 ||
            last.start.every(
              st => st.type !== 'comment' || st.indent < token.indent
            ))
        ) {
          if (top.type === 'document') top.end = last.start
          else top.items.push({ start: last.start })
          token.items.splice(-1, 1)
        }
      }
    }
  }

  private *stream(): Generator {
    switch (this.type) {
      case 'directive-line':
        yield { type: 'directive', offset: this.offset, source: this.source }
        return
      case 'byte-order-mark':
      case 'space':
      case 'comment':
      case 'newline':
        yield this.sourceToken
        return
      case 'doc-mode':
      case 'doc-start': {
        const doc: Document = {
          type: 'document',
          offset: this.offset,
          start: []
        }
        if (this.type === 'doc-start') doc.start.push(this.sourceToken)
        this.stack.push(doc)
        return
      }
    }
    yield {
      type: 'error',
      offset: this.offset,
      message: `Unexpected ${this.type} token in YAML stream`,
      source: this.source
    }
  }

  private *document(doc: Document): Generator {
    if (doc.value) return yield* this.lineEnd(doc)
    switch (this.type) {
      case 'doc-start': {
        if (findNonEmptyIndex(doc.start) !== -1) {
          yield* this.pop()
          yield* this.step()
        } else doc.start.push(this.sourceToken)
        return
      }
      case 'anchor':
      case 'tag':
      case 'space':
      case 'comment':
      case 'newline':
        doc.start.push(this.sourceToken)
        return
    }
    const bv = this.startBlockValue(doc)
    if (bv) this.stack.push(bv)
    else {
      yield {
        type: 'error',
        offset: this.offset,
        message: `Unexpected ${this.type} token in YAML document`,
        source: this.source
      }
    }
  }

  private *scalar(scalar: FlowScalar) {
    if (this.type === 'map-value-ind') {
      const prev = getPrevProps(this.peek(2))
      const start = getFirstKeyStartProps(prev)

      let sep: SourceToken[]
      if (scalar.end) {
        sep = scalar.end
        sep.push(this.sourceToken)
        delete scalar.end
      } else sep = [this.sourceToken]

      const map: BlockMap = {
        type: 'block-map',
        offset: scalar.offset,
        indent: scalar.indent,
        items: [{ start, key: scalar, sep }]
      }
      this.onKeyLine = true
      this.stack[this.stack.length - 1] = map
    } else yield* this.lineEnd(scalar)
  }

  private *blockScalar(scalar: BlockScalar) {
    switch (this.type) {
      case 'space':
      case 'comment':
      case 'newline':
        scalar.props.push(this.sourceToken)
        return
      case 'scalar':
        scalar.source = this.source
        // block-scalar source includes trailing newline
        this.atNewLine = true
        this.indent = 0
        if (this.onNewLine) {
          let nl = this.source.indexOf('\n') + 1
          while (nl !== 0) {
            this.onNewLine(this.offset + nl)
            nl = this.source.indexOf('\n', nl) + 1
          }
        }
        yield* this.pop()
        break
      /* istanbul ignore next should not happen */
      default:
        yield* this.pop()
        yield* this.step()
    }
  }

  private *blockMap(map: BlockMap) {
    const it = map.items[map.items.length - 1]

    // it.sep is true-ish if pair already has key or : separator
    switch (this.type) {
      case 'newline':
        this.onKeyLine = false
        if (it.value) {
          const end = 'end' in it.value ? it.value.end : undefined
          const last = Array.isArray(end) ? end[end.length - 1] : undefined
          if (last?.type === 'comment') end?.push(this.sourceToken)
          else map.items.push({ start: [this.sourceToken] })
        } else if (it.sep) {
          it.sep.push(this.sourceToken)
        } else {
          it.start.push(this.sourceToken)
        }
        return
      case 'space':
      case 'comment':
        if (it.value) {
          map.items.push({ start: [this.sourceToken] })
        } else if (it.sep) {
          it.sep.push(this.sourceToken)
        } else {
          if (this.atIndentedComment(it.start, map.indent)) {
            const prev = map.items[map.items.length - 2]
            const end = (prev?.value as { end: SourceToken[] })?.end
            if (Array.isArray(end)) {
              Array.prototype.push.apply(end, it.start)
              end.push(this.sourceToken)
              map.items.pop()
              return
            }
          }
          it.start.push(this.sourceToken)
        }
        return
    }

    if (this.indent >= map.indent) {
      const atMapIndent = !this.onKeyLine && this.indent === map.indent
      const atNextItem =
        atMapIndent &&
        (it.sep || it.explicitKey) &&
        this.type !== 'seq-item-ind'

      // For empty nodes, assign newline-separated not indented empty tokens to following node
      let start: SourceToken[] = []
      if (atNextItem && it.sep && !it.value) {
        const nl: number[] = []
        for (let i = 0; i < it.sep.length; ++i) {
          const st = it.sep[i]
          switch (st.type) {
            case 'newline':
              nl.push(i)
              break
            case 'space':
              break
            case 'comment':
              if (st.indent > map.indent) nl.length = 0
              break
            default:
              nl.length = 0
          }
        }
        if (nl.length >= 2) start = it.sep.splice(nl[1])
      }

      switch (this.type) {
        case 'anchor':
        case 'tag':
          if (atNextItem || it.value) {
            start.push(this.sourceToken)
            map.items.push({ start })
            this.onKeyLine = true
          } else if (it.sep) {
            it.sep.push(this.sourceToken)
          } else {
            it.start.push(this.sourceToken)
          }
          return

        case 'explicit-key-ind':
          if (!it.sep && !it.explicitKey) {
            it.start.push(this.sourceToken)
            it.explicitKey = true
          } else if (atNextItem || it.value) {
            start.push(this.sourceToken)
            map.items.push({ start, explicitKey: true })
          } else {
            this.stack.push({
              type: 'block-map',
              offset: this.offset,
              indent: this.indent,
              items: [{ start: [this.sourceToken], explicitKey: true }]
            })
          }
          this.onKeyLine = true
          return

        case 'map-value-ind':
          if (it.explicitKey) {
            if (!it.sep) {
              if (includesToken(it.start, 'newline')) {
                Object.assign(it, { key: null, sep: [this.sourceToken] })
              } else {
                const start = getFirstKeyStartProps(it.start)
                this.stack.push({
                  type: 'block-map',
                  offset: this.offset,
                  indent: this.indent,
                  items: [{ start, key: null, sep: [this.sourceToken] }]
                })
              }
            } else if (it.value) {
              map.items.push({ start: [], key: null, sep: [this.sourceToken] })
            } else if (includesToken(it.sep, 'map-value-ind')) {
              this.stack.push({
                type: 'block-map',
                offset: this.offset,
                indent: this.indent,
                items: [{ start, key: null, sep: [this.sourceToken] }]
              })
            } else if (
              isFlowToken(it.key) &&
              !includesToken(it.sep, 'newline')
            ) {
              const start = getFirstKeyStartProps(it.start)
              const key = it.key
              const sep = it.sep
              sep.push(this.sourceToken)
              // @ts-expect-error type guard is wrong here
              delete it.key
              // @ts-expect-error type guard is wrong here
              delete it.sep
              this.stack.push({
                type: 'block-map',
                offset: this.offset,
                indent: this.indent,
                items: [{ start, key, sep }]
              })
            } else if (start.length > 0) {
              // Not actually at next item
              it.sep = it.sep.concat(start, this.sourceToken)
            } else {
              it.sep.push(this.sourceToken)
            }
          } else {
            if (!it.sep) {
              Object.assign(it, { key: null, sep: [this.sourceToken] })
            } else if (it.value || atNextItem) {
              map.items.push({ start, key: null, sep: [this.sourceToken] })
            } else if (includesToken(it.sep, 'map-value-ind')) {
              this.stack.push({
                type: 'block-map',
                offset: this.offset,
                indent: this.indent,
                items: [{ start: [], key: null, sep: [this.sourceToken] }]
              })
            } else {
              it.sep.push(this.sourceToken)
            }
          }
          this.onKeyLine = true
          return

        case 'alias':
        case 'scalar':
        case 'single-quoted-scalar':
        case 'double-quoted-scalar': {
          const fs = this.flowScalar(this.type)
          if (atNextItem || it.value) {
            map.items.push({ start, key: fs, sep: [] })
            this.onKeyLine = true
          } else if (it.sep) {
            this.stack.push(fs)
          } else {
            Object.assign(it, { key: fs, sep: [] })
            this.onKeyLine = true
          }
          return
        }

        default: {
          const bv = this.startBlockValue(map)
          if (bv) {
            if (bv.type === 'block-seq') {
              if (
                !it.explicitKey &&
                it.sep &&
                !includesToken(it.sep, 'newline')
              ) {
                yield* this.pop({
                  type: 'error',
                  offset: this.offset,
                  message: 'Unexpected block-seq-ind on same line with key',
                  source: this.source
                })
                return
              }
            } else if (atMapIndent) {
              map.items.push({ start })
            }
            this.stack.push(bv)
            return
          }
        }
      }
    }
    yield* this.pop()
    yield* this.step()
  }

  private *blockSequence(seq: BlockSequence) {
    const it = seq.items[seq.items.length - 1]
    switch (this.type) {
      case 'newline':
        if (it.value) {
          const end = 'end' in it.value ? it.value.end : undefined
          const last = Array.isArray(end) ? end[end.length - 1] : undefined
          if (last?.type === 'comment') end?.push(this.sourceToken)
          else seq.items.push({ start: [this.sourceToken] })
        } else it.start.push(this.sourceToken)
        return
      case 'space':
      case 'comment':
        if (it.value) seq.items.push({ start: [this.sourceToken] })
        else {
          if (this.atIndentedComment(it.start, seq.indent)) {
            const prev = seq.items[seq.items.length - 2]
            const end = (prev?.value as { end: SourceToken[] })?.end
            if (Array.isArray(end)) {
              Array.prototype.push.apply(end, it.start)
              end.push(this.sourceToken)
              seq.items.pop()
              return
            }
          }
          it.start.push(this.sourceToken)
        }
        return
      case 'anchor':
      case 'tag':
        if (it.value || this.indent <= seq.indent) break
        it.start.push(this.sourceToken)
        return
      case 'seq-item-ind':
        if (this.indent !== seq.indent) break
        if (it.value || includesToken(it.start, 'seq-item-ind'))
          seq.items.push({ start: [this.sourceToken] })
        else it.start.push(this.sourceToken)
        return
    }
    if (this.indent > seq.indent) {
      const bv = this.startBlockValue(seq)
      if (bv) {
        this.stack.push(bv)
        return
      }
    }
    yield* this.pop()
    yield* this.step()
  }

  private *flowCollection(fc: FlowCollection) {
    const it = fc.items[fc.items.length - 1]
    if (this.type === 'flow-error-end') {
      let top: Token | undefined
      do {
        yield* this.pop()
        top = this.peek(1)
      } while (top?.type === 'flow-collection')
    } else if (fc.end.length === 0) {
      switch (this.type) {
        case 'comma':
        case 'explicit-key-ind':
          if (!it || it.sep) fc.items.push({ start: [this.sourceToken] })
          else it.start.push(this.sourceToken)
          return

        case 'map-value-ind':
          if (!it || it.value)
            fc.items.push({ start: [], key: null, sep: [this.sourceToken] })
          else if (it.sep) it.sep.push(this.sourceToken)
          else Object.assign(it, { key: null, sep: [this.sourceToken] })
          return

        case 'space':
        case 'comment':
        case 'newline':
        case 'anchor':
        case 'tag':
          if (!it || it.value) fc.items.push({ start: [this.sourceToken] })
          else if (it.sep) it.sep.push(this.sourceToken)
          else it.start.push(this.sourceToken)
          return

        case 'alias':
        case 'scalar':
        case 'single-quoted-scalar':
        case 'double-quoted-scalar': {
          const fs = this.flowScalar(this.type)
          if (!it || it.value) fc.items.push({ start: [], key: fs, sep: [] })
          else if (it.sep) this.stack.push(fs)
          else Object.assign(it, { key: fs, sep: [] })
          return
        }

        case 'flow-map-end':
        case 'flow-seq-end':
          fc.end.push(this.sourceToken)
          return
      }
      const bv = this.startBlockValue(fc)
      /* istanbul ignore else should not happen */
      if (bv) this.stack.push(bv)
      else {
        yield* this.pop()
        yield* this.step()
      }
    } else {
      const parent = this.peek(2)
      if (
        parent.type === 'block-map' &&
        ((this.type === 'map-value-ind' && parent.indent === fc.indent) ||
          (this.type === 'newline' &&
            !parent.items[parent.items.length - 1].sep))
      ) {
        yield* this.pop()
        yield* this.step()
      } else if (
        this.type === 'map-value-ind' &&
        parent.type !== 'flow-collection'
      ) {
        const prev = getPrevProps(parent)
        const start = getFirstKeyStartProps(prev)
        fixFlowSeqItems(fc)
        const sep = fc.end.splice(1, fc.end.length)
        sep.push(this.sourceToken)
        const map: BlockMap = {
          type: 'block-map',
          offset: fc.offset,
          indent: fc.indent,
          items: [{ start, key: fc, sep }]
        }
        this.onKeyLine = true
        this.stack[this.stack.length - 1] = map
      } else {
        yield* this.lineEnd(fc)
      }
    }
  }

  private flowScalar(
    type: 'alias' | 'scalar' | 'single-quoted-scalar' | 'double-quoted-scalar'
  ) {
    if (this.onNewLine) {
      let nl = this.source.indexOf('\n') + 1
      while (nl !== 0) {
        this.onNewLine(this.offset + nl)
        nl = this.source.indexOf('\n', nl) + 1
      }
    }
    return {
      type,
      offset: this.offset,
      indent: this.indent,
      source: this.source
    } as FlowScalar
  }

  private startBlockValue(parent: Token) {
    switch (this.type) {
      case 'alias':
      case 'scalar':
      case 'single-quoted-scalar':
      case 'double-quoted-scalar':
        return this.flowScalar(this.type)
      case 'block-scalar-header':
        return {
          type: 'block-scalar',
          offset: this.offset,
          indent: this.indent,
          props: [this.sourceToken],
          source: ''
        } as BlockScalar
      case 'flow-map-start':
      case 'flow-seq-start':
        return {
          type: 'flow-collection',
          offset: this.offset,
          indent: this.indent,
          start: this.sourceToken,
          items: [],
          end: []
        } as FlowCollection
      case 'seq-item-ind':
        return {
          type: 'block-seq',
          offset: this.offset,
          indent: this.indent,
          items: [{ start: [this.sourceToken] }]
        } as BlockSequence
      case 'explicit-key-ind': {
        this.onKeyLine = true
        const prev = getPrevProps(parent)
        const start = getFirstKeyStartProps(prev)
        start.push(this.sourceToken)
        return {
          type: 'block-map',
          offset: this.offset,
          indent: this.indent,
          items: [{ start, explicitKey: true }]
        } as BlockMap
      }
      case 'map-value-ind': {
        this.onKeyLine = true
        const prev = getPrevProps(parent)
        const start = getFirstKeyStartProps(prev)
        return {
          type: 'block-map',
          offset: this.offset,
          indent: this.indent,
          items: [{ start, key: null, sep: [this.sourceToken] }]
        } as BlockMap
      }
    }
    return null
  }

  private atIndentedComment(start: SourceToken[], indent: number) {
    if (this.type !== 'comment') return false
    if (this.indent <= indent) return false
    return start.every(st => st.type === 'newline' || st.type === 'space')
  }

  private *documentEnd(docEnd: DocumentEnd) {
    if (this.type !== 'doc-mode') {
      if (docEnd.end) docEnd.end.push(this.sourceToken)
      else docEnd.end = [this.sourceToken]
      if (this.type === 'newline') yield* this.pop()
    }
  }

  private *lineEnd(token: Document | FlowCollection | FlowScalar) {
    switch (this.type) {
      case 'comma':
      case 'doc-start':
      case 'doc-end':
      case 'flow-seq-end':
      case 'flow-map-end':
      case 'map-value-ind':
        yield* this.pop()
        yield* this.step()
        break
      case 'newline':
        this.onKeyLine = false
      // fallthrough
      case 'space':
      case 'comment':
      default:
        // all other values are errors
        if (token.end) token.end.push(this.sourceToken)
        else token.end = [this.sourceToken]
        if (this.type === 'newline') yield* this.pop()
    }
  }
}
eemeli-yaml-086fa6b/src/public-api.ts000066400000000000000000000156221511277410200175220ustar00rootroot00000000000000import { Composer } from './compose/composer.ts'
import type { Reviver } from './doc/applyReviver.ts'
import type { Replacer } from './doc/Document.ts'
import { Document } from './doc/Document.ts'
import { prettifyError, YAMLParseError } from './errors.ts'
import { warn } from './log.ts'
import { isDocument } from './nodes/identity.ts'
import type { Node, ParsedNode } from './nodes/Node.ts'
import type {
  CreateNodeOptions,
  DocumentOptions,
  ParseOptions,
  SchemaOptions,
  ToJSOptions,
  ToStringOptions
} from './options.ts'
import { LineCounter } from './parse/line-counter.ts'
import { Parser } from './parse/parser.ts'

export interface EmptyStream
  extends Array, ReturnType {
  empty: true
}

function parseOptions(options: ParseOptions) {
  const prettyErrors = options.prettyErrors !== false
  const lineCounter =
    options.lineCounter || (prettyErrors && new LineCounter()) || null
  return { lineCounter, prettyErrors }
}

/**
 * Parse the input as a stream of YAML documents.
 *
 * Documents should be separated from each other by `...` or `---` marker lines.
 *
 * @returns If an empty `docs` array is returned, it will be of type
 *   EmptyStream and contain additional stream information. In
 *   TypeScript, you should use `'empty' in docs` as a type guard for it.
 */
export function parseAllDocuments<
  Contents extends Node = ParsedNode,
  Strict extends boolean = true
>(
  source: string,
  options: ParseOptions & DocumentOptions & SchemaOptions = {}
):
  | Array<
      Contents extends ParsedNode
        ? Document.Parsed
        : Document
    >
  | EmptyStream {
  const { lineCounter, prettyErrors } = parseOptions(options)
  const parser = new Parser(lineCounter?.addNewLine)
  const composer = new Composer(options)
  const docs = Array.from(composer.compose(parser.parse(source)))

  if (prettyErrors && lineCounter)
    for (const doc of docs) {
      doc.errors.forEach(prettifyError(source, lineCounter))
      doc.warnings.forEach(prettifyError(source, lineCounter))
    }

  type DocType = Contents extends ParsedNode
    ? Document.Parsed
    : Document
  if (docs.length > 0) return docs as DocType[]
  return Object.assign<
    DocType[],
    { empty: true },
    ReturnType
  >([], { empty: true }, composer.streamInfo())
}

/** Parse an input string into a single YAML.Document */
export function parseDocument<
  Contents extends Node = ParsedNode,
  Strict extends boolean = true
>(
  source: string,
  options: ParseOptions & DocumentOptions & SchemaOptions = {}
): Contents extends ParsedNode
  ? Document.Parsed
  : Document {
  const { lineCounter, prettyErrors } = parseOptions(options)
  const parser = new Parser(lineCounter?.addNewLine)
  const composer = new Composer(options)

  type DocType = Contents extends ParsedNode
    ? Document.Parsed
    : Document
  // `doc` is always set by compose.end(true) at the very latest
  let doc: DocType = null as any
  for (const _doc of composer.compose(
    parser.parse(source),
    true,
    source.length
  )) {
    if (!doc) doc = _doc as DocType
    else if (doc.options.logLevel !== 'silent') {
      doc.errors.push(
        new YAMLParseError(
          _doc.range.slice(0, 2) as [number, number],
          'MULTIPLE_DOCS',
          'Source contains multiple documents; please use YAML.parseAllDocuments()'
        )
      )
      break
    }
  }

  if (prettyErrors && lineCounter) {
    doc.errors.forEach(prettifyError(source, lineCounter))
    doc.warnings.forEach(prettifyError(source, lineCounter))
  }
  return doc
}

/**
 * Parse an input string into JavaScript.
 *
 * Only supports input consisting of a single YAML document; for multi-document
 * support you should use `YAML.parseAllDocuments`. May throw on error, and may
 * log warnings using `console.warn`.
 *
 * @param str - A string with YAML formatting.
 * @param reviver - A reviver function, as in `JSON.parse()`
 * @returns The value will match the type of the root value of the parsed YAML
 *   document, so Maps become objects, Sequences arrays, and scalars result in
 *   nulls, booleans, numbers and strings.
 */
export function parse(
  src: string,
  options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions
): any
export function parse(
  src: string,
  reviver: Reviver,
  options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions
): any

export function parse(
  src: string,
  reviver?:
    | Reviver
    | (ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions),
  options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions
): any {
  let _reviver: Reviver | undefined = undefined
  if (typeof reviver === 'function') {
    _reviver = reviver
  } else if (options === undefined && reviver && typeof reviver === 'object') {
    options = reviver
  }

  const doc = parseDocument(src, options)
  if (!doc) return null
  doc.warnings.forEach(warning => warn(doc.options.logLevel, warning))
  if (doc.errors.length > 0) {
    if (doc.options.logLevel !== 'silent') throw doc.errors[0]
    else doc.errors = []
  }
  return doc.toJS(Object.assign({ reviver: _reviver }, options))
}

/**
 * Stringify a value as a YAML document.
 *
 * @param replacer - A replacer array or function, as in `JSON.stringify()`
 * @returns Will always include `\n` as the last character, as is expected of YAML documents.
 */
export function stringify(
  value: any,
  options?: DocumentOptions &
    SchemaOptions &
    ParseOptions &
    CreateNodeOptions &
    ToStringOptions
): string
export function stringify(
  value: any,
  replacer?: Replacer | null,
  options?:
    | string
    | number
    | (DocumentOptions &
        SchemaOptions &
        ParseOptions &
        CreateNodeOptions &
        ToStringOptions)
): string

export function stringify(
  value: any,
  replacer?:
    | Replacer
    | (DocumentOptions &
        SchemaOptions &
        ParseOptions &
        CreateNodeOptions &
        ToStringOptions)
    | null,
  options?:
    | string
    | number
    | (DocumentOptions &
        SchemaOptions &
        ParseOptions &
        CreateNodeOptions &
        ToStringOptions)
) {
  let _replacer: Replacer | null = null
  if (typeof replacer === 'function' || Array.isArray(replacer)) {
    _replacer = replacer
  } else if (options === undefined && replacer) {
    options = replacer
  }

  if (typeof options === 'string') options = options.length
  if (typeof options === 'number') {
    const indent = Math.round(options)
    options = indent < 1 ? undefined : indent > 8 ? { indent: 8 } : { indent }
  }
  if (value === undefined) {
    const { keepUndefined } = options ?? (replacer as CreateNodeOptions) ?? {}
    if (!keepUndefined) return undefined
  }
  if (isDocument(value) && !_replacer) return value.toString(options)
  return new Document(value, _replacer, options).toString(options)
}
eemeli-yaml-086fa6b/src/schema/000077500000000000000000000000001511277410200163575ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/schema/Schema.ts000066400000000000000000000040011511277410200201220ustar00rootroot00000000000000import { MAP, SCALAR, SEQ } from '../nodes/identity.ts'
import type { Pair } from '../nodes/Pair.ts'
import type { SchemaOptions, ToStringOptions } from '../options.ts'
import { map } from './common/map.ts'
import { seq } from './common/seq.ts'
import { string } from './common/string.ts'
import { coreKnownTags, getTags } from './tags.ts'
import type { CollectionTag, ScalarTag } from './types.ts'

const sortMapEntriesByKey = (a: Pair, b: Pair) =>
  a.key < b.key ? -1 : a.key > b.key ? 1 : 0

export class Schema {
  compat: Array | null
  knownTags: Record
  name: string
  sortMapEntries: ((a: Pair, b: Pair) => number) | null
  tags: Array
  toStringOptions: Readonly | null

  // Used by createNode() and composeScalar()
  declare readonly [MAP]: CollectionTag
  declare readonly [SCALAR]: ScalarTag
  declare readonly [SEQ]: CollectionTag

  constructor({
    compat,
    customTags,
    merge,
    resolveKnownTags,
    schema,
    sortMapEntries,
    toStringDefaults
  }: SchemaOptions) {
    this.compat = Array.isArray(compat)
      ? getTags(compat, 'compat')
      : compat
        ? getTags(null, compat)
        : null
    this.name = (typeof schema === 'string' && schema) || 'core'
    this.knownTags = resolveKnownTags ? coreKnownTags : {}
    this.tags = getTags(customTags, this.name, merge)
    this.toStringOptions = toStringDefaults ?? null

    Object.defineProperty(this, MAP, { value: map })
    Object.defineProperty(this, SCALAR, { value: string })
    Object.defineProperty(this, SEQ, { value: seq })

    // Used by createMap()
    this.sortMapEntries =
      typeof sortMapEntries === 'function'
        ? sortMapEntries
        : sortMapEntries === true
          ? sortMapEntriesByKey
          : null
  }

  clone(): Schema {
    const copy: Schema = Object.create(
      Schema.prototype,
      Object.getOwnPropertyDescriptors(this)
    )
    copy.tags = this.tags.slice()
    return copy
  }
}
eemeli-yaml-086fa6b/src/schema/common/000077500000000000000000000000001511277410200176475ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/schema/common/map.ts000066400000000000000000000007061511277410200207770ustar00rootroot00000000000000import { isMap } from '../../nodes/identity.ts'
import { YAMLMap } from '../../nodes/YAMLMap.ts'
import type { CollectionTag } from '../types.ts'

export const map: CollectionTag = {
  collection: 'map',
  default: true,
  nodeClass: YAMLMap,
  tag: 'tag:yaml.org,2002:map',
  resolve(map, onError) {
    if (!isMap(map)) onError('Expected a mapping for this tag')
    return map
  },
  createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)
}
eemeli-yaml-086fa6b/src/schema/common/null.ts000066400000000000000000000007371511277410200212000ustar00rootroot00000000000000import { Scalar } from '../../nodes/Scalar.ts'
import type { ScalarTag } from '../types.ts'

export const nullTag: ScalarTag & { test: RegExp } = {
  identify: value => value == null,
  createNode: () => new Scalar(null),
  default: true,
  tag: 'tag:yaml.org,2002:null',
  test: /^(?:~|[Nn]ull|NULL)?$/,
  resolve: () => new Scalar(null),
  stringify: ({ source }, ctx) =>
    typeof source === 'string' && nullTag.test.test(source)
      ? source
      : ctx.options.nullStr
}
eemeli-yaml-086fa6b/src/schema/common/seq.ts000066400000000000000000000007071511277410200210130ustar00rootroot00000000000000import { isSeq } from '../../nodes/identity.ts'
import { YAMLSeq } from '../../nodes/YAMLSeq.ts'
import type { CollectionTag } from '../types.ts'

export const seq: CollectionTag = {
  collection: 'seq',
  default: true,
  nodeClass: YAMLSeq,
  tag: 'tag:yaml.org,2002:seq',
  resolve(seq, onError) {
    if (!isSeq(seq)) onError('Expected a sequence for this tag')
    return seq
  },
  createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)
}
eemeli-yaml-086fa6b/src/schema/common/string.ts000066400000000000000000000006701511277410200215300ustar00rootroot00000000000000import { stringifyString } from '../../stringify/stringifyString.ts'
import type { ScalarTag } from '../types.ts'

export const string: ScalarTag = {
  identify: value => typeof value === 'string',
  default: true,
  tag: 'tag:yaml.org,2002:str',
  resolve: str => str,
  stringify(item, ctx, onComment, onChompKeep) {
    ctx = Object.assign({ actualString: true }, ctx)
    return stringifyString(item, ctx, onComment, onChompKeep)
  }
}
eemeli-yaml-086fa6b/src/schema/core/000077500000000000000000000000001511277410200173075ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/schema/core/bool.ts000066400000000000000000000011411511277410200206070ustar00rootroot00000000000000import { Scalar } from '../../nodes/Scalar.ts'
import type { ScalarTag } from '../types.ts'

export const boolTag: ScalarTag & { test: RegExp } = {
  identify: value => typeof value === 'boolean',
  default: true,
  tag: 'tag:yaml.org,2002:bool',
  test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
  resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),
  stringify({ source, value }, ctx) {
    if (source && boolTag.test.test(source)) {
      const sv = source[0] === 't' || source[0] === 'T'
      if (value === sv) return source
    }
    return value ? ctx.options.trueStr : ctx.options.falseStr
  }
}
eemeli-yaml-086fa6b/src/schema/core/float.ts000066400000000000000000000025321511277410200207660ustar00rootroot00000000000000import { Scalar } from '../../nodes/Scalar.ts'
import { stringifyNumber } from '../../stringify/stringifyNumber.ts'
import type { ScalarTag } from '../types.ts'

export const floatNaN: ScalarTag = {
  identify: value => typeof value === 'number',
  default: true,
  tag: 'tag:yaml.org,2002:float',
  test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
  resolve: str =>
    str.slice(-3).toLowerCase() === 'nan'
      ? NaN
      : str[0] === '-'
        ? Number.NEGATIVE_INFINITY
        : Number.POSITIVE_INFINITY,
  stringify: stringifyNumber
}

export const floatExp: ScalarTag = {
  identify: value => typeof value === 'number',
  default: true,
  tag: 'tag:yaml.org,2002:float',
  format: 'EXP',
  test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
  resolve: str => parseFloat(str),
  stringify(node) {
    const num = Number(node.value)
    return isFinite(num) ? num.toExponential() : stringifyNumber(node)
  }
}

export const float: ScalarTag = {
  identify: value => typeof value === 'number',
  default: true,
  tag: 'tag:yaml.org,2002:float',
  test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
  resolve(str) {
    const node = new Scalar(parseFloat(str))
    const dot = str.indexOf('.')
    if (dot !== -1 && str[str.length - 1] === '0')
      node.minFractionDigits = str.length - dot - 1
    return node
  },
  stringify: stringifyNumber
}
eemeli-yaml-086fa6b/src/schema/core/int.ts000066400000000000000000000030121511277410200204450ustar00rootroot00000000000000import type { Scalar } from '../../nodes/Scalar.ts'
import type { ParseOptions } from '../../options.ts'
import { stringifyNumber } from '../../stringify/stringifyNumber.ts'
import type { ScalarTag } from '../types.ts'

const intIdentify = (value: unknown): value is number | bigint =>
  typeof value === 'bigint' || Number.isInteger(value)

const intResolve = (
  str: string,
  offset: number,
  radix: number,
  { intAsBigInt }: ParseOptions
) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix))

function intStringify(node: Scalar, radix: number, prefix: string) {
  const { value } = node
  if (intIdentify(value) && value >= 0) return prefix + value.toString(radix)
  return stringifyNumber(node)
}

export const intOct: ScalarTag = {
  identify: value => intIdentify(value) && value >= 0,
  default: true,
  tag: 'tag:yaml.org,2002:int',
  format: 'OCT',
  test: /^0o[0-7]+$/,
  resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),
  stringify: node => intStringify(node, 8, '0o')
}

export const int: ScalarTag = {
  identify: intIdentify,
  default: true,
  tag: 'tag:yaml.org,2002:int',
  test: /^[-+]?[0-9]+$/,
  resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
  stringify: stringifyNumber
}

export const intHex: ScalarTag = {
  identify: value => intIdentify(value) && value >= 0,
  default: true,
  tag: 'tag:yaml.org,2002:int',
  format: 'HEX',
  test: /^0x[0-9a-fA-F]+$/,
  resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
  stringify: node => intStringify(node, 16, '0x')
}
eemeli-yaml-086fa6b/src/schema/core/schema.ts000066400000000000000000000006651511277410200211260ustar00rootroot00000000000000import { map } from '../common/map.ts'
import { nullTag } from '../common/null.ts'
import { seq } from '../common/seq.ts'
import { string } from '../common/string.ts'
import { boolTag } from './bool.ts'
import { float, floatExp, floatNaN } from './float.ts'
import { int, intHex, intOct } from './int.ts'

export const schema = [
  map,
  seq,
  string,
  nullTag,
  boolTag,
  intOct,
  int,
  intHex,
  floatNaN,
  floatExp,
  float
]
eemeli-yaml-086fa6b/src/schema/json-schema.ts000066400000000000000000000044311511277410200211400ustar00rootroot00000000000000// https://json-schema.org/draft/2020-12/json-schema-core.html
// https://json-schema.org/draft/2020-12/json-schema-validation.html

type JsonSchema =
  | boolean
  | ArraySchema
  | ObjectSchema
  | NumberSchema
  | StringSchema

type JsonType =
  | 'array'
  | 'object'
  | 'string'
  | 'number'
  | 'integer'
  | 'boolean'
  | 'null'

interface CommonSchema {
  type?: JsonType | JsonType[]
  const?: unknown
  enum?: unknown[]
  format?: string

  // logic/conditionals
  allOf?: JsonSchema[]
  anyOf?: JsonSchema[]
  oneOf?: JsonSchema[]
  not?: JsonSchema
  if?: JsonSchema
  then?: JsonSchema
  else?: JsonSchema

  // references
  $id?: string // uri
  $defs?: Record
  $anchor?: string // [A-Za-z_][\w.-]*
  $dynamicAnchor?: string
  $ref?: string
  $dynamicRef?: string

  // meta
  $schema?: string // uri
  $vocabulary?: Record // key is uri
  $comment?: string

  // annotations
  default?: unknown
  deprecated?: boolean
  readOnly?: boolean
  writeOnly?: boolean
  title?: string
  description?: string
  examples?: unknown[]
}

interface ArraySchema extends CommonSchema {
  prefixItems?: JsonSchema[]
  items?: JsonSchema
  contains?: JsonSchema
  unevaluatedItems?: JsonSchema
  maxItems?: number // non-negative integer
  minItems?: number // non-negative integer
  uniqueItems?: boolean
  maxContains?: number // non-negative integer
  minContains?: number // non-negative integer
}

interface ObjectSchema extends CommonSchema {
  properties?: Record
  patternProperties?: Record // key is regexp
  additionalProperties?: JsonSchema
  propertyNames?: JsonSchema
  unevaluatedProperties?: JsonSchema
  maxProperties?: number // non-negative integer
  minProperties?: number // non-negative integer
  required?: string[]
  dependentRequired?: Record
  dependentSchemas?: Record
}

interface StringSchema extends CommonSchema {
  maxLength?: number // non-negative integer
  minLength?: number // non-negative integer
  patter?: string // regex
  contentEncoding?: string
  contentMediaType?: string
  contentSchema?: JsonSchema
}

interface NumberSchema extends CommonSchema {
  multipleOf?: number
  maximum?: number
  exclusiveMaximum?: number
  minimum?: number
  exclusiveMinimum?: number
}
eemeli-yaml-086fa6b/src/schema/json/000077500000000000000000000000001511277410200173305ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/schema/json/schema.ts000066400000000000000000000035171511277410200211460ustar00rootroot00000000000000import { Scalar } from '../../nodes/Scalar.ts'
import { map } from '../common/map.ts'
import { seq } from '../common/seq.ts'
import type { CollectionTag, ScalarTag } from '../types.ts'

function intIdentify(value: unknown): value is number | bigint {
  return typeof value === 'bigint' || Number.isInteger(value)
}

const stringifyJSON = ({ value }: Scalar) => JSON.stringify(value)

const jsonScalars: ScalarTag[] = [
  {
    identify: value => typeof value === 'string',
    default: true,
    tag: 'tag:yaml.org,2002:str',
    resolve: str => str,
    stringify: stringifyJSON
  },
  {
    identify: value => value == null,
    createNode: () => new Scalar(null),
    default: true,
    tag: 'tag:yaml.org,2002:null',
    test: /^null$/,
    resolve: () => null,
    stringify: stringifyJSON
  },
  {
    identify: value => typeof value === 'boolean',
    default: true,
    tag: 'tag:yaml.org,2002:bool',
    test: /^true$|^false$/,
    resolve: str => str === 'true',
    stringify: stringifyJSON
  },
  {
    identify: intIdentify,
    default: true,
    tag: 'tag:yaml.org,2002:int',
    test: /^-?(?:0|[1-9][0-9]*)$/,
    resolve: (str, _onError, { intAsBigInt }) =>
      intAsBigInt ? BigInt(str) : parseInt(str, 10),
    stringify: ({ value }) =>
      intIdentify(value) ? value.toString() : JSON.stringify(value)
  },
  {
    identify: value => typeof value === 'number',
    default: true,
    tag: 'tag:yaml.org,2002:float',
    test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
    resolve: str => parseFloat(str),
    stringify: stringifyJSON
  }
]

const jsonError: ScalarTag = {
  default: true,
  tag: '',
  test: /^/,
  resolve(str, onError) {
    onError(`Unresolved plain scalar ${JSON.stringify(str)}`)
    return str
  }
}

export const schema = ([map, seq] as Array).concat(
  jsonScalars,
  jsonError
)
eemeli-yaml-086fa6b/src/schema/tags.ts000066400000000000000000000057351511277410200176770ustar00rootroot00000000000000import type { SchemaOptions } from '../options.ts'
import { map } from './common/map.ts'
import { nullTag } from './common/null.ts'
import { seq } from './common/seq.ts'
import { string } from './common/string.ts'
import { boolTag } from './core/bool.ts'
import { float, floatExp, floatNaN } from './core/float.ts'
import { int, intHex, intOct } from './core/int.ts'
import { schema as core } from './core/schema.ts'
import { schema as json } from './json/schema.ts'
import type { CollectionTag, ScalarTag } from './types.ts'
import { binary } from './yaml-1.1/binary.ts'
import { merge } from './yaml-1.1/merge.ts'
import { omap } from './yaml-1.1/omap.ts'
import { pairs } from './yaml-1.1/pairs.ts'
import { schema as yaml11 } from './yaml-1.1/schema.ts'
import { set } from './yaml-1.1/set.ts'
import { floatTime, intTime, timestamp } from './yaml-1.1/timestamp.ts'

const schemas = new Map>([
  ['core', core],
  ['failsafe', [map, seq, string]],
  ['json', json],
  ['yaml11', yaml11],
  ['yaml-1.1', yaml11]
])

const tagsByName = {
  binary,
  bool: boolTag,
  float,
  floatExp,
  floatNaN,
  floatTime,
  int,
  intHex,
  intOct,
  intTime,
  map,
  merge,
  null: nullTag,
  omap,
  pairs,
  seq,
  set,
  timestamp
}

export type TagId = keyof typeof tagsByName

export type Tags = Array

export const coreKnownTags = {
  'tag:yaml.org,2002:binary': binary,
  'tag:yaml.org,2002:merge': merge,
  'tag:yaml.org,2002:omap': omap,
  'tag:yaml.org,2002:pairs': pairs,
  'tag:yaml.org,2002:set': set,
  'tag:yaml.org,2002:timestamp': timestamp
}

export function getTags(
  customTags: SchemaOptions['customTags'] | undefined,
  schemaName: string,
  addMergeTag?: boolean
) {
  const schemaTags = schemas.get(schemaName)
  if (schemaTags && !customTags) {
    return addMergeTag && !schemaTags.includes(merge)
      ? schemaTags.concat(merge)
      : schemaTags.slice()
  }

  let tags: Tags | undefined = schemaTags
  if (!tags) {
    if (Array.isArray(customTags)) tags = []
    else {
      const keys = Array.from(schemas.keys())
        .filter(key => key !== 'yaml11')
        .map(key => JSON.stringify(key))
        .join(', ')
      throw new Error(
        `Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`
      )
    }
  }

  if (Array.isArray(customTags)) {
    for (const tag of customTags) tags = tags.concat(tag)
  } else if (typeof customTags === 'function') {
    tags = customTags(tags.slice())
  }
  if (addMergeTag) tags = tags.concat(merge)

  return tags.reduce<(CollectionTag | ScalarTag)[]>((tags, tag) => {
    const tagObj = typeof tag === 'string' ? tagsByName[tag] : tag
    if (!tagObj) {
      const tagName = JSON.stringify(tag)
      const keys = Object.keys(tagsByName)
        .map(key => JSON.stringify(key))
        .join(', ')
      throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`)
    }
    if (!tags.includes(tagObj)) tags.push(tagObj)
    return tags
  }, [])
}
eemeli-yaml-086fa6b/src/schema/types.ts000066400000000000000000000071121511277410200200740ustar00rootroot00000000000000import type { CreateNodeContext } from '../doc/createNode.ts'
import type { Node } from '../nodes/Node.ts'
import type { Scalar } from '../nodes/Scalar.ts'
import type { YAMLMap } from '../nodes/YAMLMap.ts'
import type { YAMLSeq } from '../nodes/YAMLSeq.ts'
import type { ParseOptions } from '../options.ts'
import type { StringifyContext } from '../stringify/stringify.ts'
import type { Schema } from './Schema.ts'

interface TagBase {
  /**
   * An optional factory function, used e.g. by collections when wrapping JS objects as AST nodes.
   */
  createNode?: (schema: Schema, value: unknown, ctx: CreateNodeContext) => Node

  /**
   * If `true`, allows for values to be stringified without
   * an explicit tag together with `test`.
   * If `'key'`, this only applies if the value is used as a mapping key.
   * For most cases, it's unlikely that you'll actually want to use this,
   * even if you first think you do.
   */
  default?: boolean | 'key'

  /**
   * If a tag has multiple forms that should be parsed and/or stringified
   * differently, use `format` to identify them.
   */
  format?: string

  /**
   * Used by `YAML.createNode` to detect your data type, e.g. using `typeof` or
   * `instanceof`.
   */
  identify?: (value: unknown) => boolean

  /**
   * The identifier for your data type, with which its stringified form will be
   * prefixed. Should either be a !-prefixed local `!tag`, or a fully qualified
   * `tag:domain,date:foo`.
   */
  tag: string
}

export interface ScalarTag extends TagBase {
  collection?: never
  nodeClass?: never

  /**
   * Turns a value into an AST node.
   * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
   */
  resolve(
    value: string,
    onError: (message: string) => void,
    options: ParseOptions
  ): unknown

  /**
   * Optional function stringifying a Scalar node. If your data includes a
   * suitable `.toString()` method, you can probably leave this undefined and
   * use the default stringifier.
   *
   * @param item The node being stringified.
   * @param ctx Contains the stringifying context variables.
   * @param onComment Callback to signal that the stringifier includes the
   *   item's comment in its output.
   * @param onChompKeep Callback to signal that the output uses a block scalar
   *   type with the `+` chomping indicator.
   */
  stringify?: (
    item: Scalar,
    ctx: StringifyContext,
    onComment?: () => void,
    onChompKeep?: () => void
  ) => string

  /**
   * Together with `default` allows for values to be stringified without an
   * explicit tag and detected using a regular expression. For most cases, it's
   * unlikely that you'll actually want to use these, even if you first think
   * you do.
   */
  test?: RegExp
}

export interface CollectionTag extends TagBase {
  stringify?: never
  test?: never

  /** The source collection type supported by this tag. */
  collection: 'map' | 'seq'

  /**
   * The `Node` child class that implements this tag.
   * If set, used to select this tag when stringifying.
   *
   * If the class provides a static `from` method, then that
   * will be used if the tag object doesn't have a `createNode` method.
   */
  nodeClass?: {
    new (schema?: Schema): Node
    from?: (schema: Schema, obj: unknown, ctx: CreateNodeContext) => Node
  }

  /**
   * Turns a value into an AST node.
   * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
   *
   * Note: this is required if nodeClass is not provided.
   */
  resolve?: (
    value: YAMLMap.Parsed | YAMLSeq.Parsed,
    onError: (message: string) => void,
    options: ParseOptions
  ) => unknown
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/000077500000000000000000000000001511277410200176165ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/schema/yaml-1.1/binary.ts000066400000000000000000000047041511277410200214570ustar00rootroot00000000000000import { Buffer } from 'node:buffer'
import { Scalar } from '../../nodes/Scalar.ts'
import { stringifyString } from '../../stringify/stringifyString.ts'
import type { ScalarTag } from '../types.ts'

export const binary: ScalarTag = {
  identify: value => value instanceof Uint8Array, // Buffer inherits from Uint8Array
  default: false,
  tag: 'tag:yaml.org,2002:binary',

  /**
   * Returns a Buffer in node and an Uint8Array in browsers
   *
   * To use the resulting buffer as an image, you'll want to do something like:
   *
   *   const blob = new Blob([buffer], { type: 'image/jpeg' })
   *   document.querySelector('#photo').src = URL.createObjectURL(blob)
   */
  resolve(src, onError) {
    if (typeof Buffer === 'function') {
      return Buffer.from(src, 'base64')
    } else if (typeof atob === 'function') {
      // On IE 11, atob() can't handle newlines
      const str = atob(src.replace(/[\n\r]/g, ''))
      const buffer = new Uint8Array(str.length)
      for (let i = 0; i < str.length; ++i) buffer[i] = str.charCodeAt(i)
      return buffer
    } else {
      onError(
        'This environment does not support reading binary tags; either Buffer or atob is required'
      )
      return src
    }
  },

  stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
    if (!value) return ''
    const buf = value as Uint8Array // checked earlier by binary.identify()
    let str: string
    if (typeof Buffer === 'function') {
      str =
        buf instanceof Buffer
          ? buf.toString('base64')
          : Buffer.from(buf.buffer).toString('base64')
    } else if (typeof btoa === 'function') {
      let s = ''
      for (let i = 0; i < buf.length; ++i) s += String.fromCharCode(buf[i])
      str = btoa(s)
    } else {
      throw new Error(
        'This environment does not support writing binary tags; either Buffer or btoa is required'
      )
    }

    type ??= Scalar.BLOCK_LITERAL
    if (type !== Scalar.QUOTE_DOUBLE) {
      const lineWidth = Math.max(
        ctx.options.lineWidth - ctx.indent.length,
        ctx.options.minContentWidth
      )
      const n = Math.ceil(str.length / lineWidth)
      const lines = new Array(n)
      for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
        lines[i] = str.substr(o, lineWidth)
      }
      str = lines.join(type === Scalar.BLOCK_LITERAL ? '\n' : ' ')
    }

    return stringifyString(
      { comment, type, value: str } as Scalar,
      ctx,
      onComment,
      onChompKeep
    )
  }
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/bool.ts000066400000000000000000000016401511277410200211220ustar00rootroot00000000000000import { Scalar } from '../../nodes/Scalar.ts'
import type { StringifyContext } from '../../stringify/stringify.ts'
import type { ScalarTag } from '../types.ts'

function boolStringify({ value, source }: Scalar, ctx: StringifyContext) {
  const boolObj = value ? trueTag : falseTag
  if (source && boolObj.test.test(source)) return source
  return value ? ctx.options.trueStr : ctx.options.falseStr
}

export const trueTag: ScalarTag & { test: RegExp } = {
  identify: value => value === true,
  default: true,
  tag: 'tag:yaml.org,2002:bool',
  test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
  resolve: () => new Scalar(true),
  stringify: boolStringify
}

export const falseTag: ScalarTag & { test: RegExp } = {
  identify: value => value === false,
  default: true,
  tag: 'tag:yaml.org,2002:bool',
  test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
  resolve: () => new Scalar(false),
  stringify: boolStringify
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/float.ts000066400000000000000000000027131511277410200212760ustar00rootroot00000000000000import { Scalar } from '../../nodes/Scalar.ts'
import { stringifyNumber } from '../../stringify/stringifyNumber.ts'
import type { ScalarTag } from '../types.ts'

export const floatNaN: ScalarTag = {
  identify: value => typeof value === 'number',
  default: true,
  tag: 'tag:yaml.org,2002:float',
  test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
  resolve: (str: string) =>
    str.slice(-3).toLowerCase() === 'nan'
      ? NaN
      : str[0] === '-'
        ? Number.NEGATIVE_INFINITY
        : Number.POSITIVE_INFINITY,
  stringify: stringifyNumber
}

export const floatExp: ScalarTag = {
  identify: value => typeof value === 'number',
  default: true,
  tag: 'tag:yaml.org,2002:float',
  format: 'EXP',
  test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
  resolve: (str: string) => parseFloat(str.replace(/_/g, '')),
  stringify(node) {
    const num = Number(node.value)
    return isFinite(num) ? num.toExponential() : stringifyNumber(node)
  }
}

export const float: ScalarTag = {
  identify: value => typeof value === 'number',
  default: true,
  tag: 'tag:yaml.org,2002:float',
  test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
  resolve(str: string) {
    const node = new Scalar(parseFloat(str.replace(/_/g, '')))
    const dot = str.indexOf('.')
    if (dot !== -1) {
      const f = str.substring(dot + 1).replace(/_/g, '')
      if (f[f.length - 1] === '0') node.minFractionDigits = f.length
    }
    return node
  },
  stringify: stringifyNumber
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/int.ts000066400000000000000000000045031511277410200207620ustar00rootroot00000000000000import type { Scalar } from '../../nodes/Scalar.ts'
import type { ParseOptions } from '../../options.ts'
import { stringifyNumber } from '../../stringify/stringifyNumber.ts'
import type { ScalarTag } from '../types.ts'

const intIdentify = (value: unknown): value is number | bigint =>
  typeof value === 'bigint' || Number.isInteger(value)

function intResolve(
  str: string,
  offset: number,
  radix: number,
  { intAsBigInt }: ParseOptions
) {
  const sign = str[0]
  if (sign === '-' || sign === '+') offset += 1
  str = str.substring(offset).replace(/_/g, '')
  if (intAsBigInt) {
    switch (radix) {
      case 2:
        str = `0b${str}`
        break
      case 8:
        str = `0o${str}`
        break
      case 16:
        str = `0x${str}`
        break
    }
    const n = BigInt(str)
    return sign === '-' ? BigInt(-1) * n : n
  }
  const n = parseInt(str, radix)
  return sign === '-' ? -1 * n : n
}

function intStringify(node: Scalar, radix: number, prefix: string) {
  const { value } = node
  if (intIdentify(value)) {
    const str = value.toString(radix)
    return value < 0 ? '-' + prefix + str.substr(1) : prefix + str
  }
  return stringifyNumber(node)
}

export const intBin: ScalarTag = {
  identify: intIdentify,
  default: true,
  tag: 'tag:yaml.org,2002:int',
  format: 'BIN',
  test: /^[-+]?0b[0-1_]+$/,
  resolve: (str: string, _onError: unknown, opt: ParseOptions) =>
    intResolve(str, 2, 2, opt),
  stringify: node => intStringify(node, 2, '0b')
}

export const intOct: ScalarTag = {
  identify: intIdentify,
  default: true,
  tag: 'tag:yaml.org,2002:int',
  format: 'OCT',
  test: /^[-+]?0[0-7_]+$/,
  resolve: (str: string, _onError: unknown, opt: ParseOptions) =>
    intResolve(str, 1, 8, opt),
  stringify: node => intStringify(node, 8, '0')
}

export const int: ScalarTag = {
  identify: intIdentify,
  default: true,
  tag: 'tag:yaml.org,2002:int',
  test: /^[-+]?[0-9][0-9_]*$/,
  resolve: (str: string, _onError: unknown, opt: ParseOptions) =>
    intResolve(str, 0, 10, opt),
  stringify: stringifyNumber
}

export const intHex: ScalarTag = {
  identify: intIdentify,
  default: true,
  tag: 'tag:yaml.org,2002:int',
  format: 'HEX',
  test: /^[-+]?0x[0-9a-fA-F_]+$/,
  resolve: (str: string, _onError: unknown, opt: ParseOptions) =>
    intResolve(str, 2, 16, opt),
  stringify: node => intStringify(node, 16, '0x')
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/merge.ts000066400000000000000000000050251511277410200212670ustar00rootroot00000000000000import { isAlias, isMap, isScalar, isSeq } from '../../nodes/identity.ts'
import { Scalar } from '../../nodes/Scalar.ts'
import type { ToJSContext } from '../../nodes/toJS.ts'
import type { MapLike } from '../../nodes/YAMLMap.ts'
import type { ScalarTag } from '../types.ts'

// If the value associated with a merge key is a single mapping node, each of
// its key/value pairs is inserted into the current mapping, unless the key
// already exists in it. If the value associated with the merge key is a
// sequence, then this sequence is expected to contain mapping nodes and each
// of these nodes is merged in turn according to its order in the sequence.
// Keys in mapping nodes earlier in the sequence override keys specified in
// later mapping nodes. -- http://yaml.org/type/merge.html

const MERGE_KEY = '<<'

export const merge: ScalarTag & {
  identify(value: unknown): boolean
  test: RegExp
} = {
  identify: value =>
    value === MERGE_KEY ||
    (typeof value === 'symbol' && value.description === MERGE_KEY),
  default: 'key',
  tag: 'tag:yaml.org,2002:merge',
  test: /^<<$/,
  resolve: () =>
    Object.assign(new Scalar(Symbol(MERGE_KEY)), {
      addToJSMap: addMergeToJSMap
    }),
  stringify: () => MERGE_KEY
}

export const isMergeKey = (ctx: ToJSContext | undefined, key: unknown) =>
  (merge.identify(key) ||
    (isScalar(key) &&
      (!key.type || key.type === Scalar.PLAIN) &&
      merge.identify(key.value))) &&
  ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default)

export function addMergeToJSMap(
  ctx: ToJSContext | undefined,
  map: MapLike,
  value: unknown
) {
  value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value
  if (isSeq(value)) for (const it of value.items) mergeValue(ctx, map, it)
  else if (Array.isArray(value))
    for (const it of value) mergeValue(ctx, map, it)
  else mergeValue(ctx, map, value)
}

function mergeValue(
  ctx: ToJSContext | undefined,
  map: MapLike,
  value: unknown
) {
  const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value
  if (!isMap(source))
    throw new Error('Merge sources must be maps or map aliases')
  const srcMap = source.toJSON(null, ctx, Map)
  for (const [key, value] of srcMap) {
    if (map instanceof Map) {
      if (!map.has(key)) map.set(key, value)
    } else if (map instanceof Set) {
      map.add(key)
    } else if (!Object.prototype.hasOwnProperty.call(map, key)) {
      Object.defineProperty(map, key, {
        value,
        writable: true,
        enumerable: true,
        configurable: true
      })
    }
  }
  return map
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/omap.ts000066400000000000000000000050471511277410200211300ustar00rootroot00000000000000import { isPair, isScalar } from '../../nodes/identity.ts'
import type { ToJSContext } from '../../nodes/toJS.ts'
import { toJS } from '../../nodes/toJS.ts'
import { YAMLMap } from '../../nodes/YAMLMap.ts'
import { YAMLSeq } from '../../nodes/YAMLSeq.ts'
import type { CreateNodeContext } from '../../util.ts'
import type { Schema } from '../Schema.ts'
import type { CollectionTag } from '../types.ts'
import { createPairs, resolvePairs } from './pairs.ts'

export class YAMLOMap extends YAMLSeq {
  static tag = 'tag:yaml.org,2002:omap'

  constructor() {
    super()
    this.tag = YAMLOMap.tag
  }

  add: typeof YAMLMap.prototype.add = YAMLMap.prototype.add.bind(this)
  delete: typeof YAMLMap.prototype.delete = YAMLMap.prototype.delete.bind(this)
  get: typeof YAMLMap.prototype.get = YAMLMap.prototype.get.bind(this)
  has: typeof YAMLMap.prototype.has = YAMLMap.prototype.has.bind(this)
  set: typeof YAMLMap.prototype.set = YAMLMap.prototype.set.bind(this)

  /**
   * If `ctx` is given, the return type is actually `Map`,
   * but TypeScript won't allow widening the signature of a child method.
   */
  toJSON(_?: unknown, ctx?: ToJSContext): unknown[] {
    if (!ctx) return super.toJSON(_)
    const map = new Map()
    if (ctx?.onCreate) ctx.onCreate(map)
    for (const pair of this.items) {
      let key, value
      if (isPair(pair)) {
        key = toJS(pair.key, '', ctx)
        value = toJS(pair.value, key, ctx)
      } else {
        key = toJS(pair, '', ctx)
      }
      if (map.has(key))
        throw new Error('Ordered maps must not include duplicate keys')
      map.set(key, value)
    }
    return map as unknown as unknown[]
  }

  static from(
    schema: Schema,
    iterable: unknown,
    ctx: CreateNodeContext
  ): YAMLOMap {
    const pairs = createPairs(schema, iterable, ctx)
    const omap = new this()
    omap.items = pairs.items
    return omap
  }
}

export const omap: CollectionTag = {
  collection: 'seq',
  identify: value => value instanceof Map,
  nodeClass: YAMLOMap,
  default: false,
  tag: 'tag:yaml.org,2002:omap',

  resolve(seq, onError) {
    const pairs = resolvePairs(seq, onError)
    const seenKeys: unknown[] = []
    for (const { key } of pairs.items) {
      if (isScalar(key)) {
        if (seenKeys.includes(key.value)) {
          onError(`Ordered maps must not include duplicate keys: ${key.value}`)
        } else {
          seenKeys.push(key.value)
        }
      }
    }
    return Object.assign(new YAMLOMap(), pairs)
  },
  createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/pairs.ts000066400000000000000000000054421511277410200213110ustar00rootroot00000000000000import type { CreateNodeContext } from '../../doc/createNode.ts'
import { isMap, isPair, isSeq } from '../../nodes/identity.ts'
import type { ParsedNode } from '../../nodes/Node.ts'
import { createPair, Pair } from '../../nodes/Pair.ts'
import { Scalar } from '../../nodes/Scalar.ts'
import type { YAMLMap } from '../../nodes/YAMLMap.ts'
import { YAMLSeq } from '../../nodes/YAMLSeq.ts'
import type { Schema } from '../../schema/Schema.ts'
import type { CollectionTag } from '../types.ts'

export function resolvePairs(
  seq:
    | YAMLSeq.Parsed>
    | YAMLMap.Parsed,
  onError: (message: string) => void
) {
  if (isSeq(seq)) {
    for (let i = 0; i < seq.items.length; ++i) {
      let item = seq.items[i]
      if (isPair(item)) continue
      else if (isMap(item)) {
        if (item.items.length > 1)
          onError('Each pair must have its own sequence indicator')
        const pair =
          item.items[0] || new Pair(new Scalar(null) as Scalar.Parsed)
        if (item.commentBefore)
          pair.key.commentBefore = pair.key.commentBefore
            ? `${item.commentBefore}\n${pair.key.commentBefore}`
            : item.commentBefore
        if (item.comment) {
          const cn = pair.value ?? pair.key
          cn.comment = cn.comment
            ? `${item.comment}\n${cn.comment}`
            : item.comment
        }
        item = pair
      }
      seq.items[i] = isPair(item) ? item : new Pair(item)
    }
  } else onError('Expected a sequence for this tag')
  return seq as YAMLSeq.Parsed>
}

export function createPairs(
  schema: Schema,
  iterable: unknown,
  ctx: CreateNodeContext
) {
  const { replacer } = ctx
  const pairs = new YAMLSeq(schema)
  pairs.tag = 'tag:yaml.org,2002:pairs'
  let i = 0
  if (iterable && Symbol.iterator in Object(iterable))
    for (let it of iterable as Iterable) {
      if (typeof replacer === 'function')
        it = replacer.call(iterable, String(i++), it)
      let key: unknown, value: unknown
      if (Array.isArray(it)) {
        if (it.length === 2) {
          key = it[0]
          value = it[1]
        } else throw new TypeError(`Expected [key, value] tuple: ${it}`)
      } else if (it && it instanceof Object) {
        const keys = Object.keys(it)
        if (keys.length === 1) {
          key = keys[0]
          value = (it as any)[key as string]
        } else {
          throw new TypeError(
            `Expected tuple with one key, not ${keys.length} keys`
          )
        }
      } else {
        key = it
      }
      pairs.items.push(createPair(key, value, ctx))
    }
  return pairs
}

export const pairs: CollectionTag = {
  collection: 'seq',
  default: false,
  tag: 'tag:yaml.org,2002:pairs',
  resolve: resolvePairs,
  createNode: createPairs
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/schema.ts000066400000000000000000000014271511277410200214320ustar00rootroot00000000000000import { map } from '../common/map.ts'
import { nullTag } from '../common/null.ts'
import { seq } from '../common/seq.ts'
import { string } from '../common/string.ts'
import { binary } from './binary.ts'
import { falseTag, trueTag } from './bool.ts'
import { float, floatExp, floatNaN } from './float.ts'
import { intBin, int, intHex, intOct } from './int.ts'
import { merge } from './merge.ts'
import { omap } from './omap.ts'
import { pairs } from './pairs.ts'
import { set } from './set.ts'
import { intTime, floatTime, timestamp } from './timestamp.ts'

export const schema = [
  map,
  seq,
  string,
  nullTag,
  trueTag,
  falseTag,
  intBin,
  intOct,
  int,
  intHex,
  floatNaN,
  floatExp,
  float,
  binary,
  merge,
  omap,
  pairs,
  set,
  intTime,
  floatTime,
  timestamp
]
eemeli-yaml-086fa6b/src/schema/yaml-1.1/set.ts000066400000000000000000000070331511277410200207640ustar00rootroot00000000000000import { isMap, isPair, isScalar } from '../../nodes/identity.ts'
import { Pair } from '../../nodes/Pair.ts'
import type { Scalar } from '../../nodes/Scalar.ts'
import type { ToJSContext } from '../../nodes/toJS.ts'
import { findPair, YAMLMap } from '../../nodes/YAMLMap.ts'
import type { Schema } from '../../schema/Schema.ts'
import type { StringifyContext } from '../../stringify/stringify.ts'
import type { CreateNodeContext } from '../../util.ts'
import { createPair } from '../../util.ts'
import type { CollectionTag } from '../types.ts'

export class YAMLSet extends YAMLMap | null> {
  static tag = 'tag:yaml.org,2002:set'

  constructor(schema?: Schema) {
    super(schema)
    this.tag = YAMLSet.tag
  }

  add(
    key:
      | T
      | Pair | null>
      | { key: T; value: Scalar | null }
  ) {
    let pair: Pair | null>
    if (isPair(key)) pair = key
    else if (
      key &&
      typeof key === 'object' &&
      'key' in key &&
      'value' in key &&
      key.value === null
    )
      pair = new Pair(key.key, null)
    else pair = new Pair(key as T, null)
    const prev = findPair(this.items, pair.key)
    if (!prev) this.items.push(pair)
  }

  /**
   * If `keepPair` is `true`, returns the Pair matching `key`.
   * Otherwise, returns the value of that Pair's key.
   */
  get(key: unknown, keepPair?: boolean): any {
    const pair = findPair(this.items, key)
    return !keepPair && isPair(pair)
      ? isScalar(pair.key)
        ? pair.key.value
        : pair.key
      : pair
  }

  set(key: T, value: boolean): void

  /** @deprecated Will throw; `value` must be boolean */
  set(key: T, value: null): void
  set(key: T, value: boolean | null) {
    if (typeof value !== 'boolean')
      throw new Error(
        `Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`
      )
    const prev = findPair(this.items, key)
    if (prev && !value) {
      this.items.splice(this.items.indexOf(prev), 1)
    } else if (!prev && value) {
      this.items.push(new Pair(key))
    }
  }

  toJSON(_?: unknown, ctx?: ToJSContext): any {
    return super.toJSON(_, ctx, Set)
  }

  toString(
    ctx?: StringifyContext,
    onComment?: () => void,
    onChompKeep?: () => void
  ): string {
    if (!ctx) return JSON.stringify(this)
    if (this.hasAllNullValues(true))
      return super.toString(
        Object.assign({}, ctx, { allNullValues: true }),
        onComment,
        onChompKeep
      )
    else throw new Error('Set items must all have null values')
  }

  static from(
    schema: Schema,
    iterable: unknown,
    ctx: CreateNodeContext
  ): YAMLSet {
    const { replacer } = ctx
    const set = new this(schema)
    if (iterable && Symbol.iterator in Object(iterable))
      for (let value of iterable as Iterable) {
        if (typeof replacer === 'function')
          value = replacer.call(iterable, value, value)
        set.items.push(
          createPair(value, null, ctx) as Pair>
        )
      }
    return set
  }
}

export const set: CollectionTag = {
  collection: 'map',
  identify: value => value instanceof Set,
  nodeClass: YAMLSet,
  default: false,
  tag: 'tag:yaml.org,2002:set',
  createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
  resolve(map, onError) {
    if (isMap(map)) {
      if (map.hasAllNullValues(true)) return Object.assign(new YAMLSet(), map)
      else onError('Set items must all have null values')
    } else onError('Expected a mapping for this tag')
    return map
  }
}
eemeli-yaml-086fa6b/src/schema/yaml-1.1/timestamp.ts000066400000000000000000000073221511277410200221750ustar00rootroot00000000000000import type { Scalar } from '../../nodes/Scalar.ts'
import { stringifyNumber } from '../../stringify/stringifyNumber.ts'
import type { ScalarTag } from '../types.ts'

/** Internal types handle bigint as number, because TS can't figure it out. */
function parseSexagesimal(str: string, asBigInt?: B) {
  const sign = str[0]
  const parts = sign === '-' || sign === '+' ? str.substring(1) : str
  const num = (n: number | string) =>
    asBigInt ? (BigInt(n) as unknown as number) : Number(n)
  const res = parts
    .replace(/_/g, '')
    .split(':')
    .reduce((res, p) => res * num(60) + num(p), num(0))
  return (sign === '-' ? num(-1) * res : res) as B extends true
    ? number | bigint
    : number
}

/**
 * hhhh:mm:ss.sss
 *
 * Internal types handle bigint as number, because TS can't figure it out.
 */
function stringifySexagesimal(node: Scalar) {
  let { value } = node as Scalar
  let num = (n: number) => n
  if (typeof value === 'bigint') num = n => BigInt(n) as unknown as number
  else if (isNaN(value) || !isFinite(value)) return stringifyNumber(node)
  let sign = ''
  if (value < 0) {
    sign = '-'
    value *= num(-1)
  }
  const _60 = num(60)
  const parts = [value % _60] // seconds, including ms
  if (value < 60) {
    parts.unshift(0) // at least one : is required
  } else {
    value = (value - parts[0]) / _60
    parts.unshift(value % _60) // minutes
    if (value >= 60) {
      value = (value - parts[0]) / _60
      parts.unshift(value) // hours
    }
  }
  return (
    sign +
    parts
      .map(n => String(n).padStart(2, '0'))
      .join(':')
      .replace(/000000\d*$/, '') // % 60 may introduce error
  )
}

export const intTime: ScalarTag = {
  identify: value => typeof value === 'bigint' || Number.isInteger(value),
  default: true,
  tag: 'tag:yaml.org,2002:int',
  format: 'TIME',
  test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
  resolve: (str, _onError, { intAsBigInt }) =>
    parseSexagesimal(str, intAsBigInt),
  stringify: stringifySexagesimal
}

export const floatTime: ScalarTag = {
  identify: value => typeof value === 'number',
  default: true,
  tag: 'tag:yaml.org,2002:float',
  format: 'TIME',
  test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
  resolve: str => parseSexagesimal(str, false),
  stringify: stringifySexagesimal
}

export const timestamp: ScalarTag & { test: RegExp } = {
  identify: value => value instanceof Date,
  default: true,
  tag: 'tag:yaml.org,2002:timestamp',

  // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part
  // may be omitted altogether, resulting in a date format. In such a case, the time part is
  // assumed to be 00:00:00Z (start of day, UTC).
  test: RegExp(
    '^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd
      '(?:' + // time is optional
      '(?:t|T|[ \\t]+)' + // t | T | whitespace
      '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)?
      '(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30
      ')?$'
  ),

  resolve(str) {
    const match = str.match(timestamp.test)
    if (!match)
      throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd')
    const [, year, month, day, hour, minute, second] = match.map(Number)
    const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0
    let date = Date.UTC(
      year,
      month - 1,
      day,
      hour || 0,
      minute || 0,
      second || 0,
      millisec
    )
    const tz = match[8]
    if (tz && tz !== 'Z') {
      let d = parseSexagesimal(tz, false)
      if (Math.abs(d) < 30) d *= 60
      date -= 60000 * d
    }
    return new Date(date)
  },

  stringify: ({ value }) =>
    (value as Date)?.toISOString().replace(/(T00:00:00)?\.000Z$/, '') ?? ''
}
eemeli-yaml-086fa6b/src/stringify/000077500000000000000000000000001511277410200171355ustar00rootroot00000000000000eemeli-yaml-086fa6b/src/stringify/foldFlowLines.ts000066400000000000000000000111441511277410200222550ustar00rootroot00000000000000export const FOLD_FLOW = 'flow'
export const FOLD_BLOCK = 'block'
export const FOLD_QUOTED = 'quoted'

/**
 * `'block'` prevents more-indented lines from being folded;
 * `'quoted'` allows for `\` escapes, including escaped newlines
 */
export type FoldMode = 'flow' | 'block' | 'quoted'

export interface FoldOptions {
  /**
   * Accounts for leading contents on the first line, defaulting to
   * `indent.length`
   */
  indentAtStart?: number

  /** Default: `80` */
  lineWidth?: number

  /**
   * Allow highly indented lines to stretch the line width or indent content
   * from the start.
   *
   * Default: `20`
   */
  minContentWidth?: number

  /** Called once if the text is folded */
  onFold?: () => void

  /** Called once if any line of text exceeds lineWidth characters */
  onOverflow?: () => void
}

/**
 * Tries to keep input at up to `lineWidth` characters, splitting only on spaces
 * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
 * terminated with `\n` and started with `indent`.
 */
export function foldFlowLines(
  text: string,
  indent: string,
  mode: FoldMode = 'flow',
  {
    indentAtStart,
    lineWidth = 80,
    minContentWidth = 20,
    onFold,
    onOverflow
  }: FoldOptions = {}
): string {
  if (!lineWidth || lineWidth < 0) return text
  if (lineWidth < minContentWidth) minContentWidth = 0
  const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length)
  if (text.length <= endStep) return text
  const folds = []
  const escapedFolds: Record = {}
  let end = lineWidth - indent.length
  if (typeof indentAtStart === 'number') {
    if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0)
    else end = lineWidth - indentAtStart
  }
  let split = undefined
  let prev = undefined
  let overflow = false
  let i = -1
  let escStart = -1
  let escEnd = -1
  if (mode === FOLD_BLOCK) {
    i = consumeMoreIndentedLines(text, i, indent.length)
    if (i !== -1) end = i + endStep
  }
  for (let ch; (ch = text[(i += 1)]); ) {
    if (mode === FOLD_QUOTED && ch === '\\') {
      escStart = i
      switch (text[i + 1]) {
        case 'x':
          i += 3
          break
        case 'u':
          i += 5
          break
        case 'U':
          i += 9
          break
        default:
          i += 1
      }
      escEnd = i
    }
    if (ch === '\n') {
      if (mode === FOLD_BLOCK)
        i = consumeMoreIndentedLines(text, i, indent.length)
      end = i + indent.length + endStep
      split = undefined
    } else {
      if (
        ch === ' ' &&
        prev &&
        prev !== ' ' &&
        prev !== '\n' &&
        prev !== '\t'
      ) {
        // space surrounded by non-space can be replaced with newline + indent
        const next = text[i + 1]
        if (next && next !== ' ' && next !== '\n' && next !== '\t') split = i
      }
      if (i >= end) {
        if (split) {
          folds.push(split)
          end = split + endStep
          split = undefined
        } else if (mode === FOLD_QUOTED) {
          // white-space collected at end may stretch past lineWidth
          while (prev === ' ' || prev === '\t') {
            prev = ch
            ch = text[(i += 1)]
            overflow = true
          }
          // Account for newline escape, but don't break preceding escape
          const j = i > escEnd + 1 ? i - 2 : escStart - 1
          // Bail out if lineWidth & minContentWidth are shorter than an escape string
          if (escapedFolds[j]) return text
          folds.push(j)
          escapedFolds[j] = true
          end = j + endStep
          split = undefined
        } else {
          overflow = true
        }
      }
    }
    prev = ch
  }
  if (overflow && onOverflow) onOverflow()
  if (folds.length === 0) return text
  if (onFold) onFold()
  let res = text.slice(0, folds[0])
  for (let i = 0; i < folds.length; ++i) {
    const fold = folds[i]
    const end = folds[i + 1] || text.length
    if (fold === 0) res = `\n${indent}${text.slice(0, end)}`
    else {
      if (mode === FOLD_QUOTED && escapedFolds[fold]) res += `${text[fold]}\\`
      res += `\n${indent}${text.slice(fold + 1, end)}`
    }
  }
  return res
}

/**
 * Presumes `i + 1` is at the start of a line
 * @returns index of last newline in more-indented block
 */
function consumeMoreIndentedLines(text: string, i: number, indent: number) {
  let end = i
  let start = i + 1
  let ch = text[start]
  while (ch === ' ' || ch === '\t') {
    if (i < start + indent) {
      ch = text[++i]
    } else {
      do {
        ch = text[++i]
      } while (ch && ch !== '\n')
      end = i
      start = i + 1
      ch = text[start]
    }
  }
  return end
}
eemeli-yaml-086fa6b/src/stringify/stringify.ts000066400000000000000000000116471511277410200215340ustar00rootroot00000000000000import { anchorIsValid } from '../doc/anchors.ts'
import type { Document } from '../doc/Document.ts'
import type { Alias } from '../nodes/Alias.ts'
import {
  isAlias,
  isCollection,
  isNode,
  isPair,
  isScalar
} from '../nodes/identity.ts'
import type { Node } from '../nodes/Node.ts'
import type { Scalar } from '../nodes/Scalar.ts'
import type { ToStringOptions } from '../options.ts'
import type { CollectionTag, ScalarTag } from '../schema/types.ts'
import { stringifyComment } from './stringifyComment.ts'
import { stringifyString } from './stringifyString.ts'

export type StringifyContext = {
  actualString?: boolean
  allNullValues?: boolean
  anchors: Set
  doc: Document
  forceBlockIndent?: boolean
  implicitKey?: boolean
  indent: string
  indentStep: string
  indentAtStart?: number
  inFlow: boolean | null
  inStringifyKey?: boolean
  flowCollectionPadding: string
  options: Readonly<
    Required>
  >
  resolvedAliases?: Set
}

export function createStringifyContext(
  doc: Document,
  options: ToStringOptions
): StringifyContext {
  const opt = Object.assign(
    {
      blockQuote: true,
      commentString: stringifyComment,
      defaultKeyType: null,
      defaultStringType: 'PLAIN',
      directives: null,
      doubleQuotedAsJSON: false,
      doubleQuotedMinMultiLineLength: 40,
      falseStr: 'false',
      flowCollectionPadding: true,
      indentSeq: true,
      lineWidth: 80,
      minContentWidth: 20,
      nullStr: 'null',
      simpleKeys: false,
      singleQuote: null,
      trueStr: 'true',
      verifyAliasOrder: true
    },
    doc.schema.toStringOptions,
    options
  )

  let inFlow: boolean | null
  switch (opt.collectionStyle) {
    case 'block':
      inFlow = false
      break
    case 'flow':
      inFlow = true
      break
    default:
      inFlow = null
  }

  return {
    anchors: new Set(),
    doc,
    flowCollectionPadding: opt.flowCollectionPadding ? ' ' : '',
    indent: '',
    indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',
    inFlow,
    options: opt
  }
}

function getTagObject(tags: Array, item: Node) {
  if (item.tag) {
    const match = tags.filter(t => t.tag === item.tag)
    if (match.length > 0)
      return match.find(t => t.format === (item as Scalar).format) ?? match[0]
  }

  let tagObj: ScalarTag | CollectionTag | undefined = undefined
  let obj: unknown
  if (isScalar(item)) {
    obj = item.value
    let match = tags.filter(t => t.identify?.(obj))
    if (match.length > 1) {
      const testMatch = match.filter(t => t.test)
      if (testMatch.length > 0) match = testMatch
    }
    tagObj =
      match.find(t => t.format === item.format) ?? match.find(t => !t.format)
  } else {
    obj = item
    tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass)
  }

  if (!tagObj) {
    const name =
      (obj as any)?.constructor?.name ?? (obj === null ? 'null' : typeof obj)
    throw new Error(`Tag not resolved for ${name} value`)
  }
  return tagObj
}

// needs to be called before value stringifier to allow for circular anchor refs
function stringifyProps(
  node: Node,
  tagObj: ScalarTag | CollectionTag,
  { anchors, doc }: StringifyContext
) {
  if (!doc.directives) return ''
  const props = []
  const anchor = (isScalar(node) || isCollection(node)) && node.anchor
  if (anchor && anchorIsValid(anchor)) {
    anchors.add(anchor)
    props.push(`&${anchor}`)
  }
  const tag = node.tag ?? (tagObj.default ? null : tagObj.tag)
  if (tag) props.push(doc.directives.tagString(tag))
  return props.join(' ')
}

export function stringify(
  item: unknown,
  ctx: StringifyContext,
  onComment?: () => void,
  onChompKeep?: () => void
): string {
  if (isPair(item)) return item.toString(ctx, onComment, onChompKeep)
  if (isAlias(item)) {
    if (ctx.doc.directives) return item.toString(ctx)

    if (ctx.resolvedAliases?.has(item)) {
      throw new TypeError(
        `Cannot stringify circular structure without alias nodes`
      )
    } else {
      if (ctx.resolvedAliases) ctx.resolvedAliases.add(item)
      else ctx.resolvedAliases = new Set([item])
      item = item.resolve(ctx.doc)
    }
  }

  let tagObj: ScalarTag | CollectionTag | undefined = undefined
  const node = isNode(item)
    ? item
    : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) })
  tagObj ??= getTagObject(ctx.doc.schema.tags, node)

  const props = stringifyProps(node, tagObj, ctx)
  if (props.length > 0)
    ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1

  const str =
    typeof tagObj.stringify === 'function'
      ? tagObj.stringify(node as Scalar, ctx, onComment, onChompKeep)
      : isScalar(node)
        ? stringifyString(node, ctx, onComment, onChompKeep)
        : node.toString(ctx, onComment, onChompKeep)
  if (!props) return str
  return isScalar(node) || str[0] === '{' || str[0] === '['
    ? `${props} ${str}`
    : `${props}\n${ctx.indent}${str}`
}
eemeli-yaml-086fa6b/src/stringify/stringifyCollection.ts000066400000000000000000000120061511277410200235360ustar00rootroot00000000000000import type { Collection } from '../nodes/Collection.ts'
import { isNode, isPair } from '../nodes/identity.ts'
import type { StringifyContext } from './stringify.ts'
import { stringify } from './stringify.ts'
import { indentComment, lineComment } from './stringifyComment.ts'

interface StringifyCollectionOptions {
  blockItemPrefix: string
  flowChars: { start: '{'; end: '}' } | { start: '['; end: ']' }
  itemIndent: string
  onChompKeep?: () => void
  onComment?: () => void
}

export function stringifyCollection(
  collection: Readonly,
  ctx: StringifyContext,
  options: StringifyCollectionOptions
) {
  const flow = ctx.inFlow ?? collection.flow
  const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection
  return stringify(collection, ctx, options)
}

function stringifyBlockCollection(
  { comment, items }: Readonly,
  ctx: StringifyContext,
  {
    blockItemPrefix,
    flowChars,
    itemIndent,
    onChompKeep,
    onComment
  }: StringifyCollectionOptions
) {
  const {
    indent,
    options: { commentString }
  } = ctx
  const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null })

  let chompKeep = false // flag for the preceding node's status
  const lines: string[] = []
  for (let i = 0; i < items.length; ++i) {
    const item = items[i]
    let comment: string | null = null
    if (isNode(item)) {
      if (!chompKeep && item.spaceBefore) lines.push('')
      addCommentBefore(ctx, lines, item.commentBefore, chompKeep)
      if (item.comment) comment = item.comment
    } else if (isPair(item)) {
      const ik = isNode(item.key) ? item.key : null
      if (ik) {
        if (!chompKeep && ik.spaceBefore) lines.push('')
        addCommentBefore(ctx, lines, ik.commentBefore, chompKeep)
      }
    }

    chompKeep = false
    let str = stringify(
      item,
      itemCtx,
      () => (comment = null),
      () => (chompKeep = true)
    )
    if (comment) str += lineComment(str, itemIndent, commentString(comment))
    if (chompKeep && comment) chompKeep = false
    lines.push(blockItemPrefix + str)
  }

  let str: string
  if (lines.length === 0) {
    str = flowChars.start + flowChars.end
  } else {
    str = lines[0]
    for (let i = 1; i < lines.length; ++i) {
      const line = lines[i]
      str += line ? `\n${indent}${line}` : '\n'
    }
  }

  if (comment) {
    str += '\n' + indentComment(commentString(comment), indent)
    if (onComment) onComment()
  } else if (chompKeep && onChompKeep) onChompKeep()

  return str
}

function stringifyFlowCollection(
  { items }: Readonly,
  ctx: StringifyContext,
  { flowChars, itemIndent }: StringifyCollectionOptions
) {
  const {
    indent,
    indentStep,
    flowCollectionPadding: fcPadding,
    options: { commentString }
  } = ctx
  itemIndent += indentStep
  const itemCtx = Object.assign({}, ctx, {
    indent: itemIndent,
    inFlow: true,
    type: null
  })

  let reqNewline = false
  let linesAtValue = 0
  const lines: string[] = []
  for (let i = 0; i < items.length; ++i) {
    const item = items[i]
    let comment: string | null = null
    if (isNode(item)) {
      if (item.spaceBefore) lines.push('')
      addCommentBefore(ctx, lines, item.commentBefore, false)
      if (item.comment) comment = item.comment
    } else if (isPair(item)) {
      const ik = isNode(item.key) ? item.key : null
      if (ik) {
        if (ik.spaceBefore) lines.push('')
        addCommentBefore(ctx, lines, ik.commentBefore, false)
        if (ik.comment) reqNewline = true
      }

      const iv = isNode(item.value) ? item.value : null
      if (iv) {
        if (iv.comment) comment = iv.comment
        if (iv.commentBefore) reqNewline = true
      } else if (item.value == null && ik?.comment) {
        comment = ik.comment
      }
    }

    if (comment) reqNewline = true
    let str = stringify(item, itemCtx, () => (comment = null))
    if (i < items.length - 1) str += ','
    if (comment) str += lineComment(str, itemIndent, commentString(comment))
    if (!reqNewline && (lines.length > linesAtValue || str.includes('\n')))
      reqNewline = true
    lines.push(str)
    linesAtValue = lines.length
  }

  const { start, end } = flowChars
  if (lines.length === 0) {
    return start + end
  } else {
    if (!reqNewline) {
      const len = lines.reduce((sum, line) => sum + line.length + 2, 2)
      reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth
    }
    if (reqNewline) {
      let str = start
      for (const line of lines)
        str += line ? `\n${indentStep}${indent}${line}` : '\n'
      return `${str}\n${indent}${end}`
    } else {
      return `${start}${fcPadding}${lines.join(' ')}${fcPadding}${end}`
    }
  }
}

function addCommentBefore(
  { indent, options: { commentString } }: StringifyContext,
  lines: string[],
  comment: string | null | undefined,
  chompKeep: boolean
) {
  if (comment && chompKeep) comment = comment.replace(/^\n+/, '')
  if (comment) {
    const ic = indentComment(commentString(comment), indent)
    lines.push(ic.trimStart()) // Avoid double indent on first line
  }
}
eemeli-yaml-086fa6b/src/stringify/stringifyComment.ts000066400000000000000000000013211511277410200230430ustar00rootroot00000000000000/**
 * Stringifies a comment.
 *
 * Empty comment lines are left empty,
 * lines consisting of a single space are replaced by `#`,
 * and all other lines are prefixed with a `#`.
 */
export const stringifyComment = (str: string) =>
  str.replace(/^(?!$)(?: $)?/gm, '#')

export function indentComment(comment: string, indent: string) {
  if (/^\n+$/.test(comment)) return comment.substring(1)
  return indent ? comment.replace(/^(?! *$)/gm, indent) : comment
}

export const lineComment = (str: string, indent: string, comment: string) =>
  str.endsWith('\n')
    ? indentComment(comment, indent)
    : comment.includes('\n')
      ? '\n' + indentComment(comment, indent)
      : (str.endsWith(' ') ? '' : ' ') + comment
eemeli-yaml-086fa6b/src/stringify/stringifyDocument.ts000066400000000000000000000054121511277410200232240ustar00rootroot00000000000000import type { Document } from '../doc/Document.ts'
import { isNode } from '../nodes/identity.ts'
import type { Node } from '../nodes/Node.ts'
import type { ToStringOptions } from '../options.ts'
import {
  createStringifyContext,
  stringify,
  type StringifyContext
} from './stringify.ts'
import { indentComment, lineComment } from './stringifyComment.ts'

export function stringifyDocument(
  doc: Readonly>,
  options: ToStringOptions
) {
  const lines: string[] = []
  let hasDirectives = options.directives === true
  if (options.directives !== false && doc.directives) {
    const dir = doc.directives.toString(doc)
    if (dir) {
      lines.push(dir)
      hasDirectives = true
    } else if (doc.directives.docStart) hasDirectives = true
  }
  if (hasDirectives) lines.push('---')

  const ctx: StringifyContext = createStringifyContext(doc, options)
  const { commentString } = ctx.options

  if (doc.commentBefore) {
    if (lines.length !== 1) lines.unshift('')
    const cs = commentString(doc.commentBefore)
    lines.unshift(indentComment(cs, ''))
  }

  let chompKeep = false
  let contentComment = null
  if (doc.contents) {
    if (isNode(doc.contents)) {
      if (doc.contents.spaceBefore && hasDirectives) lines.push('')
      if (doc.contents.commentBefore) {
        const cs = commentString(doc.contents.commentBefore)
        lines.push(indentComment(cs, ''))
      }
      // top-level block scalars need to be indented if followed by a comment
      ctx.forceBlockIndent = !!doc.comment
      contentComment = doc.contents.comment
    }
    const onChompKeep = contentComment ? undefined : () => (chompKeep = true)
    let body = stringify(
      doc.contents,
      ctx,
      () => (contentComment = null),
      onChompKeep
    )
    if (contentComment)
      body += lineComment(body, '', commentString(contentComment))
    if (
      (body[0] === '|' || body[0] === '>') &&
      lines[lines.length - 1] === '---'
    ) {
      // Top-level block scalars with a preceding doc marker ought to use the
      // same line for their header.
      lines[lines.length - 1] = `--- ${body}`
    } else lines.push(body)
  } else {
    lines.push(stringify(doc.contents, ctx))
  }
  if (doc.directives?.docEnd) {
    if (doc.comment) {
      const cs = commentString(doc.comment)
      if (cs.includes('\n')) {
        lines.push('...')
        lines.push(indentComment(cs, ''))
      } else {
        lines.push(`... ${cs}`)
      }
    } else {
      lines.push('...')
    }
  } else {
    let dc = doc.comment
    if (dc && chompKeep) dc = dc.replace(/^\n+/, '')
    if (dc) {
      if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
        lines.push('')
      lines.push(indentComment(commentString(dc), ''))
    }
  }
  return lines.join('\n') + '\n'
}
eemeli-yaml-086fa6b/src/stringify/stringifyNumber.ts000066400000000000000000000013101511277410200226670ustar00rootroot00000000000000import type { Scalar } from '../nodes/Scalar.ts'

export function stringifyNumber({
  format,
  minFractionDigits,
  tag,
  value
}: Scalar): string {
  if (typeof value === 'bigint') return String(value)
  const num = typeof value === 'number' ? value : Number(value)
  if (!isFinite(num)) return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf'
  let n = Object.is(value, -0) ? '-0' : JSON.stringify(value)
  if (
    !format &&
    minFractionDigits &&
    (!tag || tag === 'tag:yaml.org,2002:float') &&
    /^\d/.test(n)
  ) {
    let i = n.indexOf('.')
    if (i < 0) {
      i = n.length
      n += '.'
    }
    let d = minFractionDigits - (n.length - i - 1)
    while (d-- > 0) n += '0'
  }
  return n
}
eemeli-yaml-086fa6b/src/stringify/stringifyPair.ts000066400000000000000000000113411511277410200223370ustar00rootroot00000000000000import { isCollection, isNode, isScalar, isSeq } from '../nodes/identity.ts'
import type { Pair } from '../nodes/Pair.ts'
import { Scalar } from '../nodes/Scalar.ts'
import type { StringifyContext } from './stringify.ts'
import { stringify } from './stringify.ts'
import { indentComment, lineComment } from './stringifyComment.ts'

export function stringifyPair(
  { key, value }: Readonly,
  ctx: StringifyContext,
  onComment?: () => void,
  onChompKeep?: () => void
) {
  const {
    allNullValues,
    doc,
    indent,
    indentStep,
    options: { commentString, indentSeq, simpleKeys }
  } = ctx
  let keyComment = (isNode(key) && key.comment) || null
  if (simpleKeys) {
    if (keyComment) {
      throw new Error('With simple keys, key nodes cannot have comments')
    }
    if (isCollection(key) || (!isNode(key) && typeof key === 'object')) {
      const msg = 'With simple keys, collection cannot be used as a key value'
      throw new Error(msg)
    }
  }
  let explicitKey =
    !simpleKeys &&
    (!key ||
      (keyComment && value == null && !ctx.inFlow) ||
      isCollection(key) ||
      (isScalar(key)
        ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL
        : typeof key === 'object'))

  ctx = Object.assign({}, ctx, {
    allNullValues: false,
    implicitKey: !explicitKey && (simpleKeys || !allNullValues),
    indent: indent + indentStep
  })
  let keyCommentDone = false
  let chompKeep = false
  let str = stringify(
    key,
    ctx,
    () => (keyCommentDone = true),
    () => (chompKeep = true)
  )

  if (!explicitKey && !ctx.inFlow && str.length > 1024) {
    if (simpleKeys)
      throw new Error(
        'With simple keys, single line scalar must not span more than 1024 characters'
      )
    explicitKey = true
  }

  if (ctx.inFlow) {
    if (allNullValues || value == null) {
      if (keyCommentDone && onComment) onComment()
      return str === '' ? '?' : explicitKey ? `? ${str}` : str
    }
  } else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
    str = `? ${str}`
    if (keyComment && !keyCommentDone) {
      str += lineComment(str, ctx.indent, commentString(keyComment))
    } else if (chompKeep && onChompKeep) onChompKeep()
    return str
  }

  if (keyCommentDone) keyComment = null
  if (explicitKey) {
    if (keyComment)
      str += lineComment(str, ctx.indent, commentString(keyComment))
    str = `? ${str}\n${indent}:`
  } else {
    str = `${str}:`
    if (keyComment)
      str += lineComment(str, ctx.indent, commentString(keyComment))
  }

  let vsb, vcb, valueComment
  if (isNode(value)) {
    vsb = !!value.spaceBefore
    vcb = value.commentBefore
    valueComment = value.comment
  } else {
    vsb = false
    vcb = null
    valueComment = null
    if (value && typeof value === 'object') value = doc.createNode(value)
  }
  ctx.implicitKey = false
  if (!explicitKey && !keyComment && isScalar(value))
    ctx.indentAtStart = str.length + 1
  chompKeep = false
  if (
    !indentSeq &&
    indentStep.length >= 2 &&
    !ctx.inFlow &&
    !explicitKey &&
    isSeq(value) &&
    !value.flow &&
    !value.tag &&
    !value.anchor
  ) {
    // If indentSeq === false, consider '- ' as part of indentation where possible
    ctx.indent = ctx.indent.substring(2)
  }

  let valueCommentDone = false
  const valueStr = stringify(
    value,
    ctx,
    () => (valueCommentDone = true),
    () => (chompKeep = true)
  )
  let ws = ' '
  if (keyComment || vsb || vcb) {
    ws = vsb ? '\n' : ''
    if (vcb) {
      const cs = commentString(vcb)
      ws += `\n${indentComment(cs, ctx.indent)}`
    }
    if (valueStr === '' && !ctx.inFlow) {
      if (ws === '\n' && valueComment) ws = '\n\n'
    } else {
      ws += `\n${ctx.indent}`
    }
  } else if (!explicitKey && isCollection(value)) {
    const vs0 = valueStr[0]
    const nl0 = valueStr.indexOf('\n')
    const hasNewline = nl0 !== -1
    const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0
    if (hasNewline || !flow) {
      let hasPropsLine = false
      if (hasNewline && (vs0 === '&' || vs0 === '!')) {
        let sp0 = valueStr.indexOf(' ')
        if (
          vs0 === '&' &&
          sp0 !== -1 &&
          sp0 < nl0 &&
          valueStr[sp0 + 1] === '!'
        ) {
          sp0 = valueStr.indexOf(' ', sp0 + 1)
        }
        if (sp0 === -1 || nl0 < sp0) hasPropsLine = true
      }
      if (!hasPropsLine) ws = `\n${ctx.indent}`
    }
  } else if (valueStr === '' || valueStr[0] === '\n') {
    ws = ''
  }
  str += ws + valueStr

  if (ctx.inFlow) {
    if (valueCommentDone && onComment) onComment()
  } else if (valueComment && !valueCommentDone) {
    str += lineComment(str, ctx.indent, commentString(valueComment))
  } else if (chompKeep && onChompKeep) {
    onChompKeep()
  }

  return str
}
eemeli-yaml-086fa6b/src/stringify/stringifyString.ts000066400000000000000000000273651511277410200227270ustar00rootroot00000000000000import { Scalar } from '../nodes/Scalar.ts'
import type { CollectionTag, ScalarTag } from '../schema/types.ts'
import {
  FOLD_BLOCK,
  FOLD_FLOW,
  FOLD_QUOTED,
  foldFlowLines,
  type FoldOptions
} from './foldFlowLines.ts'
import type { StringifyContext } from './stringify.ts'

interface StringifyScalar {
  value: string
  comment?: string | null
  type?: string
}

const getFoldOptions = (
  ctx: StringifyContext,
  isBlock: boolean
): FoldOptions => ({
  indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,
  lineWidth: ctx.options.lineWidth,
  minContentWidth: ctx.options.minContentWidth
})

// Also checks for lines starting with %, as parsing the output as YAML 1.1 will
// presume that's starting a new document.
const containsDocumentMarker = (str: string) => /^(%|---|\.\.\.)/m.test(str)

function lineLengthOverLimit(
  str: string,
  lineWidth: number,
  indentLength: number
) {
  if (!lineWidth || lineWidth < 0) return false
  const limit = lineWidth - indentLength
  const strLen = str.length
  if (strLen <= limit) return false
  for (let i = 0, start = 0; i < strLen; ++i) {
    if (str[i] === '\n') {
      if (i - start > limit) return true
      start = i + 1
      if (strLen - start <= limit) return false
    }
  }
  return true
}

function doubleQuotedString(value: string, ctx: StringifyContext) {
  const json = JSON.stringify(value)
  if (ctx.options.doubleQuotedAsJSON) return json

  const { implicitKey } = ctx
  const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength
  const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '')
  let str = ''
  let start = 0
  for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
    if (ch === ' ' && json[i + 1] === '\\' && json[i + 2] === 'n') {
      // space before newline needs to be escaped to not be folded
      str += json.slice(start, i) + '\\ '
      i += 1
      start = i
      ch = '\\'
    }
    if (ch === '\\')
      switch (json[i + 1]) {
        case 'u':
          {
            str += json.slice(start, i)
            const code = json.substr(i + 2, 4)
            switch (code) {
              case '0000':
                str += '\\0'
                break
              case '0007':
                str += '\\a'
                break
              case '000b':
                str += '\\v'
                break
              case '001b':
                str += '\\e'
                break
              case '0085':
                str += '\\N'
                break
              case '00a0':
                str += '\\_'
                break
              case '2028':
                str += '\\L'
                break
              case '2029':
                str += '\\P'
                break
              default:
                if (code.substr(0, 2) === '00') str += '\\x' + code.substr(2)
                else str += json.substr(i, 6)
            }
            i += 5
            start = i + 1
          }
          break
        case 'n':
          if (
            implicitKey ||
            json[i + 2] === '"' ||
            json.length < minMultiLineLength
          ) {
            i += 1
          } else {
            // folding will eat first newline
            str += json.slice(start, i) + '\n\n'
            while (
              json[i + 2] === '\\' &&
              json[i + 3] === 'n' &&
              json[i + 4] !== '"'
            ) {
              str += '\n'
              i += 2
            }
            str += indent
            // space after newline needs to be escaped to not be folded
            if (json[i + 2] === ' ') str += '\\'
            i += 1
            start = i + 1
          }
          break
        default:
          i += 1
      }
  }
  str = start ? str + json.slice(start) : json
  return implicitKey
    ? str
    : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false))
}

function singleQuotedString(value: string, ctx: StringifyContext) {
  if (
    ctx.options.singleQuote === false ||
    (ctx.implicitKey && value.includes('\n')) ||
    /[ \t]\n|\n[ \t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline
  )
    return doubleQuotedString(value, ctx)

  const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '')
  const res =
    "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'"
  return ctx.implicitKey
    ? res
    : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false))
}

function quotedString(value: string, ctx: StringifyContext) {
  const { singleQuote } = ctx.options
  let qs
  if (singleQuote === false) qs = doubleQuotedString
  else {
    const hasDouble = value.includes('"')
    const hasSingle = value.includes("'")
    if (hasDouble && !hasSingle) qs = singleQuotedString
    else if (hasSingle && !hasDouble) qs = doubleQuotedString
    else qs = singleQuote ? singleQuotedString : doubleQuotedString
  }
  return qs(value, ctx)
}

// The negative lookbehind avoids a polynomial search,
// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind
let blockEndNewlines: RegExp
try {
  blockEndNewlines = new RegExp('(^|(? void,
  onChompKeep?: () => void
) {
  const { blockQuote, commentString, lineWidth } = ctx.options
  // 1. Block can't end in whitespace unless the last line is non-empty.
  // 2. Strings consisting of only whitespace are best rendered explicitly.
  if (!blockQuote || /\n[\t ]+$/.test(value)) {
    return quotedString(value, ctx)
  }

  const indent =
    ctx.indent ||
    (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '')
  const literal =
    blockQuote === 'literal'
      ? true
      : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED
        ? false
        : type === Scalar.BLOCK_LITERAL
          ? true
          : !lineLengthOverLimit(value, lineWidth, indent.length)
  if (!value) return literal ? '|\n' : '>\n'

  // determine chomping from whitespace at value end
  let chomp: '' | '-' | '+'
  let endStart: number
  for (endStart = value.length; endStart > 0; --endStart) {
    const ch = value[endStart - 1]
    if (ch !== '\n' && ch !== '\t' && ch !== ' ') break
  }
  let end = value.substring(endStart)
  const endNlPos = end.indexOf('\n')
  if (endNlPos === -1) {
    chomp = '-' // strip
  } else if (value === end || endNlPos !== end.length - 1) {
    chomp = '+' // keep
    if (onChompKeep) onChompKeep()
  } else {
    chomp = '' // clip
  }
  if (end) {
    value = value.slice(0, -end.length)
    if (end[end.length - 1] === '\n') end = end.slice(0, -1)
    end = end.replace(blockEndNewlines, `$&${indent}`)
  }

  // determine indent indicator from whitespace at value start
  let startWithSpace = false
  let startEnd: number
  let startNlPos = -1
  for (startEnd = 0; startEnd < value.length; ++startEnd) {
    const ch = value[startEnd]
    if (ch === ' ') startWithSpace = true
    else if (ch === '\n') startNlPos = startEnd
    else break
  }
  let start = value.substring(
    0,
    startNlPos < startEnd ? startNlPos + 1 : startEnd
  )
  if (start) {
    value = value.substring(start.length)
    start = start.replace(/\n+/g, `$&${indent}`)
  }

  const indentSize = indent ? '2' : '1' // root is at -1
  // Leading | or > is added later
  let header = (startWithSpace ? indentSize : '') + chomp
  if (comment) {
    header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' '))
    if (onComment) onComment()
  }

  if (!literal) {
    const foldedValue = value
      .replace(/\n+/g, '\n$&')
      .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
      //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
      .replace(/\n+/g, `$&${indent}`)
    let literalFallback = false
    const foldOptions = getFoldOptions(ctx, true)
    if (blockQuote !== 'folded' && type !== Scalar.BLOCK_FOLDED) {
      foldOptions.onOverflow = () => {
        literalFallback = true
      }
    }
    const body = foldFlowLines(
      `${start}${foldedValue}${end}`,
      indent,
      FOLD_BLOCK,
      foldOptions
    )
    if (!literalFallback) return `>${header}\n${indent}${body}`
  }

  value = value.replace(/\n+/g, `$&${indent}`)
  return `|${header}\n${indent}${start}${value}${end}`
}

function plainString(
  item: StringifyScalar,
  ctx: StringifyContext,
  onComment?: () => void,
  onChompKeep?: () => void
) {
  const { type, value } = item
  const { actualString, implicitKey, indent, indentStep, inFlow } = ctx
  if (
    (implicitKey && value.includes('\n')) ||
    (inFlow && /[[\]{},]/.test(value))
  ) {
    return quotedString(value, ctx)
  }
  if (
    /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(
      value
    )
  ) {
    // not allowed:
    // - '-' or '?'
    // - start with an indicator character (except [?:-]) or /[?-] /
    // - '\n ', ': ' or ' \n' anywhere
    // - '#' not preceded by a non-space char
    // - end with ' ' or ':'
    return implicitKey || inFlow || !value.includes('\n')
      ? quotedString(value, ctx)
      : blockString(item, ctx, onComment, onChompKeep)
  }
  if (
    !implicitKey &&
    !inFlow &&
    type !== Scalar.PLAIN &&
    value.includes('\n')
  ) {
    // Where allowed & type not set explicitly, prefer block style for multiline strings
    return blockString(item, ctx, onComment, onChompKeep)
  }
  if (containsDocumentMarker(value)) {
    if (indent === '') {
      ctx.forceBlockIndent = true
      return blockString(item, ctx, onComment, onChompKeep)
    } else if (implicitKey && indent === indentStep) {
      return quotedString(value, ctx)
    }
  }
  const str = value.replace(/\n+/g, `$&\n${indent}`)
  // Verify that output will be parsed as a string, as e.g. plain numbers and
  // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),
  // and others in v1.1.
  if (actualString) {
    const test = (tag: CollectionTag | ScalarTag) =>
      tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str)
    const { compat, tags } = ctx.doc.schema
    if (tags.some(test) || compat?.some(test)) return quotedString(value, ctx)
  }
  return implicitKey
    ? str
    : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false))
}

export function stringifyString(
  item: Scalar | StringifyScalar,
  ctx: StringifyContext,
  onComment?: () => void,
  onChompKeep?: () => void
): string {
  const { implicitKey, inFlow } = ctx
  const ss: StringifyScalar =
    typeof item.value === 'string'
      ? (item as StringifyScalar)
      : Object.assign({}, item, { value: String(item.value) })

  let { type } = item
  if (type !== Scalar.QUOTE_DOUBLE) {
    // force double quotes on control characters & unpaired surrogates
    if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value))
      type = Scalar.QUOTE_DOUBLE
  }

  const _stringify = (_type: string | undefined) => {
    switch (_type) {
      case Scalar.BLOCK_FOLDED:
      case Scalar.BLOCK_LITERAL:
        return implicitKey || inFlow
          ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers
          : blockString(ss, ctx, onComment, onChompKeep)
      case Scalar.QUOTE_DOUBLE:
        return doubleQuotedString(ss.value, ctx)
      case Scalar.QUOTE_SINGLE:
        return singleQuotedString(ss.value, ctx)
      case Scalar.PLAIN:
        return plainString(ss, ctx, onComment, onChompKeep)
      default:
        return null
    }
  }

  let res = _stringify(type)
  if (res === null) {
    const { defaultKeyType, defaultStringType } = ctx.options
    const t = (implicitKey && defaultKeyType) || defaultStringType
    res = _stringify(t)
    if (res === null) throw new Error(`Unsupported default string type ${t}`)
  }
  return res
}
eemeli-yaml-086fa6b/src/test-events.ts000066400000000000000000000075141511277410200177570ustar00rootroot00000000000000import type { Document } from './doc/Document.ts'
import {
  isAlias,
  isCollection,
  isMap,
  isNode,
  isPair,
  isScalar,
  isSeq
} from './nodes/identity.ts'
import type { Node, ParsedNode } from './nodes/Node.ts'
import type { Pair } from './nodes/Pair.ts'
import { parseAllDocuments } from './public-api.ts'
import { visit } from './visit.ts'

const scalarChar: Record = {
  BLOCK_FOLDED: '>',
  BLOCK_LITERAL: '|',
  PLAIN: ':',
  QUOTE_DOUBLE: '"',
  QUOTE_SINGLE: "'"
}

function anchorExists(doc: Document, anchor: string): boolean {
  let found = false
  visit(doc, {
    Value(_key: unknown, node: Node) {
      if (node.anchor === anchor) {
        found = true
        return visit.BREAK
      }
    }
  })
  return found
}

// test harness for yaml-test-suite event tests
export function testEvents(src: string) {
  const docs = parseAllDocuments(src)
  const errDoc = docs.find(doc => doc.errors.length > 0)
  const error = errDoc ? errDoc.errors[0].message : null
  const events = ['+STR']
  try {
    for (let i = 0; i < docs.length; ++i) {
      const doc = docs[i]
      let root = doc.contents
      if (Array.isArray(root)) root = root[0]
      const [rootStart] = doc.range || [0]
      const error = doc.errors[0]
      if (error && (!error.pos || error.pos[0] < rootStart)) throw new Error()
      let docStart = '+DOC'
      if (doc.directives.docStart) docStart += ' ---'
      else if (
        doc.contents &&
        doc.contents.range[2] === doc.contents.range[0] &&
        !doc.contents.anchor &&
        !doc.contents.tag
      )
        continue
      events.push(docStart)
      addEvents(events, doc, error?.pos[0] ?? -1, root)

      let docEnd = '-DOC'
      if (doc.directives.docEnd) docEnd += ' ...'
      events.push(docEnd)
    }
  } catch (e) {
    return { events, error: error ?? e }
  }
  events.push('-STR')
  return { events, error }
}

function addEvents(
  events: string[],
  doc: Document,
  errPos: number,
  node: ParsedNode | Pair | null
) {
  if (!node) {
    events.push('=VAL :')
    return
  }
  if (errPos !== -1 && isNode(node) && node.range[0] >= errPos)
    throw new Error()
  let props = ''
  let anchor = isScalar(node) || isCollection(node) ? node.anchor : undefined
  if (anchor) {
    if (/\d$/.test(anchor)) {
      const alt = anchor.replace(/\d$/, '')
      if (anchorExists(doc, alt)) anchor = alt
    }
    props = ` &${anchor}`
  }
  if (isNode(node) && node.tag) props += ` <${node.tag}>`

  if (isMap(node)) {
    const ev = node.flow ? '+MAP {}' : '+MAP'
    events.push(`${ev}${props}`)
    node.items.forEach(({ key, value }) => {
      addEvents(events, doc, errPos, key)
      addEvents(events, doc, errPos, value)
    })
    events.push('-MAP')
  } else if (isSeq(node)) {
    const ev = node.flow ? '+SEQ []' : '+SEQ'
    events.push(`${ev}${props}`)
    node.items.forEach(item => {
      addEvents(events, doc, errPos, item)
    })
    events.push('-SEQ')
  } else if (isPair(node)) {
    events.push(`+MAP${props}`)
    addEvents(events, doc, errPos, node.key)
    addEvents(events, doc, errPos, node.value)
    events.push('-MAP')
  } else if (isAlias(node)) {
    let alias = node.source
    if (alias && /\d$/.test(alias)) {
      const alt = alias.replace(/\d$/, '')
      if (anchorExists(doc, alt)) alias = alt
    }
    events.push(`=ALI${props} *${alias}`)
  } else {
    const scalar = scalarChar[String(node.type)]
    if (!scalar) throw new Error(`Unexpected node type ${node.type}`)
    const value = node.source
      .replace(/\\/g, '\\\\')
      .replace(/\0/g, '\\0')
      .replace(/\x07/g, '\\a')
      .replace(/\x08/g, '\\b')
      .replace(/\t/g, '\\t')
      .replace(/\n/g, '\\n')
      .replace(/\v/g, '\\v')
      .replace(/\f/g, '\\f')
      .replace(/\r/g, '\\r')
      .replace(/\x1b/g, '\\e')
    events.push(`=VAL${props} ${scalar}${value}`)
  }
}
eemeli-yaml-086fa6b/src/util.ts000066400000000000000000000015431511277410200164470ustar00rootroot00000000000000export { createNode } from './doc/createNode.ts'
export type { CreateNodeContext } from './doc/createNode.ts'
export { debug, warn } from './log.ts'
export type { LogLevelId } from './log.ts'
export { createPair } from './nodes/Pair.ts'
export { toJS } from './nodes/toJS.ts'
export type { ToJSContext } from './nodes/toJS.ts'
export { findPair } from './nodes/YAMLMap.ts'
export { map as mapTag } from './schema/common/map.ts'
export { seq as seqTag } from './schema/common/seq.ts'
export { string as stringTag } from './schema/common/string.ts'
export { foldFlowLines } from './stringify/foldFlowLines.ts'
export type { FoldOptions } from './stringify/foldFlowLines.ts'
export type { StringifyContext } from './stringify/stringify.ts'
export { stringifyNumber } from './stringify/stringifyNumber.ts'
export { stringifyString } from './stringify/stringifyString.ts'
eemeli-yaml-086fa6b/src/visit.ts000066400000000000000000000253351511277410200166350ustar00rootroot00000000000000import type { Document } from './doc/Document.ts'
import type { Alias } from './nodes/Alias.ts'
import {
  isAlias,
  isCollection,
  isDocument,
  isMap,
  isNode,
  isPair,
  isScalar,
  isSeq
} from './nodes/identity.ts'
import type { Node } from './nodes/Node.ts'
import type { Pair } from './nodes/Pair.ts'
import type { Scalar } from './nodes/Scalar.ts'
import type { YAMLMap } from './nodes/YAMLMap.ts'
import type { YAMLSeq } from './nodes/YAMLSeq.ts'

const BREAK = Symbol('break visit')
const SKIP = Symbol('skip children')
const REMOVE = Symbol('remove node')

export type visitorFn = (
  key: number | 'key' | 'value' | null,
  node: T,
  path: readonly (Document | Node | Pair)[]
) => void | symbol | number | Node | Pair

export type visitor =
  | visitorFn
  | {
      Alias?: visitorFn
      Collection?: visitorFn
      Map?: visitorFn
      Node?: visitorFn
      Pair?: visitorFn
      Scalar?: visitorFn
      Seq?: visitorFn
      Value?: visitorFn
    }

export type asyncVisitorFn = (
  key: number | 'key' | 'value' | null,
  node: T,
  path: readonly (Document | Node | Pair)[]
) =>
  | void
  | symbol
  | number
  | Node
  | Pair
  | Promise

export type asyncVisitor =
  | asyncVisitorFn
  | {
      Alias?: asyncVisitorFn
      Collection?: asyncVisitorFn
      Map?: asyncVisitorFn
      Node?: asyncVisitorFn
      Pair?: asyncVisitorFn
      Scalar?: asyncVisitorFn
      Seq?: asyncVisitorFn
      Value?: asyncVisitorFn
    }

/**
 * Apply a visitor to an AST node or document.
 *
 * Walks through the tree (depth-first) starting from `node`, calling a
 * `visitor` function with three arguments:
 *   - `key`: For sequence values and map `Pair`, the node's index in the
 *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
 *     `null` for the root node.
 *   - `node`: The current node.
 *   - `path`: The ancestry of the current node.
 *
 * The return value of the visitor may be used to control the traversal:
 *   - `undefined` (default): Do nothing and continue
 *   - `visit.SKIP`: Do not visit the children of this node, continue with next
 *     sibling
 *   - `visit.BREAK`: Terminate traversal completely
 *   - `visit.REMOVE`: Remove the current node, then continue with the next one
 *   - `Node`: Replace the current node, then continue by visiting it
 *   - `number`: While iterating the items of a sequence or map, set the index
 *     of the next step. This is useful especially if the index of the current
 *     node has changed.
 *
 * If `visitor` is a single function, it will be called with all values
 * encountered in the tree, including e.g. `null` values. Alternatively,
 * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
 * `Alias` and `Scalar` node. To define the same visitor function for more than
 * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
 * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
 * specific defined one will be used for each node.
 */
export function visit(node: Node | Document | null, visitor: visitor) {
  const visitor_ = initVisitor(visitor)
  if (isDocument(node)) {
    const cd = visit_(null, node.contents, visitor_, Object.freeze([node]))
    if (cd === REMOVE) node.contents = null
  } else visit_(null, node, visitor_, Object.freeze([]))
}

// Without the `as symbol` casts, TS declares these in the `visit`
// namespace using `var`, but then complains about that because
// `unique symbol` must be `const`.

/** Terminate visit traversal completely */
visit.BREAK = BREAK as symbol

/** Do not visit the children of the current node */
visit.SKIP = SKIP as symbol

/** Remove the current node */
visit.REMOVE = REMOVE as symbol

function visit_(
  key: number | 'key' | 'value' | null,
  node: unknown,
  visitor: visitor,
  path: readonly (Document | Node | Pair)[]
): number | symbol | void {
  const ctrl = callVisitor(key, node, visitor, path)

  if (isNode(ctrl) || isPair(ctrl)) {
    replaceNode(key, path, ctrl)
    return visit_(key, ctrl, visitor, path)
  }

  if (typeof ctrl !== 'symbol') {
    if (isCollection(node)) {
      path = Object.freeze(path.concat(node))
      for (let i = 0; i < node.items.length; ++i) {
        const ci = visit_(i, node.items[i], visitor, path)
        if (typeof ci === 'number') i = ci - 1
        else if (ci === BREAK) return BREAK
        else if (ci === REMOVE) {
          node.items.splice(i, 1)
          i -= 1
        }
      }
    } else if (isPair(node)) {
      path = Object.freeze(path.concat(node))
      const ck = visit_('key', node.key, visitor, path)
      if (ck === BREAK) return BREAK
      else if (ck === REMOVE) node.key = null
      const cv = visit_('value', node.value, visitor, path)
      if (cv === BREAK) return BREAK
      else if (cv === REMOVE) node.value = null
    }
  }

  return ctrl
}

/**
 * Apply an async visitor to an AST node or document.
 *
 * Walks through the tree (depth-first) starting from `node`, calling a
 * `visitor` function with three arguments:
 *   - `key`: For sequence values and map `Pair`, the node's index in the
 *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
 *     `null` for the root node.
 *   - `node`: The current node.
 *   - `path`: The ancestry of the current node.
 *
 * The return value of the visitor may be used to control the traversal:
 *   - `Promise`: Must resolve to one of the following values
 *   - `undefined` (default): Do nothing and continue
 *   - `visit.SKIP`: Do not visit the children of this node, continue with next
 *     sibling
 *   - `visit.BREAK`: Terminate traversal completely
 *   - `visit.REMOVE`: Remove the current node, then continue with the next one
 *   - `Node`: Replace the current node, then continue by visiting it
 *   - `number`: While iterating the items of a sequence or map, set the index
 *     of the next step. This is useful especially if the index of the current
 *     node has changed.
 *
 * If `visitor` is a single function, it will be called with all values
 * encountered in the tree, including e.g. `null` values. Alternatively,
 * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
 * `Alias` and `Scalar` node. To define the same visitor function for more than
 * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
 * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
 * specific defined one will be used for each node.
 */
export async function visitAsync(
  node: Node | Document | null,
  visitor: asyncVisitor
) {
  const visitor_ = initVisitor(visitor)
  if (isDocument(node)) {
    const cd = await visitAsync_(
      null,
      node.contents,
      visitor_,
      Object.freeze([node])
    )
    if (cd === REMOVE) node.contents = null
  } else await visitAsync_(null, node, visitor_, Object.freeze([]))
}

// Without the `as symbol` casts, TS declares these in the `visit`
// namespace using `var`, but then complains about that because
// `unique symbol` must be `const`.

/** Terminate visit traversal completely */
visitAsync.BREAK = BREAK as symbol

/** Do not visit the children of the current node */
visitAsync.SKIP = SKIP as symbol

/** Remove the current node */
visitAsync.REMOVE = REMOVE as symbol

async function visitAsync_(
  key: number | 'key' | 'value' | null,
  node: unknown,
  visitor: asyncVisitor,
  path: readonly (Document | Node | Pair)[]
): Promise {
  const ctrl = await callVisitor(key, node, visitor, path)

  if (isNode(ctrl) || isPair(ctrl)) {
    replaceNode(key, path, ctrl)
    return visitAsync_(key, ctrl, visitor, path)
  }

  if (typeof ctrl !== 'symbol') {
    if (isCollection(node)) {
      path = Object.freeze(path.concat(node))
      for (let i = 0; i < node.items.length; ++i) {
        const ci = await visitAsync_(i, node.items[i], visitor, path)
        if (typeof ci === 'number') i = ci - 1
        else if (ci === BREAK) return BREAK
        else if (ci === REMOVE) {
          node.items.splice(i, 1)
          i -= 1
        }
      }
    } else if (isPair(node)) {
      path = Object.freeze(path.concat(node))
      const ck = await visitAsync_('key', node.key, visitor, path)
      if (ck === BREAK) return BREAK
      else if (ck === REMOVE) node.key = null
      const cv = await visitAsync_('value', node.value, visitor, path)
      if (cv === BREAK) return BREAK
      else if (cv === REMOVE) node.value = null
    }
  }

  return ctrl
}

function initVisitor(visitor: V) {
  if (
    typeof visitor === 'object' &&
    (visitor.Collection || visitor.Node || visitor.Value)
  ) {
    return Object.assign(
      {
        Alias: visitor.Node,
        Map: visitor.Node,
        Scalar: visitor.Node,
        Seq: visitor.Node
      },
      visitor.Value && {
        Map: visitor.Value,
        Scalar: visitor.Value,
        Seq: visitor.Value
      },
      visitor.Collection && {
        Map: visitor.Collection,
        Seq: visitor.Collection
      },
      visitor
    )
  }

  return visitor
}

function callVisitor(
  key: number | 'key' | 'value' | null,
  node: unknown,
  visitor: visitor,
  path: readonly (Document | Node | Pair)[]
): ReturnType>
function callVisitor(
  key: number | 'key' | 'value' | null,
  node: unknown,
  visitor: asyncVisitor,
  path: readonly (Document | Node | Pair)[]
): ReturnType>
function callVisitor(
  key: number | 'key' | 'value' | null,
  node: unknown,
  visitor: visitor | asyncVisitor,
  path: readonly (Document | Node | Pair)[]
): ReturnType> | ReturnType> {
  if (typeof visitor === 'function') return visitor(key, node, path)
  if (isMap(node)) return visitor.Map?.(key, node, path)
  if (isSeq(node)) return visitor.Seq?.(key, node, path)
  if (isPair(node)) return visitor.Pair?.(key, node, path)
  if (isScalar(node)) return visitor.Scalar?.(key, node, path)
  if (isAlias(node)) return visitor.Alias?.(key, node, path)
  return undefined
}

function replaceNode(
  key: number | 'key' | 'value' | null,
  path: readonly (Document | Node | Pair)[],
  node: Node | Pair
): number | symbol | void {
  const parent = path[path.length - 1]
  if (isCollection(parent)) {
    parent.items[key as number] = node
  } else if (isPair(parent)) {
    if (key === 'key') parent.key = node
    else parent.value = node
  } else if (isDocument(parent)) {
    parent.contents = node as Node
  } else {
    const pt = isAlias(parent) ? 'alias' : 'scalar'
    throw new Error(`Cannot replace node with ${pt} parent`)
  }
}
eemeli-yaml-086fa6b/tests/000077500000000000000000000000001511277410200154725ustar00rootroot00000000000000eemeli-yaml-086fa6b/tests/_utils.ts000066400000000000000000000011651511277410200173440ustar00rootroot00000000000000/** Trim leading whitespace from each line */
export function source(
  strings: TemplateStringsArray,
  ...expressions: unknown[]
) {
  // concatenate
  let res = strings[0]
  for (let i = 1; i < strings.length; ++i)
    res += String(expressions[i]) + strings[i + 1]

  // remove trailing whitespace + initial newline
  res = res.replace(/[^\S\n]+$/gm, '').replace(/^\n/, '')

  // remove the shortest leading indentation from each line
  const match = res.match(/^[^\S\n]*(?=\S)/gm)
  const indent = match && Math.min(...match.map(el => el.length))
  return indent ? res.replace(new RegExp(`^.{${indent}}`, 'gm'), '') : res
}
eemeli-yaml-086fa6b/tests/artifacts/000077500000000000000000000000001511277410200174525ustar00rootroot00000000000000eemeli-yaml-086fa6b/tests/artifacts/cli-singlequote.mjs000066400000000000000000000001731511277410200232720ustar00rootroot00000000000000/** @type {import('../../src/index').visitor} */
export default {
  Scalar(_, node) {
    node.type = 'QUOTE_SINGLE'
  }
}
eemeli-yaml-086fa6b/tests/artifacts/cli-unstyle.cjs000066400000000000000000000002741511277410200224260ustar00rootroot00000000000000/** @type {import('../../src/index').visitor} */
module.exports = {
  Collection(_, node) {
    delete node.flow
  },
  Scalar(_, node) {
    delete node.format
    delete node.type
  }
}
eemeli-yaml-086fa6b/tests/artifacts/pr104/000077500000000000000000000000001511277410200203205ustar00rootroot00000000000000eemeli-yaml-086fa6b/tests/artifacts/pr104/billion-laughs.yml000066400000000000000000000006141511277410200237550ustar00rootroot00000000000000a: &a [lol, lol, lol, lol, lol, lol, lol, lol, lol]
b: &b [*a, *a, *a, *a, *a, *a, *a, *a, *a]
c: &c [*b, *b, *b, *b, *b, *b, *b, *b, *b]
d: &d [*c, *c, *c, *c, *c, *c, *c, *c, *c]
e: &e [*d, *d, *d, *d, *d, *d, *d, *d, *d]
f: &f [*e, *e, *e, *e, *e, *e, *e, *e, *e]
g: &g [*f, *f, *f, *f, *f, *f, *f, *f, *f]
h: &h [*g, *g, *g, *g, *g, *g, *g, *g, *g]
i: &i [*h, *h, *h, *h, *h, *h, *h, *h, *h]
eemeli-yaml-086fa6b/tests/artifacts/pr104/case1.yml000066400000000000000000000114311511277410200220370ustar00rootroot00000000000000# From https://github.com/nodeca/js-yaml/blob/a567ef3c6e61eb319f0bfc2671d91061afb01235/test/issues/0475-case1.yml

? - - &id057
      - &id055
        - &id053
          - &id051
            - &id049
              - &id047
                - &id045
                  - &id043
                    - &id041
                      - &id039
                        - &id037
                          - &id035
                            - &id033
                              - &id031
                                - &id029
                                  - &id027
                                    - &id025
                                      - &id023
                                        - &id021
                                          - &id019
                                            - &id017
                                              - &id015
                                                - &id013
                                                  - &id011
                                                    - &id009
                                                      - &id007
                                                        - &id005
                                                          - &id003
                                                            - &id001 [lol]
                                                            - &id002 [lol]
                                                          - &id004
                                                            - *id001
                                                            - *id002
                                                        - &id006
                                                          - *id003
                                                          - *id004
                                                      - &id008
                                                        - *id005
                                                        - *id006
                                                    - &id010
                                                      - *id007
                                                      - *id008
                                                  - &id012
                                                    - *id009
                                                    - *id010
                                                - &id014
                                                  - *id011
                                                  - *id012
                                              - &id016
                                                - *id013
                                                - *id014
                                            - &id018
                                              - *id015
                                              - *id016
                                          - &id020
                                            - *id017
                                            - *id018
                                        - &id022
                                          - *id019
                                          - *id020
                                      - &id024
                                        - *id021
                                        - *id022
                                    - &id026
                                      - *id023
                                      - *id024
                                  - &id028
                                    - *id025
                                    - *id026
                                - &id030
                                  - *id027
                                  - *id028
                              - &id032
                                - *id029
                                - *id030
                            - &id034
                              - *id031
                              - *id032
                          - &id036
                            - *id033
                            - *id034
                        - &id038
                          - *id035
                          - *id036
                      - &id040
                        - *id037
                        - *id038
                    - &id042
                      - *id039
                      - *id040
                  - &id044
                    - *id041
                    - *id042
                - &id046
                  - *id043
                  - *id044
              - &id048
                - *id045
                - *id046
            - &id050
              - *id047
              - *id048
          - &id052
            - *id049
            - *id050
        - &id054
          - *id051
          - *id052
      - &id056
        - *id053
        - *id054
    - &id058
      - *id055
      - *id056
  - - *id057
    - *id058
: key
eemeli-yaml-086fa6b/tests/artifacts/pr104/case2.yml000066400000000000000000000104371511277410200220450ustar00rootroot00000000000000# From https://github.com/nodeca/js-yaml/blob/a567ef3c6e61eb319f0bfc2671d91061afb01235/test/issues/0475-case2.yml

- &id057
  - &id055
    - &id053
      - &id051
        - &id049
          - &id047
            - &id045
              - &id043
                - &id041
                  - &id039
                    - &id037
                      - &id035
                        - &id033
                          - &id031
                            - &id029
                              - &id027
                                - &id025
                                  - &id023
                                    - &id021
                                      - &id019
                                        - &id017
                                          - &id015
                                            - &id013
                                              - &id011
                                                - &id009
                                                  - &id007
                                                    - &id005
                                                      - &id003
                                                        - &id001 [lol]
                                                        - &id002 [lol]
                                                      - &id004
                                                        - *id001
                                                        - *id002
                                                    - &id006
                                                      - *id003
                                                      - *id004
                                                  - &id008
                                                    - *id005
                                                    - *id006
                                                - &id010
                                                  - *id007
                                                  - *id008
                                              - &id012
                                                - *id009
                                                - *id010
                                            - &id014
                                              - *id011
                                              - *id012
                                          - &id016
                                            - *id013
                                            - *id014
                                        - &id018
                                          - *id015
                                          - *id016
                                      - &id020
                                        - *id017
                                        - *id018
                                    - &id022
                                      - *id019
                                      - *id020
                                  - &id024
                                    - *id021
                                    - *id022
                                - &id026
                                  - *id023
                                  - *id024
                              - &id028
                                - *id025
                                - *id026
                            - &id030
                              - *id027
                              - *id028
                          - &id032
                            - *id029
                            - *id030
                        - &id034
                          - *id031
                          - *id032
                      - &id036
                        - *id033
                        - *id034
                    - &id038
                      - *id035
                      - *id036
                  - &id040
                    - *id037
                    - *id038
                - &id042
                  - *id039
                  - *id040
              - &id044
                - *id041
                - *id042
            - &id046
              - *id043
              - *id044
          - &id048
            - *id045
            - *id046
        - &id050
          - *id047
          - *id048
      - &id052
        - *id049
        - *id050
    - &id054
      - *id051
      - *id052
  - &id056
    - *id053
    - *id054
- *id057 : 1
eemeli-yaml-086fa6b/tests/artifacts/pr104/quadratic.yml000066400000000000000000000007541511277410200230260ustar00rootroot00000000000000a: &a [lol, lol, lol, lol, lol, lol, lol, lol, lol]
b: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
c: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
d: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
e: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
f: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
g: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
h: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
i: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
j: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
k: [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]
eemeli-yaml-086fa6b/tests/artifacts/prettier-circleci-config.yml000066400000000000000000000035671511277410200250640ustar00rootroot00000000000000aliases:
  # Cache management
  - &restore_yarn_cache
    restore_cache:
      keys:
        - v1-yarn-cache

  - &save_yarn_cache
    save_cache:
      paths:
        - ~/.cache/yarn
      key: v1-yarn-cache

  - &restore_deps_cache
    restore_cache:
      keys:
        - v1-deps-cache-{{ checksum "yarn.lock" }}

  - &save_deps_cache
    save_cache:
      paths:
        - node_modules
      key: v1-yarn-deps-{{ checksum "yarn.lock" }}

  # Default
  - &defaults
    working_directory: ~/prettier
    docker:
      - image: circleci/node:9

version: 2
jobs:
  # Install dependencies and cache everything
  checkout_code:
    <<: *defaults
    steps:
      - checkout
      - *restore_yarn_cache
      - *restore_deps_cache
      - run: yarn install
      - run: yarn check-deps
      - *save_deps_cache
      - *save_yarn_cache
      - persist_to_workspace:
          root: .
          paths:
            - .

  # Create the production bundle and cache
  build_prod:
    <<: *defaults
    environment:
      NODE_ENV: production
    steps:
      - attach_workspace:
          at: ~/prettier
      - run: yarn build
      - persist_to_workspace:
          root: .
          paths:
            - dist
      - store_artifacts:
          path: ~/prettier/dist

  # Run tests on the production bundle
  test_prod_node4:
    <<: *defaults
    docker:
      - image: circleci/node:4
    steps:
      - attach_workspace:
          at: ~/prettier
      - run: yarn test:dist

  # Run tests on the production bundle
  test_prod_node9:
    <<: *defaults
    steps:
      - attach_workspace:
          at: ~/prettier
      - run: yarn test:dist

workflows:
  version: 2
  prod:
    jobs:
      - checkout_code
      - build_prod:
          requires:
            - checkout_code
      - test_prod_node4:
          requires:
            - build_prod
      - test_prod_node9:
          requires:
            - build_prod
eemeli-yaml-086fa6b/tests/cli.ts000066400000000000000000000165151511277410200166210ustar00rootroot00000000000000import { Readable } from 'stream'
import { cli } from 'yaml/cli'

const [major] = process.versions.node.split('.')
const skip = Number(major) < 20

;(skip ? describe.skip : describe)('CLI', () => {
  const stdout: unknown[] = []
  const stderr: unknown[] = []
  beforeAll(() => {
    jest.spyOn(global.console, 'log').mockImplementation(thing => {
      stdout.push(thing)
    })
    jest.spyOn(global.console, 'dir').mockImplementation(thing => {
      stdout.push(thing)
    })
    jest.spyOn(global.console, 'error').mockImplementation(thing => {
      stderr.push(thing)
    })
  })

  function ok(
    name: string,
    input: string,
    args: string[],
    output: unknown[],
    errors: unknown[] = []
  ) {
    test(name, done => {
      stdout.length = 0
      stderr.length = 0
      cli(
        Readable.from([input]),
        error => {
          try {
            expect(stdout).toMatchObject(output)
            expect(stderr).toMatchObject(errors)
            expect(error).toBeUndefined()
          } finally {
            done()
          }
        },
        args
      ).catch(done)
    })
  }

  function fail(
    name: string,
    input: string,
    args: string[],
    errors: unknown[]
  ) {
    test(name, done => {
      stderr.length = 0
      let doned = false
      cli(
        Readable.from([input]),
        error => {
          if (doned) return
          try {
            expect(stderr).toMatchObject(errors)
            expect(error).not.toBeUndefined()
          } finally {
            done()
            doned = true
          }
        },
        args
      ).catch(done)
    })
  }

  describe('Bad arguments', () => {
    fail('command', '42', ['nonesuch'], [])
    fail('option', '42', ['--nonesuch'], [])
  })

  describe('Stream processing', () => {
    ok('empty', '', [], [])
    ok('basic', 'hello: world', [], ['hello: world'])
    ok('valid ok', 'hello: world', ['valid'], [])
    fail('valid fail', 'hello: world: 2', ['valid'], [])
    ok(
      'multiple',
      'hello: world\n---\n42',
      [],
      ['hello: world', '...', '---\n42']
    )
    ok(
      'warn',
      'hello: !foo world',
      [],
      ['hello: !foo world'],
      [{ name: 'YAMLWarning' }]
    )
    fail('error', 'hello: world: 2', [], [{ name: 'YAMLParseError' }])
    fail('--single + empty', '', ['--single'], [])
    fail('--single + multiple', 'hello: world\n---\n42', ['--single'], [])
    describe('--json', () => {
      ok('basic', 'hello: world', ['--json'], ['[{"hello":"world"}]'])
      ok(
        '--single',
        'hello: world',
        ['--json', '--single'],
        ['{"hello":"world"}']
      )
      ok(
        'multiple',
        'hello: world\n---\n42',
        ['--json'],
        ['[{"hello":"world"},42]']
      )
    })
    describe('--indent', () => {
      ok(
        'basic',
        'hello:\n  world: 2',
        ['--indent', '3'],
        ['hello:\n   world: 2']
      )
      ok(
        '--json',
        'hello: world',
        ['--json', '--indent', '2'],
        ['[\n  {\n    "hello": "world"\n  }\n]']
      )
      ok(
        '--single',
        'hello: world',
        ['--json', '--indent', '2', '--single'],
        ['{\n  "hello": "world"\n}']
      )
      ok(
        'multiple',
        'hello: world\n---\n42',
        ['--json', '--indent', '2'],
        ['[\n  {\n    "hello": "world"\n  },\n  42\n]']
      )
      ok(
        'Lexer',
        'hello: world',
        ['lex', '--json', '--indent', '2'],
        [
          '[\n  "\\u0002",\n  "\\u001f",\n  "hello",\n  ":",\n  " ",\n  "\\u001f",\n  "world"\n]'
        ]
      )
      ok(
        'CST parser',
        'hello: world\n',
        ['cst', '--json', '--indent', '2'],
        [
          JSON.stringify(
            [
              {
                type: 'document',
                offset: 0,
                start: [],
                value: {
                  type: 'block-map',
                  offset: 0,
                  indent: 0,
                  items: [
                    {
                      start: [],
                      key: {
                        type: 'scalar',
                        offset: 0,
                        indent: 0,
                        source: 'hello'
                      },
                      sep: [
                        {
                          type: 'map-value-ind',
                          offset: 5,
                          indent: 0,
                          source: ':'
                        },
                        {
                          type: 'space',
                          offset: 6,
                          indent: 0,
                          source: ' '
                        }
                      ],
                      value: {
                        type: 'scalar',
                        offset: 7,
                        indent: 0,
                        source: 'world',
                        end: [
                          {
                            type: 'newline',
                            offset: 12,
                            indent: 0,
                            source: '\n'
                          }
                        ]
                      }
                    }
                  ]
                }
              }
            ],
            null,
            2
          )
        ]
      )
    })
    describe('--merge', () => {
      ok(
        'can be set',
        'hello:\n  world: 2\nfoo:\n  world: 2',
        ['--merge', '--json'],
        ['[{"hello":{"world":2},"foo":{"world":2}}]']
      )
      ok(
        'basic',
        'hello: &a\n  world: 2\nfoo:\n  <<: *a',
        ['--merge', '--json'],
        ['[{"hello":{"world":2},"foo":{"world":2}}]']
      )
      ok(
        'also enabled with --yaml=1.1',
        'hello: &a\n  world: 2\nfoo:\n  <<: *a',
        ['--yaml=1.1', '--json'],
        ['[{"hello":{"world":2},"foo":{"world":2}}]']
      )
      ok(
        'not enabled by default',
        'hello: &a\n  world: 2\nfoo:\n  <<: *a',
        ['--json'],
        ['[{"hello":{"world":2},"foo":{"<<":{"world":2}}}]']
      )
    })
    describe('--doc', () => {
      ok('basic', 'hello: world', ['--doc'], [{ contents: { items: [{}] } }])
      ok(
        'multiple',
        'hello: world\n---\n42',
        ['--doc'],
        [{ contents: { items: [{}] } }, { contents: { value: 42 } }]
      )
      ok(
        'error',
        'hello: world: 2',
        ['--doc'],
        [{ contents: { items: [{}] } }],
        [{ name: 'YAMLParseError' }]
      )
    })
    describe('--visit', () => {
      ok(
        'unstyle',
        '{"hello":"world"}',
        ['--visit', './tests/artifacts/cli-unstyle.cjs'],
        ['hello: world']
      )
      ok(
        'singlequote',
        '{"hello":"world"}',
        ['--visit', './tests/artifacts/cli-singlequote.mjs'],
        ["{ 'hello': 'world' }"]
      )
    })
  })

  describe('CST parser', () => {
    ok('basic', 'hello: world', ['cst'], [{ type: 'document' }])
    ok(
      'multiple',
      'hello: world\n---\n42',
      ['cst'],
      [{ type: 'document' }, { type: 'document' }]
    )
  })

  describe('Lexer', () => {
    ok(
      'basic',
      'hello: world',
      ['lex'],
      ['', '', '"hello"', '":"', '" "', '', '"world"']
    )
    ok(
      '--json',
      'hello: world',
      ['lex', '--json'],
      ['["\\u0002","\\u001f","hello",":"," ","\\u001f","world"]']
    )
  })
})
eemeli-yaml-086fa6b/tests/clone.ts000066400000000000000000000036751511277410200171550ustar00rootroot00000000000000import type { Scalar, YAMLMap } from 'yaml'
import { isAlias, isScalar, parseDocument, visit } from 'yaml'
import { source } from './_utils.ts'

describe('doc.clone()', () => {
  test('has expected members', () => {
    const doc = parseDocument('foo: bar')
    const copy = doc.clone()
    expect(copy).toMatchObject({
      comment: null,
      commentBefore: null,
      errors: [],
      warnings: []
    })
  })

  test('has expected methods', () => {
    const doc = parseDocument('foo: bar')
    const copy = doc.clone()
    expect(copy.toString()).toBe('foo: bar\n')
    expect(copy.toJS()).toEqual({ foo: 'bar' })

    const node = copy.createNode(42)
    expect(isScalar(node)).toBe(true)
    expect(node).toMatchObject({ value: 42 })

    const alias = copy.createAlias(node as Scalar, 'foo')
    expect(isAlias(alias)).toBe(true)
    expect(alias).toMatchObject({ source: 'foo' })
  })

  test('has separate contents from original', () => {
    const doc = parseDocument('foo: bar')
    const copy = doc.clone()
    copy.set('foo', 'fizz')
    expect(doc.get('foo')).toBe('bar')
    expect(copy.get('foo')).toBe('fizz')
  })

  test('has separate directives from original', () => {
    const doc = parseDocument('foo: bar')
    const copy = doc.clone()
    copy.directives.yaml.explicit = true
    expect(copy.toString()).toBe(source`
      %YAML 1.2
      ---
      foo: bar
    `)
    expect(doc.toString()).toBe('foo: bar\n')
  })

  test('handles anchors & aliases', () => {
    const src = source`
      foo: &foo FOO
      bar: *foo
    `
    const doc = parseDocument(src)
    const copy = doc.clone()
    expect(copy.toString()).toBe(src)

    visit(doc, {
      Alias(_, it) {
        if (it.source === 'foo') it.source = 'x'
      },
      Node(_, it) {
        if (it.anchor === 'foo') it.anchor = 'x'
      }
    })
    expect(doc.toString()).toBe(source`
      foo: &x FOO
      bar: *x
    `)
    expect(copy.toString()).toBe(src)
  })
})
eemeli-yaml-086fa6b/tests/collection-access.ts000066400000000000000000000443321511277410200214420ustar00rootroot00000000000000import {
  Document,
  Pair,
  type Scalar,
  type YAMLMap,
  type YAMLOMap,
  type YAMLSeq,
  type YAMLSet,
  isMap,
  isSeq,
  parseDocument
} from 'yaml'

describe('Map', () => {
  let doc: Document
  let map: YAMLMap<
    string | Scalar,
    | number
    | string
    | Scalar
    | YAMLMap, number | Scalar>
  >
  beforeEach(() => {
    doc = new Document({ a: 1, b: { c: 3, d: 4 } })
    map = doc.contents as any
    expect(map.items).toMatchObject([
      { key: { value: 'a' }, value: { value: 1 } },
      {
        key: { value: 'b' },
        value: {
          items: [
            { key: { value: 'c' }, value: { value: 3 } },
            { key: { value: 'd' }, value: { value: 4 } }
          ]
        }
      }
    ])
  })

  test('add', () => {
    map.add({ key: 'c', value: 'x' })
    expect(map.get('c')).toBe('x')
    // @ts-expect-error TS should complain here
    expect(() => map.add('a')).toThrow(/already set/)
    expect(() => map.add(new Pair('c', 'y'))).toThrow(/already set/)
    expect(map.items).toHaveLength(3)
  })

  test('delete', () => {
    expect(map.delete('a')).toBe(true)
    expect(map.get('a')).toBeUndefined()
    expect(map.delete('c')).toBe(false)
    expect(map.get('b')).toMatchObject({ items: [{}, {}] })
    expect(map.items).toHaveLength(1)
  })

  test('get with value', () => {
    expect(map.get('a')).toBe(1)
    expect(map.get('a', true)).toMatchObject({ value: 1 })
    const subMap = map.get('b')
    if (isMap(subMap)) {
      expect(subMap.toJSON()).toMatchObject({
        c: 3,
        d: 4
      })
      expect(map.get('c')).toBeUndefined()
    } else {
      throw new Error('Expected subMap to be a Map')
    }
  })

  test('get with node', () => {
    expect(map.get(doc.createNode('a'))).toBe(1)
    expect(map.get(doc.createNode('a'), true)).toMatchObject({ value: 1 })
    const subMap = map.get(doc.createNode('b'))
    if (isMap(subMap)) {
      expect(subMap.toJSON()).toMatchObject({ c: 3, d: 4 })
      expect(map.get(doc.createNode('c'))).toBeUndefined()
    } else {
      throw new Error('Expected subMap to be a Map')
    }
  })

  test('has with value', () => {
    expect(map.has('a')).toBe(true)
    expect(map.has('b')).toBe(true)
    expect(map.has('c')).toBe(false)
    expect(map.has('')).toBe(false)
    // @ts-expect-error TS should complain here
    expect(map.has()).toBe(false)
  })

  test('has with node', () => {
    expect(map.has(doc.createNode('a'))).toBe(true)
    expect(map.has(doc.createNode('b'))).toBe(true)
    expect(map.has(doc.createNode('c'))).toBe(false)
    // @ts-expect-error TS should complain here
    expect(map.has(doc.createNode())).toBe(false)
  })

  test('set with value', () => {
    map.set('a', 2)
    expect(map.get('a')).toBe(2)
    expect(map.get('a', true)).toMatchObject({ value: 2 })
    map.set('b', 5)
    expect(map.get('b')).toBe(5)
    map.set('c', 6)
    expect(map.get('c')).toBe(6)
    expect(map.items).toHaveLength(3)
  })

  test('set with node', () => {
    map.set(doc.createNode('a'), 2)
    expect(map.get('a')).toBe(2)
    expect(map.get('a', true)).toMatchObject({ value: 2 })
    map.set(doc.createNode('b'), 5)
    expect(map.get('b')).toBe(5)
    map.set(doc.createNode('c'), 6)
    expect(map.get('c')).toBe(6)
    expect(map.items).toHaveLength(3)
  })

  test('set scalar node with anchor', () => {
    doc = parseDocument('a: &A value\nb: *A\n')
    doc.set('a', 'foo')
    expect(doc.get('a', true)).toMatchObject({ value: 'foo' })
    expect(String(doc)).toBe('a: &A foo\nb: *A\n')
  })
})

describe('Seq', () => {
  let doc: Document
  let seq: YAMLSeq | YAMLSeq>>
  beforeEach(() => {
    doc = new Document([1, [2, 3]])
    seq = doc.contents as any
    expect(seq.items).toMatchObject([
      { value: 1 },
      { items: [{ value: 2 }, { value: 3 }] }
    ])
  })

  test('add', () => {
    seq.add(9)
    expect(seq.get(2)).toBe(9)
    seq.add(1)
    expect(seq.items).toHaveLength(4)
  })

  test('delete', () => {
    expect(seq.delete(0)).toBe(true)
    expect(seq.delete(2)).toBe(false)
    expect(seq.delete('a')).toBe(false)
    expect(seq.get(0)).toMatchObject({ items: [{ value: 2 }, { value: 3 }] })
    expect(seq.items).toHaveLength(1)
  })

  test('get with value', () => {
    expect(seq.get(0)).toBe(1)
    expect(seq.get('0')).toBe(1)
    expect(seq.get(0, true)).toMatchObject({ value: 1 })
    const subSeq = seq.get(1)
    if (isSeq(subSeq)) {
      expect(subSeq.toJSON()).toMatchObject([2, 3])
      expect(seq.get(2)).toBeUndefined()
    } else {
      throw new Error('not a seq')
    }
  })

  test('get with node', () => {
    expect(seq.get(doc.createNode(0))).toBe(1)
    expect(seq.get(doc.createNode('0'))).toBe(1)
    expect(seq.get(doc.createNode(0), true)).toMatchObject({ value: 1 })
    const subSeq = seq.get(doc.createNode(1))
    if (isSeq(subSeq)) {
      expect(subSeq.toJSON()).toMatchObject([2, 3])
      expect(seq.get(doc.createNode(2))).toBeUndefined()
    } else {
      throw new Error('not a seq')
    }
  })

  test('has with value', () => {
    expect(seq.has(0)).toBe(true)
    expect(seq.has(1)).toBe(true)
    expect(seq.has(2)).toBe(false)
    expect(seq.has('0')).toBe(true)
    expect(seq.has('')).toBe(false)
    // @ts-expect-error TS should complain here
    expect(seq.has()).toBe(false)
  })

  test('has with node', () => {
    expect(seq.has(doc.createNode(0))).toBe(true)
    expect(seq.has(doc.createNode('0'))).toBe(true)
    expect(seq.has(doc.createNode(2))).toBe(false)
    expect(seq.has(doc.createNode(''))).toBe(false)
    // @ts-expect-error TS should complain here
    expect(seq.has(doc.createNode())).toBe(false)
  })

  test('set with value', () => {
    seq.set(0, 2)
    expect(seq.get(0)).toBe(2)
    expect(seq.get(0, true)).toMatchObject({ value: 2 })
    seq.set('1', 5)
    expect(seq.get(1)).toBe(5)
    seq.set(2, 6)
    expect(seq.get(2)).toBe(6)
    expect(seq.items).toHaveLength(3)
  })

  test('set with node', () => {
    seq.set(doc.createNode(0), 2)
    expect(seq.get(0)).toBe(2)
    expect(seq.get(0, true)).toMatchObject({ value: 2 })
    seq.set(doc.createNode('1'), 5)
    expect(seq.get(1)).toBe(5)
    seq.set(doc.createNode(2), 6)
    expect(seq.get(2)).toBe(6)
    expect(seq.items).toHaveLength(3)
  })
})

describe('Set', () => {
  let doc: Document
  let set: YAMLSet | Pair>
  beforeEach(() => {
    doc = new Document(null, { version: '1.1' })
    set = doc.createNode([1, 2, 3], { tag: '!!set' }) as any
    doc.contents = set
    expect(set.items).toMatchObject([
      { key: { value: 1 }, value: { value: null } },
      { key: { value: 2 }, value: { value: null } },
      { key: { value: 3 }, value: { value: null } }
    ])
  })

  test('add', () => {
    set.add('x')
    expect(set.get('x')).toBe('x')
    set.add('x')
    const y0 = new Pair('y')
    set.add(y0)
    set.add(new Pair('y'))
    expect(set.get('y', true)).toBe(y0)
    expect(set.items).toHaveLength(5)
  })

  test('get', () => {
    expect(set.get(1)).toBe(1)
    expect(set.get(1, true)).toMatchObject({
      key: { value: 1 },
      value: { value: null }
    })
    expect(set.get(0)).toBeUndefined()
    expect(set.get('1')).toBeUndefined()
  })

  test('set', () => {
    set.set(1, true)
    expect(set.get(1)).toBe(1)
    set.set(1, false)
    expect(set.get(1)).toBeUndefined()
    set.set(4, false)
    expect(set.get(4)).toBeUndefined()
    set.set(4, true)
    expect(set.get(4)).toBe(4)
    expect(set.get(4, true)).toMatchObject({ key: 4, value: null })
    expect(set.items).toHaveLength(3)
  })
})

describe('OMap', () => {
  let doc: Document
  let omap: YAMLOMap
  beforeEach(() => {
    doc = new Document(null, { version: '1.1' })
    omap = doc.createNode([{ a: 1 }, { b: { c: 3, d: 4 } }], {
      tag: '!!omap'
    }) as any
    doc.contents = omap
    expect(omap.items).toMatchObject([
      { key: { value: 'a' }, value: { value: 1 } },
      {
        key: { value: 'b' },
        value: {
          items: [
            { key: { value: 'c' }, value: { value: 3 } },
            { key: { value: 'd' }, value: { value: 4 } }
          ]
        }
      }
    ])
  })

  test('add', () => {
    omap.add({ key: 'c', value: 'x' })
    expect(omap.get('c')).toBe('x')
    // @ts-expect-error TS should complain here
    expect(() => omap.add('a')).toThrow(/already set/)
    expect(() => omap.add(new Pair('c', 'y'))).toThrow(/already set/)
    expect(omap.items).toHaveLength(3)
  })

  test('delete', () => {
    expect(omap.delete('a')).toBe(true)
    expect(omap.get('a')).toBeUndefined()
    expect(omap.delete('c')).toBe(false)
    expect(omap.get('b')).toMatchObject({ items: [{}, {}] })
    expect(omap.items).toHaveLength(1)
  })

  test('get', () => {
    expect(omap.get('a')).toBe(1)
    expect(omap.get('a', true)).toMatchObject({ value: 1 })
    const subMap = omap.get('b')
    if (isMap(subMap)) {
      expect(subMap.toJSON()).toMatchObject({ c: 3, d: 4 })
      expect(omap.get('c')).toBeUndefined()
    } else {
      throw new Error('Expected subMap to be a map')
    }
  })

  test('has', () => {
    expect(omap.has('a')).toBe(true)
    expect(omap.has('b')).toBe(true)
    expect(omap.has('c')).toBe(false)
    expect(omap.has('')).toBe(false)
    // @ts-expect-error TS should complain here
    expect(omap.has()).toBe(false)
  })

  test('set', () => {
    omap.set('a', 2)
    expect(omap.get('a')).toBe(2)
    expect(omap.get('a', true)).toMatchObject({ value: 2 })
    omap.set('b', 5)
    expect(omap.get('b')).toBe(5)
    omap.set('c', 6)
    expect(omap.get('c')).toBe(6)
    expect(omap.items).toHaveLength(3)
  })
})

describe('Collection', () => {
  let doc: Document
  let map: YAMLMap | YAMLSeq>>
  beforeEach(() => {
    doc = new Document({ a: 1, b: [2, 3] })
    map = doc.contents as any
  })

  test('addIn', () => {
    map.addIn(['b'], 4)
    expect(map.getIn(['b', 2])).toBe(4)
    map.addIn([], new Pair('c', 5))
    expect(map.get('c')).toBe(5)
    expect(() => map.addIn(['a'], -1)).toThrow(/Expected YAML collection/)
    map.addIn(['b', 3], 6)
    expect(map.items).toHaveLength(3)
    const seq = map.getIn(['b'])
    if (isSeq(seq)) {
      expect(seq.items).toHaveLength(4)
    } else {
      throw new Error('Expected seq to be a seq')
    }
  })

  test('deleteIn', () => {
    expect(map.deleteIn(['a'])).toBe(true)
    expect(map.get('a')).toBeUndefined()
    expect(map.deleteIn(['b', 1])).toBe(true)
    expect(map.getIn(['b', 1])).toBeUndefined()
    expect(map.deleteIn([1])).toBe(false)
    expect(map.deleteIn(['b', 2])).toBe(false)
    expect(() => map.deleteIn(['a', 'e'])).toThrow(/Expected YAML collection/)
    expect(map.items).toHaveLength(1)
    const subSeq = map.getIn(['b'])
    if (isSeq(subSeq)) {
      expect(subSeq.items).toHaveLength(1)
    } else {
      throw new Error('Expected subSeq to be a seq')
    }
  })

  test('getIn', () => {
    expect(map.getIn(['a'])).toBe(1)
    expect(map.getIn(['a'], true)).toMatchObject({ value: 1 })
    expect(map.getIn(['b', 1])).toBe(3)
    expect(map.getIn(['b', '1'])).toBe(3)
    expect(map.getIn(['b', 1], true)).toMatchObject({ value: 3 })
    expect(map.getIn(['b', 2])).toBeUndefined()
    expect(map.getIn(['c', 'e'])).toBeUndefined()
    expect(map.getIn(['a', 'e'])).toBeUndefined()
  })

  test('hasIn', () => {
    expect(map.hasIn(['a'])).toBe(true)
    expect(map.hasIn(['b', 1])).toBe(true)
    expect(map.hasIn(['b', '1'])).toBe(true)
    expect(map.hasIn(['b', 2])).toBe(false)
    expect(map.hasIn(['c', 'e'])).toBe(false)
    expect(map.hasIn(['a', 'e'])).toBe(false)
  })

  test('setIn', () => {
    map.setIn(['a'], 2)
    expect(map.get('a')).toBe(2)
    expect(map.get('a', true)).toMatchObject({ value: 2 })
    map.setIn(['b', 1], 5)
    expect(map.getIn(['b', 1])).toBe(5)
    map.setIn([1], 6)
    expect(map.get(1)).toBe(6)
    map.setIn(['b', 2], 6)
    expect(map.getIn(['b', 2])).toBe(6)
    map.setIn(['e', 'e'], 7)
    expect(map.getIn(['e', 'e'])).toBe(7)
    expect(() => map.setIn(['a', 'e'], 8)).toThrow(/Expected YAML collection/)
    expect(map.items).toHaveLength(4)
    const subSeq = map.getIn(['b'])
    if (isSeq(subSeq)) {
      expect(subSeq.items).toHaveLength(3)
    } else {
      throw new Error('Expected subSeq to be a seq')
    }
  })
})

describe('Document', () => {
  let doc: Document | YAMLSeq>>>
  beforeEach(() => {
    doc = new Document({ a: 1, b: [2, 3] })
    expect(doc.contents?.items).toMatchObject([
      { key: { value: 'a' }, value: { value: 1 } },
      {
        key: { value: 'b' },
        value: { items: [{ value: 2 }, { value: 3 }] }
      }
    ])
  })

  test('add', () => {
    doc.add({ key: 'c', value: 'x' })
    expect(doc.get('c')).toBe('x')
    expect(() => doc.add('a')).toThrow(/already set/)
    expect(() => doc.add(new Pair('c', 'y'))).toThrow(/already set/)
    expect(doc.contents?.items).toHaveLength(3)
  })

  test('addIn', () => {
    doc.addIn(['b'], 4)
    expect(doc.getIn(['b', 2])).toBe(4)
    doc.addIn([], new Pair('c', 5))
    expect(doc.get('c')).toBe(5)
    expect(() => doc.addIn(['a'], -1)).toThrow(/Expected YAML collection/)
    doc.addIn(['b', 3], 6)
    expect(doc.contents?.items).toHaveLength(3)
    expect((doc.get('b') as any).items).toHaveLength(4)
  })

  test('delete', () => {
    expect(doc.delete('a')).toBe(true)
    expect(doc.delete('a')).toBe(false)
    expect(doc.get('a')).toBeUndefined()
    expect(doc.contents?.items).toHaveLength(1)
  })

  test('delete on scalar contents', () => {
    const doc = new Document('s')
    expect(() => doc.set('a', 1)).toThrow(/document contents/)
  })

  test('deleteIn', () => {
    expect(doc.deleteIn(['a'])).toBe(true)
    expect(doc.get('a')).toBeUndefined()
    expect(doc.deleteIn(['b', 1])).toBe(true)
    expect(doc.getIn(['b', 1])).toBeUndefined()
    expect(doc.deleteIn([1])).toBe(false)
    expect(doc.deleteIn(['b', 2])).toBe(false)
    expect(() => doc.deleteIn(['a', 'e'])).toThrow(/Expected/)
    expect(doc.contents?.items).toHaveLength(1)
    expect((doc.get('b') as any).items).toHaveLength(1)
    expect(doc.deleteIn(null)).toBe(true)
    expect(doc.deleteIn(null)).toBe(false)
  })

  test('get', () => {
    expect(doc.get('a')).toBe(1)
    expect(doc.get('a', true)).toMatchObject({ value: 1 })
    expect(doc.get('c')).toBeUndefined()
  })

  test('get on scalar contents', () => {
    const doc = new Document('s')
    expect(doc.get('a')).toBeUndefined()
  })

  test('getIn collection', () => {
    expect(doc.getIn(['a'])).toBe(1)
    expect(doc.getIn(['a'], true)).toMatchObject({ value: 1 })
    expect(doc.getIn(['b', 1])).toBe(3)
    expect(doc.getIn(['b', 1], true)).toMatchObject({ value: 3 })
    expect(doc.getIn(['b', 'e'])).toBeUndefined()
    expect(doc.getIn(['c', 'e'])).toBeUndefined()
    expect(doc.getIn(['a', 'e'])).toBeUndefined()
  })

  test('getIn scalar', () => {
    const doc = new Document('s')
    expect(doc.getIn([])).toBe('s')
    expect(doc.getIn(null, true)).toMatchObject({ value: 's' })
    expect(doc.getIn([0])).toBeUndefined()
  })

  test('has', () => {
    expect(doc.has('a')).toBe(true)
    expect(doc.has('c')).toBe(false)
  })

  test('has on scalar contents', () => {
    const doc = new Document('s')
    expect(doc.has('a')).toBe(false)
  })

  test('hasIn', () => {
    expect(doc.hasIn(['a'])).toBe(true)
    expect(doc.hasIn(['b', 1])).toBe(true)
    expect(doc.hasIn(['b', 'e'])).toBe(false)
    expect(doc.hasIn(['c', 'e'])).toBe(false)
    expect(doc.hasIn(['a', 'e'])).toBe(false)
  })

  test('set', () => {
    doc.set('a', 2)
    expect(doc.get('a')).toBe(2)
    expect(doc.get('a', true)).toMatchObject({ value: 2 })
    doc.set('c', 6)
    expect(doc.get('c')).toBe(6)
    expect(doc.contents?.items).toHaveLength(3)
  })

  test('set on scalar contents', () => {
    const doc = new Document('s')
    expect(() => doc.set('a', 1)).toThrow(/document contents/)
  })

  test('set on empty document', () => {
    doc.contents = null
    doc.set('a', 1)
    expect(doc.get('a')).toBe(1)
  })

  test('setIn', () => {
    doc.setIn(['a'], 2)
    expect(doc.getIn(['a'])).toBe(2)
    expect(doc.getIn(['a'], true)).toMatchObject({ value: 2 })
    doc.setIn(['b', 1], 5)
    expect(doc.getIn(['b', 1])).toBe(5)
    doc.setIn(['c'], 6)
    expect(doc.getIn(['c'])).toBe(6)
    doc.setIn(['e', 1, 'e'], 7)
    expect(doc.getIn(['e', 1, 'e'])).toBe(7)
    expect(() => doc.setIn(['a', 'e'], 8)).toThrow(/Expected YAML collection/)
    expect(doc.contents?.items).toHaveLength(4)
    expect((doc.get('b') as any).items).toHaveLength(2)
    expect(String(doc)).toBe(
      'a: 2\nb:\n  - 2\n  - 5\nc: 6\ne:\n  - null\n  - e: 7\n'
    )
  })

  test('setIn on scalar contents', () => {
    const doc = new Document('s')
    expect(() => doc.setIn(['a'], 1)).toThrow(/document contents/)
  })

  test('setIn on empty document', () => {
    doc.contents = null
    doc.setIn(['a', 2], 1)
    expect(doc.get('a')).toMatchObject({
      items: [{ value: null }, { value: null }, { value: 1 }]
    })
  })

  test('setIn on parsed document', () => {
    const doc = parseDocument('{ a: 1, b: [2, 3] }')
    doc.setIn(['c', 1], 9)
    expect(String(doc)).toBe('{ a: 1, b: [ 2, 3 ], c: [ null, 9 ] }\n')
  })

  test('setIn with __proto__ as key', () => {
    doc.setIn(['c', '__proto__'], 9)
    expect(String(doc)).toBe('a: 1\nb:\n  - 2\n  - 3\nc:\n  __proto__: 9\n')
  })

  test('setIn with object key', () => {
    doc.contents = null
    const foo = { foo: 'FOO' }
    doc.setIn([foo], 'BAR')
    // @ts-expect-error - Doesn't see that setIn() changes contents
    expect(doc.contents?.items).toMatchObject([
      {
        key: { items: [{ key: { value: 'foo' }, value: { value: 'FOO' } }] },
        value: { value: 'BAR' }
      }
    ])
  })

  test('setIn with repeated object key', () => {
    doc.contents = null
    const foo = { foo: 'FOO' }
    doc.setIn([foo, foo], 'BAR')
    // @ts-expect-error - Doesn't see that setIn() changes contents
    expect(doc.contents?.items).toMatchObject([
      {
        key: { items: [{ key: { value: 'foo' }, value: { value: 'FOO' } }] },
        value: {
          items: [
            {
              key: {
                items: [{ key: { value: 'foo' }, value: { value: 'FOO' } }]
              },
              value: { value: 'BAR' }
            }
          ]
        }
      }
    ])
  })
})
eemeli-yaml-086fa6b/tests/compat.ts000066400000000000000000000057121511277410200173320ustar00rootroot00000000000000import { parseDocument, stringify } from 'yaml'

describe('composer compatibility warnings', () => {
  test('disabled by default', () => {
    let doc = parseDocument('x: true\ny: off\n')
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toHaveLength(0)
    expect(doc.toJS()).toEqual({ x: true, y: 'off' })

    doc = parseDocument('x: true\ny: off\n', { version: '1.1' })
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toHaveLength(0)
    expect(doc.toJS()).toEqual({ x: true, true: false })
  })

  test("schema: 'core', compat: 'yaml-1.1'", () => {
    const doc = parseDocument('x: true\ny: off\n', { compat: 'yaml-1.1' })
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toMatchObject([
      { code: 'TAG_RESOLVE_FAILED', pos: [8, 9] },
      { code: 'TAG_RESOLVE_FAILED', pos: [11, 14] }
    ])
    expect(doc.toJS()).toEqual({ x: true, y: 'off' })
  })

  test("schema: 'yaml-1.1', compat: 'core'", () => {
    const doc = parseDocument('x: true\ny: off\n', {
      schema: 'yaml-1.1',
      compat: 'core'
    })
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toMatchObject([
      { code: 'TAG_RESOLVE_FAILED', pos: [8, 9] },
      { code: 'TAG_RESOLVE_FAILED', pos: [11, 14] }
    ])
    expect(doc.toJS()).toEqual({ x: true, true: false })
  })

  test('single-line flow collection', () => {
    const doc = parseDocument('foo: { x: 42 }\n', { compat: 'core' })
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toHaveLength(0)
  })

  test('flow collection with end at parent map indent', () => {
    let doc = parseDocument('x: {\n  y: 42\n}', { compat: 'core' })
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toMatchObject([{ code: 'BAD_INDENT', pos: [13, 14] }])

    doc = parseDocument('x:\n {\n  y: 42\n }', { compat: 'core' })
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toHaveLength(0)
  })

  test('flow collection with end at parent seq indent', () => {
    let doc = parseDocument('- {\n  y: 42\n}', { compat: 'core' })
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toMatchObject([{ code: 'BAD_INDENT', pos: [12, 13] }])

    doc = parseDocument('- {\n  y: 42\n }', { compat: 'core' })
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toHaveLength(0)
  })
})

describe('stringify compatible values', () => {
  test('disabled by default', () => {
    let res = stringify({ x: true, y: 'off' })
    expect(res).toBe('x: true\ny: off\n')

    res = stringify({ x: true, y: 'off' }, { version: '1.1' })
    expect(res).toBe('x: true\n"y": "off"\n')
  })

  test("schema: 'core', compat: 'yaml-1.1'", () => {
    const res = stringify({ x: true, y: 'off' }, { compat: 'yaml-1.1' })
    expect(res).toBe('x: true\n"y": "off"\n')
  })

  test("schema: 'yaml-1.1', compat: 'json'", () => {
    const res = stringify(
      { x: true, y: 'off' },
      { schema: 'yaml-1.1', compat: 'json' }
    )
    expect(res).toBe('"x": true\n"y": "off"\n')
  })
})
eemeli-yaml-086fa6b/tests/cst.ts000066400000000000000000000106111511277410200166320ustar00rootroot00000000000000import { CST, Parser } from 'yaml'
import { source } from './_utils.ts'

function cstDoc(src: string) {
  const tokens = Array.from(new Parser().parse(src))
  expect(tokens).toHaveLength(1)
  expect(tokens[0].type).toBe('document')
  return tokens[0] as CST.Document
}

describe('CST.visit', () => {
  test('Visit paths in order', () => {
    const doc = cstDoc(source`
      foo:
        - baz
        - [ bar: 42 ]
      ? { fuzz, ball }
      : fii
    `)
    const paths: CST.VisitPath[] = []
    CST.visit(doc, (_item, path) => {
      paths.push(path)
    })
    expect(paths).toMatchObject([
      [],
      [['value', 0]],
      [
        ['value', 0],
        ['value', 0]
      ],
      [
        ['value', 0],
        ['value', 1]
      ],
      [
        ['value', 0],
        ['value', 1],
        ['value', 0]
      ],
      [['value', 1]],
      [
        ['value', 1],
        ['key', 0]
      ],
      [
        ['value', 1],
        ['key', 1]
      ]
    ])
  })

  test('break visit', () => {
    const doc = cstDoc(source`
      - " foo"
      - "foo"
      - "bar"
    `)
    let visits = 0
    CST.visit(doc, item => {
      visits += 1
      const scalar = CST.resolveAsScalar(item.value)
      if (scalar?.value === 'foo') return CST.visit.BREAK
    })
    expect(visits).toBe(3)
  })

  test('remove item', () => {
    const doc = cstDoc(source`
      -  " foo"
      - "foo"
      - "bar"
    `)
    let visits = 0
    CST.visit(doc, item => {
      visits += 1
      const scalar = CST.resolveAsScalar(item.value)
      if (scalar?.value === 'foo') return CST.visit.REMOVE
    })
    expect(visits).toBe(4)
    expect(CST.stringify(doc)).toBe(source`
      -  " foo"
      - "bar"
    `)
  })

  test('replace value with block scalar in seq', () => {
    const doc = cstDoc(source`
      -  " foo"
      - "foo"
      - "bar"
    `)
    let visits = 0
    CST.visit(doc, item => {
      visits += 1
      if (item.value) {
        const scalar = CST.resolveAsScalar(item.value)
        if (scalar?.value === 'foo')
          CST.setScalarValue(item.value, 'foo', { type: 'BLOCK_LITERAL' })
      }
    })
    expect(visits).toBe(4)
    expect(CST.stringify(doc)).toBe(source`
      -  " foo"
      - |-
        foo
      - "bar"
    `)
  })

  test('add item', () => {
    const doc = cstDoc(source`
      -  " foo"
      - "foo"
      - "bar"
    `)
    let visits = 0
    CST.visit(doc, (item, path) => {
      visits += 1
      if (CST.isScalar(item.value)) {
        const scalar = CST.resolveAsScalar(item.value)
        if (scalar?.value === 'foo') {
          const parent = CST.visit.parentCollection(doc, path)
          const idx = path[path.length - 1][1]
          const { indent } = item.value
          parent.items.splice(idx, 0, {
            start: item.start.slice(),
            value: CST.createScalarToken('hip', { indent })
          })
          return idx + 2
        }
      }
    })
    expect(visits).toBe(4)
    expect(CST.stringify(doc)).toBe(source`
      -  " foo"
      - hip
      - "foo"
      - "bar"
    `)
  })

  test('replace value with flow scalar in map', () => {
    const doc = cstDoc(source`
      - a:  A
        b: B\t#comment
        c: C
    `)
    let visits = 0
    CST.visit(doc, item => {
      visits += 1
      if (item.value) {
        const scalar = CST.resolveAsScalar(item.value)
        if (scalar?.value === 'B') {
          CST.setScalarValue(item.value, 'foo\n\nbar', { afterKey: !!item.key })
        }
      }
    })
    expect(visits).toBe(5)
    expect(CST.stringify(doc)).toBe(source`
      - a:  A
        b: foo


          bar\t#comment
        c: C
    `)
  })

  test('skip children', () => {
    const doc = cstDoc(source`
      - " foo"
      - [ foo, 13, 42 ]
      - "bar"
    `)
    let visits = 0
    CST.visit(doc, item => {
      visits += 1
      if (item.value?.type === 'flow-collection') return CST.visit.SKIP
    })
    expect(visits).toBe(4)
  })

  test('set next index', () => {
    const doc = cstDoc(source`
      - "foo"
      - [ foo, 13, 42 ]
      - "bar"
    `)
    let visits = 0
    CST.visit(doc, item => {
      visits += 1
      const scalar = CST.resolveAsScalar(item.value)
      if (scalar?.value === 'foo') return 2
    })
    expect(visits).toBe(3)
  })
})

test('Line comment before unindented block-seq in block-map (#525)', () => {
  const src = 'a:\n#\n- b'
  const [doc] = Array.from(new Parser().parse(src))
  expect(CST.stringify(doc)).toBe(src)
})
eemeli-yaml-086fa6b/tests/directives.ts000066400000000000000000000044741511277410200202140ustar00rootroot00000000000000import type { Scalar } from 'yaml'
import { parseDocument } from 'yaml'
import { source } from './_utils.ts'

describe('%TAG', () => {
  test('parse local tags', () => {
    const doc = parseDocument(source`
      %TAG ! !foo:
      %TAG !bar! !bar:
      ---
      - !bar v1
      - !bar!foo v2
    `)
    expect(doc.errors).toHaveLength(0)
    expect(doc.directives.tags).toMatchObject({
      '!!': 'tag:yaml.org,2002:',
      '!': '!foo:',
      '!bar!': '!bar:'
    })
    expect(doc.contents).toMatchObject({
      items: [
        { value: 'v1', tag: '!foo:bar' },
        { value: 'v2', tag: '!bar:foo' }
      ]
    })
  })

  test('parse global tags', () => {
    const doc = parseDocument(source`
      %TAG ! foo:
      %TAG !bar! bar:bar#bar? #comment
      ---
      - !bar v1
      - !bar!foo v2
    `)
    expect(doc.errors).toHaveLength(0)
    expect(doc.directives.tags).toMatchObject({
      '!!': 'tag:yaml.org,2002:',
      '!': 'foo:',
      '!bar!': 'bar:bar#bar?'
    })
    expect(doc.contents).toMatchObject({
      items: [
        { value: 'v1', tag: 'foo:bar' },
        { value: 'v2', tag: 'bar:bar#bar?foo' }
      ]
    })
  })

  test('create & stringify', () => {
    const doc = parseDocument('[ v1, v2 ]\n')
    ;(doc.get(0, true) as Scalar).tag = '!foo:foo'
    ;(doc.get(1, true) as Scalar).tag = '!bar:bar'
    doc.directives.tags['!'] = '!foo:'
    doc.directives.tags['!bar!'] = '!bar:'
    expect(String(doc)).toBe(source`
      %TAG ! !foo:
      %TAG !bar! !bar:
      ---
      [ !foo v1, !bar!bar v2 ]
    `)
  })
})

describe('broken directives', () => {
  for (const tag of ['%TAG', '%YAML'])
    test(`incomplete ${tag} directive`, () => {
      const doc = parseDocument(`${tag}\n---\n`)
      expect(doc.errors).toMatchObject([{ pos: [0, tag.length] }])
    })

  test('missing separator at end of stream', () => {
    const doc = parseDocument(`%YAML 1.2\n`)
    expect(doc.errors).toMatchObject([{ pos: [10, 11] }])
  })

  test('missing separator before doc contents', () => {
    const doc = parseDocument(`%YAML 1.2\nfoo\n`)
    expect(doc.errors).toMatchObject([{ pos: [10, 11] }])
  })

  test('lone %', () => {
    const doc = parseDocument(`%`)
    expect(doc).toMatchObject({
      errors: [{ code: 'MISSING_CHAR', pos: [1, 2] }],
      warnings: [{ code: 'BAD_DIRECTIVE', pos: [0, 1] }]
    })
  })
})
eemeli-yaml-086fa6b/tests/doc/000077500000000000000000000000001511277410200162375ustar00rootroot00000000000000eemeli-yaml-086fa6b/tests/doc/YAML-1.1.spec.ts000066400000000000000000000030031511277410200205730ustar00rootroot00000000000000import { source } from '../_utils.ts'
import { parseAllDocuments } from 'yaml'

test('Use preceding directives if none defined', () => {
  const src = source`
    !bar "First document"
    ...
    %TAG ! !foo
    ---
    !bar "With directives"
    ---
    !bar "Using previous TAG directive"
    ...
    %YAML 1.1
    ---
    !bar "Reset settings"
    ---
    !bar "Using previous YAML directive"
  `
  const docs = parseAllDocuments(src, { prettyErrors: false, version: '1.1' })
  const warn = (tag: string) => ({ message: `Unresolved tag: ${tag}` })
  expect(docs).toMatchObject([
    {
      directives: { yaml: { version: '1.1', explicit: false } },
      errors: [],
      warnings: [warn('!bar')]
    },
    {
      directives: { yaml: { version: '1.1', explicit: false } },
      errors: [],
      warnings: [warn('!foobar')]
    },
    {
      directives: { yaml: { version: '1.1', explicit: false } },
      errors: [],
      warnings: [warn('!foobar')]
    },
    {
      directives: { yaml: { version: '1.1', explicit: true } },
      errors: [],
      warnings: [warn('!bar')]
    },
    {
      directives: { yaml: { version: '1.1', explicit: true } },
      errors: [],
      warnings: [warn('!bar')]
    }
  ])
  expect(docs.map(String)).toMatchObject([
    '!bar "First document"\n...\n',
    '%TAG ! !foo\n---\n!bar "With directives"\n',
    '%TAG ! !foo\n---\n!bar "Using previous TAG directive"\n...\n',
    '%YAML 1.1\n---\n!bar "Reset settings"\n',
    '%YAML 1.1\n---\n!bar "Using previous YAML directive"\n'
  ])
})
eemeli-yaml-086fa6b/tests/doc/YAML-1.2.spec.ts000066400000000000000000001217501511277410200206060ustar00rootroot00000000000000import * as YAML from 'yaml'
import { YAMLError } from 'yaml'

const collectionKeyWarning =
  /^Keys with collection values will be stringified due to JS Object restrictions/

const spec: Record<
  string,
  Record<
    string,
    {
      src: string
      tgt: unknown[]
      errors?: string[][]
      warnings?: string[][]
      jsWarnings?: RegExp[]
      special?: (src: string) => void
    }
  >
> = {
  '2.1. Collections': {
    'Example 2.1. Sequence of Scalars': {
      src: `- Mark McGwire\r
- Sammy Sosa\r
- Ken Griffey\r\n`,
      tgt: [['Mark McGwire', 'Sammy Sosa', 'Ken Griffey']]
    },

    'Example 2.2. Mapping Scalars to Scalars': {
      src: `hr:  65    # Home runs\r
avg: 0.278 # Batting average\r
rbi: 147   # Runs Batted In`,
      tgt: [
        {
          hr: 65, // ' Home runs'
          avg: 0.278, // ' Batting average'
          rbi: 147 // ' Runs Batted In'
        }
      ]
    },

    'Example 2.3. Mapping Scalars to Sequences': {
      src: `american:\r
  - Boston Red Sox\r
  - Detroit Tigers\r
  - New York Yankees\r
national:\r
  - New York Mets\r
  - Chicago Cubs\r
  - Atlanta Braves`,
      tgt: [
        {
          american: ['Boston Red Sox', 'Detroit Tigers', 'New York Yankees'],
          national: ['New York Mets', 'Chicago Cubs', 'Atlanta Braves']
        }
      ]
    },

    'Example 2.4. Sequence of Mappings': {
      src: `-
  name: Mark McGwire
  hr:   65
  avg:  0.278
-
  name: Sammy Sosa
  hr:   63
  avg:  0.288`,
      tgt: [
        [
          {
            name: 'Mark McGwire',
            hr: 65,
            avg: 0.278
          },
          {
            name: 'Sammy Sosa',
            hr: 63,
            avg: 0.288
          }
        ]
      ]
    },

    'Example 2.5. Sequence of Sequences': {
      src: `- [name        , hr, avg  ]
- [Mark McGwire, 65, 0.278]
- [Sammy Sosa  , 63, 0.288]`,
      tgt: [
        [
          ['name', 'hr', 'avg'],
          ['Mark McGwire', 65, 0.278],
          ['Sammy Sosa', 63, 0.288]
        ]
      ]
    },

    'Example 2.6. Mapping of Mappings': {
      src: `Mark McGwire: {hr: 65, avg: 0.278}
Sammy Sosa: {
    hr: 63,
    avg: 0.288
  }`,
      tgt: [
        {
          'Mark McGwire': { hr: 65, avg: 0.278 },
          'Sammy Sosa': { hr: 63, avg: 0.288 }
        }
      ]
    }
  },

  '2.2. Structures': {
    'Example 2.7. Two Documents in a Stream': {
      src: `# Ranking of 1998 home runs
---
- Mark McGwire
- Sammy Sosa
- Ken Griffey

# Team ranking
---
- Chicago Cubs
- St Louis Cardinals`,
      tgt: [
        // ' Ranking of 1998 home runs'
        ['Mark McGwire', 'Sammy Sosa', 'Ken Griffey'],
        // ' Team ranking'
        ['Chicago Cubs', 'St Louis Cardinals']
      ]
    },

    'Example 2.8. Play by Play Feed': {
      src: `---
time: 20:03:20
player: Sammy Sosa
action: strike (miss)
...
---
time: 20:03:47
player: Sammy Sosa
action: grand slam
...`,
      tgt: [
        {
          time: '20:03:20',
          player: 'Sammy Sosa',
          action: 'strike (miss)'
        },
        {
          time: '20:03:47',
          player: 'Sammy Sosa',
          action: 'grand slam'
        }
      ]
    },

    'Example 2.9. Single Document with Two Comments': {
      src: `---
hr: # 1998 hr ranking
  - Mark McGwire
  - Sammy Sosa
rbi:
  # 1998 rbi ranking
  - Sammy Sosa
  - Ken Griffey`,
      tgt: [
        {
          hr: [
            // ' 1998 hr ranking'
            'Mark McGwire',
            'Sammy Sosa'
          ],
          rbi: [
            // ' 1998 rbi ranking'
            'Sammy Sosa',
            'Ken Griffey'
          ]
        }
      ]
    },

    'Example 2.10. Node for “Sammy Sosa” appears twice in this document': {
      src: `---
hr:
  - Mark McGwire
  # Following node labeled SS
  - &SS Sammy Sosa
rbi:
  - *SS # Subsequent occurrence
  - Ken Griffey`,
      tgt: [
        {
          hr: ['Mark McGwire', /* Following node labeled SS */ 'Sammy Sosa'],
          rbi: ['Sammy Sosa' /* Subsequent occurrence */, 'Ken Griffey']
        }
      ]
    },

    'Example 2.11. Mapping between Sequences': {
      src: `? - Detroit Tigers
  - Chicago cubs
:
  - 2001-07-23

? [ New York Yankees,
    Atlanta Braves ]
: [ 2001-07-02, 2001-08-12,
    2001-08-14 ]`,
      tgt: [
        {
          '[ Detroit Tigers, Chicago cubs ]': ['2001-07-23'],
          '[ New York Yankees, Atlanta Braves ]': [
            '2001-07-02',
            '2001-08-12',
            '2001-08-14'
          ]
        }
      ],
      jsWarnings: [collectionKeyWarning]
    },

    'Example 2.12. Compact Nested Mapping': {
      src: `---
# Products purchased
- item    : Super Hoop
  quantity: 1
- item    : Basketball
  quantity: 4
- item    : Big Shoes
  quantity: 1`,
      tgt: [
        [
          // Products purchased
          { item: 'Super Hoop', quantity: 1 },
          { item: 'Basketball', quantity: 4 },
          { item: 'Big Shoes', quantity: 1 }
        ]
      ]
    }
  },

  '2.3. Scalars': {
    'Example 2.13. In literals, newlines are preserved': {
      src: `# ASCII Art
--- |
  \\//||\\/||
  // ||  ||__`,
      tgt: ['\\//||\\/||\n' + '// ||  ||__\n']
    },

    'Example 2.14. In the folded scalars, newlines become spaces': {
      src: `--- >
  Mark McGwire's
  year was crippled
  by a knee injury.`,
      tgt: ["Mark McGwire's year was crippled by a knee injury.\n"]
    },

    'Example 2.15. Folded newlines are preserved for "more indented" and blank lines':
      {
        src: `>
 Sammy Sosa completed another
 fine season with great stats.

   63 Home Runs
   0.288 Batting Average

 What a year!`,
        tgt: [
          `Sammy Sosa completed another fine season with great stats.

  63 Home Runs
  0.288 Batting Average

What a year!\n`
        ]
      },

    'Example 2.16. Indentation determines scope': {
      src: `name: Mark McGwire
accomplishment: >
  Mark set a major league
  home run record in 1998.
stats: |
  65 Home Runs
  0.278 Batting Average`,
      tgt: [
        {
          name: 'Mark McGwire',
          accomplishment: 'Mark set a major league home run record in 1998.\n',
          stats: '65 Home Runs\n0.278 Batting Average\n'
        }
      ]
    },

    'Example 2.17. Quoted Scalars': {
      src: `unicode: "Sosa did fine.\\u263A"
control: "\\b1998\\t1999\\t2000\\n"
hex esc: "\\x0d\\x0a is \\r\\n"

single: '"Howdy!" he cried.'
quoted: ' # Not a ''comment''.'
tie-fighter: '|\\-*-/|'`,
      tgt: [
        {
          unicode: 'Sosa did fine.☺',
          control: '\b1998\t1999\t2000\n',
          'hex esc': '\r\n is \r\n',
          single: '"Howdy!" he cried.',
          quoted: " # Not a 'comment'.",
          'tie-fighter': '|\\-*-/|'
        }
      ]
    },

    'Example 2.18. Multi-line Flow Scalars': {
      src: `plain:
  This unquoted scalar
  spans many lines.

quoted: "So does this
  quoted scalar.\\n"`,
      tgt: [
        {
          plain: 'This unquoted scalar spans many lines.',
          quoted: 'So does this quoted scalar.\n'
        }
      ]
    }
  },

  '2.4. Tags': {
    'Example 2.19. Integers': {
      src: `canonical: 12345
decimal: +12345
octal: 0o14
hexadecimal: 0xC`,
      tgt: [
        {
          canonical: 12345,
          decimal: 12345,
          octal: 12,
          hexadecimal: 12
        }
      ]
    },

    'Example 2.20. Floating Point': {
      src: `canonical: 1.23015e+3
exponential: 12.3015e+02
fixed: 1230.15
negative infinity: -.inf
not a number: .NaN`,
      tgt: [
        {
          canonical: 1230.15,
          exponential: 1230.15,
          fixed: 1230.15,
          'negative infinity': -Infinity,
          'not a number': NaN
        }
      ]
    },

    'Example 2.21. Miscellaneous': {
      src: `null:
booleans: [ true, false ]
string: '012345'`,
      tgt: [
        {
          '': null,
          booleans: [true, false],
          string: '012345'
        }
      ]
    },

    'Example 2.22. Timestamps': {
      src: `canonical: 2001-12-15T02:59:43.1Z
iso8601: 2001-12-14t21:59:43.10-05:00
spaced: 2001-12-14 21:59:43.10 -5
date: 2001-12-14`,
      tgt: [
        {
          canonical: '2001-12-15T02:59:43.1Z',
          iso8601: '2001-12-14t21:59:43.10-05:00',
          spaced: '2001-12-14 21:59:43.10 -5',
          date: '2001-12-14'
        }
      ],
      special(src) {
        const obj = YAML.parse(src, { schema: 'yaml-1.1' })
        expect(Object.keys(obj)).toHaveLength(4)
        for (const key of ['canonical', 'iso8601', 'spaced', 'date']) {
          const date = obj[key]
          expect(date).toBeInstanceOf(Date)
          expect(date.getFullYear()).toBe(2001)
          expect(date.getMonth()).toBe(11)
        }
      }
    },

    'Example 2.23. Various Explicit Tags': {
      src: `---
not-date: !!str 2002-04-28

picture: !!binary |
 R0lGODlhDAAMAIQAAP//9/X
 17unp5WZmZgAAAOfn515eXv
 Pz7Y6OjuDg4J+fn5OTk6enp
 56enmleECcgggoBADs=

application specific tag: !something |
 The semantics of the tag
 above may be different for
 different documents.`,
      tgt: [
        {
          'not-date': '2002-04-28',
          picture: Buffer.from([
            71, 73, 70, 56, 57, 97, 12, 0, 12, 0, 132, 0, 0, 255, 255, 247, 245,
            245, 238, 233, 233, 229, 102, 102, 102, 0, 0, 0, 231, 231, 231, 94,
            94, 94, 243, 243, 237, 142, 142, 142, 224, 224, 224, 159, 159, 159,
            147, 147, 147, 167, 167, 167, 158, 158, 158, 105, 94, 16, 39, 32,
            130, 10, 1, 0, 59
          ]),
          'application specific tag':
            'The semantics of the tag\nabove may be different for\ndifferent documents.\n'
        }
      ],
      warnings: [['Unresolved tag: !something']],
      special(src) {
        const doc = YAML.parseDocument(src, { schema: 'yaml-1.1' })
        const data = doc.contents.items[1].value.value
        expect(data).toBeInstanceOf(Uint8Array)
        expect(data.byteLength).toBe(65)
      }
    },

    'Example 2.24. Global Tags': {
      src: `%TAG ! tag:clarkevans.com,2002:
--- !shape
  # Use the ! handle for presenting
  # tag:clarkevans.com,2002:circle
- !circle
  center: &ORIGIN {x: 73, y: 129}
  radius: 7
- !line
  start: *ORIGIN
  finish: { x: 89, y: 102 }
- !label
  start: *ORIGIN
  color: 0xFFEEBB
  text: Pretty vector drawing.`,
      tgt: [
        [
          { center: { x: 73, y: 129 }, radius: 7 },
          { start: { x: 73, y: 129 }, finish: { x: 89, y: 102 } },
          {
            start: { x: 73, y: 129 },
            color: 16772795,
            text: 'Pretty vector drawing.'
          }
        ]
      ],
      warnings: [
        [
          'Unresolved tag: tag:clarkevans.com,2002:circle',
          'Unresolved tag: tag:clarkevans.com,2002:line',
          'Unresolved tag: tag:clarkevans.com,2002:label',
          'Unresolved tag: tag:clarkevans.com,2002:shape'
        ]
      ]
    },

    'Example 2.25. Unordered Sets': {
      src: `# Sets are represented as a
# Mapping where each key is
# associated with a null value
--- !!set
? Mark McGwire
? Sammy Sosa
? Ken Griff`,
      tgt: [new Set(['Mark McGwire', 'Sammy Sosa', 'Ken Griff'])]
    },

    'Example 2.26. Ordered Mappings': {
      src: `# Ordered maps are represented as
# A sequence of mappings, with
# each mapping having one key
--- !!omap
- Mark McGwire: 65
- Sammy Sosa: 63
- Ken Griffy: 58\n\n`,
      tgt: [
        new Map([
          ['Mark McGwire', 65],
          ['Sammy Sosa', 63],
          ['Ken Griffy', 58]
        ])
      ]
    }
  },

  '2.5. Full Length Example': {
    'Example 2.27. Invoice': {
      src: `--- !
invoice: 34843
date   : 2001-01-23
bill-to: &id001
    given  : Chris
    family : Dumars
    address:
        lines: |
            458 Walkman Dr.
            Suite #292
        city    : Royal Oak
        state   : MI
        postal  : 48046
ship-to: *id001
product:
    - sku         : BL394D
      quantity    : 4
      description : Basketball
      price       : 450.00
    - sku         : BL4438H
      quantity    : 1
      description : Super Hoop
      price       : 2392.00
tax  : 251.42
total: 4443.52
comments:
    Late afternoon is best.
    Backup contact is Nancy
    Billsmer @ 338-4338.`,
      tgt: [
        {
          invoice: 34843,
          date: '2001-01-23',
          'bill-to': {
            given: 'Chris',
            family: 'Dumars',
            address: {
              lines: '458 Walkman Dr.\nSuite #292\n',
              city: 'Royal Oak',
              state: 'MI',
              postal: 48046
            }
          },
          'ship-to': {
            given: 'Chris',
            family: 'Dumars',
            address: {
              lines: '458 Walkman Dr.\nSuite #292\n',
              city: 'Royal Oak',
              state: 'MI',
              postal: 48046
            }
          },
          product: [
            {
              sku: 'BL394D',
              quantity: 4,
              description: 'Basketball',
              price: 450
            },
            {
              sku: 'BL4438H',
              quantity: 1,
              description: 'Super Hoop',
              price: 2392
            }
          ],
          tax: 251.42,
          total: 4443.52,
          comments:
            'Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.'
        }
      ],
      warnings: [['Unresolved tag: tag:clarkevans.com,2002:invoice']]
    },

    'Example 2.28. Log File': {
      src: `---
Time: 2001-11-23 15:01:42 -5
User: ed
Warning:
  This is an error message
  for the log file
---
Time: 2001-11-23 15:02:31 -5
User: ed
Warning:
  A slightly different error
  message.
---
Date: 2001-11-23 15:03:17 -5
User: ed
Fatal:
  Unknown variable "bar"
Stack:
  - file: TopClass.py
    line: 23
    code: |
      x = MoreObject("345\\n")
  - file: MoreClass.py
    line: 58
    code: |-
      foo = bar\n`,
      tgt: [
        {
          Time: '2001-11-23 15:01:42 -5',
          User: 'ed',
          Warning: 'This is an error message for the log file'
        },
        {
          Time: '2001-11-23 15:02:31 -5',
          User: 'ed',
          Warning: 'A slightly different error message.'
        },
        {
          Date: '2001-11-23 15:03:17 -5',
          User: 'ed',
          Fatal: 'Unknown variable "bar"',
          Stack: [
            {
              file: 'TopClass.py',
              line: 23,
              code: 'x = MoreObject("345\\n")\n'
            },
            { file: 'MoreClass.py', line: 58, code: 'foo = bar' }
          ]
        }
      ]
    }
  },

  '5.3. Indicator Characters': {
    'Example 5.3. Block Structure Indicators': {
      src: `sequence:
- one
- two
mapping:
  ? sky
  : blue
  sea : green`,
      tgt: [
        {
          sequence: ['one', 'two'],
          mapping: { sky: 'blue', sea: 'green' }
        }
      ]
    },

    'Example 5.4. Flow Collection Indicators': {
      src: `sequence: [ one, two, ]
mapping: { sky: blue, sea: green }`,
      tgt: [
        {
          sequence: ['one', 'two'],
          mapping: { sky: 'blue', sea: 'green' }
        }
      ]
    },

    'Example 5.5. Comment Indicator': {
      src: `# Comment only.`,
      tgt: [],
      special(src) {
        const doc = YAML.parseDocument(src)
        expect(doc.commentBefore).toBe(' Comment only.')
      }
    },

    'Example 5.6. Node Property Indicators': {
      src: `anchored: !local &anchor value
alias: *anchor`,
      tgt: [{ anchored: 'value', alias: 'value' }],
      warnings: [['Unresolved tag: !local']],
      special(src) {
        const tag = { tag: '!local', resolve: (str: string) => `local:${str}` }
        const res = YAML.parse(src, { customTags: [tag] })
        expect(res).toMatchObject({
          anchored: 'local:value',
          alias: 'local:value'
        })
      }
    },

    'Example 5.7. Block Scalar Indicators': {
      src: `literal: |
  some
  text
folded: >
  some
  text
`,
      tgt: [
        {
          literal: 'some\ntext\n',
          folded: 'some text\n'
        }
      ]
    },

    'Example 5.8. Quoted Scalar Indicators': {
      src: `single: 'text'
double: "text"`,
      tgt: [{ single: 'text', double: 'text' }]
    },

    'Example 5.9. Directive Indicator': {
      src: `%YAML 1.2
--- text`,
      tgt: ['text'],
      special(src) {
        const doc = YAML.parseDocument(src)
        expect(doc.directives.yaml).toMatchObject({
          version: '1.2',
          explicit: true
        })
      }
    },

    'Example 5.10. Invalid use of Reserved Indicators': {
      src: `commercial-at: @text
grave-accent: \`text`,
      tgt: [{ 'commercial-at': '@text', 'grave-accent': '`text' }],
      errors: [
        [
          'Plain value cannot start with reserved character @',
          'Plain value cannot start with reserved character `'
        ]
      ]
    }
  },
  '5.5. White Space Characters': {
    'Example 5.12. Tabs and Spaces': {
      src: `# Tabs and spaces
quoted: "Quoted \t"
block:\t|
  void main() {
  \tprintf("Hello, world!\\n");
  }`,
      tgt: [
        {
          quoted: 'Quoted \t',
          block: 'void main() {\n\tprintf("Hello, world!\\n");\n}\n'
        }
      ]
    }
  },

  '5.7. Escaped Characters': {
    'Example 5.13. Escaped Characters': {
      src: `"Fun with \\\\
\\" \\a \\b \\e \\f \\
\\n \\r \\t \\v \\0 \\
\\  \\_ \\N \\L \\P \\
\\x41 \\u0041 \\U00000041"`,
      tgt: [
        'Fun with \x5C \x22 \x07 \x08 \x1B \x0C \x0A \x0D \x09 \x0B \x00 \x20 \xA0 \x85 \u2028 \u2029 A A A'
      ]
    },

    'Example 5.14. Invalid Escaped Characters': {
      src: `Bad escapes:
  "\\c
  \\xq-"`,
      tgt: [{ 'Bad escapes': '\\c \\xq-' }],
      errors: [['Invalid escape sequence \\c', 'Invalid escape sequence \\xq-']]
    }
  },

  '6.1. Indentation Spaces': {
    'Example 6.1. Indentation Spaces': {
      src: `  # Leading comment line spaces are
   # neither content nor indentation.

Not indented:
 By one space: |
    By four
      spaces
 Flow style: [    # Leading spaces
   By two,        # in flow style
  Also by two,    # are neither
  \tStill by two   # content nor
    ]             # indentation.`,
      tgt: [
        {
          'Not indented': {
            'By one space': 'By four\n  spaces\n',
            'Flow style': ['By two', 'Also by two', 'Still by two']
          }
        }
      ]
    },

    'Example 6.2. Indentation Indicators': {
      src: `? a
: -\tb
  -  -\tc
     - d`,
      tgt: [{ a: ['b', ['c', 'd']] }]
    }
  },

  '6.2. Separation Spaces': {
    'Example 6.3. Separation Spaces': {
      src: `- foo:\t bar
- - baz
  -\tbaz`,
      tgt: [[{ foo: 'bar' }, ['baz', 'baz']]]
    }
  },

  '6.3. Line Prefixes': {
    'Example 6.4. Line Prefixes': {
      src: `plain: text
  lines
quoted: "text
  \tlines"
block: |
  text
   \tlines`,
      tgt: [
        {
          plain: 'text lines',
          quoted: 'text lines',
          block: 'text\n \tlines\n'
        }
      ]
    }
  },

  '6.4. Empty Lines': {
    'Example 6.5. Empty Lines': {
      src: `Folding:
  "Empty line
   \t
  as a line feed"
Chomping: |
  Clipped empty lines
 `,
      tgt: [
        {
          Folding: 'Empty line\nas a line feed',
          Chomping: 'Clipped empty lines\n'
        }
      ]
    }
  },

  '6.5. Line Folding': {
    'Example 6.6. Line Folding': {
      src: `>-
  trimmed
··
·

··as
··space`.replace(/·/g, ' '),
      tgt: ['trimmed\n\n\nas space']
    },

    'Example 6.7. Block Folding': {
      src: `>
··foo·
·
··\t·bar

··baz\n`.replace(/·/g, ' '),
      tgt: ['foo \n\n\t bar\n\nbaz\n']
    },

    'Example 6.8. Flow Folding': {
      src: `"
  foo\t
\t
  \t bar

  baz
"`,
      tgt: [' foo\nbar\nbaz ']
    }
  },

  '6.6. Comments': {
    'Example 6.9. Separated Comment': {
      src: `key:    # Comment
  value`,
      tgt: [{ key: 'value' }]
    },

    'Example 6.10. Comment Lines': {
      src: `  # Comment
   \n\n`,
      tgt: [],
      special(src) {
        const doc = YAML.parseDocument(src)
        expect(doc.commentBefore).toBe(' Comment')
      }
    },

    'Example 6.11. Multi-Line Comments': {
      src: `key:    # Comment
        # lines
  value\n`,
      tgt: [{ key: 'value' }]
    }
  },
  '6.7. Separation Lines': {
    'Example 6.12. Separation Spaces': {
      src: `{ first: Sammy, last: Sosa }:
# Statistics:
  hr:  # Home runs
     65
  avg: # Average
   0.278`,
      tgt: [{ '{ first: Sammy, last: Sosa }': { hr: 65, avg: 0.278 } }],
      jsWarnings: [collectionKeyWarning]
    }
  },
  '6.8. Directives': {
    'Example 6.13. Reserved Directives': {
      src: `%FOO  bar baz # Should be ignored
# with a warning.
--- "foo"`,
      tgt: ['foo'],
      warnings: [['Unknown directive %FOO']]
    }
  },
  '6.8.1. “YAML” Directives': {
    'Example 6.14. “YAML” directive': {
      src: `%YAML 1.3 # Attempt parsing
           # with a warning
---
"foo"`,
      tgt: ['foo'],
      warnings: [['Unsupported YAML version 1.3']],
      special(src) {
        const doc = YAML.parseDocument(src)
        expect(doc.directives.yaml).toMatchObject({
          version: '1.2',
          explicit: true
        })
      }
    },

    'Example 6.15. Invalid Repeated YAML directive': {
      src: `%YAML 1.2
%YAML 1.1
---
foo`,
      tgt: ['foo'],
      special(src) {
        const doc = YAML.parseDocument(src)
        expect(doc.directives.yaml).toMatchObject({
          version: '1.1',
          explicit: true
        })
      }
    }
  },
  '6.8.2. “TAG” Directives': {
    'Example 6.16. “TAG” directive': {
      src: `%TAG !yaml! tag:yaml.org,2002:
---
!yaml!str "foo"`,
      tgt: ['foo']
    },

    'Example 6.17. Invalid Repeated TAG directive': {
      src: `%TAG ! !foo
%TAG ! !foo
---
bar`,
      tgt: ['bar'],
      special(src) {
        const doc = YAML.parseDocument(src)
        expect(doc.directives.tags).toMatchObject({
          '!!': 'tag:yaml.org,2002:',
          '!': '!foo'
        })
      }
    },

    'Example 6.18. Primary Tag Handle': {
      src: `# Private
!foo "bar"
...
# Global
%TAG ! tag:example.com,2000:app/
---
!foo "bar"`,
      tgt: ['bar', 'bar'],
      warnings: [
        ['Unresolved tag: !foo'],
        ['Unresolved tag: tag:example.com,2000:app/foo']
      ],
      special(src) {
        const customTags = [
          {
            tag: '!foo',
            resolve: () => 'private'
          },
          {
            tag: 'tag:example.com,2000:app/foo',
            resolve: () => 'global'
          }
        ]
        const docs = YAML.parseAllDocuments(src, { customTags })
        expect(docs.map(d => d.toJS())).toMatchObject(['private', 'global'])
      }
    },

    'Example 6.19. Secondary Tag Handle': {
      src: `%TAG !! tag:example.com,2000:app/
---
!!int 1 - 3 # Interval, not integer`,
      tgt: ['1 - 3'],
      warnings: [['Unresolved tag: tag:example.com,2000:app/int']],
      special(src) {
        const tag = {
          tag: 'tag:example.com,2000:app/int',
          resolve: () => 'interval'
        }
        const res = YAML.parse(src, { customTags: [tag] })
        expect(res).toBe('interval')
      }
    },

    'Example 6.20. Tag Handles': {
      src: `%TAG !e! tag:example.com,2000:app/
---
!e!foo "bar"`,
      tgt: ['bar'],
      warnings: [['Unresolved tag: tag:example.com,2000:app/foo']],
      special(src) {
        const tag = {
          tag: 'tag:example.com,2000:app/foo',
          resolve: (str: string) => `foo${str}`
        }
        const res = YAML.parse(src, { customTags: [tag] })
        expect(res).toBe('foobar')
      }
    },

    'Example 6.21. Local Tag Prefix': {
      src: `%TAG !m! !my-
--- # Bulb here
!m!light fluorescent
...
%TAG !m! !my-
--- # Color here
!m!light green`,
      tgt: ['fluorescent', 'green'],
      warnings: [['Unresolved tag: !my-light'], ['Unresolved tag: !my-light']],
      special(src) {
        const tag = {
          tag: '!my-light',
          resolve: (str: string) => `light:${str}`
        }
        const docs = YAML.parseAllDocuments(src, { customTags: [tag] })
        expect(docs.map(d => d.toJS())).toMatchObject([
          'light:fluorescent',
          'light:green'
        ])
      }
    },

    'Example 6.22. Global Tag Prefix': {
      src: `%TAG !e! tag:example.com,2000:app/
---
- !e!foo "bar"`,
      tgt: [['bar']],
      warnings: [['Unresolved tag: tag:example.com,2000:app/foo']],
      special(src) {
        const tag = {
          tag: 'tag:example.com,2000:app/foo',
          resolve: (str: string) => `foo${str}`
        }
        const res = YAML.parse(src, { customTags: [tag] })
        expect(res).toMatchObject(['foobar'])
      }
    }
  },
  '6.9. Node Properties': {
    'Example 6.23. Node Properties': {
      src: `!!str &a1 "foo":
  !!str bar
&a2 baz : *a1`,
      tgt: [{ foo: 'bar', baz: 'foo' }]
    },

    'Example 6.24. Verbatim Tags': {
      src: `! foo :
  ! baz`,
      tgt: [{ foo: 'baz' }],
      warnings: [['Unresolved tag: !bar']],
      special(src) {
        const tag = { tag: '!bar', resolve: (str: string) => `bar${str}` }
        const res = YAML.parse(src, { customTags: [tag] })
        expect(res).toMatchObject({ foo: 'barbaz' })
      }
    },

    'Example 6.25. Invalid Verbatim Tags': {
      src: `- ! foo
- !<$:?> bar`,
      tgt: [['foo', 'bar']],
      errors: [["Verbatim tags aren't resolved, so ! is invalid."]],
      warnings: [['Unresolved tag: $:?']]
    },

    'Example 6.26. Tag Shorthands': {
      src: `%TAG !e! tag:example.com,2000:app/
---
- !local foo
- !!str bar
- !e!tag%21 baz`,
      tgt: [['foo', 'bar', 'baz']],
      warnings: [
        [
          'Unresolved tag: !local',
          'Unresolved tag: tag:example.com,2000:app/tag!'
        ]
      ],
      special(src) {
        const customTags = [
          { tag: '!local', resolve: (str: string) => `local:${str}` },
          {
            tag: 'tag:example.com,2000:app/tag!',
            resolve: (str: string) => `tag!${str}`
          }
        ]
        const res = YAML.parse(src, { customTags })
        expect(res).toMatchObject(['local:foo', 'bar', 'tag!baz'])
      }
    },

    'Example 6.27. Invalid Tag Shorthands': {
      src: `%TAG !e! tag:example,2000:app/
---
- !e! foo
- !h!bar baz`,
      tgt: [['foo', 'baz']],
      errors: [['The !e! tag has no suffix', 'Could not resolve tag: !h!bar']],
      warnings: [['Unresolved tag: tag:example,2000:app/']]
    },

    'Example 6.28. Non-Specific Tags': {
      src: `# Assuming conventional resolution:
- "12"
- 12
- ! 12`,
      tgt: [['12', 12, '12']]
    },

    'Example 6.29. Node Anchors': {
      src: `First occurrence: &anchor Value
Second occurrence: *anchor`,
      tgt: [
        {
          'First occurrence': 'Value',
          'Second occurrence': 'Value'
        }
      ]
    }
  },

  '7.1. Alias Nodes': {
    'Example 7.1. Alias Nodes': {
      src: `First occurrence: &anchor Foo
Second occurrence: *anchor
Override anchor: &anchor Bar
Reuse anchor: *anchor`,
      tgt: [
        {
          'First occurrence': 'Foo',
          'Second occurrence': 'Foo',
          'Override anchor': 'Bar',
          'Reuse anchor': 'Bar'
        }
      ]
    }
  },

  '7.2. Empty Nodes': {
    'Example 7.2. Empty Content': {
      src: `{
  foo : !!str,
  !!str : bar,
}`,
      tgt: [{ foo: '', '': 'bar' }]
    },

    'Example 7.3. Completely Empty Flow Nodes': {
      src: `{
  ? foo :,
  : bar,
}`,
      tgt: [{ foo: null, '': 'bar' }]
    }
  },

  '7.3.1. Double-Quoted Style': {
    'Example 7.4. Double Quoted Implicit Keys': {
      src: `"implicit block key" : [
  "implicit flow key" : value,
 ]`,
      tgt: [{ 'implicit block key': [{ 'implicit flow key': 'value' }] }]
    },

    'Example 7.5. Double Quoted Line Breaks': {
      src: `"folded
to a space,\t

to a line feed, or \t\\
 \\ \tnon-content"`,
      tgt: ['folded to a space,\nto a line feed, or \t \tnon-content']
    },

    'Example 7.6. Double Quoted Lines': {
      src: `" 1st non-empty

 2nd non-empty
\t3rd non-empty "`,
      tgt: [' 1st non-empty\n2nd non-empty 3rd non-empty ']
    }
  },

  '7.3.2. Single-Quoted Style': {
    'Example 7.7. Single Quoted Characters': {
      src: ` 'here''s to "quotes"'`,
      tgt: ['here\'s to "quotes"']
    },

    'Example 7.8. Single Quoted Implicit Keys': {
      src: `'implicit block key' : [
  'implicit flow key' : value,
 ]`,
      tgt: [{ 'implicit block key': [{ 'implicit flow key': 'value' }] }]
    },

    'Example 7.9. Single Quoted Lines': {
      src: `' 1st non-empty

 2nd non-empty\t
\t3rd non-empty '`,
      tgt: [' 1st non-empty\n2nd non-empty 3rd non-empty ']
    }
  },

  '7.3.3. Plain Style': {
    'Example 7.10. Plain Characters': {
      src: `# Outside flow collection:
- ::vector
- ": - ()"
- Up, up, and away!
- -123
- http://example.com/foo#bar
# Inside flow collection:
- [ ::vector,
  ": - ()",
  "Up, up and away!",
  -123,
  http://example.com/foo#bar ]`,
      tgt: [
        [
          '::vector',
          ': - ()',
          'Up, up, and away!',
          -123,
          'http://example.com/foo#bar',
          [
            '::vector',
            ': - ()',
            'Up, up and away!',
            -123,
            'http://example.com/foo#bar'
          ]
        ]
      ]
    },

    'Example 7.11. Plain Implicit Keys': {
      src: `implicit block key : [
  implicit flow key : value,
 ]`,
      tgt: [{ 'implicit block key': [{ 'implicit flow key': 'value' }] }]
    },

    'Example 7.12. Plain Lines': {
      src: `1st non-empty

 2nd non-empty
\t3rd non-empty`,
      tgt: ['1st non-empty\n2nd non-empty 3rd non-empty']
    }
  },

  '7.4.1. Flow Sequences': {
    'Example 7.13. Flow Sequence': {
      src: `- [ one, two, ]
- [three ,four]`,
      tgt: [
        [
          ['one', 'two'],
          ['three', 'four']
        ]
      ]
    },

    'Example 7.14. Flow Sequence Entries': {
      src: `[
"double
 quoted", 'single
           quoted',
plain
 text, [ nested ],
single: pair,
]`,
      tgt: [
        [
          'double quoted',
          'single quoted',
          'plain text',
          ['nested'],
          { single: 'pair' }
        ]
      ]
    }
  },

  '7.4.2. Flow Mappings': {
    'Example 7.15. Flow Mappings': {
      src: `- { one : two , three: four , }
- {five: six,seven : eight}`,
      tgt: [
        [
          { one: 'two', three: 'four' },
          { five: 'six', seven: 'eight' }
        ]
      ]
    },

    'Example 7.16. Flow Mapping Entries': {
      src: `{
? explicit: entry,
implicit: entry,
?
}`,
      tgt: [{ explicit: 'entry', implicit: 'entry', '': null }]
    },

    'Example 7.17. Flow Mapping Separate Values': {
      src: `{
unquoted : "separate",
http://foo.com,
omitted value:,
: omitted key,
}`,
      tgt: [
        {
          unquoted: 'separate',
          'http://foo.com': null,
          'omitted value': null,
          '': 'omitted key'
        }
      ]
    },

    'Example 7.18. Flow Mapping Adjacent Values': {
      src: `{
"adjacent":value,
"readable": value,
"empty":
}`,
      tgt: [{ adjacent: 'value', readable: 'value', empty: null }]
    },

    'Example 7.19. Single Pair Flow Mappings': {
      src: `[
foo: bar
]`,
      tgt: [[{ foo: 'bar' }]]
    },

    'Example 7.20. Single Pair Explicit Entry': {
      src: `[
? foo
 bar : baz
]`,
      tgt: [[{ 'foo bar': 'baz' }]]
    },

    'Example 7.21. Single Pair Implicit Entries': {
      src: `- [ YAML : separate ]
- [ : empty key entry ]
- [ {JSON: like}:adjacent ]`,
      tgt: [
        [
          [{ YAML: 'separate' }],
          [{ '': 'empty key entry' }],
          [{ '{ JSON: like }': 'adjacent' }]
        ]
      ],
      jsWarnings: [collectionKeyWarning]
    },

    'Example 7.22. Invalid Implicit Keys': {
      src: `[ foo
 bar: invalid,
 "foo ${'x'.repeat(1024)} bar": invalid ]`,
      tgt: [
        [
          { 'foo bar': 'invalid' },
          {
            'foo xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx bar':
              'invalid'
          }
        ]
      ],
      errors: [
        [
          'Implicit keys of flow sequence pairs need to be on a single line',
          'The : indicator must be at most 1024 chars after the start of an implicit flow sequence key'
        ]
      ]
    }
  },

  '7.5. Flow Nodes': {
    'Example 7.23. Flow Content': {
      src: `- [ a, b ]
- { a: b }
- "a"
- 'b'
- c`,
      tgt: [[['a', 'b'], { a: 'b' }, 'a', 'b', 'c']]
    },

    'Example 7.24. Flow Nodes': {
      src: `- !!str "a"
- 'b'
- &anchor "c"
- *anchor
- !!str`,
      tgt: [['a', 'b', 'c', 'c', '']]
    }
  },

  '8.1.1. Block Scalar Headers': {
    'Example 8.1. Block Scalar Header': {
      src: `- | # Empty header
 literal
- >1 # Indentation indicator
  folded
- |+ # Chomping indicator
 keep

- >1- # Both indicators
  strip`,
      tgt: [['literal\n', ' folded\n', 'keep\n\n', ' strip']]
    },

    'Example 8.2. Block Indentation Indicator': {
      src: `- |
·detected
- >
·
··
··# detected
- |1
··explicit
- >
·\t
·detected`.replace(/·/g, ' '),
      tgt: [['detected\n', '\n\n# detected\n', ' explicit\n', '\t\ndetected\n']]
    },

    'Example 8.3. Invalid Block Scalar Indentation Indicators': {
      src: `- |
··
·text
---
- >
··text
·text
---
- |2
·text`.replace(/·/g, ' '),
      tgt: [[' \ntext\n'], ['text\n', 'text'], ['', 'text']],
      errors: [
        [
          'Block scalars with more-indented leading empty lines must use an explicit indentation indicator'
        ],
        ['Sequence item without - indicator'],
        ['Sequence item without - indicator']
      ]
    },

    'Example 8.4. Chomping Final Line Break': {
      src: `strip: |-
  text
clip: |
  text
keep: |+
  text\n`,
      tgt: [{ strip: 'text', clip: 'text\n', keep: 'text\n' }]
    },

    'Example 8.5. Chomping Trailing Lines': {
      src: `
 # Strip
  # Comments:
strip: |-
  # text

 # Clip
  # comments:

clip: |
  # text

 # Keep
  # comments:

keep: |+
  # text

 # Trail
  # comments.`,
      tgt: [{ strip: '# text', clip: '# text\n', keep: '# text\n\n' }]
    },

    'Example 8.6. Empty Scalar Chomping': {
      src: `strip: >-

clip: >

keep: |+\n\n`,
      tgt: [{ strip: '', clip: '', keep: '\n' }]
    }
  },

  '8.1.2. Literal Style': {
    'Example 8.7. Literal Scalar': {
      src: `|
 literal
 \ttext\n\n`,
      tgt: ['literal\n\ttext\n']
    },

    'Example 8.8. Literal Content': {
      src: `|
·
··
··literal
···
··
··text

·# Comment`.replace(/·/g, ' '),
      tgt: ['\n\nliteral\n \n\ntext\n']
    }
  },

  '8.1.3. Folded Style': {
    'Example 8.9. Folded Scalar': {
      src: `>
 folded
 text\n\n`,
      tgt: ['folded text\n']
    },

    'Example 8.10. Folded Lines': {
      src: `>

 folded
 line

 next
 line
   * bullet

   * list
   * lines

 last
 line

# Comment`,
      tgt: [
        `
folded line
next line
  * bullet

  * list
  * lines

last line
`
      ]
    }
  },

  '8.2.1. Block Sequences': {
    'Example 8.14. Block Sequence': {
      src: `block sequence:
  - one
  - two : three\n`,
      tgt: [{ 'block sequence': ['one', { two: 'three' }] }]
    },

    'Example 8.15. Block Sequence Entry Types': {
      src: `- # Empty
- |
 block node
- - one # Compact
  - two # sequence
- one: two # Compact mapping`,
      tgt: [[null, 'block node\n', ['one', 'two'], { one: 'two' }]]
    }
  },

  '8.2.2. Block Mappings': {
    'Example 8.16. Block Mappings': {
      src: `block mapping:
 key: value\n`,
      tgt: [{ 'block mapping': { key: 'value' } }]
    },

    'Example 8.17. Explicit Block Mapping Entries': {
      src: `? explicit key # Empty value
? |
  block key
: - one # Explicit compact
  - two # block value\n`,
      tgt: [
        {
          'explicit key': null,
          'block key\n': ['one', 'two']
        }
      ]
    },

    'Example 8.18. Implicit Block Mapping Entries': {
      src: `plain key: in-line value
: # Both empty
"quoted key":
- entry`,
      tgt: [
        {
          'plain key': 'in-line value',
          '': null,
          'quoted key': ['entry']
        }
      ]
    },

    'Example 8.19. Compact Block Mappings': {
      src: `- sun: yellow
- ? earth: blue
  : moon: white\n`,
      tgt: [[{ sun: 'yellow' }, { '{ earth: blue }': { moon: 'white' } }]],
      jsWarnings: [collectionKeyWarning]
    }
  },

  '8.2.3. Block Nodes': {
    'Example 8.20. Block Types': {
      src: `-
  "flow in block"
- >
 Block scalar
- !!map # Block collection
  foo : bar\n`,
      tgt: [['flow in block', 'Block scalar\n', { foo: 'bar' }]]
    },

    'Example 8.21. Block Scalar Nodes': {
      src: `literal: |2
  value
folded:
   !foo
  >1
 value`,
      tgt: [{ literal: 'value\n', folded: 'value\n' }],
      warnings: [['Unresolved tag: !foo']],
      special(src) {
        const tag = { tag: '!foo', resolve: (str: string) => `foo${str}` }
        const res = YAML.parse(src, { customTags: [tag] })
        expect(res).toMatchObject({ literal: 'value\n', folded: 'foovalue\n' })
      }
    },

    'Example 8.22. Block Collection Nodes': {
      src: `sequence: !!seq
- entry
- !!seq
 - nested
mapping: !!map
 foo: bar`,
      tgt: [
        {
          sequence: ['entry', ['nested']],
          mapping: { foo: 'bar' }
        }
      ],
      special(src) {
        const doc = YAML.parseDocument, false>(src)
        expect(doc.contents.tag).toBeUndefined()
        expect(doc.contents.items[0].value.tag).toBe('tag:yaml.org,2002:seq')
        expect(doc.contents.items[0].value.items[1].tag).toBe(
          'tag:yaml.org,2002:seq'
        )
        expect(doc.contents.items[1].value.tag).toBe('tag:yaml.org,2002:map')
      }
    }
  },

  '9.1. Documents': {
    'Example 9.1. Document Prefix': {
      src: `\u{FEFF}# Comment
# lines
Document`,
      tgt: ['Document']
    },

    'Example 9.2. Document Markers': {
      src: `%YAML 1.2
---
Document
... # Suffix`,
      tgt: ['Document'],
      special(src) {
        expect(YAML.parseDocument(src).directives.yaml).toMatchObject({
          version: '1.2',
          explicit: true
        })
      }
    },

    'Example 9.3. Bare Documents': {
      src: `Bare
document
...
# No document
...
|
%!PS-Adobe-2.0 # Not the first line`,
      tgt: ['Bare document', null, '%!PS-Adobe-2.0 # Not the first line\n']
    },

    'Example 9.4. Explicit Documents': {
      src: `---
{ matches
% : 20 }
...
---
# Empty
...`,
      tgt: [{ 'matches %': 20 }, null]
    },

    'Example 9.5. Directives Documents': {
      src: `%YAML 1.2
--- |
%!PS-Adobe-2.0
...
%YAML 1.2
---
# Empty
...`,
      tgt: ['%!PS-Adobe-2.0\n', null],
      special(src) {
        expect(
          YAML.parseAllDocuments(src).map(doc => doc.directives.yaml)
        ).toMatchObject([
          { version: '1.2', explicit: true },
          { version: '1.2', explicit: true }
        ])
      }
    }
  },

  '9.2. Streams': {
    'Example 9.6. Stream': {
      src: `Document
---
# Empty
...
%YAML 1.2
---
matches %: 20`,
      tgt: ['Document', null, { 'matches %': 20 }],
      special(src) {
        expect(
          YAML.parseAllDocuments(src).map(doc => doc.directives.yaml)
        ).toMatchObject([
          { version: '1.2', explicit: false },
          { version: '1.2', explicit: false },
          { version: '1.2', explicit: true }
        ])
      }
    }
  }
}

const mockWarn = jest.spyOn(global.process, 'emitWarning').mockImplementation()
beforeEach(() => mockWarn.mockClear())
afterAll(() => mockWarn.mockRestore())

for (const section in spec) {
  describe(section, () => {
    for (const name in spec[section]) {
      test(name, () => {
        const { src, tgt, errors, special, jsWarnings, warnings } =
          spec[section][name]
        const documents = YAML.parseAllDocuments(src, { prettyErrors: false })
        const json = documents.map(doc => doc.toJS())
        expect(json).toMatchObject(tgt)
        documents.forEach((doc, i) => {
          expect(doc.errors.map(err => err.message)).toMatchObject(
            errors?.[i] ?? []
          )
          expect(new Set(doc.warnings.map(err => err.message))).toMatchObject(
            new Set(warnings?.[i] ?? [])
          )
          for (const err of doc.errors.concat(doc.warnings))
            expect(err).toBeInstanceOf(YAMLError)
          if (!jsWarnings) expect(mockWarn).not.toHaveBeenCalled()
          else {
            for (const warning of jsWarnings)
              expect(
                mockWarn.mock.calls.some(call => warning.test(String(call[0])))
              )
          }
        })
        if (special) special(src)
        if (!errors) {
          const src2 = documents.map(String).join('')
          const documents2 = YAML.parseAllDocuments(src2, {
            prettyErrors: false
          })
          const json2 = documents2.map(doc => doc.toJS())
          expect(json2).toMatchObject(tgt)
        }
      })
    }
  })
}
eemeli-yaml-086fa6b/tests/doc/anchors.ts000066400000000000000000000330321511277410200202450ustar00rootroot00000000000000import type { Alias, YAMLMap, YAMLSeq } from 'yaml'
import { Document, parse, parseDocument } from 'yaml'

test('basic', () => {
  const src = `- &a 1\n- *a\n`
  const doc = parseDocument(src)
  expect(doc.errors).toHaveLength(0)
  expect(doc.contents?.items).toMatchObject([
    { anchor: 'a', value: 1 },
    { source: 'a' }
  ])
  expect(String(doc)).toBe(src)
})

test('re-defined anchor', () => {
  const src = '- &a 1\n- &a 2\n- *a\n'
  const doc = parseDocument(src)
  expect(doc.errors).toHaveLength(0)
  expect(doc.contents?.items).toMatchObject([
    { anchor: 'a', value: 1 },
    { anchor: 'a', value: 2 },
    { source: 'a' }
  ])
  expect(doc.toJS()).toMatchObject([1, 2, 2])
  expect(String(doc)).toBe('- &a 1\n- &a 2\n- *a\n')
})

test('circular reference', () => {
  const src = '&a [ 1, *a ]\n'
  const doc = parseDocument(src)
  expect(doc.errors).toHaveLength(0)
  expect(doc.warnings).toHaveLength(0)
  expect(doc.contents).toMatchObject({
    anchor: 'a',
    items: [{ value: 1 }, { source: 'a' }]
  })
  const res = doc.toJS()
  expect(res[1]).toBe(res)
  expect(String(doc)).toBe(src)
})

describe('anchor on tagged collection', () => {
  test('!!set', () => {
    const res = parse('- &a !!set { 1, 2 }\n- *a\n')
    expect(Array.from(res[0])).toMatchObject([1, 2])
    expect(res[1]).toBe(res[0])
  })

  test('!!omap', () => {
    const res = parse('- &a !!omap [ 1: 1, 2: 2 ]\n- *a\n')
    expect(Array.from(res[0])).toMatchObject([
      [1, 1],
      [2, 2]
    ])
    expect(res[1]).toBe(res[0])
  })
})

describe('create', () => {
  test('node.anchor', () => {
    const doc = parseDocument('[{ a: A }, { b: B }]')
    doc.get(0).anchor = 'AA'
    doc.getIn([0, 'a'], true).anchor = 'a'
    doc.getIn([0, 'a'], true).anchor = ''
    doc.getIn([1, 'b'], true).anchor = 'BB'
    expect(String(doc)).toBe('[ &AA { a: A }, { b: &BB B } ]\n')
  })

  test('doc.createAlias', () => {
    const doc = parseDocument('[{ a: A }, { b: B }]')
    const alias = doc.createAlias(doc.get(0), 'AA')
    doc.contents?.items.push(alias)
    expect(doc.toJS()).toMatchObject([{ a: 'A' }, { b: 'B' }, { a: 'A' }])
    const alias2 = doc.createAlias(doc.get(1), 'AA')
    expect(doc.get(1).anchor).toBe('AA1')
    expect(alias2.source).toBe('AA1')
    expect(String(doc)).toMatch('[ &AA { a: A }, &AA1 { b: B }, *AA ]\n')
  })

  test('repeated Array in createNode', () => {
    const doc = new Document()
    const ref: unknown[] = []
    const node = doc.createNode({ src: ref, ref })
    expect(node).toMatchObject({
      items: [
        { key: { value: 'src' }, value: { items: [], anchor: 'a1' } },
        { key: { value: 'ref' }, value: { source: 'a1' } }
      ]
    })
  })

  test('repeated Date in createNode', () => {
    const doc = new Document()
    const date = new Date()
    const value = date.toJSON()
    const node = doc.createNode({ src: date, ref: date })
    expect(node).toMatchObject({
      items: [
        { key: { value: 'src' }, value: { value, anchor: 'a1' } },
        { key: { value: 'ref' }, value: { source: 'a1' } }
      ]
    })
  })
})

describe('errors', () => {
  test('invalid anchor characters', () => {
    const doc = parseDocument('[{ a: A }, { b: B }]')
    doc.get(0).anchor = 'A A'
    expect(() => String(doc)).toThrow(
      'Anchor must not contain whitespace or control characters: "A A"'
    )
  })

  test('set tag on alias', () => {
    const doc = parseDocument, false>('[{ a: A }, { b: B }]')
    const node = doc.contents.items[0]
    const alias = doc.createAlias(node, 'AA')
    expect(() => {
      alias.tag = 'tag:yaml.org,2002:alias'
    }).toThrow('Alias nodes cannot have tags')
  })

  test('alias before anchor', () => {
    const doc = parseDocument, false>(
      '[{ a: A }, { b: B }]'
    )
    const alias = doc.createAlias(doc.get(0), 'AA')
    doc.contents.items.unshift(alias)
    expect(() => String(doc)).toThrow(
      'Unresolved alias (the anchor must be set before the alias): AA'
    )
  })

  test('empty alias', () => {
    const doc = parseDocument('- *\n')
    expect(doc.errors).toMatchObject([{ code: 'BAD_ALIAS' }])
  })

  test('empty anchor on value', () => {
    const doc = parseDocument('- & foo\n')
    expect(doc.errors).toMatchObject([{ code: 'BAD_ALIAS' }])
  })

  test('empty anchor at end', () => {
    const doc = parseDocument('- &\n')
    expect(doc.errors).toMatchObject([{ code: 'BAD_ALIAS' }])
  })
})

describe('warnings', () => {
  test('anchor ending in colon', () => {
    const doc = parseDocument('- &x:\n')
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toMatchObject([{ code: 'BAD_ALIAS' }])
  })

  test('alias ending in colon', () => {
    const doc = parseDocument('- *x:\n')
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toMatchObject([{ code: 'BAD_ALIAS' }])
  })
})

describe('__proto__ as anchor name', () => {
  test('parse', () => {
    const src = `- &__proto__ 1\n- *__proto__\n`
    const doc = parseDocument(src)
    expect(doc.errors).toHaveLength(0)
    expect(doc.contents?.items).toMatchObject([
      { anchor: '__proto__', value: 1 },
      { source: '__proto__' }
    ])
    expect(doc.toJS()).toMatchObject([1, 1])
    expect(String(doc)).toBe(src)
  })

  test('create/stringify', () => {
    const doc = parseDocument, false>(
      '[{ a: A }, { b: B }]'
    )
    const alias = doc.createAlias(doc.contents.items[0], '__proto__')
    doc.contents.items.push(alias)
    expect(doc.toJSON()).toMatchObject([{ a: 'A' }, { b: 'B' }, { a: 'A' }])
    expect(String(doc)).toMatch(
      '[ &__proto__ { a: A }, { b: B }, *__proto__ ]\n'
    )
  })
})

describe('merge <<', () => {
  const src = `---
- &CENTER { x: 1, y: 2 }
- &LEFT { x: 0, y: 2 }
- &BIG { r: 10 }
- &SMALL { r: 1 }

# All the following maps are equal:

- # Explicit keys
  x: 1
  y: 2
  r: 10
  label: center/big

- # Merge one map
  << : *CENTER
  r: 10
  label: center/big

- # Merge multiple maps
  << : [ *CENTER, *BIG ]
  label: center/big

- # Override with explicit tag
  !!merge << : [ *BIG, *LEFT, *SMALL ]
  x: 1
  label: center/big`

  test('YAML.parse with merge:true', () => {
    const res = parse(src, { merge: true })
    expect(res).toHaveLength(8)
    for (let i = 4; i < res.length; ++i) {
      expect(res[i]).toMatchObject({ x: 1, y: 2, r: 10, label: 'center/big' })
    }
  })

  test('YAML.parse with customTags:["merge"]', () => {
    const res = parse(src, { customTags: ['merge'] })
    expect(res).toHaveLength(8)
    for (let i = 4; i < res.length; ++i) {
      expect(res[i]).toMatchObject({ x: 1, y: 2, r: 10, label: 'center/big' })
    }
  })

  test('YAML.parse with merge:false', () => {
    const res = parse(src)
    expect(res).toHaveLength(8)
    for (let i = 5; i < res.length - 1; ++i) {
      expect(res[i]).toHaveProperty('<<')
    }
    expect(res[res.length - 1]).toMatchObject({
      x: 1,
      y: 2,
      r: 10,
      label: 'center/big'
    })
  })

  test('YAML.parseDocument', () => {
    const doc = parseDocument, false>(src, { merge: true })
    expect(
      doc.contents.items.slice(5).map(it => it.items[0].value)
    ).toMatchObject([
      { source: 'CENTER' },
      { items: [{ source: 'CENTER' }, { source: 'BIG' }] },
      { items: [{ source: 'BIG' }, { source: 'LEFT' }, { source: 'SMALL' }] }
    ])
  })

  test('alias is associated with a sequence', () => {
    const res = parse('- &items [{ a: A }, { b: B }]\n- { <<: *items, c: C }', {
      merge: true
    })
    expect(res[1]).toEqual({ a: 'A', b: 'B', c: 'C' })
  })

  describe('non-alias merges', () => {
    test('single map', () => {
      const res = parse('{ <<: { a: A }, b: B }', { merge: true })
      expect(res).toEqual({ a: 'A', b: 'B' })
    })

    test('multiple maps', () => {
      const res = parse('{ <<: [{ a: A }, { b: B }], c: C }', {
        merge: true
      })
      expect(res).toEqual({ a: 'A', b: 'B', c: 'C' })
    })

    test('mixed refs & maps', () => {
      const res = parse('{ <<: [{ a: &a { A: 1 } }, *a], b: B }', {
        merge: true
      })
      expect(res).toEqual({ a: { A: 1 }, A: 1, b: 'B' })
    })
  })

  describe('create', () => {
    test('simple case', () => {
      const doc = parseDocument, false>(
        '[{ a: A }, { b: B }]',
        { merge: true }
      )
      const [a, b] = doc.contents.items
      const merge = doc.createPair('<<', doc.createAlias(a))
      b.items.push(merge)
      expect(doc.toJS()).toMatchObject([{ a: 'A' }, { a: 'A', b: 'B' }])
      expect(String(doc)).toBe('[ &a1 { a: A }, { b: B, <<: *a1 } ]\n')
    })

    test('using customTags:["merge"]', () => {
      const doc = parseDocument, false>(
        '[{ a: A }, { b: B }]',
        { customTags: ['merge'] }
      )
      const [a, b] = doc.contents.items
      const merge = doc.createPair('<<', doc.createAlias(a))
      b.items.push(merge)
      expect(doc.toJS()).toMatchObject([{ a: 'A' }, { a: 'A', b: 'B' }])
      expect(String(doc)).toBe('[ &a1 { a: A }, { b: B, <<: *a1 } ]\n')
    })

    test('symbol value', () => {
      const doc = parseDocument, false>(
        '[{ a: A }, { b: B }]',
        { merge: true }
      )
      const [a, b] = doc.contents.items
      const merge = doc.createPair(Symbol('<<'), doc.createAlias(a))
      b.items.push(merge)
      expect(doc.toJS()).toMatchObject([{ a: 'A' }, { a: 'A', b: 'B' }])
      expect(String(doc)).toBe('[ &a1 { a: A }, { b: B, <<: *a1 } ]\n')
    })

    test('merge pair of an alias', () => {
      const doc = parseDocument, false>(
        '[{ a: A }, { b: B }]',
        { merge: true }
      )
      const [a, b] = doc.contents.items
      const alias = doc.createAlias(a, 'AA')
      const merge = doc.createPair('<<', alias)
      b.items.push(merge)
      expect(doc.toJS()).toMatchObject([{ a: 'A' }, { a: 'A', b: 'B' }])
      expect(String(doc)).toBe('[ &AA { a: A }, { b: B, <<: *AA } ]\n')
    })

    test('require map node', () => {
      const doc = parseDocument('[{ a: A }, { b: B }]', {
        merge: true
      })
      const alias = doc.createAlias(doc.getIn([0, 'a'], true))
      doc.addIn([1], doc.createPair('<<', alias))
      expect(String(doc)).toBe('[ { a: &a1 A }, { b: B, <<: *a1 } ]\n')
      expect(() => doc.toJS()).toThrow(
        'Merge sources must be maps or map aliases'
      )
    })
  })

  describe('merge multiple times', () => {
    const srcKeys = `
x:
  - &a
    k0: v1
    k1: v1
  - &b
    k1: v2
    k2: v2
y:
  k0: v0
  <<: *a
  <<: *b`

    const srcSeq = `
x:
  - &a
    k0: v1
    k1: v1
  - &b
    k1: v2
    k2: v2
y:
  k0: v0
  <<: [ *a, *b ]`

    const expObj = {
      x: [
        { k0: 'v1', k1: 'v1' },
        { k1: 'v2', k2: 'v2' }
      ],
      y: { k0: 'v0', k1: 'v1', k2: 'v2' }
    }

    const expMap = new Map([
      [
        'x',
        [
          new Map([
            ['k0', 'v1'],
            ['k1', 'v1']
          ]),
          new Map([
            ['k1', 'v2'],
            ['k2', 'v2']
          ])
        ]
      ],
      [
        'y',
        new Map([
          ['k0', 'v0'],
          ['k1', 'v1'],
          ['k2', 'v2']
        ])
      ]
    ])

    test('multiple merge keys, masAsMap: false', () => {
      const res = parse(srcKeys, { merge: true })
      expect(res).toEqual(expObj)
    })

    test('multiple merge keys, masAsMap: true', () => {
      const res = parse(srcKeys, { merge: true, mapAsMap: true })
      expect(res).toEqual(expMap)
    })

    test('sequence of anchors, masAsMap: false', () => {
      const res = parse(srcSeq, { merge: true })
      expect(res).toEqual(expObj)
    })

    test('sequence of anchors, masAsMap: true', () => {
      const res = parse(srcSeq, { merge: true, mapAsMap: true })
      expect(res).toEqual(expMap)
    })
  })

  test('do not throw error when key is null', () => {
    const src = ': 123'
    expect(() => parse(src, { merge: true })).not.toThrow()
  })

  describe('parse errors', () => {
    test('non-alias merge value', () => {
      const src = '{ <<: A, B: b }'
      expect(() => parse(src, { merge: true })).toThrow(
        'Merge sources must be maps or map aliases'
      )
    })

    test('non-map alias', () => {
      const src = '- &A a\n- { <<: *A, B: b }'
      expect(() => parse(src, { merge: true })).toThrow(
        'Merge sources must be maps or map aliases'
      )
    })

    test('immediate non-map merge value', () => {
      const src = '{ <<: [ [42] ], a: A }'
      expect(() => parse(src, { merge: true })).toThrow(
        'Merge sources must be maps or map aliases'
      )
    })

    test('circular reference', () => {
      const src = '&A { <<: *A, B: b }\n'
      const doc = parseDocument(src, { merge: true })
      expect(doc.errors).toHaveLength(0)
      expect(doc.warnings).toHaveLength(0)
      expect(() => doc.toJS()).toThrow('Maximum call stack size exceeded')
      expect(String(doc)).toBe(src)
    })

    test('missing whitespace', () => {
      expect(() => parse('&a{}')).toThrow(
        'Tags and anchors must be separated from the next token by white space'
      )
    })
  })

  describe('stringify', () => {
    test('example', () => {
      const doc = parseDocument(src, { merge: true })
      expect(parse(String(doc), { merge: true })).toMatchObject([
        { x: 1, y: 2 },
        { x: 0, y: 2 },
        { r: 10 },
        { r: 1 },
        { label: 'center/big', r: 10, x: 1, y: 2 },
        { label: 'center/big', r: 10, x: 1, y: 2 },
        { label: 'center/big', r: 10, x: 1, y: 2 },
        { label: 'center/big', r: 10, x: 1, y: 2 }
      ])
    })
  })
})
eemeli-yaml-086fa6b/tests/doc/comments.ts000066400000000000000000000730601511277410200204420ustar00rootroot00000000000000import { source } from '../_utils.ts'
import * as YAML from 'yaml'

describe('parse comments', () => {
  describe('body', () => {
    test('directives', () => {
      const src = '#comment\n%YAML 1.2 #comment\n---\nstring\n'
      const doc = YAML.parseDocument(src)
      expect(doc.commentBefore).toBe('comment\ncomment')
      expect(String(doc)).toBe('#comment\n#comment\n\n%YAML 1.2\n---\nstring\n')
    })

    test('body start comments', () => {
      const src = source`
        ---
        #comment
        #comment
        string
      `
      const doc = YAML.parseDocument(src)
      expect(doc.contents.commentBefore).toBe('comment\ncomment')
      expect(String(doc)).toBe(src)
    })

    test('body start comments with empty comment line', () => {
      const src = source`
        ---
        #comment
        #
        #comment
        string
      `
      const doc = YAML.parseDocument(src)
      expect(doc.contents.commentBefore).toBe('comment\n \ncomment')
      expect(String(doc)).toBe(source`
        ---
        #comment
        #
        #comment
        string
      `)
    })

    test('body end comments', () => {
      const src = '\nstring\n#comment\n#comment\n'
      const doc = YAML.parseDocument(src)
      expect(doc.comment).toBe('comment\ncomment')
      expect(String(doc)).toBe('string\n\n#comment\n#comment\n')
    })
  })

  describe('top-level scalar comments', () => {
    test('plain', () => {
      const src = '#c0\nvalue #c1\n#c2'
      const doc = YAML.parseDocument(src)
      expect(doc.contents.commentBefore).toBe('c0')
      expect(doc.contents.comment).toBe('c1')
      expect(doc.comment).toBe('c2')
      expect(doc.contents.value).toBe('value')
      expect(doc.contents.range).toMatchObject([4, 9, 14])
    })

    test('"quoted"', () => {
      const src = '#c0\n"value" #c1\n#c2'
      const doc = YAML.parseDocument(src)
      expect(doc.contents.commentBefore).toBe('c0')
      expect(doc.contents.comment).toBe('c1')
      expect(doc.comment).toBe('c2')
      expect(doc.contents.value).toBe('value')
      expect(doc.contents.range).toMatchObject([4, 11, 16])
    })

    test('block', () => {
      const src = '#c0\n>- #c1\n value\n#c2\n'
      const doc = YAML.parseDocument(src)
      expect(doc.contents.commentBefore).toBe('c0')
      expect(doc.contents.comment).toBe('c1')
      expect(doc.comment).toBe('c2')
      expect(doc.contents.value).toBe('value')
      expect(doc.contents.range).toMatchObject([4, 18, 18])
    })
  })

  describe('seq entry comments', () => {
    test('plain', () => {
      const src = source`
        #c0
        - value 1
          #c1

        - value 2

        #c2
      `
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        contents: {
          items: [
            { commentBefore: 'c0', value: 'value 1', comment: 'c1' },
            { value: 'value 2' }
          ],
          range: [4, 31, 31]
        },
        comment: 'c2'
      })
    })

    test('multiline', () => {
      const src = source`
        - value 1
          #c0
        #c1

        #c2
        - value 2

        #c3
        #c4
      `
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        contents: {
          items: [{ comment: 'c0' }, { commentBefore: 'c1\n\nc2' }]
        },
        comment: 'c3\nc4'
      })
    })
  })

  describe('map entry comments', () => {
    test('plain', () => {
      const src = source`
        #c0
        key1: value 1
          #c1

        key2: value 2

        #c2
      `
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        contents: {
          items: [
            { key: { commentBefore: 'c0' }, value: { comment: 'c1' } },
            { key: {}, value: {} }
          ]
        },
        comment: 'c2'
      })
    })

    test('multiline', () => {
      const src = source`
        key1: value 1
          #c0
        #c1

        #c2
        key2: value 2

        #c3
        #c4
      `
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        contents: {
          items: [
            { value: { comment: 'c0' } },
            { key: { commentBefore: 'c1\n\nc2' } }
          ]
        },
        comment: 'c3\nc4'
      })
    })
  })

  describe('map-in-seq comments', () => {
    test('plain', () => {
      const src = source`
        #c0
        - #c1
          k1: v1
          #c2
          k2: v2 #c3
        #c4
          k3: v3
        #c5
      `
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        contents: {
          items: [
            {
              commentBefore: 'c0\nc1',
              items: [
                {},
                { key: { commentBefore: 'c2' }, value: { comment: 'c3' } },
                { key: { commentBefore: 'c4' } }
              ]
            }
          ]
        },
        comment: 'c5'
      })
      expect(String(doc)).toBe(source`
        #c0
        #c1
        - k1: v1
          #c2
          k2: v2 #c3
          #c4
          k3: v3

        #c5
      `)
    })
  })

  describe('seq-in-map comments', () => {
    test('plain', () => {
      const src = source`
        #c0
        k1: #c1
          - v1
        #c2
          - v2
          #c3
        k2:
          - v3 #c4
        #c5
      `
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        contents: {
          items: [
            {
              key: { commentBefore: 'c0', value: 'k1' },
              value: {
                commentBefore: 'c1',
                items: [{ value: 'v1' }, { commentBefore: 'c2', value: 'v2' }],
                comment: 'c3'
              }
            },
            {
              key: { value: 'k2' },
              value: { items: [{ value: 'v3', comment: 'c4' }] }
            }
          ]
        },
        comment: 'c5'
      })
      expect(String(doc)).toBe(source`
        #c0
        k1:
          #c1
          - v1
          #c2
          - v2
          #c3
        k2:
          - v3 #c4

        #c5
      `)
    })
  })

  describe('flow collection comments', () => {
    test('line comment after , in seq', () => {
      const doc = YAML.parseDocument(source`
        [ a, #c0
          b #c1
        ]`)
      expect(doc.contents.items).toMatchObject([
        { value: 'a', comment: 'c0' },
        { value: 'b', comment: 'c1' }
      ])
    })

    test('line comment after , in map', () => {
      const doc = YAML.parseDocument(source`
        { a, #c0
          b: c, #c1
          d #c2
        }`)
      expect(doc.contents.items).toMatchObject([
        { key: { value: 'a', comment: 'c0' } },
        { key: { value: 'b' }, value: { value: 'c', comment: 'c1' } },
        { key: { value: 'd', comment: 'c2' } }
      ])
    })

    test('multi-line comments', () => {
      const doc = YAML.parseDocument('{ a,\n#c0\n#c1\nb }')
      expect(doc.contents.items).toMatchObject([
        { key: { value: 'a' } },
        { key: { commentBefore: 'c0\nc1', value: 'b' } }
      ])
    })
  })

  describe('line comments with leading tabs (#548)', () => {
    for (const { name, src } of [
      { name: 'after scalar', src: 'foo\n\t#c' },
      { name: 'in seq', src: '- x\n\t#c\n- y\n\t #d\n- z' },
      { name: 'in map value', src: 'x:\n\t#c\ny:' },
      { name: 'in map', src: 'x: 1\n\t#c\ny: 2' }
    ]) {
      test(name, () => {
        const doc = YAML.parseDocument(src)
        expect(doc.errors).toHaveLength(0)
      })
    }
  })
})

describe('stringify comments', () => {
  describe('single-line comments', () => {
    test('plain', () => {
      const src = 'string'
      const doc = YAML.parseDocument(src)
      doc.contents.comment = 'comment'
      expect(String(doc)).toBe('string #comment\n')
    })

    test('"quoted"', () => {
      const src = '"string\\u0000"'
      const doc = YAML.parseDocument(src)
      doc.contents.comment = 'comment'
      expect(String(doc)).toBe('"string\\0" #comment\n')
    })

    test('block', () => {
      const src = '>\nstring\n'
      const doc = YAML.parseDocument(src)
      doc.contents.comment = 'comment'
      expect(String(doc)).toBe('> #comment\nstring\n')
    })
  })

  describe('multi-line comments', () => {
    test('plain', () => {
      const src = 'string'
      const doc = YAML.parseDocument(src)
      doc.contents.comment = 'comment\nlines'
      expect(String(doc)).toBe('string\n#comment\n#lines\n')
    })

    test('"quoted"', () => {
      const src = '"string\\u0000"'
      const doc = YAML.parseDocument(src)
      doc.contents.comment = 'comment\nlines'
      expect(String(doc)).toBe('"string\\0"\n#comment\n#lines\n')
    })

    test('block', () => {
      const src = '>\nstring\n'
      const doc = YAML.parseDocument(src)
      doc.contents.comment = 'comment\nlines'
      expect(String(doc)).toBe('> #comment lines\nstring\n')
    })
  })

  describe('document comments', () => {
    test('directive', () => {
      const src = source`
        #c0
        ---
        string
      `
      const doc = YAML.parseDocument(src)
      expect(doc.commentBefore).toBe('c0')
      doc.commentBefore += '\nc1'
      expect(String(doc)).toBe(source`
        #c0
        #c1
        ---
        string
      `)
    })
  })

  describe('seq comments', () => {
    test('plain', () => {
      const src = '- value 1\n- value 2\n'
      const doc = YAML.parseDocument, false>(src)
      doc.contents.commentBefore = 'c0'
      doc.contents.items[0].commentBefore = 'c1'
      doc.contents.items[1].commentBefore = 'c2'
      doc.contents.comment = 'c3'
      expect(String(doc)).toBe(source`
        #c0
        #c1
        - value 1
        #c2
        - value 2
        #c3
      `)
    })

    test('multiline', () => {
      const src = '- value 1\n- value 2\n'
      const doc = YAML.parseDocument, false>(src)
      doc.contents.items[0].commentBefore = 'c0\nc1'
      doc.contents.items[1].commentBefore = ' \nc2\n\nc3'
      doc.contents.comment = 'c4\nc5'
      expect(String(doc)).toBe(source`
        #c0
        #c1
        - value 1
        #
        #c2

        #c3
        - value 2
        #c4
        #c5
      `)
    })

    test('seq-in-map', () => {
      const src = 'map:\n  - value 1\n  - value 2\n'
      const doc = YAML.parseDocument<
        YAML.YAMLMap>,
        false
      >(src)
      doc.contents.items[0].key.commentBefore = 'c0'
      doc.contents.items[0].key.comment = 'c1'
      const seq = doc.contents.items[0].value!
      seq.commentBefore = 'c2'
      seq.items[0].commentBefore = 'c3'
      seq.items[1].commentBefore = 'c4'
      seq.comment = 'c5'
      expect(String(doc)).toBe(source`
        #c0
        map: #c1
          #c2
          #c3
          - value 1
          #c4
          - value 2
          #c5
        `)
    })

    test('custom stringifier', () => {
      const doc = YAML.parseDocument, false>(
        '- a\n- b\n'
      )
      doc.contents.commentBefore = 'c0'
      doc.contents.items[0].commentBefore = 'c1'
      doc.contents.items[1].commentBefore = 'c2\nc3'
      expect(doc.toString({ commentString: str => str.replace(/^/gm, '// ') }))
        .toBe(source`
        // c0
        // c1
        - a
        // c2
        // c3
        - b
      `)
    })
  })

  describe('map entry comments', () => {
    test('plain', () => {
      const src = 'key1: value 1\nkey2: value 2\n'
      const doc = YAML.parseDocument<
        YAML.YAMLMap,
        false
      >(src)
      doc.contents.items[0].key.commentBefore = 'c0'
      doc.contents.items[1].key.commentBefore = 'c1'
      doc.contents.items[1].key.comment = 'c2'
      doc.contents.items[1].value!.spaceBefore = true
      doc.contents.comment = 'c3'
      expect(String(doc)).toBe(source`
        #c0
        key1: value 1
        #c1
        key2: #c2

          value 2
        #c3
      `)
    })

    test('multiline', () => {
      const src = 'key1: value 1\nkey2: value 2\n'
      const doc = YAML.parseDocument<
        YAML.YAMLMap,
        false
      >(src)
      doc.contents.items[0].key.commentBefore = 'c0\nc1'
      doc.contents.items[1].key.commentBefore = ' \nc2\n\nc3'
      doc.contents.items[1].key.comment = 'c4\nc5'
      doc.contents.items[1].value!.spaceBefore = true
      doc.contents.items[1].value!.commentBefore = 'c6'
      doc.contents.comment = 'c7\nc8'
      expect(String(doc)).toBe(source`
        #c0
        #c1
        key1: value 1
        #
        #c2

        #c3
        key2:
          #c4
          #c5

          #c6
          value 2
        #c7
        #c8
      `)
    })

    test('indented comment on empty value with spaceBefore', () => {
      const src = source`
        key1:

          # comment
        key2: x
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })

    test('comment after empty value with spaceBefore', () => {
      const src = source`
        key1:

        # comment
        key2: x
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })
  })

  describe('flow collection comments', () => {
    test('line comment after , in seq', () => {
      const doc = YAML.parseDocument(source`
        [ a, #c0
          b #c1
        ]`)
      expect(String(doc)).toBe(source`
        [
          a, #c0
          b #c1
        ]
      `)
    })

    test('line comment after [], in seq', () => {
      const doc = YAML.parseDocument(source`
        [ [a], #c0
          [b] #c1
        ]`)
      expect(String(doc)).toBe(source`
        [
          [ a ], #c0
          [ b ] #c1
        ]
      `)
    })

    test('line comment after , in map', () => {
      const doc = YAML.parseDocument(source`
        { a, #c0
          b: c, #c1
          d #c2
        }`)
      expect(String(doc)).toBe(source`
        {
          a, #c0
          b: c, #c1
          d #c2
        }
      `)
    })

    test('line comment after {}, in map', () => {
      const doc = YAML.parseDocument(source`
        { {a: 1}, #c0
          b: {c: 2}, #c1
          d #c2
        }`)
      expect(String(doc)).toBe(source`
        {
          ? { a: 1 }, #c0
          b: { c: 2 }, #c1
          d #c2
        }
      `)
    })

    test('line comment after flow collection (#443)', () => {
      const doc = YAML.parseDocument(source`
        [ value1, value2 ] # comment
      `)
      expect(String(doc)).toBe(source`
        [ value1, value2 ] # comment
      `)
    })
  })
})

describe('blank lines', () => {
  describe('drop leading blank lines', () => {
    test('content', () => {
      const src = '\n\nstr\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('str\n')
    })

    test('content comment', () => {
      const src = '\n\n#cc\n \nstr\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('#cc\n\nstr\n')
    })

    test('directive', () => {
      const src = '\n\n%YAML 1.2\n---\nstr\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('%YAML 1.2\n---\nstr\n')
    })

    test('directive comment', () => {
      const src = '\n\n#cc\n%YAML 1.2\n---\nstr\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('#cc\n\n%YAML 1.2\n---\nstr\n')
    })
  })

  describe('drop trailing blank lines', () => {
    test('empty contents', () => {
      const src = '\n\n\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('null\n')
    })

    test('scalar contents', () => {
      const src = 'str\n\n\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('str\n')
    })

    test('seq contents', () => {
      const src = '- a\n- b\n\n\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('- a\n- b\n')
    })

    test('empty/comment contents', () => {
      const src = '#cc\n\n\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('#cc\n\nnull\n')
    })
  })

  test('between directive comment & directive', () => {
    const src = '#cc\n\n\n%YAML 1.2\n---\nstr\n'
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe('#cc\n\n%YAML 1.2\n---\nstr\n')
  })

  test('after leading comment', () => {
    const src = '#cc\n\n\nstr\n'
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe('#cc\n\nstr\n')
  })

  test('before first node in document with directives', () => {
    const doc = YAML.parseDocument('str\n')
    doc.contents.spaceBefore = true
    expect(doc.toString({ directives: true })).toBe('---\n\nstr\n')
  })

  test('between seq items', () => {
    const src = '- a\n\n- b\n\n\n- c\n'
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe('- a\n\n- b\n\n- c\n')
  })

  test('between seq indicator and value (#590)', () => {
    const src = source`
      key:
        -
        - a

        -
        -
          b
    `
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(
      source`
        key:
          -·
          - a

          -·
          - b
      `.replace(/·/g, ' ')
    )
  })

  test('between seq items with leading comments', () => {
    const src = source`
      #A
      - a

      #B
      - b


      #C

      - c
    `
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(source`
      #A
      - a

      #B
      - b

      #C

      - c
    `)
  })

  describe('not after block scalar with keep chomping', () => {
    const cases = [
      { name: 'in seq', src: '- |+\n  a\n\n- b\n' },
      { name: 'in map', src: 'a: |+\n  A\n\nb: B\n' },
      { name: 'in seq in map', src: 'a:\n  - |+\n    A\n\nb: B\n' }
    ]
    for (const { name, src } of cases) {
      test(name, () => {
        const doc = YAML.parseDocument(src)
        expect(String(doc)).toBe(src)
        let it = doc.contents.items[1]
        if (it.key) it = it.key
        expect(it).not.toHaveProperty('spaceBefore', true)
        it.spaceBefore = true
        expect(String(doc)).toBe(src)
        it.commentBefore = '\n\n'
        expect(String(doc)).toBe(src)
      })
    }

    test('as contents', () => {
      const src = '|+\n  a\n\n#c\n'
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        comment: 'c',
        contents: { value: 'a\n\n' }
      })
      expect(String(doc)).toBe(src)
      doc.comment = '\n\nc'
      expect(String(doc)).toBe(src)
    })
  })

  test('before block map values', () => {
    const src = 'a:\n\n  1\nb:\n\n  #c\n  2\n'
    const doc = YAML.parseDocument(src)
    expect(doc.contents).toMatchObject({
      items: [
        {
          key: { value: 'a' },
          value: { value: 1, spaceBefore: true }
        },
        {
          key: { value: 'b' },
          value: { value: 2, commentBefore: 'c', spaceBefore: true }
        }
      ]
    })
    expect(String(doc)).toBe(src)
  })

  describe('after block value', () => {
    test('in seq', () => {
      const src = '- |\n a\n\n- >-\n b\n\n- |+\n c\n\n- d\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('- |\n  a\n\n- >-\n  b\n\n- |+\n  c\n\n- d\n')
    })

    test('in map', () => {
      const src = 'A: |\n a\n\nB: >-\n b\n\nC: |+\n c\n\nD: d\n'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(
        'A: |\n  a\n\nB: >-\n  b\n\nC: |+\n  c\n\nD: d\n'
      )
    })
  })

  describe('flow collections', () => {
    test('flow seq', () => {
      const src = '[1,\n\n2,\n3,\n\n4\n\n]'
      const doc = YAML.parseDocument(src)
      expect(doc.contents).toMatchObject({
        items: [
          { value: 1 },
          { value: 2, spaceBefore: true },
          { value: 3 },
          { value: 4, spaceBefore: true }
        ]
      })
      expect(String(doc)).toBe('[\n  1,\n\n  2,\n  3,\n\n  4\n]\n')
    })

    test('flow map', () => {
      const src = '{\n\na: 1,\n\nb: 2 }'
      const doc = YAML.parseDocument(src)
      expect(doc.contents).toMatchObject({
        items: [
          { key: { value: 'a', spaceBefore: true }, value: { value: 1 } },
          { key: { value: 'b', spaceBefore: true }, value: { value: 2 } }
        ]
      })
    })

    test('flow map value comments & spaces', () => {
      const src = '{\n  a:\n    #c\n    1,\n  b:\n\n    #d\n    2\n}\n'
      const doc = YAML.parseDocument(src)
      expect(doc.contents).toMatchObject({
        items: [
          {
            key: { value: 'a' },
            value: { value: 1, commentBefore: 'c' }
          },
          {
            key: { value: 'b' },
            value: { value: 2, commentBefore: 'd', spaceBefore: true }
          }
        ]
      })
      expect(String(doc)).toBe(src)
    })
  })

  test('blank line after less-indented comment (#91)', () => {
    const src = `
map:
  foo0:
    key2: value2

#   foo1:
#     key0: value0
#     key1: value1

  foo2:
    key3: value3`
    const doc = YAML.parseDocument(src)
    expect(doc.errors).toHaveLength(0)
    expect(doc.toJS()).toMatchObject({
      map: { foo0: { key2: 'value2' }, foo2: { key3: 'value3' } }
    })
  })

  describe('commented empty lines', () => {
    test('document comments with #', () => {
      const src = source`
        # c1
        #
        # c2

        value

        # c3
        #
        # c4
      `
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        commentBefore: ' c1\n \n c2',
        comment: ' c3\n \n c4'
      })
      expect(doc.toString()).toBe(source`
        # c1
        #
        # c2

        value

        # c3
        #
        # c4
      `)
    })

    test('document comments without #', () => {
      const src = source`
        # c1

        # c2

        value

        # c3

        # c4
      `
      const doc = YAML.parseDocument(src)
      expect(doc).toMatchObject({
        commentBefore: ' c1\n\n c2',
        comment: ' c3\n\n c4'
      })
      expect(doc.toString()).toBe(src)
    })

    test('map comments with #', () => {
      const src = source`
        key:
          # c1
          #
          # c2

          value

          # c3
          #
          # c4
      `
      const doc = YAML.parseDocument(src)
      expect(doc.contents).toMatchObject({
        items: [
          { value: { commentBefore: ' c1\n \n c2\n', comment: ' c3\n \n c4' } }
        ]
      })
      expect(doc.toString()).toBe(source`
        key:
          # c1
          #
          # c2

          value
          # c3
          #
          # c4
      `)
    })

    test('map comments without #', () => {
      const src = source`
        key:
          # c1

          # c2

          value

          # c3

          # c4
      `
      const doc = YAML.parseDocument(src)
      expect(doc.contents).toMatchObject({
        items: [
          { value: { commentBefore: ' c1\n\n c2\n', comment: ' c3\n\n c4' } }
        ]
      })
      expect(doc.toString()).toBe(source`
        key:
          # c1

          # c2

          value
          # c3

          # c4
      `)
    })

    test('seq comments with #', () => {
      const src = source`
        # c1
        #
        # c2
        - v1
          # c3
          #
        # c4
        - v2
      `
      const doc = YAML.parseDocument(src)
      expect(doc.contents).toMatchObject({
        items: [
          { commentBefore: ' c1\n \n c2', comment: ' c3\n ' },
          { commentBefore: ' c4' }
        ]
      })
      expect(doc.toString()).toBe(source`
        # c1
        #
        # c2
        - v1
          # c3
          #
        # c4
        - v2
      `)
    })

    test('seq comments without #', () => {
      const src = source`
        # c1

        # c2
        - v1
          # c3

        # c4
        - v2
      `
      const doc = YAML.parseDocument(src)
      expect(doc.contents).toMatchObject({
        items: [
          { commentBefore: ' c1\n\n c2', comment: ' c3' },
          { commentBefore: ' c4', spaceBefore: true }
        ]
      })
      expect(doc.toString()).toBe(source`
        # c1

        # c2
        - v1 # c3

        # c4
        - v2
      `)
    })
  })

  describe('newlines as comments', () => {
    test('seq', () => {
      const doc = YAML.parseDocument, false>(
        '- v1\n- v2\n'
      )
      const [v1, v2] = doc.contents.items
      v1.commentBefore = '\n'
      v1.comment = '\n'
      v2.commentBefore = '\n'
      v2.comment = '\n'
      expect(doc.toString()).toBe(source`

        - v1


        - v2

      `)
    })

    test('map', () => {
      const doc = YAML.parseDocument<
        YAML.YAMLMap,
        false
      >('k1: v1\nk2: v2')
      const [p1, p2] = doc.contents.items
      p1.key.commentBefore = '\n'
      p1.value!.commentBefore = '\n'
      p1.value!.comment = '\n'
      p2.key.commentBefore = '\n'
      p2.value!.commentBefore = '\n'
      p2.value!.comment = '\n'
      expect(doc.toString()).toBe(source`

        k1:

          v1


        k2:

          v2

      `)
    })
  })

  test('trailing comment with trailing empty line (#277)', () => {
    const src = source`
      environment:
        ### SESSION START ###
        A: "true"
        B: "true"
        ### SESSION END ###

        ### ANOTHER SESSION START ###
        C: "true"
        D: "true"
        ### ANOTHER SESSION END ###

    `
    const doc = YAML.parseDocument(src)
    expect(doc.toString()).toBe(src)
  })
})

describe('comment after mapping key (#18)', () => {
  test('reported', () => {
    const src = `test1:
  foo:
    #123
    bar: 1\n`
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(src)
  })

  test('minimal', () => {
    const src = `foo:\n  #123\n  bar: baz\n`
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(src)
  })
})

describe('trailing comments on collection (#28)', () => {
  test('reported', () => {
    const src = `# This comment is ok
entryA:
  - foo

entryB:
  - bar # bar comment

# Ending comment
# Ending comment 2\n`
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(`# This comment is ok
entryA:
  - foo

entryB:
  - bar # bar comment

# Ending comment
# Ending comment 2\n`)
  })

  test('collection end comment', () => {
    const src = `a: b #c\n#d\n`
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(`a: b #c\n\n#d\n`)
  })

  test('blank line after seq in map', () => {
    const src = `a:
  - aa

b:
  - bb

c: cc\n`
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(src)
  })

  test('blank line after map in seq', () => {
    const src = `- a: aa

- b: bb
  c: cc

- d: dd\n`
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(src)
  })
})

describe('collection end comments', () => {
  test('seq in seq', () => {
    const src = source`
      #0
      - - a
        - b
        #1

      #2
      - d
    `
    const doc = YAML.parseDocument(src)
    expect(doc.contents).toMatchObject({
      items: [
        { items: [{ value: 'a' }, { value: 'b' }], comment: '1\n\n2' },
        { value: 'd' }
      ]
    })
    expect(String(doc)).toBe(source`
      #0
      - - a
        - b
        #1

        #2
      - d
    `)
  })

  test('map in seq', () => {
    const src = source`
      #0
      - a: 1
        b: 2
        #1

      #2
      - d
    `
    const doc = YAML.parseDocument(src)
    expect(doc.contents).toMatchObject({
      items: [
        {
          items: [
            { key: { value: 'a' }, value: { value: 1 } },
            { key: { value: 'b' }, value: { value: 2 } }
          ],
          comment: '1\n\n2'
        },
        { value: 'd' }
      ]
    })
    expect(String(doc)).toBe(source`
      #0
      - a: 1
        b: 2
        #1

        #2
      - d
    `)
  })

  test('seq in map', () => {
    const src = source`
      #0
      a:
        - b
        - c
        #1

      #2
      d: 1
    `
    const doc = YAML.parseDocument(src)
    expect(doc.contents).toMatchObject({
      items: [
        {
          key: { value: 'a' },
          value: { items: [{ value: 'b' }, { value: 'c' }], comment: '1\n\n2' }
        },
        { key: { value: 'd' }, value: { value: 1 } }
      ]
    })
    expect(String(doc)).toBe(source`
      #0
      a:
        - b
        - c
        #1

        #2
      d: 1
    `)
  })

  test('map in map', () => {
    const src = source`
      #0
      a:
        b: 1
        c: 2
        #1

      #2
      d: 1
    `
    const doc = YAML.parseDocument(src)
    expect(doc.contents).toMatchObject({
      items: [
        {
          key: { value: 'a' },
          value: {
            items: [
              { key: { value: 'b' }, value: { value: 1 } },
              { key: { value: 'c' }, value: { value: 2 } }
            ],
            comment: '1\n\n2'
          }
        },
        { key: { value: 'd' }, value: { value: 1 } }
      ]
    })
    expect(String(doc)).toBe(source`
      #0
      a:
        b: 1
        c: 2
        #1

        #2
      d: 1
    `)
  })

  test('indented seq in map in seq', () => {
    const src = `#0
a:
  #1
  - b:
      - c

  #2
  - e\n`
    const doc = YAML.parseDocument(src)
    expect(doc.contents).toMatchObject({
      items: [
        {
          key: { value: 'a' },
          value: {
            commentBefore: '1',
            items: [
              {
                items: [
                  {
                    key: { value: 'b' },
                    value: { items: [{ value: 'c' }] }
                  }
                ]
              },
              { spaceBefore: true, commentBefore: '2', value: 'e' }
            ]
          }
        }
      ]
    })
    expect(String(doc)).toBe(src)
  })
})
eemeli-yaml-086fa6b/tests/doc/createNode.ts000066400000000000000000000270321511277410200206640ustar00rootroot00000000000000import type { Alias, Node } from 'yaml'
import { Document, Scalar, YAMLMap, YAMLSeq } from 'yaml'
import { source } from '../_utils.ts'

describe('createNode(value)', () => {
  test('boolean', () => {
    const s = new Document().createNode(false)
    expect(s).toBeInstanceOf(Scalar)
    expect(s.value).toBe(false)
  })
  test('null', () => {
    const s = new Document().createNode(null)
    expect(s).toBeInstanceOf(Scalar)
    expect(s.value).toBe(null)
  })
  test('undefined', () => {
    const s = new Document().createNode(undefined)
    expect(s).toBeInstanceOf(Scalar)
    expect(s.value).toBe(null)
  })
  test('number', () => {
    const s = new Document().createNode(3)
    expect(s).toBeInstanceOf(Scalar)
    expect(s.value).toBe(3)
  })
  test('string', () => {
    const s = new Document().createNode('test')
    expect(s).toBeInstanceOf(Scalar)
    expect(s.value).toBe('test')
  })
})

describe('explicit tags', () => {
  test('default tag', () => {
    const s = new Document().createNode(3, { tag: '!!str' })
    expect(s).toBeInstanceOf(Scalar)
    expect(s).toMatchObject({ value: 3, tag: 'tag:yaml.org,2002:str' })
  })

  test('unknown tag', () => {
    expect(() => new Document().createNode('3', { tag: '!foo' })).toThrow(
      'Tag !foo not found'
    )
  })
})

describe('arrays', () => {
  test('createNode([])', () => {
    const s = new Document().createNode([])
    expect(s).toBeInstanceOf(YAMLSeq)
    expect(s.items).toHaveLength(0)
  })

  test('createNode([true])', () => {
    const doc = new Document()
    const s = doc.createNode([true])
    expect(s).toBeInstanceOf(YAMLSeq)
    expect(s.items).toMatchObject([{ value: true }])
    doc.contents = s
    expect(String(doc)).toBe('- true\n')
  })

  test('flow: true', () => {
    const doc = new Document()
    const s = doc.createNode([true], { flow: true })
    expect(s).toBeInstanceOf(YAMLSeq)
    expect(s.items).toMatchObject([{ value: true }])
    doc.contents = s
    expect(String(doc)).toBe('[ true ]\n')
  })

  describe('[3, ["four", 5]]', () => {
    const array = [3, ['four', 5]]
    test('createNode(value)', () => {
      const s = new Document().createNode(array) as any
      expect(s).toBeInstanceOf(YAMLSeq)
      expect(s.items).toHaveLength(2)
      expect(s.items[0].value).toBe(3)
      expect(s.items[1]).toBeInstanceOf(YAMLSeq)
      expect(s.items[1].items).toHaveLength(2)
      expect(s.items[1].items[0].value).toBe('four')
      expect(s.items[1].items[1].value).toBe(5)
    })
    test('set doc contents', () => {
      const res = '- 3\n- - four\n  - 5\n'
      const doc = new Document(array)
      expect(String(doc)).toBe(res)
      doc.contents = array as any
      expect(String(doc)).toBe(res)
      doc.contents = doc.createNode(array)
      expect(String(doc)).toBe(res)
    })
  })
})

describe('objects', () => {
  test('createNode({})', () => {
    const s = new Document().createNode({})
    expect(s).toBeInstanceOf(YAMLMap)
    expect(s.items).toHaveLength(0)
  })

  test('createNode({ x: true })', () => {
    const doc = new Document()
    const s = doc.createNode({ x: true })
    expect(s).toBeInstanceOf(YAMLMap)
    expect(s.items).toMatchObject([
      { key: { value: 'x' }, value: { value: true } }
    ])
    doc.contents = s
    expect(String(doc)).toBe('x: true\n')
  })

  test('flow: true', () => {
    const doc = new Document()
    const s = doc.createNode({ x: true }, { flow: true })
    expect(s).toBeInstanceOf(YAMLMap)
    expect(s.items).toMatchObject([
      { key: { value: 'x' }, value: { value: true } }
    ])
    doc.contents = s
    expect(String(doc)).toBe('{ x: true }\n')
  })

  test('createNode({ x: true, y: undefined })', () => {
    const s = new Document().createNode({ x: true, y: undefined })
    expect(s).toBeInstanceOf(YAMLMap)
    expect(s.items).toMatchObject([
      { key: { value: 'x' }, value: { value: true } }
    ])
  })

  test('createNode({ x: true, y: undefined }, { keepUndefined: true })', () => {
    const s = new Document().createNode(
      { x: true, y: undefined },
      { keepUndefined: true }
    )
    expect(s).toBeInstanceOf(YAMLMap)
    expect(s.items).toMatchObject([
      { key: { value: 'x' }, value: { value: true } },
      { key: { value: 'y' }, value: { value: null } }
    ])
  })

  describe('{ x: 3, y: [4], z: { w: "five", v: 6 } }', () => {
    const object = { x: 3, y: [4], z: { w: 'five', v: 6 } }
    test('createNode(value)', () => {
      const s = new Document().createNode(object)
      expect(s).toBeInstanceOf(YAMLMap)
      expect(s.items).toHaveLength(3)
      expect(s.items).toMatchObject([
        { key: { value: 'x' }, value: { value: 3 } },
        { key: { value: 'y' }, value: { items: [{ value: 4 }] } },
        {
          key: { value: 'z' },
          value: {
            items: [
              { key: { value: 'w' }, value: { value: 'five' } },
              { key: { value: 'v' }, value: { value: 6 } }
            ]
          }
        }
      ])
    })
    test('set doc contents', () => {
      const res = `x: 3
y:
  - 4
z:
  w: five
  v: 6\n`
      const doc = new Document(object)
      expect(String(doc)).toBe(res)
      doc.contents = object as any
      expect(String(doc)).toBe(res)
      doc.contents = doc.createNode(object)
      expect(String(doc)).toBe(res)
    })
  })
})

describe('Set', () => {
  test('createNode(new Set)', () => {
    const s = new Document().createNode(new Set())
    expect(s).toBeInstanceOf(YAMLSeq)
    expect(s.items).toHaveLength(0)
  })
  test('createNode(new Set([true]))', () => {
    const s = new Document().createNode(new Set([true]))
    expect(s).toBeInstanceOf(YAMLSeq)
    expect(s.items).toMatchObject([{ value: true }])
  })
  describe("Set { 3, Set { 'four', 5 } }", () => {
    const set = new Set([3, new Set(['four', 5])])
    test('createNode(set)', () => {
      const s = new Document().createNode(set) as any
      expect(s).toBeInstanceOf(YAMLSeq)
      expect(s.items).toHaveLength(2)
      expect(s.items[0].value).toBe(3)
      expect(s.items[1]).toBeInstanceOf(YAMLSeq)
      expect(s.items[1].items).toHaveLength(2)
      expect(s.items[1].items[0].value).toBe('four')
      expect(s.items[1].items[1].value).toBe(5)
    })
    test('set doc contents', () => {
      const res = '- 3\n- - four\n  - 5\n'
      const doc = new Document(set)
      expect(String(doc)).toBe(res)
      doc.contents = set as any
      expect(String(doc)).toBe(res)
      doc.contents = doc.createNode(set)
      expect(String(doc)).toBe(res)
    })
    test('Schema#createNode() - YAML 1.2', () => {
      const doc = new Document(null)
      const s = doc.createNode(set)
      expect(s).toBeInstanceOf(YAMLSeq)
      expect(s.items).toMatchObject([
        { value: 3 },
        { items: [{ value: 'four' }, { value: 5 }] }
      ])
    })
    test('Schema#createNode() - YAML 1.1', () => {
      const doc = new Document(null, { version: '1.1' })
      const s = doc.createNode(set) as any
      expect(s.constructor.tag).toBe('tag:yaml.org,2002:set')
      expect(s.items).toMatchObject([
        { key: { value: 3 } },
        { key: { items: [{ key: { value: 'four' } }, { key: { value: 5 } }] } }
      ])
    })
  })
})

describe('Map', () => {
  test('createNode(new Map)', () => {
    const s = new Document().createNode(new Map())
    expect(s).toBeInstanceOf(YAMLMap)
    expect(s.items).toHaveLength(0)
  })
  test('createNode(new Map([["x", true]]))', () => {
    const s = new Document().createNode(new Map([['x', true]]))
    expect(s).toBeInstanceOf(YAMLMap)
    expect(s.items).toMatchObject([
      { key: { value: 'x' }, value: { value: true } }
    ])
  })
  describe("Map { 'x' => 3, 'y' => Set { 4 }, Map { 'w' => 'five', 'v' => 6 } => 'z' }", () => {
    const map = new Map([
      ['x', 3],
      ['y', new Set([4])],
      [
        new Map([
          ['w', 'five'],
          ['v', 6]
        ]),
        'z'
      ]
    ])
    test('createNode(map)', () => {
      const s = new Document().createNode(map)
      expect(s).toBeInstanceOf(YAMLMap)
      expect(s.items).toHaveLength(3)
      expect(s.items).toMatchObject([
        { key: { value: 'x' }, value: { value: 3 } },
        { key: { value: 'y' }, value: { items: [{ value: 4 }] } },
        {
          key: {
            items: [
              { key: { value: 'w' }, value: { value: 'five' } },
              { key: { value: 'v' }, value: { value: 6 } }
            ]
          },
          value: { value: 'z' }
        }
      ])
    })
    test('set doc contents', () => {
      const res = `x: 3
y:
  - 4
? w: five
  v: 6
: z\n`
      const doc = new Document(map)
      expect(String(doc)).toBe(res)
      doc.contents = map as any
      expect(String(doc)).toBe(res)
      doc.contents = doc.createNode(map)
      expect(String(doc)).toBe(res)
    })
  })
})

describe('toJSON()', () => {
  test('Date', () => {
    const date = new Date('2018-12-22T08:02:52Z')
    const node = new Document().createNode(date)
    expect(node.value).toBe(date.toJSON())
  })
})

describe('strictly equal objects', () => {
  test('createNode([foo, foo])', () => {
    const foo = { foo: 'FOO' }
    const s = new Document().createNode([foo, foo])
    expect(s).toBeInstanceOf(YAMLSeq)
    expect(s.items).toMatchObject([
      {
        anchor: 'a1',
        items: [{ key: { value: 'foo' }, value: { value: 'FOO' } }]
      },
      { source: 'a1' }
    ])
  })

  test('createNode([foo, foo], { aliasDuplicateObjects: false })', () => {
    const foo = { foo: 'FOO' }
    const s = new Document().createNode([foo, foo], {
      aliasDuplicateObjects: false
    })
    expect(s).toBeInstanceOf(YAMLSeq)
    expect(s.items).toMatchObject([
      { items: [{ key: { value: 'foo' }, value: { value: 'FOO' } }] },
      { items: [{ key: { value: 'foo' }, value: { value: 'FOO' } }] }
    ])
  })
})

describe('circular references', () => {
  test('parent at root', () => {
    const map: any = { foo: 'bar' }
    map.map = map
    const doc = new Document(map)
    expect(doc.contents).toMatchObject({
      anchor: 'a1',
      items: [
        { key: { value: 'foo' }, value: { value: 'bar' } },
        {
          key: { value: 'map' },
          value: { source: 'a1' }
        }
      ]
    })
    expect(doc.toString()).toBe(source`
      &a1
      foo: bar
      map: *a1
    `)
  })

  test('ancestor at root', () => {
    const baz: any = {}
    const map = { foo: { bar: { baz } } }
    baz.map = map
    const doc = new Document(map)
    expect(doc.getIn(['foo', 'bar', 'baz', 'map'])).toMatchObject({
      source: 'a1'
    })
    expect(doc.toString()).toBe(source`
      &a1
      foo:
        bar:
          baz:
            map: *a1
    `)
  })

  test('sibling sequences', () => {
    const one = ['one']
    const two = ['two']
    const seq = [one, two, one, one, two]
    const doc = new Document(seq)
    expect(doc.contents).toMatchObject({
      items: [
        { items: [{ value: 'one' }] },
        { items: [{ value: 'two' }] },
        { source: 'a1' },
        { source: 'a1' },
        { source: 'a2' }
      ]
    })
    expect(doc.toString()).toBe(source`
      - &a1
        - one
      - &a2
        - two
      - *a1
      - *a1
      - *a2
    `)
  })

  test('further relatives', () => {
    const baz = { a: 1 }
    const seq = [{ foo: { bar: { baz } } }, { fe: { fi: { fo: { baz } } } }]
    const doc = new Document(null)
    const node = doc.createNode(seq)
    const source = node.getIn([0, 'foo', 'bar', 'baz']) as Node
    const alias = node.getIn([1, 'fe', 'fi', 'fo', 'baz']) as Alias
    expect(source).toMatchObject({
      items: [{ key: { value: 'a' }, value: { value: 1 } }]
    })
    expect(alias.source).toBe(source.anchor)
  })
})
eemeli-yaml-086fa6b/tests/doc/errors.ts000066400000000000000000000410601511277410200201240ustar00rootroot00000000000000import * as YAML from 'yaml'
import { source } from '../_utils.ts'

describe('tabs as indentation', () => {
  test('fail on map value indented with tab', () => {
    const src = 'a:\n\t1\nb:\n\t2\n'
    const doc = YAML.parseDocument(src)
    expect(doc.errors[0]).toMatchObject({ code: 'TAB_AS_INDENT' })
  })

  test('block sequence with leading tab', () => {
    const doc = YAML.parseDocument('\t- x')
    expect(doc.errors).toMatchObject([{ code: 'TAB_AS_INDENT' }])
  })

  test('block map with leading tab', () => {
    const doc = YAML.parseDocument('\tx: y')
    expect(doc.errors).toMatchObject([{ code: 'TAB_AS_INDENT' }])
  })
})

test('end with missing block map : indicator (#6)', () => {
  const src = 'abc: 123\ndef'
  const doc = YAML.parseDocument(src)
  expect(doc.errors).toMatchObject([{ pos: [9, 12] }])
})

describe('multiple trailing commas (#7)', () => {
  test('map', () => {
    const src = '{ , }\n---\n{ 123,,, }\n'
    const docs = YAML.parseAllDocuments(src)
    expect(docs[0].errors).toMatchObject([{ pos: [2, 3] }])
    expect(docs[1].errors).toMatchObject([{ pos: [16, 17] }, { pos: [17, 18] }])
  })

  test('seq', () => {
    const src = '[ , ]\n---\n[ 123,,, ]\n'
    const docs = YAML.parseAllDocuments(src)
    expect(docs[0].errors).toMatchObject([{ pos: [2, 3] }])
    expect(docs[1].errors).toMatchObject([{ pos: [16, 17] }, { pos: [17, 18] }])
  })
})

describe('block scalars', () => {
  test('invalid header', () => {
    const doc = YAML.parseDocument('>99\n foo\n')
    expect(doc.errors).toMatchObject(
      [
        'Block scalar header includes extra characters: >99',
        'Unexpected scalar at node end'
      ].map(msg => ({ message: expect.stringContaining(msg) }))
    )
  })
  test('missing newline at header end', () => {
    const doc = YAML.parseDocument('> foo\n')
    expect(doc.errors).toHaveLength(1)
    expect(doc.errors[0].message).toMatch('Not a YAML token: foo')
  })
})

describe('block collections', () => {
  test('mapping with bad indentation', () => {
    const src = 'foo: "1"\n bar: 2\n'
    const doc = YAML.parseDocument(src)
    expect(doc.errors).toHaveLength(1)
    expect(doc.errors[0].message).toMatch(
      'All mapping items must start at the same column'
    )
    expect(doc.contents).toMatchObject({
      items: [
        { key: { value: 'foo' }, value: { value: '1' } },
        { key: { value: 'bar' }, value: { value: 2 } }
      ]
    })
  })

  test('sequence with bad indentation', () => {
    const src = '- "foo"\n - bar\n'
    const doc = YAML.parseDocument(src)
    expect(doc.errors).toHaveLength(1)
    expect(doc.errors[0].message).toMatch(
      'All sequence items must start at the same column'
    )
    expect(doc.contents).toMatchObject({
      items: [{ value: 'foo' }, { items: [{ value: 'bar' }] }]
    })
  })

  test('seq item in mapping', () => {
    const src = 'foo: "1"\n- bar\n'
    const doc = YAML.parseDocument(src)
    expect(doc.errors).toMatchObject([
      { code: 'MULTILINE_IMPLICIT_KEY' },
      { code: 'UNEXPECTED_TOKEN' },
      { code: 'MISSING_CHAR' }
    ])
    expect(doc.contents).toMatchObject({
      items: [
        { key: { value: 'foo' }, value: { value: '1' } },
        { key: { value: null }, value: null }
      ]
    })
  })

  test('doubled value indicator', () => {
    const doc = YAML.parseDocument('foo : : bar\n')
    expect(doc.errors).toMatchObject([
      {
        message: source`
          Nested mappings are not allowed in compact mappings at line 1, column 7:

          foo : : bar
                ^
        `
      }
    ])
  })

  test('excessively long key', () => {
    const doc = YAML.parseDocument(`foo ${'x'.repeat(1024)} : bar\n`)
    expect(doc.errors).toMatchObject([
      {
        message: source`
          The : indicator must be at most 1024 chars after the start of an implicit block mapping key at line 1, column 1:

          foo xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx…
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        `
      }
    ])
  })

  test('key after long comment on empty value (#413)', () => {
    const doc = YAML.parseDocument(source`
      one:
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
      two: b
    `)
    expect(doc.errors).toMatchObject([])
  })

  test('key after long comment on block map (#413)', () => {
    const doc = YAML.parseDocument(source`
      one:
        sub: a
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
      two: b
    `)
    expect(doc.errors).toMatchObject([])
  })

  test('key after long comment on block seq (#413)', () => {
    const doc = YAML.parseDocument(source`
      one:
        - a
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
        # large block of text, large block of text, large block of text, large block of text, large block of text,
      two: b
    `)
    expect(doc.errors).toMatchObject([])
  })

  test('sequence with compact mapping value on same line with mapping key (#603)', () => {
    const doc = YAML.parseDocument('abc: - foo: bar')
    expect(doc.errors).toMatchObject([{ code: 'UNEXPECTED_TOKEN' }])
  })
})

describe('flow collections', () => {
  test('start only of flow map (#8)', () => {
    const doc = YAML.parseDocument('{')
    expect(doc.errors).toMatchObject([{ code: 'MISSING_CHAR', pos: [1, 2] }])
  })

  test('start only of flow sequence (#8)', () => {
    const doc = YAML.parseDocument('[')
    expect(doc.errors).toMatchObject([{ code: 'MISSING_CHAR', pos: [1, 2] }])
  })

  test('flow sequence without end', () => {
    const doc = YAML.parseDocument('[ foo, bar,')
    expect(doc.errors).toMatchObject([{ code: 'MISSING_CHAR', pos: [11, 12] }])
  })

  test('doc-end within flow sequence', () => {
    const doc = YAML.parseDocument('[ foo, bar,\n...\n]', {
      prettyErrors: false
    })
    expect(doc.errors).toMatchObject([
      { code: 'MISSING_CHAR' },
      { message: 'Unexpected flow-seq-end token in YAML document: "]"' },
      {
        message:
          'Source contains multiple documents; please use YAML.parseAllDocuments()'
      }
    ])
  })

  test('block scalar in flow collection', () => {
    const doc = YAML.parseDocument('{ |\n foo\n}')
    expect(doc.errors).toHaveLength(1)
    expect(doc.errors[0].message).toMatch(
      'Plain value cannot start with block scalar indicator |'
    )
  })

  test('block seq in flow collection', () => {
    const doc = YAML.parseDocument('{\n- foo\n}')
    expect(doc.errors).toMatchObject([{ code: 'BLOCK_IN_FLOW' }])
  })

  test('anchor before explicit key indicator in block map', () => {
    const doc = YAML.parseDocument('&a ? A')
    expect(doc.errors).toMatchObject([{ code: 'BAD_PROP_ORDER' }])
  })

  test('anchor before explicit key indicator in flow map', () => {
    const doc = YAML.parseDocument('{ &a ? A }')
    expect(doc.errors).toMatchObject([{ code: 'BAD_PROP_ORDER' }])
  })

  test('flow map with doubled indicator', () => {
    const doc = YAML.parseDocument('{ foo: : bar }')
    expect(doc.errors).toMatchObject([{ code: 'UNEXPECTED_TOKEN' }])
  })
})

describe('comments', () => {
  test('comment without whitespace after tag', () => {
    const doc = YAML.parseDocument('!#cc\nA')
    expect(doc.errors).toHaveLength(2)
    expect(doc.errors[0].message).toMatch(
      'Tags and anchors must be separated from the next token by white space'
    )
    expect(doc.errors[1].message).toMatch(
      'Comments must be separated from other tokens by white space characters'
    )
  })

  test('comment without whitespace after value', () => {
    const doc = YAML.parseDocument('foo: "bar"#cc')
    expect(doc.errors).toHaveLength(1)
    expect(doc.errors[0].message).toMatch(
      'Comments must be separated from other tokens by white space characters'
    )
  })
})

describe('pretty errors', () => {
  test('end with missing block map : indicator (#6)', () => {
    const src = 'abc: 123\ndef'
    const doc = YAML.parseDocument(src, { prettyErrors: true })
    expect(doc.errors).toMatchObject([
      {
        message: source`
          Implicit map keys need to be followed by map values at line 2, column 1:

          abc: 123
          def
          ^^^
        `,
        pos: [9, 12],
        linePos: [
          { line: 2, col: 1 },
          { line: 2, col: 4 }
        ]
      }
    ])
    expect(doc.errors[0]).not.toHaveProperty('source')
  })

  test('multiple trailing commas in mappings (#7)', () => {
    const src = '{ , }\n---\n{ 123,,, }\n'
    const docs = YAML.parseAllDocuments(src, { prettyErrors: true })
    expect(docs[0].errors).toMatchObject([
      {
        message: source`
          Unexpected , in flow map at line 1, column 3:

          { , }
            ^
        `,
        pos: [2, 3],
        linePos: [
          { line: 1, col: 3 },
          { line: 1, col: 4 }
        ]
      }
    ])
    expect(docs[0].errors[0]).not.toHaveProperty('source')
    expect(docs[1].errors).toMatchObject([
      {
        code: 'UNEXPECTED_TOKEN',
        message: source`
          Unexpected , in flow map at line 3, column 7:

          { 123,,, }
                ^
        `,
        pos: [16, 17],
        linePos: [
          { line: 3, col: 7 },
          { line: 3, col: 8 }
        ]
      },
      {
        code: 'UNEXPECTED_TOKEN',
        message: source`
          Unexpected , in flow map at line 3, column 8:

          { 123,,, }
                 ^
        `,
        pos: [17, 18],
        linePos: [
          { line: 3, col: 8 },
          { line: 3, col: 9 }
        ]
      }
    ])
    expect(docs[1].errors[0]).not.toHaveProperty('source')
    expect(docs[1].errors[1]).not.toHaveProperty('source')
  })

  test('pretty warnings', () => {
    const src = '%FOO\n---bar\n'
    const doc = YAML.parseDocument(src, { prettyErrors: true })
    expect(doc.warnings).toMatchObject([{ name: 'YAMLWarning' }])
  })

  test('repeated CR', () => {
    const src = '[' + '\r'.repeat(80)
    const doc = YAML.parseDocument(src, { prettyErrors: true })
    expect(doc.errors[0]).not.toHaveProperty('source')
  })
})

describe('tags on invalid nodes', () => {
  test('!!map on scalar', () => {
    const doc = YAML.parseDocument('!!map foo')
    expect(doc.warnings).toHaveLength(1)
    expect(doc.warnings[0].message).toMatch(
      'Unresolved tag: tag:yaml.org,2002:map'
    )
    expect(doc.toJS()).toBe('foo')
  })

  test('!!str on map', () => {
    const doc = YAML.parseDocument('!!str { answer: 42 }')
    expect(doc.warnings).toHaveLength(1)
    expect(doc.warnings[0].message).toMatch(
      'Unresolved tag: tag:yaml.org,2002:str'
    )
    expect(doc.toJS()).toMatchObject({ answer: 42 })
  })
})

describe('properties on block sequences without newline after props', () => {
  test('valid properties with newline', () => {
    const doc = YAML.parseDocument('! &a\n- b')
    expect(doc.errors).toMatchObject([])
  })

  test('properties on sequence without newline', () => {
    const doc = YAML.parseDocument('!\n&a - b')
    expect(doc.errors).toMatchObject([
      { code: 'MISSING_CHAR' },
      { code: 'UNEXPECTED_TOKEN' }
    ])
  })

  test('properties on empty sequence without newline', () => {
    const doc = YAML.parseDocument('&a\n! -')
    expect(doc.errors).toMatchObject([{ code: 'MISSING_CHAR' }])
  })

  test('properties on sequence with newline after item indicator', () => {
    const doc = YAML.parseDocument('!\n&a -\n b')
    expect(doc.errors).toMatchObject([{ code: 'MISSING_CHAR' }])
  })
})

describe('invalid options', () => {
  test('unknown schema', () => {
    expect(() => new YAML.Document(undefined, { schema: 'foo' })).toThrow(
      /Unknown schema/
    )
  })

  test('unknown custom tag', () => {
    // @ts-expect-error Deprecated option
    expect(() => new YAML.Document(undefined, { customTags: ['foo'] })).toThrow(
      /Unknown custom tag/
    )
  })
})

test('broken document with comment before first node', () => {
  const doc = YAML.parseDocument('#c\n*x\nfoo\n', { prettyErrors: false })
  expect(doc.errors).toMatchObject([
    { message: 'Unexpected scalar at node end' }
  ])
})

test('multiple tags on one node', () => {
  const doc = YAML.parseDocument('!foo !bar baz\n')
  expect(doc.contents).toMatchObject({ value: 'baz', type: 'PLAIN' })
  expect(doc.errors).toHaveLength(1)
  expect(doc.warnings).toHaveLength(1)
})

describe('logLevel', () => {
  // process.emitWarning will throw in Jest if `warning` is an Error instance
  // due to https://github.com/facebook/jest/issues/2549

  const mock = jest.spyOn(global.process, 'emitWarning').mockImplementation()
  beforeEach(() => mock.mockClear())
  afterEach(() => mock.mockRestore())

  test('by default, warn for tag fallback', () => {
    YAML.parse('!foo bar')
    const message = source`
      Unresolved tag: !foo at line 1, column 1:

      !foo bar
      ^^^^
    `
    expect(mock.mock.calls).toMatchObject([[{ message }]])
  })

  test("silence warnings with logLevel: 'error'", () => {
    YAML.parse('!foo bar', { logLevel: 'error' })
    expect(mock).toHaveBeenCalledTimes(0)
  })

  test("silence warnings with logLevel: 'silent'", () => {
    YAML.parse('!foo bar', { logLevel: 'silent' })
    expect(mock).toHaveBeenCalledTimes(0)
  })

  test("silence errors with logLevel: 'silent'", () => {
    const res = YAML.parse('foo: bar: baz\n---\ndoc2\n', { logLevel: 'silent' })
    expect(res).toMatchObject({ foo: { bar: 'baz' } })
  })
})

describe('Invalid plain first characters', () => {
  for (const ch of [',', '%', '@', '`'])
    test(ch, () => {
      const doc = YAML.parseDocument(`- ${ch}foo`)
      expect(doc.errors).toMatchObject([{ code: 'BAD_SCALAR_START' }])
    })
})
eemeli-yaml-086fa6b/tests/doc/foldFlowLines.ts000066400000000000000000000343561511277410200213710ustar00rootroot00000000000000import * as YAML from 'yaml'
import type { FoldOptions } from 'yaml/util'
import { foldFlowLines as fold } from 'yaml/util'
import { source } from '../_utils.ts'

const FOLD_FLOW = 'flow'
const FOLD_QUOTED = 'quoted'

describe('plain', () => {
  const src = 'abc def ghi jkl mno pqr stu vwx yz\n'
  let onFold: jest.Mock
  let options: FoldOptions
  beforeEach(() => {
    onFold = jest.fn()
    options = { indentAtStart: 0, lineWidth: 10, minContentWidth: 0, onFold }
  })

  test('pass-through', () => {
    options.lineWidth = 40
    expect(fold(src, '', FOLD_FLOW, options)).toBe(src)
    expect(onFold).not.toHaveBeenCalled()
  })

  test('simple', () => {
    options.lineWidth = 20
    expect(fold(src, '', FOLD_FLOW, options)).toBe(
      'abc def ghi jkl mno\npqr stu vwx yz\n'
    )
    expect(onFold).toHaveBeenCalled()
  })

  test('multiple folds', () => {
    expect(fold(src, '', FOLD_FLOW, options)).toBe(
      'abc def\nghi jkl\nmno pqr\nstu vwx yz\n'
    )
    expect(onFold).toHaveBeenCalledTimes(1)
  })

  test('indent', () => {
    expect(fold(src, '  ', FOLD_FLOW, options)).toBe(
      'abc def\n  ghi jkl\n  mno pqr\n  stu vwx\n  yz\n'
    )
  })

  test('indent > lineWidth', () => {
    const indent = '        '
    options.lineWidth = 7
    const i = '\n' + indent
    expect(fold(src, indent, FOLD_FLOW, options)).toBe(
      `abc def${i}ghi${i}jkl${i}mno${i}pqr${i}stu${i}vwx${i}yz\n`
    )
  })

  test('indent > lineWidth, with minContentWidth', () => {
    const indent = '        '
    options.lineWidth = 7
    options.minContentWidth = 7
    const i = '\n' + indent
    expect(fold(src, indent, FOLD_FLOW, options)).toBe(
      `abc def${i}ghi jkl${i}mno pqr${i}stu vwx${i}yz\n`
    )
  })

  test('positive indentAtStart', () => {
    options.indentAtStart = 8
    expect(fold(src, '', FOLD_FLOW, options)).toBe(
      'abc\ndef ghi\njkl mno\npqr stu\nvwx yz\n'
    )
  })

  test('negative indentAtStart', () => {
    options.indentAtStart = -8
    expect(fold(src, '', FOLD_FLOW, options)).toBe(
      'abc def ghi jkl\nmno pqr\nstu vwx yz\n'
    )
  })

  test('doubled spaces', () => {
    const src2 = 'abc  def  ghi  jkl  mno  pqr  stu  vwx  yz\n'
    expect(fold(src2, '', FOLD_FLOW, options)).toBe(src2)
    expect(onFold).not.toHaveBeenCalled()
  })
})

describe('double-quoted', () => {
  const src = '"abc def ghi jkl mnopqrstuvwxyz\n"'
  let onFold: jest.Mock
  let options: FoldOptions
  beforeEach(() => {
    onFold = jest.fn()
    options = {
      indentAtStart: 0,
      lineWidth: 10,
      minContentWidth: 0,
      onFold
    }
  })

  test('pass-through', () => {
    options.lineWidth = 40
    expect(fold(src, '', FOLD_QUOTED, options)).toBe(src)
    expect(onFold).not.toHaveBeenCalled()
  })

  test('simple', () => {
    options.lineWidth = 20
    expect(fold(src, '', FOLD_QUOTED, options)).toBe(
      '"abc def ghi jkl\nmnopqrstuvwxyz\n"'
    )
    expect(onFold).toHaveBeenCalled()
  })

  test('multiple folds', () => {
    expect(fold(src, '', FOLD_QUOTED, options)).toBe(
      '"abc def\nghi jkl\nmnopqrstu\\\nvwxyz\n"'
    )
    expect(onFold).toHaveBeenCalledTimes(1)
  })

  test('short lineWidth', () => {
    options.lineWidth = 3
    expect(fold(src, '', FOLD_QUOTED, options)).toBe(
      '"a\\\nbc\ndef\nghi\njkl\nmn\\\nop\\\nqr\\\nst\\\nuv\\\nwx\\\nyz\n"'
    )
  })

  test('doubled spaces', () => {
    const src2 = '"abc  def  ghi  jkl  mno  pqr  stu  vwx  yz\n"'
    options.lineWidth = 9
    expect(fold(src2, '', FOLD_QUOTED, options)).toBe(
      '"abc  de\\\nf  ghi  \\\njkl  mno  \\\npqr  stu  \\\nvwx  yz\n"'
    )
  })

  test('terminal whitespace', () => {
    const src2 = '" \t \t \t \t \tnext \t"'
    expect(fold(src2, '', FOLD_QUOTED, options)).toBe(
      '" \t \t \t \t \t\\\nnext \t"'
    )
  })

  test('escape longer than lineWidth', () => {
    const src2 = `"foo\\U01234567"`
    expect(fold(src2, '', FOLD_QUOTED, options)).toBe(src2)
  })

  describe('Folding double-quoted strings', () => {
    describe('Split \\" escape in double-quoted string (#48)', () => {
      test('minimal', () => {
        const src2 = '"01234567\\""'
        expect(fold(src2, '', FOLD_QUOTED, options)).toBe('"01234567\\\n\\""')
        const src3 = '"012345678\\""'
        expect(fold(src3, '', FOLD_QUOTED, options)).toBe('"012345678\\\n\\""')
      })

      test('reported', () => {
        const x =
          '{"module":"database","props":{"databaseType":"postgresql"},"extra":{},"foo":"bar\'"}'
        const str = YAML.stringify({ x })
        const doc = YAML.parseDocument(str)
        expect(doc.errors).toHaveLength(0)
        expect(doc.contents.items[0].value.value).toBe(x)
      })
    })

    describe('Fold on multiple escaped characters', () => {
      test('minimal (#57)', () => {
        const str = `"0123\\"\\\\ '"`
        expect(fold(str, '', FOLD_QUOTED, options)).toBe(`"0123\\"\\\\\n'"`)
      })

      test('reported (#57)', () => {
        const key2 = `!""""""""""""""""""""""""""""""""""#"\\ '`
        const str = YAML.stringify([{ key2 }])
        const res = YAML.parse(str)
        expect(res[0].key2).toBe(key2)
      })

      test('minimal (#59)', () => {
        const str = `"######\\\\P#"`
        expect(fold(str, '', FOLD_QUOTED, options)).toBe(`"######\\\\\\\nP#"`)
      })

      test('reported (#59)', () => {
        const value =
          '>####################################"##########################\'####\\P#'
        const str = YAML.stringify({ key: [[value]] })
        const doc = YAML.parseDocument(str)
        expect(doc.errors).toHaveLength(0)
        expect(doc.contents.items[0].value.items[0].items[0].value).toBe(value)
      })
    })

    describe('Fold on escaped character (awslabs/cdk8s#494)', () => {
      test('slash', () => {
        const str = `"1234567\\\\ab"`
        expect(fold(str, '', FOLD_QUOTED, options)).toBe(`"1234567\\\n\\\\ab"`)
      })

      test('null', () => {
        const str = `"1234567\\\0ab"`
        expect(fold(str, '', FOLD_QUOTED, options)).toBe(`"1234567\\\n\\\0ab"`)
      })

      test('space', () => {
        const str = `"1234567\\ ab"`
        expect(fold(str, '', FOLD_QUOTED, options)).toBe(`"1234567\\\n\\ ab"`)
      })
    })
  })

  describe('Folding input with excessive start indentation (#196)', () => {
    test('quoted', () => {
      options.indentAtStart = 6
      options.minContentWidth = 6
      expect(fold('"ab cd ef gh"', ' ', FOLD_QUOTED, options)).toBe(
        '\n "ab cd ef\n gh"'
      )
    })

    test('plain', () => {
      options.indentAtStart = 6
      options.minContentWidth = 6
      expect(fold('ab cd ef gh', ' ', FOLD_FLOW, options)).toBe(
        '\n ab cd ef\n gh'
      )
    })

    test('reported', () => {
      const input = {
        testgljrisgjsrligjsrligsjrglisrjgrligjsligrjglisjgrlijgsrilgsejrfiwlahflirgjaelfjafil:
          '&cLorem ipsum dolor sit amet, consectetur adipiscing elit. Sed sed nibh ac metus elementum venenatis eu vitae diam. Etiam tristique suscipit mauris. Donec pulvinar sed nunc a gravida. Morbi nulla lacus, gravida eu elementum id, ultricies nec ipsum. Cras bibendum tellus ut mollis malesuada. Maecenas eleifend felis at fermentum hendrerit. Nulla porta vitae erat eget faucibus. Sed egestas viverra magna ac vulputate. Suspendisse vel posuere mauris, accumsan dapibus libero. Curabitur bibendum tellus in ex ultricies, quis tempus magna luctus. Maecenas maximus orci est, id fringilla lorem gravida sit amet. Pellentesque a rutrum lorem. Vestibulum ante ipsum primis in faucibus orci.'
      }
      expect(YAML.stringify(input)).toBe(
        `testgljrisgjsrligjsrligsjrglisrjgrligjsligrjglisjgrlijgsrilgsejrfiwlahflirgjaelfjafil:
  "&cLorem ipsum dolor sit amet, consectetur adipiscing elit. Sed sed nibh ac
  metus elementum venenatis eu vitae diam. Etiam tristique suscipit mauris.
  Donec pulvinar sed nunc a gravida. Morbi nulla lacus, gravida eu elementum id,
  ultricies nec ipsum. Cras bibendum tellus ut mollis malesuada. Maecenas
  eleifend felis at fermentum hendrerit. Nulla porta vitae erat eget faucibus.
  Sed egestas viverra magna ac vulputate. Suspendisse vel posuere mauris,
  accumsan dapibus libero. Curabitur bibendum tellus in ex ultricies, quis
  tempus magna luctus. Maecenas maximus orci est, id fringilla lorem gravida sit
  amet. Pellentesque a rutrum lorem. Vestibulum ante ipsum primis in faucibus
  orci."\n`
      )
    })
  })
})

describe('block scalar', () => {
  test('Indented first line (#422)', () => {
    const obj = {
      'nginx.ingress.kubernetes.io/configuration-snippet': source`
          location ~* ^/sites/aaaaaaa.aa/files/(.+) {
            return 302 https://process.aaaaaaa.aa/sites/aaaaaaa.aa/files/$1;
          }
          location ~* ^/partner-application/cls/(.+) {
            return 301 https://process.aaaaaaa.aa/partner-application/cls/$1$is_args$args;
          }
          `
    }
    expect(YAML.stringify(obj)).toBe(source`
        nginx.ingress.kubernetes.io/configuration-snippet: >
          location ~* ^/sites/aaaaaaa.aa/files/(.+) {
            return 302 https://process.aaaaaaa.aa/sites/aaaaaaa.aa/files/$1;
          }

          location ~* ^/partner-application/cls/(.+) {
            return 301 https://process.aaaaaaa.aa/partner-application/cls/$1$is_args$args;
          }
      `)
  })

  test('block scalar with very long lines (#585)', () => {
    const str = ('a'.repeat(30) + '\n').repeat(3)
    expect(YAML.stringify(str, { lineWidth: 20 })).toBe(source`
      |
      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
    `)
  })
})

describe('end-to-end', () => {
  const foldOptions = { lineWidth: 20, minContentWidth: 0 }

  test('more-indented folded block', () => {
    const src = source`
      > # comment with an excessive length that won't get folded
      Text on a line that
      should get folded
      with a line width of
      20 characters.

        Indented text
        that appears to be
      folded but is not.

        Text that is prevented from folding due to being more-indented.

      Unfolded paragraph.
    `
    const doc = YAML.parseDocument(src)
    expect(doc.contents.value).toBe(source`
      Text on a line that should get folded with a line width of 20 characters.

        Indented text
        that appears to be
      folded but is not.

        Text that is prevented from folding due to being more-indented.

      Unfolded paragraph.
    `)
    expect(doc.toString(foldOptions)).toBe(src)
  })

  test('More-indented first line (#55)', () => {
    const str = ' first more-indented line\nnext line\n'
    const ys = YAML.stringify(str, foldOptions)
    expect(ys).toBe('>1\n first more-indented line\nnext line\n')
  })

  test('plain string', () => {
    const src = source`
      - plain value with
        enough length to
        fold twice
      - plain with comment # that won't get folded
    `
    const doc = YAML.parseDocument, false>(src)
    expect(doc.contents.items[0].value).toBe(
      'plain value with enough length to fold twice'
    )
    expect(doc.contents.items[1].value).toBe('plain with comment')
    expect(doc.toString(foldOptions)).toBe(src)
  })

  test('long line width', () => {
    const src = `\
Lorem ipsum dolor sit amet, consectetur adipiscing elit. In laoreet massa eros, dignissim aliquam nunc elementum sit amet. Mauris pulvinar nunc eget ante sodales viverra. Vivamus quis convallis sapien, ut auctor magna. Cras volutpat erat eu lacus luctus facilisis. Aenean sapien leo, auctor sed tincidunt at, scelerisque a urna. Nunc ullamcorper, libero non mollis aliquet, nulla diam lobortis neque, ac rutrum dui nibh iaculis lectus. Aenean lobortis interdum arcu eget sollicitudin.

Duis quam enim, ultricies a enim non, tincidunt lobortis ipsum. Mauris condimentum ultrices eros rutrum euismod. Fusce et mi eget quam dapibus blandit. Maecenas sodales tempor euismod. Phasellus vulputate purus felis, eleifend ullamcorper tortor semper sit amet. Sed nunc quam, iaculis et neque sit amet, consequat egestas lectus. Aenean dapibus lorem sed accumsan porttitor. Curabitur eu magna congue, mattis urna ac, lacinia eros. In in iaculis justo, nec faucibus enim. Fusce id viverra purus, nec ultricies mi. Aliquam eu risus risus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Suspendisse potenti. \n`

    const exp = `|
Lorem ipsum dolor sit amet, consectetur adipiscing elit. In laoreet massa eros, dignissim aliquam nunc elementum sit amet. Mauris pulvinar nunc eget ante sodales viverra. Vivamus quis convallis sapien, ut auctor magna. Cras volutpat erat eu lacus luctus facilisis. Aenean sapien leo, auctor sed tincidunt at, scelerisque a urna. Nunc ullamcorper, libero non mollis aliquet, nulla diam lobortis neque, ac rutrum dui nibh iaculis lectus. Aenean lobortis interdum arcu eget sollicitudin.

Duis quam enim, ultricies a enim non, tincidunt lobortis ipsum. Mauris condimentum ultrices eros rutrum euismod. Fusce et mi eget quam dapibus blandit. Maecenas sodales tempor euismod. Phasellus vulputate purus felis, eleifend ullamcorper tortor semper sit amet. Sed nunc quam, iaculis et neque sit amet, consequat egestas lectus. Aenean dapibus lorem sed accumsan porttitor. Curabitur eu magna congue, mattis urna ac, lacinia eros. In in iaculis justo, nec faucibus enim. Fusce id viverra purus, nec ultricies mi. Aliquam eu risus risus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Suspendisse potenti. \n`

    for (const lineWidth of [1000, 0, -1])
      expect(YAML.stringify(src, { lineWidth })).toBe(exp)
  })

  test('multiple lines', () => {
    const src = source`
      first line which is long enough to be wrapped to another line
      second line which is long enough to be wrapped to another line
       third line which is not wrapped because it's indented
      fourth line which is long enough to be wrapped to another line
    `
    expect(YAML.stringify({ src }, { lineWidth: 20, minContentWidth: 0 }))
      .toBe(source`
      src: >
        first line which
        is long enough to
        be wrapped to
        another line

        second line which
        is long enough to
        be wrapped to
        another line
         third line which is not wrapped because it's indented
        fourth line which
        is long enough to
        be wrapped to
        another line
    `)
  })
})
eemeli-yaml-086fa6b/tests/doc/parse.ts000066400000000000000000000655551511277410200177410ustar00rootroot00000000000000import { readFileSync } from 'fs'
import { resolve } from 'path'
import * as YAML from 'yaml'
import { source } from '../_utils.ts'

describe('scalars', () => {
  test('empty block scalar at end of document', () => {
    const docs = YAML.parseAllDocuments('|\n---\nfoo')
    expect(docs.map(doc => doc.toJS())).toMatchObject(['', 'foo'])
  })

  test('carriage returns in double-quotes', () => {
    const src = '"a\nb\n\rc\n\r\nd\n\r\n\re\n\r\n\r\nf"'
    expect(YAML.parse(src)).toBe('a b \rc\nd\n\re\n\nf')
  })
})

describe('indented block sequence (#10)', () => {
  test('reported', () => {
    const src = `
aliases:
  - restore_cache:
      - v1-yarn-cache
  - save_cache:
      paths:
        - ~/.cache/yarn
  - &restore_deps_cache
    keys:
      - v1-deps-cache-{{ checksum "yarn.lock" }}\n`
    const docs = YAML.parseAllDocuments(src)
    expect(docs).toHaveLength(1)
    expect(docs[0].errors).toHaveLength(0)
  })

  test('complete file', () => {
    const src = readFileSync(
      resolve(__dirname, '../artifacts/prettier-circleci-config.yml'),
      'utf8'
    )
    const doc = YAML.parseDocument(src)
    expect(doc.toJS()).toMatchObject({
      aliases: [
        { restore_cache: { keys: ['v1-yarn-cache'] } },
        { save_cache: { key: 'v1-yarn-cache', paths: ['~/.cache/yarn'] } },
        {
          restore_cache: { keys: ['v1-deps-cache-{{ checksum "yarn.lock" }}'] }
        },
        {
          save_cache: {
            key: 'v1-yarn-deps-{{ checksum "yarn.lock" }}',
            paths: ['node_modules']
          }
        },
        {
          docker: [{ image: 'circleci/node:9' }],
          working_directory: '~/prettier'
        }
      ],
      jobs: {
        build_prod: {
          '<<': {
            docker: [{ image: 'circleci/node:9' }],
            working_directory: '~/prettier'
          },
          environment: { NODE_ENV: 'production' },
          steps: [
            { attach_workspace: { at: '~/prettier' } },
            { run: 'yarn build' },
            { persist_to_workspace: { paths: ['dist'], root: '.' } },
            { store_artifacts: { path: '~/prettier/dist' } }
          ]
        },
        checkout_code: {
          '<<': {
            docker: [{ image: 'circleci/node:9' }],
            working_directory: '~/prettier'
          },
          steps: [
            'checkout',
            { restore_cache: { keys: ['v1-yarn-cache'] } },
            {
              restore_cache: {
                keys: ['v1-deps-cache-{{ checksum "yarn.lock" }}']
              }
            },
            { run: 'yarn install' },
            { run: 'yarn check-deps' },
            {
              save_cache: {
                key: 'v1-yarn-deps-{{ checksum "yarn.lock" }}',
                paths: ['node_modules']
              }
            },
            { save_cache: { key: 'v1-yarn-cache', paths: ['~/.cache/yarn'] } },
            { persist_to_workspace: { paths: ['.'], root: '.' } }
          ]
        },
        test_prod_node4: {
          '<<': {
            docker: [{ image: 'circleci/node:9' }],
            working_directory: '~/prettier'
          },
          docker: [{ image: 'circleci/node:4' }],
          steps: [
            { attach_workspace: { at: '~/prettier' } },
            { run: 'yarn test:dist' }
          ]
        },
        test_prod_node9: {
          '<<': {
            docker: [{ image: 'circleci/node:9' }],
            working_directory: '~/prettier'
          },
          steps: [
            { attach_workspace: { at: '~/prettier' } },
            { run: 'yarn test:dist' }
          ]
        }
      },
      version: 2,
      workflows: {
        prod: {
          jobs: [
            'checkout_code',
            { build_prod: { requires: ['checkout_code'] } },
            { test_prod_node4: { requires: ['build_prod'] } },
            { test_prod_node9: { requires: ['build_prod'] } }
          ]
        },
        version: 2
      }
    })
    const exp = src.replace(/\r\n/g, '\n') // To account for git core.autocrlf true on Windows
    expect(String(doc)).toBe(exp)
  })

  test('minimal', () => {
    const src = `
  - a
  - b:
    - c
  - d`
    const docs = YAML.parseAllDocuments(src)
    expect(docs[0].errors).toHaveLength(0)
    expect(docs[0].toJS()).toMatchObject(['a', { b: ['c'] }, 'd'])
  })
})

test('buffer as source (#459)', () => {
  const buffer = readFileSync(
    resolve(__dirname, '../artifacts/prettier-circleci-config.yml')
  )
  expect(() => YAML.parseDocument(buffer as any)).toThrow(
    'source is not a string'
  )
})

test('long scalar value in flow map (#36)', () => {
  expect(() => YAML.parse(`{ x: ${'x'.repeat(1024)} }`)).not.toThrow()
})

describe('flow collection keys', () => {
  test('block map with flow collection key as explicit key', () => {
    const doc = YAML.parseDocument(`? []: x`)
    expect(doc.errors).toHaveLength(0)
    expect(doc.contents).toMatchObject({
      items: [
        {
          key: {
            items: [{ key: { items: [], flow: true }, value: { value: 'x' } }]
          },
          value: null
        }
      ]
    })
  })

  test('flow collection as first block map key (redhat-developer/vscode-yaml#712)', () => {
    const doc = YAML.parseDocument(source`
      a:
        []: b
        c: d
    `)
    expect(doc.errors).toHaveLength(0)
    expect(doc.contents).toMatchObject({
      items: [
        {
          key: { value: 'a' },
          value: {
            items: [
              { key: { items: [] }, value: { value: 'b' } },
              { key: { value: 'c' }, value: { value: 'd' } }
            ]
          }
        }
      ]
    })
  })

  test('flow collection as second block map key (redhat-developer/vscode-yaml#712)', () => {
    const doc = YAML.parseDocument(source`
      x: y
      a:
        []: b
        c: d
    `)
    expect(doc.errors).toHaveLength(0)
    expect(doc.contents).toMatchObject({
      items: [
        { key: { value: 'x' }, value: { value: 'y' } },
        {
          key: { value: 'a' },
          value: {
            items: [
              { key: { items: [] }, value: { value: 'b' } },
              { key: { value: 'c' }, value: { value: 'd' } }
            ]
          }
        }
      ]
    })
  })

  test('empty scalar as last flow collection value (#550)', () => {
    const doc = YAML.parseDocument('{c:}')
    expect(doc.contents.items).toMatchObject([
      { key: { value: 'c' }, value: { value: null } }
    ])
  })

  test('plain key with no space before flow collection value (#550)', () => {
    const doc = YAML.parseDocument('{c:[]}')
    expect(doc.contents.items).toMatchObject([
      { key: { value: 'c' }, value: { items: [] } }
    ])
  })
})

test('indented block sequnce with inner block sequence (#38)', () => {
  const src = `
  content:
    arrayOfArray:
    -
      - first: John
        last: Black
      - first: Brian
        last: Green
    -
      - first: Mark
        last: Orange
    -
      - first: Adam
        last: Grey
  `
  expect(YAML.parse(src)).toEqual({
    content: {
      arrayOfArray: [
        [
          { first: 'John', last: 'Black' },
          { first: 'Brian', last: 'Green' }
        ],
        [{ first: 'Mark', last: 'Orange' }],
        [{ first: 'Adam', last: 'Grey' }]
      ]
    }
  })
})

test('stream end after : indicator (#120)', () => {
  const src = `test:
    - test1: test1
      test2:`
  expect(YAML.parse(src)).toEqual({
    test: [{ test1: 'test1', test2: null }]
  })
})

test('comment between key & : in flow collection (#149)', () => {
  const src1 = '{"a"\n#c\n:1}'
  expect(YAML.parse(src1)).toEqual({ a: 1 })

  const src2 = '{a\n#c\n:1}'
  const doc = YAML.parseDocument(src2)
  expect(doc.errors).toMatchObject([{ code: 'MISSING_CHAR' }])
})

describe('indented key with anchor (#378)', () => {
  test('followed by value', () => {
    const src1 = '&a foo: 1\n&b bar: 2'
    expect(YAML.parse(src1)).toEqual({ foo: 1, bar: 2 })

    const src2 = ' &a foo: 3\n &b bar: 4'
    expect(YAML.parse(src2)).toEqual({ foo: 3, bar: 4 })
  })

  test('with : on separate line', () => {
    const src1 = 'a: 1\n&b\nc: 2'
    const doc1 = YAML.parseDocument(src1)
    expect(doc1.errors).toMatchObject([{ code: 'MULTILINE_IMPLICIT_KEY' }])

    const src2 = ' a: 1\n &b\n : 2'
    const doc2 = YAML.parseDocument(src2)
    expect(doc2.errors).toMatchObject([{ code: 'MULTILINE_IMPLICIT_KEY' }])
  })
})

describe('empty(ish) nodes', () => {
  test('empty explicit key (#3)', () => {
    const src = '{ ? : 123 }'
    const doc = YAML.parseDocument(src)
    expect(doc.errors).toHaveLength(0)
    expect(doc.contents.items[0].key.value).toBeNull()
    expect(doc.contents.items[0].value.value).toBe(123)
  })

  describe('comment on empty pair value (#19)', () => {
    test('map', () => {
      const src = 'a:\n  # 123'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('a: # 123\n')
    })

    test('seq', () => {
      const src = '- a: # 123'
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe('- a: # 123\n')
    })
  })

  test('explicit key with empty value (#32)', () => {
    expect(YAML.parse('[ ? ]')).toEqual([{ '': null }])
    expect(YAML.parse('[? 123]')).toEqual([{ 123: null }])
    expect(YAML.parse('[ 123, ? ]')).toEqual([123, { '': null }])
    expect(YAML.parse('[ 123, ? 456 ]')).toEqual([123, { 456: null }])
  })

  describe('empty block scalars', () => {
    test('no body (#34)', () => {
      expect(YAML.parse('|')).toEqual('')
    })

    test('whitespace with indents (#313)', () => {
      expect(YAML.parse('|+\n   \n\n     \n')).toEqual('\n\n\n')
    })
  })

  test('empty node position', () => {
    const doc = YAML.parseDocument('\r\na: # 123\r\n')
    const empty = doc.contents.items[0].value
    expect(empty.range).toEqual([5, 5, 12])
  })

  test('parse an empty string as null', () => {
    const value = YAML.parse('')
    expect(value).toBeNull()
  })

  test('parse a non-space WS char as itself', () => {
    const src = '\u{2002}' // en space
    const value = YAML.parse(src)
    expect(value).toBe(src)
  })
})

test('comment on single-line value in flow map', () => {
  const src = '{a: 1 #c\n}'
  const doc = YAML.parseDocument(src)
  expect(String(doc)).toBe('{\n  a: 1 #c\n}\n')
})

describe('maps with no values', () => {
  test('block map', () => {
    const src = `a: null\n? b #c`
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(`a: null\n? b #c\n`)
    doc.set('b', 'x')
    expect(String(doc)).toBe(`a: null\nb: #c\n  x\n`)
  })

  test('flow map', () => {
    const src = `{\na: null,\n? b\n}`
    const doc = YAML.parseDocument(src)
    expect(String(doc)).toBe(`{ a: null, b }\n`)
    doc.contents.items[1].key.comment = 'c'
    expect(String(doc)).toBe(`{\n  a: null,\n  b #c\n}\n`)
    doc.set('b', 'x')
    expect(String(doc)).toBe(`{\n  a: null,\n  b: #c\n    x\n}\n`)
  })

  test('flow map has correct range', () => {
    const doc = YAML.parseDocument('{  }')
    expect(doc.range).toEqual([0, 4, 4])
  })

  test('pair in flow seq has correct range (#573)', () => {
    const doc = YAML.parseDocument('[a:]')
    expect(doc.range).toEqual([0, 4, 4])
    expect(doc.get(0).range).toEqual([1, 3, 3])
  })

  test('implicit scalar key after explicit key with no value', () => {
    const doc = YAML.parseDocument('? - 1\nx:\n')
    expect(doc.contents.items).toMatchObject([
      { key: { items: [{ value: 1 }] }, value: null },
      { key: { value: 'x' }, value: { value: null } }
    ])
  })

  test('implicit flow collection key after explicit key with no value', () => {
    const doc = YAML.parseDocument('? - 1\n[x]: y\n')
    expect(doc.contents.items).toMatchObject([
      { key: { items: [{ value: 1 }] }, value: null },
      { key: { items: [{ value: 'x' }] }, value: { value: 'y' } }
    ])
  })
})

describe('odd indentations', () => {
  test('Block map with empty explicit key (#551)', () => {
    const doc = YAML.parseDocument('?\n? a')
    expect(doc.errors).toHaveLength(0)
    expect(doc.contents.items).toMatchObject([
      { key: { value: null }, value: null },
      { key: { value: 'a' }, value: null }
    ])
  })

  test('Block map with unindented !!null explicit key', () => {
    const doc = YAML.parseDocument('?\n!!null')
    expect(doc.errors).not.toHaveLength(0)
  })

  test('unindented block scalar header in mapping value (#553)', () => {
    const doc = YAML.parseDocument('a:\n|\n x')
    expect(doc.errors).not.toHaveLength(0)
  })

  test('unindented flow collection in mapping value', () => {
    const doc = YAML.parseDocument('a:\n{x}')
    expect(doc.errors).not.toHaveLength(0)
  })

  test('comment after top-level block scalar with indentation indicator (#547)', () => {
    const doc = YAML.parseDocument('|1\n x\n#c')
    expect(doc.errors).toHaveLength(0)
    expect(doc.contents).toMatchObject({ value: 'x\n' })
  })

  test('tab after indent spaces for flow-in-block (#604)', () => {
    const doc = YAML.parseDocument('foo:\n \tbar')
    expect(doc.errors).toHaveLength(0)
    expect(doc.toJS()).toMatchObject({ foo: 'bar' })
  })
})

describe('Excessive entity expansion attacks', () => {
  const root = resolve(__dirname, '../artifacts/pr104')
  const src1 = readFileSync(resolve(root, 'case1.yml'), 'utf8')
  const src2 = readFileSync(resolve(root, 'case2.yml'), 'utf8')
  const srcB = readFileSync(resolve(root, 'billion-laughs.yml'), 'utf8')
  const srcQ = readFileSync(resolve(root, 'quadratic.yml'), 'utf8')

  let origEmitWarning: typeof process.emitWarning
  beforeAll(() => {
    origEmitWarning = process.emitWarning
  })
  afterAll(() => {
    process.emitWarning = origEmitWarning
  })

  describe('Limit count by default', () => {
    for (const [name, src] of [
      ['js-yaml case 1', src1],
      ['js-yaml case 2', src2],
      ['billion laughs', srcB],
      ['quadratic expansion', srcQ]
    ]) {
      test(name, () => {
        process.emitWarning = jest.fn()
        expect(() => YAML.parse(src)).toThrow(/Excessive alias count/)
      })
    }
  })

  describe('Work sensibly even with disabled limits', () => {
    test('js-yaml case 1', () => {
      process.emitWarning = jest.fn()
      const obj = YAML.parse(src1, { maxAliasCount: -1 })
      expect(obj).toMatchObject({})
      const key = Object.keys(obj)[0]
      expect(key.length).toBeGreaterThan(2000)
      expect(key.length).toBeLessThan(8000)
      expect(process.emitWarning).toHaveBeenCalled()
    })

    test('js-yaml case 2', () => {
      const arr = YAML.parse(src2, { maxAliasCount: -1 })
      expect(arr).toHaveLength(2)
      const key = Object.keys(arr[1])[0]
      expect(key).toBe('*id057')
    })

    test('billion laughs', () => {
      const obj = YAML.parse(srcB, { maxAliasCount: -1 })
      expect(Object.keys(obj)).toHaveLength(9)
    })

    test('quadratic expansion', () => {
      const obj = YAML.parse(srcQ, { maxAliasCount: -1 })
      expect(Object.keys(obj)).toHaveLength(11)
    })
  })

  describe('maxAliasCount limits', () => {
    const rows = [
      'a: &a [lol, lol, lol, lol, lol, lol, lol, lol, lol]',
      'b: &b [*a, *a, *a, *a, *a, *a, *a, *a, *a]',
      'c: &c [*b, *b, *b, *b]',
      'd: &d [*c, *c]',
      'e: [*d]'
    ]

    test(`depth 0: maxAliasCount 1 passes`, () => {
      expect(() => YAML.parse(rows[0], { maxAliasCount: 1 })).not.toThrow()
    })

    test(`depth 1: maxAliasCount 1 fails on first alias`, () => {
      const src = `${rows[0]}\nb: *a`
      expect(() => YAML.parse(src, { maxAliasCount: 1 })).toThrow()
    })

    const limits = [10, 50, 150, 300]
    for (let i = 0; i < 4; ++i) {
      const src = rows.slice(0, i + 2).join('\n')

      test(`depth ${i + 1}: maxAliasCount ${limits[i] - 1} fails`, () => {
        expect(() =>
          YAML.parse(src, { maxAliasCount: limits[i] - 1 })
        ).toThrow()
      })

      test(`depth ${i + 1}: maxAliasCount ${limits[i]} passes`, () => {
        expect(() =>
          YAML.parse(src, { maxAliasCount: limits[i] })
        ).not.toThrow()
      })
    }
  })
})

test('Anchor for empty node (6KGN)', () => {
  const src = `a: &anchor\nb: *anchor`
  expect(YAML.parse(src)).toMatchObject({ a: null, b: null })
})

describe('duplicate keys', () => {
  test('block collection scalars', () => {
    const doc = YAML.parseDocument('foo: 1\nbar: 2\nfoo: 3\n')
    expect(doc.errors).toMatchObject([{ code: 'DUPLICATE_KEY' }])
  })

  test('flow collection scalars', () => {
    const doc = YAML.parseDocument('{ foo: 1, bar: 2, foo: 3 }\n')
    expect(doc.errors).toMatchObject([{ code: 'DUPLICATE_KEY' }])
  })

  test('merge key (disabled)', () => {
    const doc = YAML.parseDocument('<<: 1\nbar: 2\n<<: 3\n', { merge: false })
    expect(doc.errors).toMatchObject([{ code: 'DUPLICATE_KEY' }])
  })

  test('disable with option', () => {
    const doc = YAML.parseDocument('foo: 1\nbar: 2\nfoo: 3\n', {
      uniqueKeys: false
    })
    expect(doc.errors).toMatchObject([])
  })

  test('customise with option', () => {
    const doc = YAML.parseDocument('foo: 1\nbar: 2\nfoo: 3\n', {
      uniqueKeys: () => true
    })
    expect(doc.errors).toMatchObject([
      { code: 'DUPLICATE_KEY' },
      { code: 'DUPLICATE_KEY' }
    ])
  })
})

describe('handling complex keys', () => {
  let origEmitWarning: typeof process.emitWarning
  beforeAll(() => {
    origEmitWarning = process.emitWarning
  })
  afterAll(() => {
    process.emitWarning = origEmitWarning
  })

  test('emit warning when casting key in collection to string as JS Object key', () => {
    const spy = (process.emitWarning = jest.fn())
    const doc = YAML.parseDocument('[foo]: bar', { prettyErrors: false })
    expect(doc.warnings).toHaveLength(0)
    expect(spy).not.toHaveBeenCalled()

    doc.toJS()
    expect(spy).toHaveBeenCalledTimes(1)
    expect(spy.mock.calls[0][0]).toMatch(
      /^Keys with collection values will be stringified due to JS Object restrictions/
    )
  })

  test('do not add warning when using mapIsMap: true', () => {
    process.emitWarning = jest.fn()
    const doc = YAML.parseDocument('[foo]: bar')
    doc.toJS({ mapAsMap: true })
    expect(doc.warnings).toMatchObject([])
    expect(process.emitWarning).not.toHaveBeenCalled()
  })

  test('warn when casting key in collection to string', () => {
    process.emitWarning = jest.fn()
    const obj = YAML.parse('[foo]: bar')
    expect(Object.keys(obj)).toMatchObject(['[ foo ]'])
    expect(process.emitWarning).toHaveBeenCalled()
  })

  test('warn when casting key in sequence to string', () => {
    process.emitWarning = jest.fn()
    const obj = YAML.parse('[ [foo]: bar ]')
    expect(obj).toMatchObject([{ '[ foo ]': 'bar' }])
    expect(process.emitWarning).toHaveBeenCalled()
  })

  test('Error on unresolved !!binary node with mapAsMap: false (#610)', () => {
    process.emitWarning = jest.fn()
    const doc = YAML.parseDocument('? ? !!binary ? !!binary')
    expect(doc.warnings).toMatchObject([{ code: 'BAD_COLLECTION_TYPE' }])
    doc.toJS()
    expect(process.emitWarning).toHaveBeenCalled()
  })

  test('Error on unresolved !!timestamp node with mapAsMap: false (#610)', () => {
    process.emitWarning = jest.fn()
    const doc = YAML.parseDocument(
      '? ? !!timestamp ? !!timestamp 2025-03-15T15:35:58.586Z'
    )
    expect(doc.warnings).toMatchObject([{ code: 'BAD_COLLECTION_TYPE' }])
    doc.toJS()
    expect(process.emitWarning).toHaveBeenCalled()
  })
})

test('Document.toJS({ onAnchor })', () => {
  const src = 'foo: &a [&v foo]\nbar: *a\nbaz: *a\n'
  const doc = YAML.parseDocument(src)
  const onAnchor = jest.fn()
  const res = doc.toJS({ onAnchor })
  expect(onAnchor.mock.calls).toMatchObject([
    [res.foo, 3],
    ['foo', 1]
  ])
})

describe('__proto__ as mapping key', () => {
  test('plain object', () => {
    const src = '{ __proto__: [42] }'
    const obj = YAML.parse(src)
    expect(Array.isArray(obj)).toBe(false)
    expect({}.hasOwnProperty.call(obj, '__proto__')).toBe(true)
    expect(obj).not.toHaveProperty('length')
    expect(JSON.stringify(obj)).toBe('{"__proto__":[42]}')
  })

  test('with merge key', () => {
    const src = '- &A { __proto__: [42] }\n- { <<: *A }\n'
    const obj = YAML.parse(src, { merge: true })
    expect({}.hasOwnProperty.call(obj[0], '__proto__')).toBe(true)
    expect({}.hasOwnProperty.call(obj[1], '__proto__')).toBe(true)
    expect(JSON.stringify(obj)).toBe('[{"__proto__":[42]},{"__proto__":[42]}]')
  })
})

describe('keepSourceTokens', () => {
  for (const [src, type] of [
    ['foo: bar', 'block-map'],
    ['{ foo: bar }', 'flow-collection']
  ]) {
    test(`${type}: default false`, () => {
      const doc = YAML.parseDocument(src)
      expect(doc.contents).not.toHaveProperty('srcToken')
      expect(doc.contents.items[0]).not.toHaveProperty('srcToken')
      expect(doc.get('foo', true)).not.toHaveProperty('srcToken')
    })

    test(`${type}: included when set`, () => {
      const doc = YAML.parseDocument(src, {
        keepSourceTokens: true
      })
      expect(doc.contents.srcToken).toMatchObject({ type })
      expect(doc.contents.items[0].srcToken).toMatchObject({
        key: { type: 'scalar' },
        value: { type: 'scalar' }
      })
      expect(doc.get('foo', true).srcToken).toMatchObject({ type: 'scalar' })
    })
  }

  test('allow for CST modifications (#903)', () => {
    const src = 'foo:\n  [ 42 ]'
    const tokens = Array.from(new YAML.Parser().parse(src))
    const docs = new YAML.Composer({
      keepSourceTokens: true
    }).compose(tokens)
    const doc = Array.from(docs)[0]
    const node = doc.get('foo', true)
    YAML.CST.setScalarValue(node.srcToken, 'eek')
    const res = tokens.map(YAML.CST.stringify).join('')
    expect(res).toBe('foo:\n  eek')
  })
})

describe('reviver', () => {
  test('MDN exemple', () => {
    const reviver = jest.fn((_key, value) => value)
    const src = '{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}'
    const obj = JSON.parse(src)
    YAML.parse(src, reviver)
    expect(reviver.mock.calls).toMatchObject([
      ['1', 1],
      ['2', 2],
      ['4', 4],
      ['6', 6],
      ['5', { 6: 6 }],
      ['3', obj[3]],
      ['', obj]
    ])
    expect(reviver.mock.instances).toMatchObject([
      obj,
      obj,
      obj[3],
      obj[3][5],
      obj[3],
      obj,
      { '': obj }
    ])
  })

  test('modify values', () => {
    const reviver = jest.fn((_key, value) =>
      typeof value === 'number' ? 2 * value : value
    )
    const src = '{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}'
    expect(YAML.parse(src, reviver)).toMatchObject({
      1: 2,
      2: 4,
      3: { 4: 8, 5: { 6: 12 } }
    })
  })

  test('remove values', () => {
    const reviver = jest.fn((key, value) =>
      key !== '' && key % 2 === 0 ? undefined : value
    )
    const src = '{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}'
    expect(YAML.parse(src, reviver)).toMatchObject({
      1: 1,
      3: { 5: {} }
    })
  })

  test('add values to this', () => {
    const reviver = jest.fn(function (key, value) {
      expect(key).not.toBe('9')
      this[9] = 9
      return value
    })
    const src = '{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}'
    expect(YAML.parse(src, reviver)).toMatchObject({
      1: 1,
      2: 2,
      3: { 4: 4, 5: { 6: 6, 9: 9 }, 9: 9 },
      9: 9
    })
  })

  test('sequence', () => {
    const these: unknown[][] = []
    const reviver = jest.fn(function (key, value) {
      these.push(Array.from(key === '' ? this[''] : this))
      if (key === '0') return undefined
      if (key === '3') return 10
      return value
    })
    const src = '[ 2, 4, 6, 8 ]'
    const seq = YAML.parse(src, reviver)
    expect(seq).toBeInstanceOf(Array)
    expect(seq).toMatchObject([undefined, 4, 6, 10])
    expect(reviver.mock.calls).toMatchObject([
      ['0', 2],
      ['1', 4],
      ['2', 6],
      ['3', 8],
      ['', {}]
    ])
    expect(these).toMatchObject([
      [2, 4, 6, 8],
      [undefined, 4, 6, 8],
      [undefined, 4, 6, 8],
      [undefined, 4, 6, 8],
      [undefined, 4, 6, 10]
    ])
  })

  test('!!set', () => {
    const these: unknown[][] = []
    const reviver = jest.fn(function (key, value) {
      these.push(Array.from(key === '' ? this[''] : this))
      if (key === 2) return undefined
      if (key === 8) return 10
      return value
    })
    const src = '!!set { 2, 4, 6, 8 }'
    const set = YAML.parse(src, reviver)
    expect(set).toBeInstanceOf(Set)
    expect(Array.from(set)).toMatchObject([4, 6, 10])
    expect(reviver.mock.calls).toMatchObject([
      [2, 2],
      [4, 4],
      [6, 6],
      [8, 8],
      ['', {}]
    ])
    expect(these).toMatchObject([
      [2, 4, 6, 8],
      [4, 6, 8],
      [4, 6, 8],
      [4, 6, 8],
      [4, 6, 10]
    ])
  })

  test('!!omap', () => {
    const these: unknown[][] = []
    const reviver = jest.fn(function (key, value) {
      these.push(Array.from(key === '' ? this[''] : this))
      if (key === 2) return undefined
      if (key === 8) return 10
      return value
    })
    const src = '!!omap [ 2: 3, 4: 5, 6: 7, 8: 9 ]'
    const map = YAML.parse(src, reviver)
    expect(map).toBeInstanceOf(Map)
    expect(Array.from(map)).toMatchObject([
      [4, 5],
      [6, 7],
      [8, 10]
    ])
    expect(reviver.mock.calls).toMatchObject([
      [2, 3],
      [4, 5],
      [6, 7],
      [8, 9],
      ['', map]
    ])
    expect(these).toMatchObject([
      [
        [2, 3],
        [4, 5],
        [6, 7],
        [8, 9]
      ],
      [
        [4, 5],
        [6, 7],
        [8, 9]
      ],
      [
        [4, 5],
        [6, 7],
        [8, 9]
      ],
      [
        [4, 5],
        [6, 7],
        [8, 9]
      ],
      [
        [4, 5],
        [6, 7],
        [8, 10]
      ]
    ])
  })
})

describe('CRLF line endings', () => {
  test('trailing space in double-quoted scalar', () => {
    const res = YAML.parse('"foo \r\nbar"')
    expect(res).toBe('foo bar')
  })

  test('escaped newline in double-quoted scalar', () => {
    const res = YAML.parse('"foo \\\r\nbar"')
    expect(res).toBe('foo bar')
  })
})

describe('stringKeys', () => {
  test('success', () => {
    const doc = YAML.parseDocument(
      source`
        x: x
        !!str y: y
        42: 42
        true: true
        null: null
        ~: ~
        :
      `,
      { stringKeys: true }
    )
    expect(doc.contents.items).toMatchObject([
      { key: { value: 'x' }, value: { value: 'x' } },
      { key: { value: 'y' }, value: { value: 'y' } },
      { key: { value: '42' }, value: { value: 42 } },
      { key: { value: 'true' }, value: { value: true } },
      { key: { value: 'null' }, value: { value: null } },
      { key: { value: '~' }, value: { value: null } },
      { key: { value: '' }, value: { value: null } }
    ])
  })

  test('explicit non-string tag', () => {
    const doc = YAML.parseDocument('!!int 42: 42', { stringKeys: true })
    expect(doc.errors).toMatchObject([{ code: 'NON_STRING_KEY' }])
  })

  test('collection key', () => {
    const doc = YAML.parseDocument('{ x, y }: 42', { stringKeys: true })
    expect(doc.errors).toMatchObject([{ code: 'NON_STRING_KEY' }])
  })
})
eemeli-yaml-086fa6b/tests/doc/stringify.ts000066400000000000000000001143721511277410200206350ustar00rootroot00000000000000import { source } from '../_utils.ts'
import * as YAML from 'yaml'
import { Pair, Scalar } from 'yaml'

for (const [name, version] of [
  ['YAML 1.1', '1.1'],
  ['YAML 1.2', '1.2']
] as const) {
  describe(name, () => {
    test('undefined', () => {
      expect(YAML.stringify(undefined, { version })).toBeUndefined()
    })

    test('null', () => {
      expect(YAML.stringify(null, { version })).toBe('null\n')
    })

    describe('boolean', () => {
      test('true', () => {
        expect(YAML.stringify(true, { version })).toBe('true\n')
      })
      test('false', () => {
        expect(YAML.stringify(false, { version })).toBe('false\n')
      })
      test('Boolean', () => {
        expect(YAML.stringify(new Boolean(true), { version })).toBe('true\n')
      })
    })

    describe('number', () => {
      test('integer', () => {
        expect(YAML.stringify(3, { version })).toBe('3\n')
      })
      test('float', () => {
        expect(YAML.stringify(3.141, { version })).toBe('3.141\n')
      })
      test('zero', () => {
        expect(YAML.stringify(0, { version })).toBe('0\n')
      })
      test('NaN', () => {
        expect(YAML.stringify(NaN, { version })).toBe('.nan\n')
      })
      test('Number', () => {
        expect(YAML.stringify(new Number(3.141), { version })).toBe('3.141\n')
      })
      test('negative zero', () => {
        expect(YAML.stringify(-0, { version })).toBe('-0\n')
      })

      test('float with trailing zeros', () => {
        const doc = new YAML.Document(3, { version })
        doc.contents.minFractionDigits = 2
        expect(String(doc)).toBe('3.00\n')
      })
      test('scientific float ignores minFractionDigits', () => {
        const doc = new YAML.Document(3, { version })
        doc.contents.format = 'EXP'
        doc.contents.minFractionDigits = 2
        expect(String(doc)).toBe('3e+0\n')
      })

      test('integer with HEX format', () => {
        const doc = new YAML.Document(42, { version })
        doc.contents.format = 'HEX'
        expect(String(doc)).toBe('0x2a\n')
      })
      test('float with HEX format', () => {
        const doc = new YAML.Document(4.2, { version })
        doc.contents.format = 'HEX'
        expect(String(doc)).toBe('4.2\n')
      })
      test('negative integer with HEX format', () => {
        const doc = new YAML.Document(-42, { version })
        doc.contents.format = 'HEX'
        const exp = version === '1.2' ? '-42\n' : '-0x2a\n'
        expect(String(doc)).toBe(exp)
      })

      test('bigint', () => {
        expect(YAML.stringify(BigInt('-42'), { version })).toBe('-42\n')
      })
      test('BigInt', () => {
        expect(YAML.stringify(Object(BigInt('-42')), { version })).toBe('-42\n')
      })
      test('BigInt with HEX format', () => {
        const doc = new YAML.Document(BigInt('42'), {
          version
        })
        doc.contents.format = 'HEX'
        expect(String(doc)).toBe('0x2a\n')
      })
      test('BigInt with OCT format', () => {
        const doc = new YAML.Document(BigInt('42'), {
          version
        })
        doc.contents.format = 'OCT'
        const exp = version === '1.2' ? '0o52\n' : '052\n'
        expect(String(doc)).toBe(exp)
      })
      test('negative BigInt with OCT format', () => {
        const doc = new YAML.Document(BigInt('-42'), {
          version
        })
        doc.contents.format = 'OCT'
        const exp = version === '1.2' ? '-42\n' : '-052\n'
        expect(String(doc)).toBe(exp)
      })
    })

    describe('string', () => {
      const opt = { lineWidth: 20, minContentWidth: 0, version }

      test('plain', () => {
        expect(YAML.stringify('STR', opt)).toBe('STR\n')
      })
      test('double-quoted', () => {
        expect(YAML.stringify('"x"', opt)).toBe('\'"x"\'\n')
      })
      test('single-quoted', () => {
        expect(YAML.stringify("'x'", opt)).toBe('"\'x\'"\n')
      })
      test('escaped', () => {
        expect(YAML.stringify('null: \u0000', opt)).toBe('"null: \\0"\n')
      })
      test('short multiline', () => {
        expect(YAML.stringify('blah\nblah\nblah', opt)).toBe(
          '|-\nblah\nblah\nblah\n'
        )
      })
      test('long multiline', () => {
        expect(
          YAML.stringify(
            'blah blah\nblah blah blah blah blah blah blah blah blah blah\n',
            opt
          )
        ).toBe(`>
blah blah

blah blah blah blah
blah blah blah blah
blah blah\n`)
      })
      test('String', () => {
        expect(YAML.stringify(new String('STR'), opt)).toBe('STR\n')
      })

      test('long line in map', () => {
        const foo = 'fuzz'.repeat(16)
        const doc = new YAML.Document<
          YAML.YAMLMap,
          false
        >({ foo }, { version })
        for (const node of doc.contents.items)
          node.value!.type = Scalar.QUOTE_DOUBLE
        expect(
          doc
            .toString(opt)
            .split('\n')
            .map(line => line.length)
        ).toMatchObject([20, 20, 20, 20, 0])
      })

      test('long line in sequence', () => {
        const foo = 'fuzz'.repeat(16)
        const doc = new YAML.Document, false>([foo], {
          version
        })
        for (const node of doc.contents.items) node.type = Scalar.QUOTE_DOUBLE
        expect(
          doc
            .toString(opt)
            .split('\n')
            .map(line => line.length)
        ).toMatchObject([20, 20, 20, 17, 0])
      })

      test('long line in sequence in map', () => {
        const foo = 'fuzz'.repeat(16)
        const doc = new YAML.Document<
          YAML.YAMLMap>,
          false
        >({ foo: [foo] }, { version })
        const seq = doc.contents.items[0].value!
        for (const node of seq.items) node.type = Scalar.QUOTE_DOUBLE
        expect(
          doc
            .toString(opt)
            .split('\n')
            .map(line => line.length)
        ).toMatchObject([4, 20, 20, 20, 20, 10, 0])
      })

      test('Keep pipe when empty block literal is given', () => {
        const doc = YAML.parseDocument('|-')
        expect(String(doc)).toBe('|\n\n')
      })

      test('Keep pipe when pipe is provided', () => {
        const doc = YAML.parseDocument('|')
        expect(String(doc)).toBe('|\n\n')
      })
    })
  })
}

describe('timestamp-like string (YAML 1.1)', () => {
  for (const [name, str] of [
    ['canonical', '2001-12-15T02:59:43.1Z'],
    ['validIso8601', '2001-12-14t21:59:43.10-05:00'],
    ['spaceSeparated', '2001-12-14 21:59:43.10 -5'],
    ['noTimeZone', '2001-12-15 2:59:43.10']
  ]) {
    test(name, () => {
      const res = YAML.stringify(str, { version: '1.1' })
      expect(res).toBe(`"${str}"\n`)
      expect(YAML.parse(res, { version: '1.1' })).toBe(str)
    })
  }
})

// https://github.com/tc39/proposal-well-formed-stringify
describe('unpaired surrogate pairs of Unicode code points', () => {
  test('𝌆', () => {
    expect(YAML.stringify('𝌆')).toBe('𝌆\n')
  })
  test('\uD834\uDF06', () => {
    expect(YAML.stringify('\uD834\uDF06')).toBe('𝌆\n')
  })
  test('😀', () => {
    expect(YAML.stringify('😀')).toBe('😀\n')
  })
  test('\uD83D\uDE00', () => {
    expect(YAML.stringify('\uD83D\uDE00')).toBe('😀\n')
  })
  test('\uDF06\uD834', () => {
    expect(YAML.stringify('\uDF06\uD834')).toBe('"\\udf06\\ud834"\n')
  })
  test('\uDEAD', () => {
    expect(YAML.stringify('\uDEAD')).toBe('"\\udead"\n')
  })
})

describe('circular references', () => {
  test('parent at root', () => {
    const map: any = { foo: 'bar' }
    map.map = map
    expect(YAML.stringify(map)).toBe(`&a1
foo: bar
map: *a1\n`)
  })

  test('ancestor at root', () => {
    const baz: any = {}
    const map = { foo: { bar: { baz } } }
    baz.map = map
    expect(YAML.stringify(map)).toBe(`&a1
foo:
  bar:
    baz:
      map: *a1\n`)
  })

  test('sibling sequences', () => {
    const one = ['one']
    const two = ['two']
    const seq = [one, two, one, one, two]
    expect(YAML.stringify(seq)).toBe(`- &a1
  - one
- &a2
  - two
- *a1
- *a1
- *a2\n`)
  })

  test('further relatives', () => {
    const baz = { a: 1 }
    const seq = [{ foo: { bar: { baz } } }, { fe: { fi: { fo: { baz } } } }]
    expect(YAML.stringify(seq)).toBe(`- foo:
    bar:
      baz: &a1
        a: 1
- fe:
    fi:
      fo:
        baz: *a1\n`)
  })

  test('only match objects', () => {
    const date = new Date('2001-12-15T02:59:43.1Z')
    const seq = ['a', 'a', 1, 1, true, true, date, date]
    expect(YAML.stringify(seq, { anchorPrefix: 'foo', version: '1.1' }))
      .toBe(`- a
- a
- 1
- 1
- true
- true
- &foo1 2001-12-15T02:59:43.100Z
- *foo1\n`)
  })

  test('do not match nulls', () => {
    const set = { a: null, b: null }
    expect(YAML.stringify(set)).toBe('a: null\nb: null\n')
  })
})

test('array', () => {
  const array = [3, ['four', 5]]
  const str = YAML.stringify(array)
  expect(str).toBe(
    `- 3
- - four
  - 5\n`
  )
})

describe('maps', () => {
  test('JS Object', () => {
    const object = { x: 3, y: [4], z: { w: 'five', v: 6 } }
    const str = YAML.stringify(object)
    expect(str).toBe(
      `x: 3
y:
  - 4
z:
  w: five
  v: 6\n`
    )
  })

  test('Map with non-Pair item', () => {
    const doc = new YAML.Document({ x: 3, y: 4 })
    expect(String(doc)).toBe('x: 3\ny: 4\n')
    // @ts-expect-error This should fail.
    doc.contents.items.push('TEST')
    expect(() => String(doc)).toThrow(/^Map items must all be pairs.*TEST/)
  })

  test('Keep block scalar types for keys', () => {
    const doc = YAML.parseDocument('? >+ #comment\n foo\n\n: bar')
    expect(String(doc)).toBe('? >+ #comment\n  foo\n\n: bar\n')
  })

  test('Document as key', () => {
    const doc = new YAML.Document({ a: 1 })
    doc.add(new YAML.Document({ b: 2, c: 3 }))
    expect(String(doc)).toBe('a: 1\n? b: 2\n  c: 3\n')
  })

  test('plain key containing flow indicators', () => {
    const doc = YAML.parseDocument('foo[{}]: bar')
    expect(doc.toString()).toBe('foo[{}]: bar\n')
  })

  describe('No extra whitespace for empty values', () => {
    const getDoc = () =>
      new YAML.Document, false>({
        a: null,
        b: null
      })

    test('Block map, no comments', () => {
      expect(getDoc().toString({ nullStr: '' })).toBe('a:\nb:\n')
    })

    test('Block map, with key.comment', () => {
      const doc = getDoc()
      doc.contents.items[0].key.comment = 'c'
      expect(doc.toString({ nullStr: '' })).toBe('a: #c\nb:\n')
    })

    test('Block map, with value.commentBefore', () => {
      const doc = getDoc()
      doc.get('a', true).commentBefore = 'c'
      expect(doc.toString({ nullStr: '' })).toBe('a:\n  #c\nb:\n')
    })

    test('Flow map, no comments', () => {
      const doc = getDoc()
      doc.contents.flow = true
      expect(doc.toString({ nullStr: '' })).toBe('{ a:, b: }\n')
    })

    test('Flow map, with key.comment', () => {
      const doc = getDoc()
      doc.contents.flow = true
      doc.contents.items[0].key.comment = 'c'
      expect(doc.toString({ nullStr: '' })).toBe('{\n  a: #c\n    ,\n  b:\n}\n')
    })

    test('Flow map, with value.commentBefore', () => {
      const doc = getDoc()
      doc.contents.flow = true
      doc.get('a', true).commentBefore = 'c'
      expect(doc.toString({ nullStr: '' })).toBe(
        '{\n  a:\n    #c\n    ,\n  b:\n}\n'
      )
    })

    test('Single newline after key with empty value', () => {
      const src = source`
      map:
        item:

      anothermap:
        anotheritem:

      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })
  })

  describe('properties on collections in block mapping', () => {
    test('explicit tag on block sequence', () => {
      const src = source`
        key: !tag
          - one
          - two
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })
    test('explicit tag on block mapping', () => {
      const src = source`
        key: !tag
          one: 1
          two: 2
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })
    test('single-line comment on block sequence', () => {
      const src = source`
        key: #comment
          - one
          - two
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(source`
        key:
          #comment
          - one
          - two
      `)
    })
    test('single-line comment and explicit tag on block sequence', () => {
      const src = source`
        key: #comment
          !tag
          - one
          - two
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(source`
        key:
          #comment
          !tag
          - one
          - two
      `)
    })
    test('explicit tag and comment on block sequence', () => {
      const src = source`
        key: !tag
          #comment
          - one
          - two
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(source`
        key:
          #comment
          !tag
          - one
          - two
      `)
    })
    test('anchor on block sequence', () => {
      const src = source`
        key: &anchor
          - one
          - two
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })
    test('anchor and explicit tag on block sequence', () => {
      const src = source`
        key: &anchor !tag
          - one
          - two
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })
    test('explicit tag on empty mapping', () => {
      const doc = new YAML.Document({ key: {} })
      doc.get('key').tag = '!tag'
      expect(String(doc)).toBe(source`
        key: !tag {}
      `)
    })
    test('explicit tag on single-line flow mapping', () => {
      const src = source`
        key: !tag { one: 1, two: 2 }
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })
    test('explicit tag on multi-line flow mapping', () => {
      const src = source`
        key: !tag {
          one: aaaaaaaaaa,
          two: bbbbbbbbbb,
          three: cccccccccc,
          four: dddddddddd,
          five: eeeeeeeeee
        }
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(source`
        key:
          !tag {
            one: aaaaaaaaaa,
            two: bbbbbbbbbb,
            three: cccccccccc,
            four: dddddddddd,
            five: eeeeeeeeee
          }
      `)
    })
    test('explicit tag on explicit-value block sequence', () => {
      const src = source`
        ? [ key ]
        : !tag
          - one
          - two
      `
      const doc = YAML.parseDocument(src)
      expect(String(doc)).toBe(src)
    })
  })
})

test('Quoting colons (#43)', () => {
  const doc = new YAML.Document({ key: ':' })
  const str = String(doc)
  expect(() => YAML.parse(str)).not.toThrow()
  expect(str).toBe('key: ":"\n')
})

test('Quoting item markers (#52)', () => {
  const doc = new YAML.Document({ key: '-' })
  const str = String(doc)
  expect(() => YAML.parse(str)).not.toThrow()
  expect(str).toBe('key: "-"\n')
  doc.contents = doc.createNode({ key: '?' })
  const str2 = String(doc)
  expect(() => YAML.parse(str2)).not.toThrow()
  expect(str2).toBe('key: "?"\n')
})

test('reserved names', () => {
  const str = YAML.stringify({ comment: 'foo' })
  expect(str).toBe('comment: foo\n')
})

describe('Collection pairs with single-line flow collections (#85)', () => {
  test('reported', () => {
    const str = `testArray: []\ntestObject: {}\ntestArray2: [ "hello" ]\n`
    const doc = YAML.parseDocument(str)
    expect(String(doc)).toBe(str)
  })

  test('multiline flow collection', () => {
    const str = `foo: [ bar, bar, bar, bar, bar, bar, bar, bar, bar, bar, bar, bar, bar, bar, bar, bar, bar, bar ]`
    const doc = YAML.parseDocument(str)
    const str2 = String(doc)
    expect(str2).toMatch(/^foo:\n {2}\[\n {4}bar/)
    expect(YAML.parse(str2)).toMatchObject(doc.toJS())
  })
})

test('set(object) in collection (#87)', () => {
  const doc = YAML.parseDocument('test: x')
  doc.set('test', { a: 'test' })
  expect(String(doc)).toBe('test:\n  a: test\n')
})

describe('Custom null/bool string representations', () => {
  test('tilde null', () => {
    const doc = YAML.parse('a: null')
    const str = YAML.stringify(doc, { nullStr: '~', simpleKeys: true })
    expect(str).toBe('a: ~\n')
    expect(YAML.parse(str)).toEqual({ a: null })
  })

  test('empty string null', () => {
    const doc = YAML.parse('a: null')
    const str = YAML.stringify(doc, { nullStr: '', simpleKeys: true })
    expect(str).toBe('a:\n')
    expect(YAML.parse(str)).toEqual({ a: null })
  })

  test('empty string camelBool', () => {
    const doc = YAML.parse('[true, false]')
    const str = YAML.stringify(doc, { trueStr: 'True', falseStr: 'False' })
    expect(str).toBe('- True\n- False\n')
    expect(YAML.parse(str)).toEqual([true, false])
  })

  test('empty string upperBool', () => {
    const doc = YAML.parse('[true, false]')
    const str = YAML.stringify(doc, { trueStr: 'TRUE', falseStr: 'FALSE' })
    expect(str).toBe('- TRUE\n- FALSE\n')
    expect(YAML.parse(str)).toEqual([true, false])
  })
})

describe('scalar styles', () => {
  test('null Scalar styles', () => {
    const doc = YAML.parseDocument('[ null, Null, NULL, ~ ]')
    expect(String(doc)).toBe('[ null, Null, NULL, ~ ]\n')
  })

  test('bool Scalar styles on core', () => {
    const doc = YAML.parseDocument(
      '[ true, false, True, False, TRUE, FALSE, on, off, y, n ]'
    )
    const str = `[
  true,
  false,
  True,
  False,
  TRUE,
  FALSE,
  on,
  off,
  y,
  n
]\n`
    expect(doc.toString({ lineWidth: 1 })).toBe(str)
    expect(YAML.parse(str)).toEqual([
      true,
      false,
      true,
      false,
      true,
      false,
      'on',
      'off',
      'y',
      'n'
    ])
  })

  test('bool Scalar styles on YAML1.1', () => {
    const doc = YAML.parseDocument(
      '[ n, N, NO, no, No, False, false, FALSE, FALse, Off, off, OFF, OfF, y, Y, Yes, yes, YES, true, True, TRUE, ON, on, On ]',
      { schema: 'yaml-1.1' }
    )
    const str = `[
  n,
  N,
  NO,
  no,
  No,
  False,
  false,
  FALSE,
  FALse,
  Off,
  off,
  OFF,
  OfF,
  y,
  Y,
  Yes,
  yes,
  YES,
  true,
  True,
  TRUE,
  ON,
  on,
  On
]\n`
    expect(String(doc)).toBe(str)
    expect(YAML.parse(str, { schema: 'yaml-1.1' })).toEqual([
      false,
      false,
      false,
      false,
      false,
      false,
      false,
      false,
      'FALse',
      false,
      false,
      false,
      'OfF',
      true,
      true,
      true,
      true,
      true,
      true,
      true,
      true,
      true,
      true,
      true
    ])
  })
})

describe('simple keys', () => {
  test('key with no value', () => {
    const doc = YAML.parseDocument('? ~')
    expect(doc.toString()).toBe('? ~\n')
    expect(doc.toString({ simpleKeys: true })).toBe('~: null\n')
  })

  test('key with block scalar value', () => {
    const doc = YAML.parseDocument('foo: bar')
    doc.contents.items[0].key.type = 'BLOCK_LITERAL'
    expect(doc.toString()).toBe('? |-\n  foo\n: bar\n')
    expect(doc.toString({ simpleKeys: true })).toBe('"foo": bar\n')
  })

  test('key with comment', () => {
    const doc = YAML.parseDocument('foo: bar')
    doc.contents.items[0].key.comment = 'FOO'
    expect(doc.toString()).toBe('foo: #FOO\n  bar\n')
    expect(() => doc.toString({ simpleKeys: true })).toThrow(
      /With simple keys, key nodes cannot have comments/
    )
  })

  test('key with collection value', () => {
    const doc = YAML.parseDocument('[foo]: bar')
    expect(doc.toString()).toBe('? [ foo ]\n: bar\n')
    expect(() => doc.toString({ simpleKeys: true })).toThrow(
      /With simple keys, collection cannot be used as a key value/
    )
  })

  test('key with JS object value', () => {
    const doc = YAML.parseDocument('[foo]: bar')
    doc.contents.items[0].key = { foo: 42 }
    expect(doc.toString()).toBe('? foo: 42\n: bar\n')
    expect(() => doc.toString({ simpleKeys: true })).toThrow(
      /With simple keys, collection cannot be used as a key value/
    )
  })

  test('key with JS null value', () => {
    const doc = YAML.parseDocument('[foo]: bar')
    doc.contents.items[0].key = null
    expect(doc.toString()).toBe('? null\n: bar\n')
    expect(() => doc.toString({ simpleKeys: true })).toThrow(
      /With simple keys, collection cannot be used as a key value/
    )
  })

  test('key value lingth > 1024', () => {
    const str = `
    ? ${new Array(1026).join('a')}
    : longkey`
    const doc = YAML.parseDocument(str)
    expect(doc.toString()).toBe(`? ${new Array(1026).join('a')}\n: longkey\n`)
    expect(() => doc.toString({ simpleKeys: true })).toThrow(
      /With simple keys, single line scalar must not span more than 1024 characters/
    )
  })
})

test('YAML node inside object (#128)', () => {
  const doc = new YAML.Document()
  const seq = doc.createNode(['a'])
  seq.commentBefore = 'sc'
  const map = doc.createNode({ foo: 'bar', seq })
  map.commentBefore = 'mc'
  const obj = { array: [1], map }
  expect(YAML.stringify(obj)).toBe(source`
    array:
      - 1
    map:
      #mc
      foo: bar
      seq:
        #sc
        - a
  `)
})

describe('sortMapEntries', () => {
  const obj = { b: 2, a: 1, c: 3 }
  test('sortMapEntries: undefined', () => {
    expect(YAML.stringify(obj)).toBe('b: 2\na: 1\nc: 3\n')
  })
  test('sortMapEntries: true', () => {
    expect(YAML.stringify(obj, { sortMapEntries: true })).toBe(
      'a: 1\nb: 2\nc: 3\n'
    )
  })
  test('sortMapEntries: function', () => {
    const sortMapEntries = (a: any, b: any) =>
      a.key < b.key ? 1 : a.key > b.key ? -1 : 0
    expect(YAML.stringify(obj, { sortMapEntries })).toBe('c: 3\nb: 2\na: 1\n')
  })
  test('doc.add', () => {
    const doc = new YAML.Document(obj, { sortMapEntries: true })
    doc.add(new Pair('bb', 4))
    expect(String(doc)).toBe('a: 1\nb: 2\nbb: 4\nc: 3\n')
  })
  test('doc.set', () => {
    const doc = new YAML.Document(obj, { sortMapEntries: true })
    doc.set('bb', 4)
    expect(String(doc)).toBe('a: 1\nb: 2\nbb: 4\nc: 3\n')
  })
})

describe('custom indent', () => {
  let obj: unknown
  beforeEach(() => {
    const doc = new YAML.Document()
    const seq = doc.createNode(['a'])
    seq.commentBefore = 'sc'
    const map = doc.createNode({ foo: 'bar', seq })
    map.commentBefore = 'mc'
    obj = { array: [{ a: 1, b: 2 }], map }
  })

  test('indent: 0', () => {
    expect(() => YAML.stringify(obj, { indent: 0 })).toThrow(
      /must be a positive integer/
    )
  })

  test('indent: 1', () => {
    expect(YAML.stringify(obj, { indent: 1 })).toBe(source`
      array:
       - a: 1
         b: 2
      map:
       #mc
       foo: bar
       seq:
        #sc
        - a
    `)
  })

  test('indent: 4', () => {
    expect(YAML.stringify(obj, { indent: 4 })).toBe(source`
      array:
          - a: 1
            b: 2
      map:
          #mc
          foo: bar
          seq:
              #sc
              - a
    `)
  })
})

describe('indentSeq: false', () => {
  let obj: unknown
  beforeEach(() => {
    const seq = new YAML.Document().createNode(['a'])
    seq.commentBefore = 'sc'
    obj = { array: [{ a: 1, b: 2 }], map: { seq } }
  })

  test('indent: 1', () => {
    expect(YAML.stringify(obj, { indent: 1, indentSeq: false })).toBe(source`
      array:
       - a: 1
         b: 2
      map:
       seq:
        #sc
        - a
    `)
  })

  test('indent: 2', () => {
    expect(YAML.stringify(obj, { indent: 2, indentSeq: false })).toBe(source`
      array:
      - a: 1
        b: 2
      map:
        seq:
        #sc
        - a
    `)
  })

  test('indent: 4', () => {
    expect(YAML.stringify(obj, { indent: 4, indentSeq: false })).toBe(source`
      array:
        - a: 1
          b: 2
      map:
          seq:
            #sc
            - a
    `)
  })
})

describe('lineWidth', () => {
  const doc = YAML.parseDocument(
    "[ 'Sed', 'ut', 'perspiciatis', 'unde', 'omnis', 'iste', 'natus', 'error', 'sit', 'voluptatem', 'accusantium', 'doloremque', 'laudantium,', 'totam' ]"
  )

  test('limit to 80 with overlong flow collection', () => {
    expect(doc.toString({ lineWidth: 80 })).toBe(`[
  'Sed',
  'ut',
  'perspiciatis',
  'unde',
  'omnis',
  'iste',
  'natus',
  'error',
  'sit',
  'voluptatem',
  'accusantium',
  'doloremque',
  'laudantium,',
  'totam'
]
`)
  })

  test('limit > flow collection length', () => {
    expect(doc.toString({ lineWidth: 162 })).toBe(
      "[ 'Sed', 'ut', 'perspiciatis', 'unde', 'omnis', 'iste', 'natus', 'error', 'sit', 'voluptatem', 'accusantium', 'doloremque', 'laudantium,', 'totam' ]\n"
    )
  })

  test('less than minContentWidth (#562)', () => {
    const doc = YAML.parseDocument('>\ntest test test test test')
    expect(doc.toString({ lineWidth: 18, minContentWidth: 20 })).toBe(
      '>\ntest test test\ntest test\n'
    )
  })
})

describe('collectionStyle', () => {
  test('collectionStyle: undefined', () => {
    const doc = new YAML.Document({ foo: ['bar'] })
    expect(doc.toString()).toBe('foo:\n  - bar\n')

    doc.contents.flow = false
    doc.get('foo').flow = true
    expect(doc.toString()).toBe('foo: [ bar ]\n')

    doc.contents.flow = true
    doc.get('foo').flow = false
    expect(doc.toString()).toBe('{ foo: [ bar ] }\n')
  })

  test("collectionStyle: 'any'", () => {
    const doc = new YAML.Document({ foo: ['bar'] })
    expect(doc.toString({ collectionStyle: 'any' })).toBe('foo:\n  - bar\n')

    doc.contents.flow = false
    doc.get('foo').flow = true
    expect(doc.toString({ collectionStyle: 'any' })).toBe('foo: [ bar ]\n')

    doc.contents.flow = true
    doc.get('foo').flow = false
    expect(doc.toString({ collectionStyle: 'any' })).toBe('{ foo: [ bar ] }\n')
  })

  test("collectionStyle: 'block'", () => {
    const doc = new YAML.Document({ foo: ['bar'] })
    expect(doc.toString({ collectionStyle: 'block' })).toBe('foo:\n  - bar\n')

    doc.contents.flow = false
    doc.get('foo').flow = true
    expect(doc.toString({ collectionStyle: 'block' })).toBe('foo:\n  - bar\n')

    doc.contents.flow = true
    doc.get('foo').flow = false
    expect(doc.toString({ collectionStyle: 'block' })).toBe('foo:\n  - bar\n')
  })

  test("collectionStyle: 'flow'", () => {
    const doc = new YAML.Document({ foo: ['bar'] })
    expect(doc.toString({ collectionStyle: 'flow' })).toBe('{ foo: [ bar ] }\n')

    doc.get('foo').flow = true
    expect(doc.toString({ collectionStyle: 'flow' })).toBe('{ foo: [ bar ] }\n')

    doc.contents.flow = true
    doc.get('foo').flow = false
    expect(doc.toString({ collectionStyle: 'flow' })).toBe('{ foo: [ bar ] }\n')
  })
})

describe('Scalar options', () => {
  describe('defaultStringType & defaultKeyType', () => {
    test('PLAIN, PLAIN', () => {
      const opt = {
        defaultStringType: Scalar.PLAIN,
        defaultKeyType: Scalar.PLAIN
      } as const
      expect(YAML.stringify({ foo: 'bar' }, opt)).toBe('foo: bar\n')
    })

    test('BLOCK_FOLDED, BLOCK_FOLDED', () => {
      const opt = {
        defaultStringType: Scalar.BLOCK_FOLDED,
        defaultKeyType: Scalar.BLOCK_FOLDED
      } as const
      expect(YAML.stringify({ foo: 'bar' }, opt)).toBe('"foo": |-\n  bar\n')
    })

    test('QUOTE_DOUBLE, PLAIN', () => {
      const opt = {
        defaultStringType: Scalar.QUOTE_DOUBLE,
        defaultKeyType: Scalar.PLAIN
      } as const
      expect(YAML.stringify({ foo: 'bar' }, opt)).toBe('foo: "bar"\n')
    })

    test('QUOTE_DOUBLE, QUOTE_SINGLE', () => {
      const opt = {
        defaultStringType: Scalar.QUOTE_DOUBLE,
        defaultKeyType: Scalar.QUOTE_SINGLE
      } as const
      expect(YAML.stringify({ foo: 'bar' }, opt)).toBe('\'foo\': "bar"\n')
    })

    test('QUOTE_DOUBLE, null', () => {
      const opt = {
        defaultStringType: Scalar.QUOTE_DOUBLE,
        defaultKeyType: null
      } as const
      expect(YAML.stringify({ foo: 'bar' }, opt)).toBe('"foo": "bar"\n')
    })

    test('Use defaultType for explicit keys', () => {
      const opt = {
        defaultStringType: Scalar.QUOTE_DOUBLE,
        defaultKeyType: Scalar.QUOTE_SINGLE
      } as const
      const doc = new YAML.Document({ foo: null })
      doc.contents.items[0].value = null
      expect(doc.toString(opt)).toBe('? "foo"\n')
    })
  })

  for (const { singleQuote, numeric, upgrade, parsed } of [
    {
      singleQuote: null,
      numeric: '"123"\n',
      upgrade: '"foo #bar"\n',
      parsed: "'foo'\n"
    },
    {
      singleQuote: false,
      numeric: '"123"\n',
      upgrade: '"foo #bar"\n',
      parsed: '"foo"\n'
    },
    {
      singleQuote: true,
      numeric: "'123'\n",
      upgrade: "'foo #bar'\n",
      parsed: "'foo'\n"
    }
  ]) {
    describe(`singleQuote: ${singleQuote}`, () => {
      const opt = { singleQuote }

      test('plain', () => {
        expect(YAML.stringify('foo bar', opt)).toBe('foo bar\n')
      })

      test('contains double-quote', () => {
        expect(YAML.stringify('foo: "bar"', opt)).toBe(
          singleQuote === false ? `"foo: \\"bar\\""\n` : `'foo: "bar"'\n`
        )
      })

      test('contains single-quote', () => {
        expect(YAML.stringify("foo: 'bar'", opt)).toBe(`"foo: 'bar'"\n`)
      })

      test('numerical string', () => {
        expect(YAML.stringify('123', opt)).toBe(numeric)
      })

      test('upgrade from plain', () => {
        expect(YAML.stringify('foo #bar', opt)).toBe(upgrade)
      })

      test('parsed node', () => {
        const doc = YAML.parseDocument("'foo'")
        expect(doc.toString(opt)).toBe(parsed)
      })
    })
  }

  for (const { blockQuote, marker, value, parsed } of [
    {
      blockQuote: false,
      marker: '"---"\n',
      value: 'foo: "bar\\nfuzz\\n"\n',
      parsed: '"foo\\n"\n'
    },
    {
      blockQuote: true,
      marker: '|-\n  ---\n',
      value: 'foo: |\n  bar\n  fuzz\n',
      parsed: '>\nfoo\n'
    },
    {
      blockQuote: 'literal',
      marker: '|-\n  ---\n',
      value: 'foo: |\n  bar\n  fuzz\n',
      parsed: '|\nfoo\n'
    },
    {
      blockQuote: 'folded',
      marker: '>-\n  ---\n',
      value: 'foo: >\n  bar\n\n  fuzz\n',
      parsed: '>\nfoo\n'
    }
  ] as const) {
    describe(`blockQuote: ${blockQuote}`, () => {
      test('doc-marker', () => {
        expect(YAML.stringify('---', { blockQuote })).toBe(marker)
      })

      test('map with value', () => {
        expect(YAML.stringify({ foo: 'bar\nfuzz\n' }, { blockQuote })).toBe(
          value
        )
      })

      test('override parsed type', () => {
        const doc = YAML.parseDocument('>\n  foo\n')
        expect(doc.toString({ blockQuote })).toBe(parsed)
      })
    })
  }
})

describe('toStringDefaults', () => {
  test('Set on Document creation', () => {
    const doc = new YAML.Document(
      { foo: null },
      { toStringDefaults: { nullStr: '~' } }
    )
    expect(doc.toString()).toBe('foo: ~\n')
  })

  test('Override in toString()', () => {
    const doc = new YAML.Document(
      { foo: null },
      { toStringDefaults: { nullStr: '~' } }
    )
    expect(doc.toString({ nullStr: '' })).toBe('foo:\n')
  })
})

describe('Document markers in top-level scalars', () => {
  test('---', () => {
    const str = YAML.stringify('---')
    expect(str).toBe('|-\n  ---\n')
    expect(YAML.parse(str)).toBe('---')
  })

  test('...', () => {
    const str = YAML.stringify('...')
    expect(str).toBe('|-\n  ...\n')
    expect(YAML.parse(str)).toBe('...')
  })

  test('foo\\n...\\n', () => {
    const str = YAML.stringify('foo\n...\n')
    expect(str).toBe('|\n  foo\n  ...\n')
    expect(YAML.parse(str)).toBe('foo\n...\n')
  })

  test("'foo\\n...'", () => {
    const doc = new YAML.Document('foo\n...')
    doc.contents.type = Scalar.QUOTE_SINGLE
    const str = String(doc)
    expect(str).toBe("'foo\n\n  ...'\n")
    expect(YAML.parse(str)).toBe('foo\n...')
  })

  test('"foo\\n..."', () => {
    const doc = new YAML.Document('foo\n...')
    doc.contents.type = Scalar.QUOTE_DOUBLE
    const str = doc.toString({ doubleQuotedMinMultiLineLength: 0 })
    expect(str).toBe('"foo\n\n  ..."\n')
    expect(YAML.parse(str)).toBe('foo\n...')
  })

  test('foo\\n%bar\\n', () => {
    const str = YAML.stringify('foo\n%bar\n')
    expect(str).toBe('|\n  foo\n  %bar\n')
    expect(YAML.parse(str)).toBe('foo\n%bar\n')
  })

  test('use marker line for block scalar header', () => {
    const doc = YAML.parseDocument('|\nfoo\n')
    expect(doc.toString({ directives: true })).toBe('--- |\nfoo\n')
  })
})

describe('Document markers in top-level map keys (#431)', () => {
  test('---', () => {
    const str = YAML.stringify({ '--- x': 42 })
    expect(str).toBe('"--- x": 42\n')
    expect(YAML.parse(str)).toEqual({ '--- x': 42 })
  })

  test('...', () => {
    const str = YAML.stringify({ '... x': 42 })
    expect(str).toBe('"... x": 42\n')
    expect(YAML.parse(str)).toEqual({ '... x': 42 })
  })
})

describe('undefined values', () => {
  test('undefined', () => {
    expect(YAML.stringify(undefined)).toBeUndefined()
  })

  test('[1, undefined, 2]', () => {
    expect(YAML.stringify([1, undefined, 2])).toBe('- 1\n- null\n- 2\n')
  })

  test("{ a: 'A', b: undefined, c: 'C' }", () => {
    expect(YAML.stringify({ a: 'A', b: undefined, c: 'C' })).toBe(
      'a: A\nc: C\n' // note: No `b` key
    )
  })

  test("{ a: 'A', b: null, c: 'C' }", () => {
    expect(YAML.stringify({ a: 'A', b: null, c: 'C' })).toBe(
      'a: A\nb: null\nc: C\n'
    )
  })

  test("{ a: 'A', b: Scalar(undefined), c: 'C' }", () => {
    const obj = { a: 'A', b: new Scalar(undefined), c: 'C' }
    expect(YAML.stringify(obj)).toBe('a: A\nb: null\nc: C\n')
  })

  test("Map { 'a' => 'A', 'b' => undefined, 'c' => 'C' }", () => {
    const map = new Map([
      ['a', 'A'],
      ['b', undefined],
      ['c', 'C']
    ])
    expect(YAML.stringify(map)).toBe('a: A\nc: C\n')
  })

  describe('keepUndefined: true', () => {
    test('undefined', () => {
      expect(YAML.stringify(undefined, { keepUndefined: true })).toBe('null\n')
    })

    test("{ a: 'A', b: undefined, c: 'C' }", () => {
      expect(
        YAML.stringify(
          { a: 'A', b: undefined, c: 'C' },
          { keepUndefined: true }
        )
      ).toBe('a: A\nb: null\nc: C\n')
    })
  })
})

describe('replacer', () => {
  test('empty array', () => {
    const arr = [
      { a: 1, b: 2 },
      { a: 4, b: 5 }
    ]
    expect(YAML.stringify(arr, [])).toBe('- {}\n- {}\n')
  })

  test('Object, array of string', () => {
    const arr = [
      { a: 1, b: 2 },
      { a: 4, b: 5 }
    ]
    expect(YAML.stringify(arr, ['a'])).toBe('- a: 1\n- a: 4\n')
  })

  test('Map, array of string', () => {
    const map = new Map([
      ['a', 1],
      ['b', 2],
      [3, 4]
    ])
    expect(YAML.stringify(map, ['a', '3'])).toBe('a: 1\n')
  })

  test('Object, array of number', () => {
    const obj = { a: 1, b: 2, 3: 4, 5: 6 }
    expect(YAML.stringify(obj, [3, 5])).toBe('"3": 4\n"5": 6\n')
  })

  test('Map, array of number', () => {
    const map = new Map([
      ['a', 1],
      ['3', 2],
      [3, 4]
    ])
    expect(YAML.stringify(map, [3])).toBe('"3": 2\n3: 4\n')
  })

  test('function as logger', () => {
    const spy = jest.fn((_key, value) => value)
    const obj = { 1: 1, b: 2, c: [4] }
    YAML.stringify(obj, spy)
    expect(spy.mock.calls).toMatchObject([
      ['', obj],
      ['1', 1],
      ['b', 2],
      ['c', [4]],
      ['0', 4]
    ])
    expect(spy.mock.instances).toMatchObject([
      { '': obj },
      obj,
      obj,
      obj,
      obj.c
    ])
  })

  test('function as filter of Object entries', () => {
    const obj = { 1: 1, b: 2, c: [4] }
    const fn = (_key: unknown, value: unknown) =>
      typeof value === 'number' ? undefined : value
    expect(YAML.stringify(obj, fn)).toBe('c:\n  - null\n')
  })

  test('function as filter of Map entries', () => {
    const map = new Map([
      [1, 1],
      ['b', 2],
      ['c', [4]]
    ])
    const fn = (_key: unknown, value: unknown) =>
      typeof value === 'number' ? undefined : value
    expect(YAML.stringify(map, fn)).toBe('c:\n  - null\n')
  })

  test('function as transformer', () => {
    const obj = { a: 1, b: 2, c: [3, 4] }
    const fn = (_key: unknown, value: unknown) =>
      typeof value === 'number' ? 2 * value : value
    expect(YAML.stringify(obj, fn)).toBe('a: 2\nb: 4\nc:\n  - 6\n  - 8\n')
  })

  test('createNode, !!set', () => {
    const replacer = jest.fn((_key, value) => value)
    const doc = new YAML.Document(null, { customTags: ['set'] })
    const set = new Set(['a', 'b', 1, [2]])
    doc.createNode(set, replacer)
    expect(replacer.mock.calls).toMatchObject([
      ['', set],
      ['a', 'a'],
      ['b', 'b'],
      [1, 1],
      [[2], [2]],
      ['0', 2]
    ])
    expect(replacer.mock.instances).toMatchObject([
      { '': set },
      set,
      set,
      set,
      set,
      [2]
    ])
  })

  test('createNode, !!omap', () => {
    const replacer = jest.fn((_key, value) => value)
    const doc = new YAML.Document(null, { customTags: ['omap'] })
    const omap = [
      ['a', 1],
      [1, 'a']
    ]
    doc.createNode(omap, replacer, { tag: '!!omap' })
    expect(replacer.mock.calls).toMatchObject([
      ['', omap],
      ['0', omap[0]],
      ['1', omap[1]]
    ])
    expect(replacer.mock.instances).toMatchObject([{ '': omap }, omap, omap])
  })
})

describe('YAML.stringify options as scalar', () => {
  test('number', () => {
    expect(YAML.stringify({ foo: 'bar\nfuzz' }, null, 1)).toBe(
      'foo: |-\n bar\n fuzz\n'
    )
  })
  test('string', () => {
    expect(YAML.stringify({ foo: 'bar\nfuzz' }, null, '123')).toBe(
      'foo: |-\n   bar\n   fuzz\n'
    )
  })
})

describe('YAML.stringify on ast Document', () => {
  test('null document', () => {
    const doc = YAML.parseDocument('null')
    expect(YAML.stringify(doc)).toBe('null\n')
  })

  test('Document with comments', () => {
    const src = 'a: 1\n\n# c\n'
    const doc = YAML.parseDocument(src)
    expect(YAML.stringify(doc)).toBe(src)
  })
})

describe('flow collection padding', () => {
  const doc = new YAML.Document()
  doc.contents = new YAML.YAMLSeq()
  doc.contents.items = [1, 2]
  doc.contents.flow = true

  test('default', () => {
    expect(doc.toString()).toBe('[ 1, 2 ]\n')
  })
  test('default', () => {
    expect(doc.toString({ flowCollectionPadding: false })).toBe('[1, 2]\n')
  })
})
eemeli-yaml-086fa6b/tests/doc/types.ts000066400000000000000000001114521511277410200177570ustar00rootroot00000000000000import {
  type CollectionTag,
  Document,
  type DocumentOptions,
  type Node,
  parseDocument as origParseDocument,
  parse,
  type ParsedNode,
  type ParseOptions,
  Scalar,
  type ScalarTag,
  Schema,
  type SchemaOptions,
  stringify,
  YAMLMap,
  YAMLSeq
} from 'yaml'
import { seqTag, stringifyString, stringTag } from 'yaml/util'
import { source } from '../_utils.ts'

const parseDocument = (
  source: string,
  options?: ParseOptions & DocumentOptions & SchemaOptions
) => origParseDocument(source, options)

describe('tags', () => {
  describe('implicit tags', () => {
    test('plain string', () => {
      const doc = parseDocument('foo')
      expect(doc.contents.tag).toBeUndefined()
      expect(doc.contents.value).toBe('foo')
    })
    test('quoted string', () => {
      const doc = parseDocument('"foo"')
      expect(doc.contents.tag).toBeUndefined()
      expect(doc.contents.value).toBe('foo')
    })
    test('flow map', () => {
      const doc = parseDocument('{ foo }')
      expect(doc.contents.tag).toBeUndefined()
      expect(doc.contents.toJSON()).toMatchObject({ foo: null })
    })
    test('flow seq', () => {
      const doc = parseDocument('[ foo ]')
      expect(doc.contents.tag).toBeUndefined()
      expect(doc.contents.toJSON()).toMatchObject(['foo'])
    })
    test('block map', () => {
      const doc = parseDocument('foo:\n')
      expect(doc.contents.tag).toBeUndefined()
      expect(doc.contents.toJSON()).toMatchObject({ foo: null })
    })
    test('block seq', () => {
      const doc = parseDocument('- foo')
      expect(doc.contents.tag).toBeUndefined()
      expect(doc.contents.toJSON()).toMatchObject(['foo'])
    })
  })

  describe('explicit tags', () => {
    test('plain string', () => {
      const doc = parseDocument('!!str foo')
      expect(doc.contents.tag).toBe('tag:yaml.org,2002:str')
      expect(doc.contents.value).toBe('foo')
    })
    test('quoted string', () => {
      const doc = parseDocument('!!str "foo"')
      expect(doc.contents.tag).toBe('tag:yaml.org,2002:str')
      expect(doc.contents.value).toBe('foo')
    })
    test('flow map', () => {
      const doc = parseDocument('!!map { foo }')
      expect(doc.contents.tag).toBe('tag:yaml.org,2002:map')
      expect(doc.contents.toJSON()).toMatchObject({ foo: null })
    })
    test('flow seq', () => {
      const doc = parseDocument('!!seq [ foo ]')
      expect(doc.contents.tag).toBe('tag:yaml.org,2002:seq')
      expect(doc.contents.toJSON()).toMatchObject(['foo'])
    })
    test('block map', () => {
      const doc = parseDocument('!!map\nfoo:\n')
      expect(doc.contents.tag).toBe('tag:yaml.org,2002:map')
      expect(doc.contents.toJSON()).toMatchObject({ foo: null })
    })
    test('block seq', () => {
      const doc = parseDocument('!!seq\n- foo')
      expect(doc.contents.tag).toBe('tag:yaml.org,2002:seq')
      expect(doc.contents.toJSON()).toMatchObject(['foo'])
    })
  })

  describe('invalid tags', () => {
    for (const tag of [
      '!t`ag x',
      '!t^ag x',
      '!t\\ag x',
      '!tag x',
      '!t,ag x',
      '!t"ag x'
    ]) {
      test(`invalid tag: ${tag}`, () => {
        const doc = parseDocument(tag)
        expect(doc.errors).not.toHaveLength(0)
        expect(doc.errors[0].code).toBe('MISSING_CHAR')
      })
    }

    test('malformed URI (#498)', () => {
      const doc = parseDocument('!!%ee 0')
      expect(doc.errors).toHaveLength(1)
      expect(doc.errors[0].message).toMatch('URIError')
    })

    test('CR in tag shorthand (#501)', () => {
      const doc = parseDocument(': | !\r!')
      const err = doc.errors.find(err => err.code === 'TAG_RESOLVE_FAILED')
      expect(err).not.toBeFalsy()
    })
  })

  test('float with fraction digits (#97)', () => {
    const doc = parseDocument('foo: !!float 3.0')
    expect(String(doc)).toBe('foo: !!float 3.0\n')
  })
})

describe('number types', () => {
  describe('intAsBigInt: false', () => {
    test('Version 1.1', () => {
      const src = `
- 0b10_10
- 0123
- -00
- 123_456
- 3.1e+2
- 5.1_2_3E-1
- 4.02
- 4.20
- .42
- 00.4`
      const doc = parseDocument(src, {
        intAsBigInt: false,
        version: '1.1'
      })
      expect(doc.contents.items).toMatchObject([
        { value: 10, format: 'BIN' },
        { value: 83, format: 'OCT' },
        { value: -0, format: 'OCT' },
        { value: 123456 },
        { value: 310, format: 'EXP' },
        { value: 0.5123, format: 'EXP' },
        { value: 4.02 },
        { value: 4.2, minFractionDigits: 2 },
        { value: 0.42 },
        { value: 0.4 }
      ])
      expect(doc.contents.items[3]).not.toHaveProperty('format')
      expect(doc.contents.items[6]).not.toHaveProperty('format')
      expect(doc.contents.items[6]).not.toHaveProperty('minFractionDigits')
      expect(doc.contents.items[7]).not.toHaveProperty('format')
    })

    test('Version 1.2', () => {
      const src = `
- 0o123
- 0o0
- 123456
- 3.1e+2
- 5.123E-1
- 4.02
- 4.20
- .42
- 00.4`
      const doc = parseDocument(src, {
        intAsBigInt: false,
        version: '1.2'
      })
      expect(doc.contents.items).toMatchObject([
        { value: 83, format: 'OCT' },
        { value: 0, format: 'OCT' },
        { value: 123456 },
        { value: 310, format: 'EXP' },
        { value: 0.5123, format: 'EXP' },
        { value: 4.02 },
        { value: 4.2, minFractionDigits: 2 },
        { value: 0.42 },
        { value: 0.4 }
      ])
      expect(doc.contents.items[2]).not.toHaveProperty('format')
      expect(doc.contents.items[5]).not.toHaveProperty('format')
      expect(doc.contents.items[5]).not.toHaveProperty('minFractionDigits')
      expect(doc.contents.items[6]).not.toHaveProperty('format')
    })
  })

  describe('intAsBigInt: true', () => {
    test('Version 1.1', () => {
      const src = `
- 0b10_10
- 0123
- -00
- 123_456
- 3.1e+2
- 5.1_2_3E-1
- 4.02`
      const doc = parseDocument(src, {
        intAsBigInt: true,
        version: '1.1'
      })
      expect(doc.contents.items).toMatchObject([
        { value: 10n, format: 'BIN' },
        { value: 83n, format: 'OCT' },
        { value: 0n, format: 'OCT' },
        { value: 123456n },
        { value: 310, format: 'EXP' },
        { value: 0.5123, format: 'EXP' },
        { value: 4.02 }
      ])
      expect(doc.contents.items[3]).not.toHaveProperty('format')
      expect(doc.contents.items[6]).not.toHaveProperty('format')
      expect(doc.contents.items[6]).not.toHaveProperty('minFractionDigits')
    })

    test('Version 1.2', () => {
      const src = `
- 0o123
- 0o0
- 123456
- 3.1e+2
- 5.123E-1
- 4.02`
      const doc = parseDocument(src, {
        intAsBigInt: true,
        version: '1.2'
      })
      expect(doc.contents.items).toMatchObject([
        { value: 83n, format: 'OCT' },
        { value: 0n, format: 'OCT' },
        { value: 123456n },
        { value: 310, format: 'EXP' },
        { value: 0.5123, format: 'EXP' },
        { value: 4.02 }
      ])
      expect(doc.contents.items[2]).not.toHaveProperty('format')
      expect(doc.contents.items[5]).not.toHaveProperty('format')
      expect(doc.contents.items[5]).not.toHaveProperty('minFractionDigits')
    })
  })
})

test('Indented sequence with sequence values (#2)', () => {
  const src = `
aliases:
  - docker:
      - image: circleci/node:8.11.2
  - key: repository-{{ .Revision }}\n`
  expect(parse(src)).toMatchObject({
    aliases: [
      { docker: [{ image: 'circleci/node:8.11.2' }] },
      { key: 'repository-{{ .Revision }}' }
    ]
  })
})

describe('failsafe schema', () => {
  test('empty scalars (#616)', () => {
    const doc = parseDocument('empty:\n', { schema: 'failsafe' })
    expect(doc.errors).toMatchObject([])
    expect(doc.get('empty', true)).toMatchObject({ value: '' })
    expect(doc.toJS()).toMatchObject({ empty: '' })
    expect(doc.toString()).toEqual('empty:\n')
  })
})

describe('json schema', () => {
  test('!!bool', () => {
    const src = `"canonical": true
"answer": false
"logical": True
"option": TruE`

    const doc = parseDocument(src, { schema: 'json' })
    expect(doc.toJS()).toMatchObject({
      canonical: true,
      answer: false,
      logical: 'True',
      option: 'TruE'
    })
    expect(doc.errors).toHaveLength(2)
    doc.errors = []
    expect(String(doc)).toBe(
      '"canonical": true\n"answer": false\n"logical": "True"\n"option": "TruE"\n'
    )
  })

  test('!!bool: js-regex-missing-regexp-anchor', () => {
    const src = `"canonical": truea
"answer": ffalse
"logical": Truea
"option": TruEp`

    const doc = parseDocument(src, { schema: 'json' })
    expect(doc.toJS()).toMatchObject({
      canonical: 'truea',
      answer: 'ffalse',
      logical: 'Truea',
      option: 'TruEp'
    })
    expect(doc.errors).toHaveLength(4)
    doc.errors = []
    expect(String(doc)).toBe(
      '"canonical": "truea"\n"answer": "ffalse"\n"logical": "Truea"\n"option": "TruEp"\n'
    )
  })

  test('!!float', () => {
    const src = `"canonical": 6.8523015e+5
"fixed": 685230.15
"negative infinity": -.inf
"not a number": .NaN`

    const doc = parseDocument>(src, { schema: 'json' })
    expect(doc.toJS()).toMatchObject({
      canonical: 685230.15,
      fixed: 685230.15,
      'negative infinity': '-.inf',
      'not a number': '.NaN'
    })
    expect(doc.errors).toHaveLength(2)
    doc.errors = []
    doc.contents.items[1].value!.tag = 'tag:yaml.org,2002:float'
    expect(String(doc)).toBe(
      '"canonical": 685230.15\n"fixed": !!float 685230.15\n"negative infinity": "-.inf"\n"not a number": ".NaN"\n'
    )
  })

  test('!!int', () => {
    const src = `"canonical": 685230
"decimal": -685230
"octal": 0o2472256
"hexadecimal": 0x0A74AE`

    const doc = parseDocument(src, { schema: 'json' })
    expect(doc.toJS()).toMatchObject({
      canonical: 685230,
      decimal: -685230,
      octal: '0o2472256',
      hexadecimal: '0x0A74AE'
    })
    expect(doc.errors).toHaveLength(2)
    doc.errors = []
    doc.set('bigint', 42n)
    expect(String(doc)).toBe(
      '"canonical": 685230\n"decimal": -685230\n"octal": "0o2472256"\n"hexadecimal": "0x0A74AE"\n"bigint": 42\n'
    )
  })

  test('!!null', () => {
    const src = `"empty":
"canonical": ~
"english": null
~: 'null key'`

    const doc = parseDocument(src, { schema: 'json' })
    expect(doc.toJS()).toMatchObject({
      empty: '',
      canonical: '~',
      english: null,
      '~': 'null key'
    })
    expect(doc.errors).toHaveLength(3)
    doc.errors = []
    expect(String(doc)).toBe(`"empty": ""
"canonical": "~"
"english": null
"~": "null key"\n`)
  })
})

describe('core schema', () => {
  test('!!bool', () => {
    const src = `canonical: true
answer: FALSE
logical: True
option: TruE\n`

    const doc = parseDocument(src)
    expect(doc.toJS()).toMatchObject({
      canonical: true,
      answer: false,
      logical: true,
      option: 'TruE'
    })
    expect(String(doc)).toBe(`canonical: true
answer: FALSE
logical: True
option: TruE\n`)
  })

  test('!!float', () => {
    const src = `canonical: 6.8523015e+5
fixed: 685230.15
negative infinity: -.inf
not a number: .NaN
not a NaN: -.NaN`

    const doc = parseDocument(src)
    expect(doc.toJS()).toMatchObject({
      canonical: 685230.15,
      fixed: 685230.15,
      'negative infinity': Number.NEGATIVE_INFINITY,
      'not a number': NaN,
      'not a NaN': '-.NaN'
    })
    expect(String(doc)).toBe(`canonical: 6.8523015e+5
fixed: 685230.15
negative infinity: -.inf
not a number: .nan
not a NaN: -.NaN\n`)
  })

  test('!!int', () => {
    const src = `canonical: 685230
decimal: +685230
octal: 0o2472256
hexadecimal: 0x0A74AE`

    const doc = parseDocument(src)
    expect(doc.toJS()).toMatchObject({
      canonical: 685230,
      decimal: 685230,
      octal: 685230,
      hexadecimal: 685230
    })
    expect(String(doc)).toBe(`canonical: 685230
decimal: 685230
octal: 0o2472256
hexadecimal: 0xa74ae\n`)
  })

  test('!!null', () => {
    const src = `empty:
canonical: ~
english: null
~: null key`

    const doc = parseDocument(src)
    expect(doc.toJS()).toMatchObject({
      empty: null,
      canonical: null,
      english: null,
      '': 'null key'
    })
    expect(String(doc)).toBe(`empty:
canonical: ~
english: null
~: null key\n`)
  })

  describe('!!map', () => {
    test('mapAsMap: false', () => {
      const src = `
one: 1
2: two
{ 3: 4 }: many\n`
      const doc = parseDocument(src, { logLevel: 'error' })
      expect(doc.toJS()).toMatchObject({
        one: 1,
        2: 'two',
        '{ 3: 4 }': 'many'
      })
      expect(doc.errors).toHaveLength(0)
      doc.contents.items[2].key = { 3: 4 }
      expect(doc.toJS()).toMatchObject({
        one: 1,
        2: 'two',
        '{"3":4}': 'many'
      })
    })

    test('mapAsMap: true', () => {
      const src = `
one: 1
2: two
{ 3: 4 }: many\n`
      const doc = parseDocument(src)
      expect(doc.toJS({ mapAsMap: true })).toMatchObject(
        new Map([
          ['one', 1],
          [2, 'two'],
          [new Map([[3, 4]]), 'many']
        ])
      )
      expect(doc.errors).toHaveLength(0)
      doc.contents.items[2].key = { 3: 4 }
      expect(doc.toJS({ mapAsMap: true })).toMatchObject(
        new Map([
          ['one', 1],
          [2, 'two'],
          [{ 3: 4 }, 'many']
        ])
      )
    })
  })
})

describe('YAML 1.1 schema', () => {
  test('!!binary', () => {
    const src = `canonical: !!binary "\\
 R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\\
 OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\\
 +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\\
 AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="
generic: !!binary |
 R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
 OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
 +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
 AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
description:
 The binary value above is a tiny arrow encoded as a gif image.`

    const doc = parseDocument>>(src, {
      schema: 'yaml-1.1'
    })
    const canonical = doc.contents.items[0].value!.value
    const generic = doc.contents.items[1].value!.value
    expect(canonical).toBeInstanceOf(Uint8Array)
    expect(generic).toBeInstanceOf(Uint8Array)
    expect(canonical).toHaveLength(185)
    expect(generic).toHaveLength(185)
    let canonicalStr = ''
    let genericStr = ''
    for (let i = 0; i < canonical.length; ++i)
      canonicalStr += String.fromCharCode(canonical[i])
    for (let i = 0; i < generic.length; ++i)
      genericStr += String.fromCharCode(generic[i])
    expect(canonicalStr).toBe(genericStr)
    expect(canonicalStr.substring(0, 5)).toBe('GIF89')
    expect(String(doc))
      .toBe(`canonical: !!binary "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J\\
  +fn5OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/\\
  ++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BN\\
  JHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="
generic: !!binary |-
  R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaW
  NjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUg
  d2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84Bww
  EeECcgggoBADs=
description: The binary value above is a tiny arrow encoded as a gif image.\n`)
  })

  test('!!bool', () => {
    const src = `
canonical: y
answer: NO
logical: True
option: on`

    const doc = parseDocument(src, { version: '1.1' })
    expect(doc.toJS()).toMatchObject({
      canonical: true,
      answer: false,
      logical: true,
      option: true
    })
    expect(String(doc)).toBe(`canonical: y
answer: NO
logical: True
option: on\n`)
  })

  test('!!float', () => {
    const src = `%YAML 1.1
---
canonical: 6.8523015e+5
exponential: 685.230_15e+03
fixed: 685_230.15
sexagesimal: 190:20:30.15
negative infinity: -.inf
not a number: .NaN
not a NaN: -.NaN`

    const doc = parseDocument(src)
    expect(doc.toJS()).toMatchObject({
      canonical: 685230.15,
      exponential: 685230.15,
      fixed: 685230.15,
      sexagesimal: 685230.15,
      'negative infinity': Number.NEGATIVE_INFINITY,
      'not a number': NaN,
      'not a NaN': '-.NaN'
    })
    expect(String(doc)).toBe(`%YAML 1.1
---
canonical: 6.8523015e+5
exponential: 6.8523015e+5
fixed: 685230.15
sexagesimal: 190:20:30.15
negative infinity: -.inf
not a number: .nan
not a NaN: -.NaN\n`)
  })

  test('!!int', () => {
    const src = `%YAML 1.1
---
canonical: 685230
decimal: +685_230
octal: 02472256
hexadecimal: 0x_0A_74_AE
binary: 0b1010_0111_0100_1010_1110
sexagesimal: 190:20:30`

    const doc = parseDocument(src)
    expect(doc.toJS()).toMatchObject({
      canonical: 685230,
      decimal: 685230,
      octal: 685230,
      hexadecimal: 685230,
      binary: 685230,
      sexagesimal: 685230
    })
    expect(String(doc)).toBe(`%YAML 1.1
---
canonical: 685230
decimal: 685230
octal: 02472256
hexadecimal: 0xa74ae
binary: 0b10100111010010101110
sexagesimal: 190:20:30\n`)
  })

  test('!!int, asBigInt', () => {
    const src = `%YAML 1.1
---
canonical: 685230
decimal: +685_230
octal: 02472256
hexadecimal: 0x_0A_74_AE
binary: 0b1010_0111_0100_1010_1110
sexagesimal: 190:20:30`

    const doc = parseDocument(src, { intAsBigInt: true })
    expect(doc.toJS()).toMatchObject({
      canonical: 685230n,
      decimal: 685230n,
      octal: 685230n,
      hexadecimal: 685230n,
      binary: 685230n,
      sexagesimal: 685230n
    })
    expect(String(doc)).toBe(`%YAML 1.1
---
canonical: 685230
decimal: 685230
octal: 02472256
hexadecimal: 0xa74ae
binary: 0b10100111010010101110
sexagesimal: 190:20:30\n`)
  })

  test('!!null', () => {
    const src = `%YAML 1.1
---
empty:
canonical: ~
english: null
~: null key`

    const doc = parseDocument(src)
    expect(doc.toJS()).toMatchObject({
      empty: null,
      canonical: null,
      english: null,
      '': 'null key'
    })
    expect(String(doc)).toBe(`%YAML 1.1
---
empty:
canonical: ~
english: null
~: null key\n`)
  })

  describe('!!timestamp', () => {
    test('parse & document', () => {
      const src = `%YAML 1.1
---
canonical:        2001-12-15T02:59:43.1Z
valid iso8601:    2001-12-14t21:59:43.10-05:00
no secs:          2001-12-15T02:59:00
space separated:  2001-12-14 21:59:43.10 -5
no time zone (Z): 2001-12-15 2:59:43.10
date (00:00:00Z): 2002-12-14`

      const doc = parseDocument>(src)
      doc.contents.items.forEach(item => {
        expect(item.value!.value).toBeInstanceOf(Date)
      })
      expect(doc.toJSON()).toMatchObject({
        canonical: '2001-12-15T02:59:43.100Z',
        'valid iso8601': '2001-12-15T02:59:43.100Z',
        'no secs': '2001-12-15T02:59:00.000Z',
        'space separated': '2001-12-15T02:59:43.100Z',
        'no time zone (Z)': '2001-12-15T02:59:43.100Z',
        'date (00:00:00Z)': '2002-12-14T00:00:00.000Z'
      })
      expect(String(doc)).toBe(`%YAML 1.1
---
canonical: 2001-12-15T02:59:43.100Z
valid iso8601: 2001-12-15T02:59:43.100Z
no secs: 2001-12-15T02:59:00
space separated: 2001-12-15T02:59:43.100Z
no time zone (Z): 2001-12-15T02:59:43.100Z
date (00:00:00Z): 2002-12-14\n`)
    })

    test('stringify', () => {
      const date = new Date('2018-12-22T08:02:52Z')
      const str = stringify(date) // stringified as !!str
      expect(str).toBe('2018-12-22T08:02:52.000Z\n')
      const str2 = stringify(date, { version: '1.1' })
      expect(str2).toBe('2018-12-22T08:02:52\n')
    })
  })

  describe('!!pairs', () => {
    for (const { name, src } of [
      { name: 'parse block seq', src: `!!pairs\n- a: 1\n- b: 2\n- a: 3\n` },
      { name: 'parse flow seq', src: `!!pairs [ a: 1, b: 2, a: 3 ]\n` }
    ])
      test(name, () => {
        const doc = parseDocument(src, { version: '1.1' })
        expect(doc.contents).toBeInstanceOf(YAMLSeq)
        expect(doc.contents.items).toMatchObject([
          { key: { value: 'a' }, value: { value: 1 } },
          { key: { value: 'b' }, value: { value: 2 } },
          { key: { value: 'a' }, value: { value: 3 } }
        ])
        expect(doc.toJS()).toBeInstanceOf(Array)
        expect(doc.toJS()).toMatchObject([{ a: 1 }, { b: 2 }, { a: 3 }])
        expect(String(doc)).toBe(src)
      })

    test('stringify', () => {
      const doc = new Document(null, { version: '1.1' })
      doc.contents = doc.createNode(
        [
          ['a', 1],
          ['b', 2],
          ['a', 3]
        ],
        { tag: '!!pairs' }
      )
      expect(doc.contents.tag).toBe('tag:yaml.org,2002:pairs')
      expect(String(doc)).toBe(`!!pairs\n- a: 1\n- b: 2\n- a: 3\n`)
    })
  })

  describe('!!omap', () => {
    for (const { name, src } of [
      { name: 'parse block seq', src: `!!omap\n- a: 1\n- b: 2\n- c: 3\n` },
      { name: 'parse flow seq', src: `!!omap [ a: 1, b: 2, c: 3 ]\n` }
    ])
      test(name, () => {
        const doc = parseDocument(src, { version: '1.1' })
        expect(doc.contents.constructor.tag).toBe('tag:yaml.org,2002:omap')
        expect(doc.toJS()).toBeInstanceOf(Map)
        expect(doc.toJS()).toMatchObject(
          new Map([
            ['a', 1],
            ['b', 2],
            ['c', 3]
          ])
        )
        expect(String(doc)).toBe(src)
      })

    test('require unique keys', () => {
      const src = `!!omap\n- a: 1\n- b: 2\n- b: 9\n`
      const doc = parseDocument(src, {
        prettyErrors: false,
        version: '1.1'
      })
      expect(doc.errors).toMatchObject([
        {
          name: 'YAMLParseError',
          message: 'Ordered maps must not include duplicate keys: b'
        }
      ])
    })

    test('stringify Map', () => {
      const map = new Map([
        ['a', 1],
        ['b', 2],
        ['c', 3]
      ])
      const str = stringify(map, { version: '1.1' })
      expect(str).toBe(`!!omap\n- a: 1\n- b: 2\n- c: 3\n`)
      const str2 = stringify(map)
      expect(str2).toBe(`a: 1\nb: 2\nc: 3\n`)
    })

    test('stringify Array', () => {
      const doc = new Document(null, { version: '1.1' })
      doc.contents = doc.createNode(
        [
          ['a', 1],
          ['b', 2],
          ['a', 3]
        ],
        { tag: '!!omap' }
      )
      expect(doc.contents.constructor.tag).toBe('tag:yaml.org,2002:omap')
      expect(String(doc)).toBe(`!!omap\n- a: 1\n- b: 2\n- a: 3\n`)
    })
  })

  describe('!!set', () => {
    for (const { name, src } of [
      { name: 'parse block map', src: `!!set\n? a\n? b\n? c\n` },
      { name: 'parse flow map', src: `!!set { a, b, c }\n` }
    ])
      test(name, () => {
        const doc = parseDocument(src, { version: '1.1' })
        expect(doc.contents.constructor.tag).toBe('tag:yaml.org,2002:set')
        expect(doc.toJS()).toBeInstanceOf(Set)
        expect(doc.toJS()).toMatchObject(new Set(['a', 'b', 'c']))
        expect(String(doc)).toBe(src)
      })

    test('require null values', () => {
      const src = `!!set\n? a\n? b\nc: d\n`
      const doc = parseDocument(src, {
        prettyErrors: false,
        version: '1.1'
      })
      expect(doc.errors).toMatchObject([
        {
          name: 'YAMLParseError',
          message: 'Set items must all have null values'
        }
      ])
    })

    test('stringify', () => {
      const set = new Set(['a', 'b', 'c'])
      const str = stringify(set, { version: '1.1' })
      expect(str).toBe(`!!set\n? a\n? b\n? c\n`)
      const str2 = stringify(set)
      expect(str2).toBe(`- a\n- b\n- c\n`)
    })

    test('stringify in collection (#78)', () => {
      const set = new Set(['a', 'b', 'c'])
      const str = stringify({ set }, { version: '1.1' })
      expect(str).toBe(source`
        set: !!set
          ? a
          ? b
          ? c
      `)
    })
  })

  describe('!!merge', () => {
    test('alias', () => {
      const src = '- &a { a: A, b: B }\n- { <<: *a, b: X }\n'
      const doc = parseDocument(src, { version: '1.1' })
      expect(doc.toJS()).toMatchObject([
        { a: 'A', b: 'B' },
        { a: 'A', b: 'X' }
      ])
      expect(doc.toString()).toBe(src)
    })

    test('alias sequence', () => {
      const src =
        '- &a { a: A, b: B, c: C }\n- &b { a: X }\n- { <<: [ *b, *a ], b: X }\n'
      const doc = parseDocument(src, { version: '1.1' })
      expect(doc.toJS()).toMatchObject([
        { a: 'A', b: 'B' },
        { a: 'X' },
        { a: 'X', b: 'X', c: 'C' }
      ])
      expect(doc.toString()).toBe(src)
    })

    test('explicit creation', () => {
      const src = '- { a: A, b: B }\n- { b: X }\n'
      const doc = parseDocument(src, { version: '1.1' })
      const alias = doc.createAlias(doc.get(0), 'a')
      doc.addIn([1], doc.createPair('<<', alias))
      expect(doc.toString()).toBe('- &a { a: A, b: B }\n- { b: X, <<: *a }\n')
      expect(doc.toJS()).toMatchObject([
        { a: 'A', b: 'B' },
        { a: 'A', b: 'X' }
      ])
    })

    test('creation by duck typing', () => {
      const src = '- { a: A, b: B }\n- { b: X }\n'
      const doc = parseDocument(src, { version: '1.1' })
      const alias = doc.createAlias(doc.get(0), 'a')
      doc.addIn([1], doc.createPair('<<', alias))
      expect(doc.toString()).toBe('- &a { a: A, b: B }\n- { b: X, <<: *a }\n')
      expect(doc.toJS()).toMatchObject([
        { a: 'A', b: 'B' },
        { a: 'A', b: 'X' }
      ])
    })
  })
})

describe('custom tags', () => {
  describe('local', () => {
    const src = source`
      %TAG !e! tag:example.com,2000:test/
      ---
      !e!x
      - !y 2
      - !e!z 3
      - ! 4
      - '5'
    `

    test('parse', () => {
      const doc = parseDocument>(src)
      expect(doc.contents).toBeInstanceOf(YAMLSeq)
      expect(doc.contents.tag).toBe('tag:example.com,2000:test/x')
      const { items } = doc.contents
      expect(items).toHaveLength(4)
      items.forEach(item => expect(typeof item.value).toBe('string'))
      expect(items[0].tag).toBe('!y')
      expect(items[1].tag).toBe('tag:example.com,2000:test/z')
      expect(items[2].tag).toBe('tag:example.com,2000:other/w')
    })

    test('stringify', () => {
      const doc = parseDocument(src)
      expect(String(doc)).toBe(source`
        %TAG !e! tag:example.com,2000:test/
        ---
        !e!x
        - !y "2"
        - !e!z "3"
        - ! "4"
        - '5'
      `)
    })

    test('modify', () => {
      const doc = parseDocument>(src)
      const prefix = 'tag:example.com,2000:other/'
      doc.directives.tags['!f!'] = prefix
      expect(doc.directives.tags).toMatchObject({
        '!!': 'tag:yaml.org,2002:',
        '!e!': 'tag:example.com,2000:test/',
        '!f!': prefix
      })

      doc.contents.commentBefore = 'c'
      doc.contents.items[3].comment = 'cc'
      const s = new Scalar(6)
      s.tag = '!g'
      // @ts-expect-error TS should complain here
      doc.contents.items.splice(1, 1, s, '7')
      expect(String(doc)).toBe(source`
        %TAG !e! tag:example.com,2000:test/
        %TAG !f! tag:example.com,2000:other/
        ---
        #c
        !e!x
        - !y "2"
        - !g 6
        - "7"
        - !f!w "4"
        - '5' #cc
      `)
    })
  })

  describe('!!binary', () => {
    const src = `!!binary |
      R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
      OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
      +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
      AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=`

    test('tag string in tags', () => {
      const bin = parse(src, { customTags: ['binary'] })
      expect(bin).toBeInstanceOf(Uint8Array)
    })

    test('tag string in tag array', () => {
      // @ts-expect-error TS should complain here
      const bin = parse(src, { customTags: [['binary']] })
      expect(bin).toBeInstanceOf(Uint8Array)
    })

    test('custom tags from function', () => {
      const bin = parse(src, { customTags: tags => tags.concat('binary') })
      expect(bin).toBeInstanceOf(Uint8Array)
    })

    test('no custom tag object', () => {
      const bin = parse(src)
      expect(bin).toBeInstanceOf(Uint8Array)
    })
  })

  const regexp: ScalarTag = {
    identify: value => value instanceof RegExp,
    tag: '!re',
    resolve(str) {
      const match = str.match(/^\/([\s\S]+)\/([gimuy]*)$/)!
      return new RegExp(match[1], match[2])
    }
  }

  const sharedSymbol: ScalarTag = {
    identify: (value: any) => value.constructor === Symbol,
    tag: '!symbol/shared',
    resolve: str => Symbol.for(str),
    stringify(item, ctx, onComment, onChompKeep) {
      const key = Symbol.keyFor(item.value as symbol)
      if (key === undefined)
        throw new Error('Only shared symbols are supported')
      return stringifyString({ value: key }, ctx, onComment, onChompKeep)
    }
  }

  class YAMLNullObject extends YAMLMap {
    tag: string = '!nullobject'
    toJSON(_?: unknown, ctx?: any): any {
      const obj = super.toJSON>(
        _,
        { ...(ctx || {}), mapAsMap: false },
        Object
      )
      return Object.assign(Object.create(null), obj)
    }
  }
  const nullObject: CollectionTag = {
    tag: '!nullobject',
    collection: 'map',
    identify: (value: any) =>
      !!value && typeof value === 'object' && !Object.getPrototypeOf(value),
    nodeClass: YAMLNullObject
  }

  describe('RegExp', () => {
    test('stringify as plain scalar', () => {
      const str = stringify(/re/g, { customTags: [regexp] })
      expect(str).toBe('!re /re/g\n')
      const res = parse(str, { customTags: [regexp] })
      expect(res).toBeInstanceOf(RegExp)
    })

    test('stringify as quoted scalar', () => {
      const str = stringify(/re: /g, { customTags: [regexp] })
      expect(str).toBe('!re "/re: /g"\n')
      const res = parse(str, { customTags: [regexp] })
      expect(res).toBeInstanceOf(RegExp)
    })

    test('parse plain string as string', () => {
      const res = parse('/re/g', { customTags: [regexp] })
      expect(res).toBe('/re/g')
    })

    test('parse quoted string as string', () => {
      const res = parse('"/re/g"', { customTags: [regexp] })
      expect(res).toBe('/re/g')
    })
  })

  describe('Symbol', () => {
    test('stringify as plain scalar', () => {
      const symbol = Symbol.for('foo')
      const str = stringify(symbol, { customTags: [sharedSymbol] })
      expect(str).toBe('!symbol/shared foo\n')
      const res = parse(str, { customTags: [sharedSymbol] })
      expect(res).toBe(symbol)
    })

    test('stringify as block scalar', () => {
      const symbol = Symbol.for('foo\nbar')
      const str = stringify(symbol, { customTags: [sharedSymbol] })
      expect(str).toBe('!symbol/shared |-\nfoo\nbar\n')
      const res = parse(str, { customTags: [sharedSymbol] })
      expect(res).toBe(symbol)
    })
  })

  test('null prototyped object', () => {
    const obj = Object.assign(Object.create(null), { x: 'y', z: 1 })
    const str = stringify(obj, { customTags: [nullObject] })
    expect(str).toBe('!nullobject\nx: y\nz: 1\n')
    const res = parse(str, { customTags: [nullObject] })
    expect(Object.getPrototypeOf(res)).toBe(null)
    expect(res).toMatchObject(obj)
  })

  test('cannot parse sequence as nullobject', () => {
    const str = '!nullobject\n- y\n- 1\n'
    const doc = origParseDocument(str)
    expect(doc.warnings).toMatchObject([{ code: 'TAG_RESOLVE_FAILED' }])
  })

  test('array within customTags', () => {
    const obj = { re: /re/g, symbol: Symbol.for('foo') }
    // @ts-expect-error TS should complain here
    const str = stringify(obj, { customTags: [[regexp, sharedSymbol]] })
    expect(str).toBe('re: !re /re/g\nsymbol: !symbol/shared foo\n')
  })

  describe('schema from custom tags', () => {
    test('customTags is required', () => {
      expect(() => parseDocument('foo', { schema: 'custom-test' })).toThrow(
        /Unknown schema "custom-test"/
      )
    })

    test('parse success', () => {
      const src = '- foo\n- !re /bar/\n'
      const doc = parseDocument(src, {
        customTags: [seqTag, stringTag, regexp],
        schema: 'custom-test'
      })
      expect(doc.errors).toEqual([])
      expect(doc.warnings).toEqual([])
      expect(doc.schema.name).toBe('custom-test')
      expect(doc.toJS()).toEqual(['foo', /bar/])
    })

    test('parse fail', () => {
      // map, seq & string are always parsed, even if not included
      const src = '- foo\n- !re /bar/\n'
      const doc = parseDocument(src, {
        customTags: [],
        schema: 'custom-test'
      })
      expect(doc.errors).toEqual([])
      expect(doc.warnings).toHaveLength(1)
      expect(doc.warnings[0].message).toMatch(/Unresolved tag: !re/)
    })

    test('stringify success', () => {
      let src = '- foo\n'
      let doc = parseDocument(src, {
        customTags: [seqTag, stringTag],
        schema: 'custom-test'
      })
      expect(doc.toString()).toBe(src)

      src = '- foo\n- !re /bar/\n'
      doc = parseDocument(src, {
        customTags: [seqTag, stringTag, regexp],
        schema: 'custom-test'
      })
      expect(doc.toString()).toBe(src)
    })

    test('stringify fail', () => {
      const src = '- foo\n'
      let doc = parseDocument(src, {
        customTags: [],
        schema: 'custom-test'
      })
      expect(() => String(doc)).toThrow(/Tag not resolved for YAMLSeq value/)

      doc = parseDocument(src, {
        customTags: [seqTag],
        schema: 'custom-test'
      })
      expect(() => String(doc)).toThrow(/Tag not resolved for String value/)
    })

    test('setSchema', () => {
      const src = '- foo\n'
      const doc = parseDocument(src)

      doc.setSchema('1.2', {
        customTags: [seqTag, stringTag],
        schema: 'custom-test-1'
      })
      expect(doc.toString()).toBe(src)

      doc.setSchema('1.2', {
        customTags: [stringTag],
        schema: 'custom-test-2'
      })
      expect(() => String(doc)).toThrow(/Tag not resolved for YAMLSeq value/)
    })
  })
})

describe('schema changes', () => {
  test('write as json', () => {
    const doc = parseDocument('foo: bar', { schema: 'core' })
    expect(doc.schema.name).toBe('core')
    doc.setSchema('1.2', { schema: 'json' })
    expect(doc.schema.name).toBe('json')
    expect(String(doc)).toBe('"foo": "bar"\n')
  })

  test('fail for missing type', () => {
    const doc = parseDocument('foo: 1971-02-03T12:13:14', {
      version: '1.1'
    })
    expect(doc.directives.yaml).toMatchObject({
      version: '1.1',
      explicit: false
    })
    doc.setSchema('1.2')
    expect(doc.directives.yaml).toMatchObject({
      version: '1.2',
      explicit: false
    })
    expect(doc.schema.name).toBe('core')
    expect(() => String(doc)).toThrow(/Tag not resolved for Date value/)
  })

  test('fail for missing null type (#616)', () => {
    const doc = parseDocument('foo:')
    doc.setSchema('1.2', { schema: 'failsafe' })
    expect(() => String(doc)).toThrow(/Tag not resolved for null value/)
  })

  test('set schema + custom tags', () => {
    const doc = parseDocument('foo: 1971-02-03T12:13:14', {
      version: '1.1'
    })
    doc.setSchema('1.1', { customTags: ['timestamp'], schema: 'json' })
    expect(String(doc)).toBe('"foo": 1971-02-03T12:13:14\n')
  })

  test('set version + custom tags', () => {
    const doc = parseDocument('foo: 1971-02-03T12:13:14', {
      version: '1.1'
    })
    // @ts-expect-error TS should complain here
    doc.setSchema(1.2, { customTags: ['timestamp'] })
    expect(String(doc)).toBe('foo: 1971-02-03T12:13:14\n')
  })

  test('schema changes on bool', () => {
    const doc = parseDocument('[y, yes, on, n, no, off]', {
      version: '1.1'
    })
    doc.setSchema('1.1', { schema: 'core' })
    expect(String(doc)).toBe('[ true, true, true, false, false, false ]\n')
    doc.setSchema('1.1')
    expect(String(doc)).toBe('[ y, yes, on, n, no, off ]\n')
  })

  test('set bool + re-stringified', () => {
    let doc = parseDocument('a: True', {
      version: '1.2'
    })
    doc.set('a', false)
    expect(String(doc)).toBe('a: false\n')

    doc = parseDocument('a: on', {
      version: '1.1'
    })
    doc.set('a', false)
    expect(String(doc)).toBe('a: false\n')
  })

  test('custom schema instance', () => {
    const src = '[ !!bool yes, &foo no, *foo ]'
    const doc = parseDocument(src, { version: '1.1' })

    const core = new Schema({ schema: 'core' })
    doc.setSchema('1.2', { schema: core })
    expect(String(doc)).toBe('[ !!bool true, &foo false, *foo ]\n')

    const yaml11 = new Schema({ schema: 'yaml-1.1' })
    doc.setSchema('1.1', { schema: Object.assign({}, yaml11) })
    expect(String(doc)).toBe('[ !!bool yes, &foo no, *foo ]\n')

    doc.setSchema(null, { schema: core })
    expect(String(doc)).toBe('[ true, false, false ]\n')
  })

  test('null version requires Schema instance', () => {
    const doc = parseDocument('foo: bar')
    const msg =
      'With a null YAML version, the { schema: Schema } option is required'
    expect(() => doc.setSchema(null)).toThrow(msg)
    expect(() => doc.setSchema(null, { schema: 'core' })).toThrow(msg)
    doc.setSchema(null, { schema: doc.schema })
    expect(doc.toString()).toBe('foo: bar\n')
  })
})
eemeli-yaml-086fa6b/tests/is-node.ts000066400000000000000000000061201511277410200173770ustar00rootroot00000000000000import {
  Alias,
  Document,
  isAlias,
  isCollection,
  isDocument,
  isMap,
  isNode,
  isPair,
  isScalar,
  isSeq,
  Pair,
  parseDocument,
  Scalar,
  YAMLMap,
  YAMLSeq
} from 'yaml'

for (const { fn, exp } of [
  {
    fn: isAlias,
    exp: {
      doc: false,
      scalar: false,
      map: false,
      seq: false,
      alias: true,
      pair: false
    }
  },
  {
    fn: isCollection,
    exp: {
      doc: false,
      scalar: false,
      map: true,
      seq: true,
      alias: false,
      pair: false
    }
  },
  {
    fn: isDocument,
    exp: {
      doc: true,
      scalar: false,
      map: false,
      seq: false,
      alias: false,
      pair: false
    }
  },
  {
    fn: isMap,
    exp: {
      doc: false,
      scalar: false,
      map: true,
      seq: false,
      alias: false,
      pair: false
    }
  },
  {
    fn: isNode,
    exp: {
      doc: false,
      scalar: true,
      map: true,
      seq: true,
      alias: true,
      pair: false
    }
  },
  {
    fn: isPair,
    exp: {
      doc: false,
      scalar: false,
      map: false,
      seq: false,
      alias: false,
      pair: true
    }
  },
  {
    fn: isScalar,
    exp: {
      doc: false,
      scalar: true,
      map: false,
      seq: false,
      alias: false,
      pair: false
    }
  },
  {
    fn: isSeq,
    exp: {
      doc: false,
      scalar: false,
      map: false,
      seq: true,
      alias: false,
      pair: false
    }
  }
] as { fn: (x: unknown) => boolean; exp: Record }[]) {
  describe(fn.name, () => {
    test('parsed doc', () => {
      const doc = parseDocument('foo')
      expect(fn(doc)).toBe(exp.doc)
    })

    test('parsed scalar', () => {
      const doc = parseDocument('foo')
      expect(fn(doc.contents)).toBe(exp.scalar)
    })

    test('parsed map', () => {
      const doc = parseDocument('foo: bar')
      expect(fn(doc.contents)).toBe(exp.map)
    })

    test('parsed seq', () => {
      const doc = parseDocument('[foo, bar]')
      expect(fn(doc.contents)).toBe(exp.seq)
    })

    test('parsed alias', () => {
      const doc = parseDocument('[ &a foo, *a ]')
      expect(fn(doc.contents?.items[1])).toBe(exp.alias)
    })

    test('parsed pair', () => {
      const doc = parseDocument('foo: bar')
      expect(fn(doc.contents?.items[0])).toBe(exp.pair)
    })

    test('created doc', () => {
      expect(fn(new Document())).toBe(exp.doc)
    })

    test('created scalar', () => {
      expect(fn(new Scalar(42))).toBe(exp.scalar)
    })

    test('created map', () => {
      expect(fn(new YAMLMap())).toBe(exp.map)
    })

    test('created seq', () => {
      expect(fn(new YAMLSeq())).toBe(exp.seq)
    })

    test('created alias', () => {
      expect(fn(new Alias('42'))).toBe(exp.alias)
    })

    test('created pair', () => {
      expect(fn(new Pair(null))).toBe(exp.pair)
    })

    test('null', () => {
      expect(fn(null)).toBe(false)
    })

    test('string', () => {
      expect(fn('foo')).toBe(false)
    })

    test('object', () => {
      expect(fn({ type: 'SCALAR', value: 42 })).toBe(false)
    })
  })
}
eemeli-yaml-086fa6b/tests/json-test-suite/000077500000000000000000000000001511277410200205475ustar00rootroot00000000000000eemeli-yaml-086fa6b/tests/json-test-suite.ts000066400000000000000000000040001511277410200211110ustar00rootroot00000000000000import { readdirSync, readFileSync } from 'fs'
import { basename, resolve } from 'path'
import { parseDocument } from 'yaml'

const skip = [
  // Maximum call stack size exceeded
  'n_structure_100000_opening_arrays',
  'n_structure_open_array_object',

  // YAMLParseError: Map keys must be unique
  'y_object_duplicated_key',
  'y_object_duplicated_key_and_value',
  'object_same_key_different_values',
  'object_same_key_same_value',
  'object_same_key_unclear_values'
]

function testReject(name: string, src: string) {
  if (skip.includes(name)) return test.skip(name, () => {})

  test(name, () => {
    const doc = parseDocument(src)
    if (doc.errors.length === 0) {
      const res = doc.toJS()
      const doc2 = parseDocument(doc.toString())
      const res2 = doc2.toJS()
      expect(JSON.stringify(res2)).toBe(JSON.stringify(res))
    }
  })
}

function testSuccess(name: string, src: string) {
  if (skip.includes(name)) return test.skip(name, () => {})

  test(name, () => {
    const doc = parseDocument(src)
    expect(doc.errors).toHaveLength(0)
    expect(doc.warnings).toHaveLength(0)
    const res = doc.toJS()

    const doc2 = parseDocument(doc.toString())
    expect(doc2.errors).toHaveLength(0)
    expect(doc2.warnings).toHaveLength(0)
    const res2 = doc2.toJS()

    expect(JSON.stringify(res2)).toBe(JSON.stringify(res))
  })
}

describe('json-test-suite test_parsing', () => {
  const dir = resolve(__dirname, 'json-test-suite', 'test_parsing')
  for (const fn of readdirSync(dir)) {
    if (!fn.endsWith('.json')) continue
    const name = basename(fn, '.json')
    const src = readFileSync(resolve(dir, fn), 'utf8')
    if (fn.startsWith('y_')) testSuccess(name, src)
    else testReject(name, src)
  }
})

describe('json-test-suite test_transform', () => {
  const dir = resolve(__dirname, 'json-test-suite', 'test_transform')
  for (const fn of readdirSync(dir)) {
    if (!fn.endsWith('.json')) continue
    const src = readFileSync(resolve(dir, fn), 'utf8')
    testSuccess(basename(fn, '.json'), src)
  }
})
eemeli-yaml-086fa6b/tests/lexer.ts000066400000000000000000000023111511277410200171560ustar00rootroot00000000000000import { CST, Lexer } from 'yaml'

const { DOCUMENT: DOC, SCALAR } = CST

test('unexpected unindent in quoted string with CRLF', () => {
  const src = '- "\r\nx"'
  let n = 0
  const res: string[] = []
  for (const lex of new Lexer().lex(src)) {
    res.push(lex)
    if (++n === 10) break
  }
  expect(res).toEqual([DOC, '-', ' ', '"', '\r\n', SCALAR, 'x"'])
})

test('plain scalar + CRLF + comment', () => {
  const src = 'foo\r\n# bar'
  const res = Array.from(new Lexer().lex(src))
  expect(res).toEqual([DOC, SCALAR, 'foo', '\r\n', '# bar'])
})

test('Scalar starting with : after flow-ish key in preceding node in flow collection', () => {
  const src = '[[], :@]'
  const res = Array.from(new Lexer().lex(src))
  expect(res).toEqual([DOC, '[', '[', ']', ',', ' ', SCALAR, ':@', ']'])
})

test('unindented comment in flow collection', () => {
  const src = '- {\n#c\n  }'
  const res = Array.from(new Lexer().lex(src))
  expect(res).toEqual([DOC, '-', ' ', '{', '\n', '#c', '\n', '  ', '}'])
})

test('indented map + ... + unindented flow collection', () => {
  const src = ' :\n...\n{\n}'
  const res = Array.from(new Lexer().lex(src))
  expect(res).toEqual([DOC, ' ', ':', '\n', '...', '\n', DOC, '{', '\n', '}'])
})
eemeli-yaml-086fa6b/tests/line-counter.ts000066400000000000000000000034231511277410200204500ustar00rootroot00000000000000import { LineCounter, parseDocument } from 'yaml'

test('Parse error, no newlines', () => {
  const lineCounter = new LineCounter()
  const doc = parseDocument('foo: bar: baz', { lineCounter })
  expect(doc.errors).toMatchObject([{ pos: [5, 6] }])
  expect(lineCounter.lineStarts).toMatchObject([0])
  expect(lineCounter.linePos(5)).toMatchObject({ line: 1, col: 6 })
})

test('Parse error with newlines', () => {
  const lineCounter = new LineCounter()
  const doc = parseDocument('foo:\n  bar: - baz\n', { lineCounter })
  expect(doc.errors).toMatchObject([{ pos: [12, 13] }, { pos: [14, 17] }])
  expect(lineCounter.lineStarts).toMatchObject([0, 5, 18])
  expect(lineCounter.linePos(14)).toMatchObject({ line: 2, col: 10 })
  expect(lineCounter.linePos(17)).toMatchObject({ line: 2, col: 13 })
})

test('block scalar', () => {
  const lineCounter = new LineCounter()
  parseDocument('foo: |\n a\n b\n c\nbar:\n baz\n', { lineCounter })
  expect(lineCounter.lineStarts).toMatchObject([0, 7, 10, 13, 16, 21, 26])
  for (const { offset, line, col } of [
    { offset: 0, line: 1, col: 1 },
    { offset: 10, line: 3, col: 1 },
    { offset: 11, line: 3, col: 2 },
    { offset: 12, line: 3, col: 3 },
    { offset: 13, line: 4, col: 1 },
    { offset: 14, line: 4, col: 2 },
    { offset: 15, line: 4, col: 3 },
    { offset: 16, line: 5, col: 1 },
    { offset: 17, line: 5, col: 2 },
    { offset: 18, line: 5, col: 3 }
  ]) {
    expect(lineCounter.linePos(offset)).toMatchObject({ line, col })
  }
})

test('flow scalar', () => {
  const lineCounter = new LineCounter()
  const doc = parseDocument(`?\n "a\n b"\n: '\n c\n \n\n d'\n`, {
    lineCounter
  })
  expect(doc.toJS()).toMatchObject({ 'a b': ' c\n\nd' })
  expect(lineCounter.lineStarts).toMatchObject([
    0, 2, 6, 10, 14, 17, 19, 20, 24
  ])
})
eemeli-yaml-086fa6b/tests/node-to-js.ts000066400000000000000000000050441511277410200200240ustar00rootroot00000000000000import type { YAMLMap, YAMLSeq } from 'yaml'
import { parseDocument } from 'yaml'
import { source } from './_utils.ts'

describe('scalars', () => {
  test('plain', () => {
    const doc = parseDocument('42')
    expect(doc.contents?.toJS(doc)).toBe(42)
  })

  test('plain in map', () => {
    const doc = parseDocument('key: 42')
    expect(doc.get('key', true).toJS(doc)).toBe(42)
  })
})

describe('collections', () => {
  test('map', () => {
    const doc = parseDocument('key: 42')
    expect(doc.contents?.toJS(doc)).toMatchObject({ key: 42 })
  })

  test('map in seq', () => {
    const doc = parseDocument('- key: 42')
    expect(doc.get(0).toJS(doc)).toMatchObject({ key: 42 })
  })
})

describe('alias', () => {
  test('simple', () => {
    const doc = parseDocument(source`
      one: &a 42
      two: *a
    `)
    expect(doc.get('two').toJS(doc)).toBe(42)
  })

  test('repeated identifier', () => {
    const doc = parseDocument(source`
      one: &a 13
      two: &a 42
      three: *a
      four: &a 99
    `)
    expect(doc.get('three').toJS(doc)).toBe(42)
  })

  test('nested aliases', () => {
    const doc = parseDocument(source`
      one: &a 42
      two: &b { key: *a }
      three: *b
    `)
    expect(doc.get('three').toJS(doc)).toMatchObject({ key: 42 })
  })

  test('missing anchor', () => {
    const doc = parseDocument(source`
      one: &a 42
      two: *b
    `)
    expect(() => doc.get('two').toJS(doc)).toThrow(ReferenceError)
  })
})

describe('options', () => {
  test('doc is required', () => {
    const doc = parseDocument('key: 42')
    expect(() => doc.contents?.toJS({} as any)).toThrow(TypeError)
  })

  test('mapAsMap', () => {
    const doc = parseDocument('key: 42')
    expect(doc.contents?.toJS(doc, { mapAsMap: true })).toMatchObject(
      new Map([['key', 42]])
    )
  })

  test('onAnchor', () => {
    const doc = parseDocument(source`
      one: &a 42
      two: &b { key: *a }
      three: *b
    `)
    const onAnchor = jest.fn()
    doc.get('three').toJS(doc, { onAnchor })
    expect(onAnchor.mock.calls).toMatchObject([
      [{ key: 42 }, 2],
      [42, 2]
    ])
  })

  test('reviver', () => {
    const doc = parseDocument(source`
      one: &a 42
      two: &b { key: *a }
      three: *b
    `)
    const reviver = jest.fn((_key, value) => value)
    doc.get('three').toJS(doc, { reviver })
    expect(reviver.mock.calls).toMatchObject([
      ['key', 42],
      ['', { key: 42 }]
    ])
  })
})
eemeli-yaml-086fa6b/tests/properties.ts000066400000000000000000000017251511277410200202430ustar00rootroot00000000000000import * as fc from 'fast-check'
import { parse, stringify } from 'yaml'

describe('properties', () => {
  test('parse stringified object', () => {
    const key = fc.fullUnicodeString()
    const values = [
      key,
      fc.lorem({ maxCount: 1000, mode: 'words' }),
      fc.lorem({ maxCount: 100, mode: 'sentences' }),
      fc.boolean(),
      fc.integer(),
      fc.double(),
      fc.constantFrom(null, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY)
    ]
    const yamlArbitrary = fc.anything({ key: key, values: values })
    const optionsArbitrary = fc.record(
      {
        mapAsMap: fc.constant(false),
        merge: fc.boolean(),
        schema: fc.constantFrom<('core' | 'yaml-1.1')[]>('core', 'yaml-1.1') // ignore 'failsafe', 'json'
      },
      { withDeletedKeys: true }
    )

    fc.assert(
      fc.property(yamlArbitrary, optionsArbitrary, (obj, opts) => {
        expect(parse(stringify(obj, opts), opts)).toStrictEqual(obj)
      })
    )
  })
})
eemeli-yaml-086fa6b/tests/stream.ts000066400000000000000000000034401511277410200173360ustar00rootroot00000000000000import type { Document } from 'yaml'
import { Composer, Parser, parseDocument } from 'yaml'

const src = `
#c0\n \n
%YAML 1.2
#c1
---
#c2\n \n
aa: AA
 AA
'bb': 'BB
  BB'
"cc": "CC\n\n \\ "
? |
 dd
: >

  DD
   DD

  DD
? EE
[ ee , ff ] : {
 "gg
   gg":[GG]
}
{hh}:
 - HH
 -\tII\rII
    II
`

describe('Input in parts', () => {
  const cases = [
    { title: 'LF line endings', src, nl: '\n' },
    { title: 'CRLF line endings', src: src.replace(/\n/g, '\r\n'), nl: '\r\n' }
  ]
  for (const { title, src, nl } of cases)
    test(title, () => {
      const doc = parseDocument(src, { logLevel: 'error' })
      const exp = [doc.toJS()]
      expect(exp[0]).toMatchObject({
        aa: 'AA AA',
        bb: 'BB BB',
        cc: 'CC\n ',
        'dd\n': '\nDD\n DD\n\nDD\n',
        EE: null,
        '[ ee, ff ]': { 'gg gg': ['GG'] },
        '{ hh }': ['HH', 'II\rII II']
      })
      const cb = [doc.commentBefore, doc.contents?.commentBefore]
      expect(cb).toMatchObject(['c0\n\nc1', `c2${nl}${nl}`])

      for (let i = 1; i < src.length - 1; ++i) {
        const res: Document.Parsed[] = []
        const composer = new Composer({ logLevel: 'error' })
        const parser = new Parser()
        const start = src.substring(0, i)
        const end = src.substring(i)
        for (const token of [
          ...parser.parse(start, true),
          ...parser.parse(end, false)
        ])
          for (const doc of composer.next(token)) res.push(doc)
        for (const doc of composer.end()) res.push(doc)

        try {
          expect(res.map(doc => doc.toJS())).toMatchObject(exp)
          expect(res[0].commentBefore).toBe(cb[0])
          expect(res[0].contents?.commentBefore).toBe(cb[1])
        } catch (error) {
          console.log({ start, end, res })
          throw error
        }
      }
    })
})
eemeli-yaml-086fa6b/tests/tsconfig.json000066400000000000000000000005121511277410200201770ustar00rootroot00000000000000{
  "extends": "../tsconfig.json",
  "compilerOptions": {
    "baseUrl": "..",
    "declaration": false,
    "paths": {
      "yaml": ["src/index.ts"],
      "yaml/cli": ["src/cli.ts"],
      "yaml/util": ["src/util.ts"]
    },
    "rootDir": "..",
    "types": ["jest", "node"]
  },
  "include": ["**/*.ts", "artifacts/cli-*"]
}
eemeli-yaml-086fa6b/tests/visit.ts000066400000000000000000000214751511277410200172110ustar00rootroot00000000000000import type { Scalar } from 'yaml'
import { Document, isSeq, parseDocument, visit, visitAsync } from 'yaml'

const coll = { items: {} }

for (const [visit_, title] of [
  [visit, 'visit()'],
  [visitAsync, 'visitAsync()']
] as const) {
  describe(title, () => {
    test('Map', async () => {
      const doc = parseDocument('{ one: 1, two }')
      const fn = jest.fn()
      await visit_(doc, { Map: fn, Pair: fn, Seq: fn, Alias: fn, Scalar: fn })
      expect(fn.mock.calls).toMatchObject([
        [null, coll, [{}]],
        [0, { key: {}, value: {} }, [{}, {}]],
        ['key', { type: 'PLAIN', value: 'one' }, [{}, {}, {}]],
        ['value', { type: 'PLAIN', value: 1 }, [{}, {}, {}]],
        [1, { key: {}, value: {} }, [{}, {}]],
        ['key', { type: 'PLAIN', value: 'two' }, [{}, {}, {}]]
      ])
    })

    test('Seq', async () => {
      const doc = parseDocument('- 1\n- two\n')
      const fn = jest.fn()
      await visit_(doc, { Map: fn, Pair: fn, Seq: fn, Alias: fn, Scalar: fn })
      expect(fn.mock.calls).toMatchObject([
        [null, coll, [{ contents: {} }]],
        [0, { type: 'PLAIN', value: 1 }, [{ contents: {} }, coll]],
        [1, { type: 'PLAIN', value: 'two' }, [{ contents: {} }, coll]]
      ])
    })

    test('Alias', async () => {
      const doc = parseDocument('- &a 1\n- *a\n')
      const fn = jest.fn()
      await visit_(doc, { Map: fn, Pair: fn, Seq: fn, Alias: fn, Scalar: fn })
      expect(fn.mock.calls).toMatchObject([
        [null, coll, [{}]],
        [0, { type: 'PLAIN', value: 1, anchor: 'a' }, [{}, {}]],
        [1, { source: 'a' }, [{}, {}]]
      ])
    })

    test('Seq in Map', async () => {
      const doc = parseDocument('foo:\n  - "one"\n  - \'two\'\n')
      const fn = jest.fn()
      await visit_(doc, { Map: fn, Pair: fn, Seq: fn, Alias: fn, Scalar: fn })
      expect(fn.mock.calls).toMatchObject([
        [null, coll, [{}]],
        [0, { key: {}, value: {} }, [{}, {}]],
        ['key', { type: 'PLAIN', value: 'foo' }, [{}, {}, {}]],
        ['value', coll, [{}, {}, {}]],
        [0, { type: 'QUOTE_DOUBLE', value: 'one' }, [{}, {}, {}, {}]],
        [1, { type: 'QUOTE_SINGLE', value: 'two' }, [{}, {}, {}, {}]]
      ])
    })

    test('Visit called with non-Document root', async () => {
      const doc = parseDocument('foo:\n  - "one"\n  - \'two\'\n')
      const fn = jest.fn()
      await visit_(doc.get('foo') as Scalar, fn)
      expect(fn.mock.calls).toMatchObject([
        [null, coll, []],
        [0, { type: 'QUOTE_DOUBLE', value: 'one' }, [coll]],
        [1, { type: 'QUOTE_SINGLE', value: 'two' }, [coll]]
      ])
    })

    test('Visiting a constructed document', async () => {
      const doc = new Document([1, 'two'])
      const fn = jest.fn()
      await visit_(doc, { Map: fn, Pair: fn, Seq: fn, Alias: fn, Scalar: fn })
      expect(fn.mock.calls).toMatchObject([
        [null, { items: [{}, {}] }, [{}]],
        [0, { value: 1 }, [{}, {}]],
        [1, { value: 'two' }, [{}, {}]]
      ])
      expect(String(doc)).toBe('- 1\n- two\n')
    })

    test('Only Scalar defined', async () => {
      const doc = parseDocument('foo:\n  - "one"\n  - \'two\'\n')
      const Scalar = jest.fn()
      await visit_(doc, { Scalar })
      expect(Scalar.mock.calls).toMatchObject([
        ['key', { type: 'PLAIN', value: 'foo' }, [{}, {}, {}]],
        [0, { type: 'QUOTE_DOUBLE', value: 'one' }, [{}, {}, {}, {}]],
        [1, { type: 'QUOTE_SINGLE', value: 'two' }, [{}, {}, {}, {}]]
      ])
    })

    test('Function as visitor', async () => {
      const doc = parseDocument('{ one: 1, two }')
      const fn = jest.fn()
      await visit_(doc, fn)
      expect(fn.mock.calls).toMatchObject([
        [null, coll, [{}]],
        [0, { key: {}, value: {} }, [{}, {}]],
        ['key', { type: 'PLAIN', value: 'one' }, [{}, {}, {}]],
        ['value', { type: 'PLAIN', value: 1 }, [{}, {}, {}]],
        [1, { key: {}, value: {} }, [{}, {}]],
        ['key', { type: 'PLAIN', value: 'two' }, [{}, {}, {}]],
        ['value', null, [{}, {}, {}]]
      ])
    })

    test('Change key value within Pair', async () => {
      const doc = parseDocument('foo:\n  - "one"\n  - \'two\'\n')
      await visit_(doc, {
        Pair(_, pair) {
          const sc = pair.key as Scalar
          if (sc.value === 'foo') sc.value = 'bar'
        }
      })
      expect(String(doc)).toBe('bar:\n  - "one"\n  - \'two\'\n')
    })

    test('Change key value within Scalar', async () => {
      const doc = parseDocument('foo:\n  - "one"\n  - \'two\'\n')
      await visit_(doc, {
        Scalar(key, node) {
          if (key === 'key' && node.value === 'foo') node.value = 'bar'
        }
      })
      expect(String(doc)).toBe('bar:\n  - "one"\n  - \'two\'\n')
    })

    test('Add item to Seq', async () => {
      const doc = parseDocument('- one\n- two\n')
      const Scalar = jest.fn()
      await visit_(doc, {
        Seq(_, seq) {
          seq.items.push(doc.createNode('three'))
        },
        Scalar
      })
      expect(Scalar.mock.calls).toMatchObject([
        [0, { type: 'PLAIN', value: 'one' }, [{}, {}]],
        [1, { type: 'PLAIN', value: 'two' }, [{}, {}]],
        [2, { value: 'three' }, [{}, {}]]
      ])
      expect(String(doc)).toBe('- one\n- two\n- three\n')
    })

    test('Do not visit block seq items', async () => {
      const doc = parseDocument('foo:\n  - one\n  - two\nbar:\n')
      const fn = jest.fn((_, node) => (isSeq(node) ? visit_.SKIP : undefined))
      await visit_(doc, { Map: fn, Pair: fn, Seq: fn, Scalar: fn })
      expect(fn.mock.calls).toMatchObject([
        [null, coll, [{}]],
        [0, { key: {}, value: {} }, [{}, {}]],
        ['key', { type: 'PLAIN', value: 'foo' }, [{}, {}, {}]],
        ['value', coll, [{}, {}, {}]],
        [1, { key: {}, value: {} }, [{}, {}]],
        ['key', { type: 'PLAIN', value: 'bar' }, [{}, {}, {}]],
        ['value', { type: 'PLAIN', value: null }, [{}, {}, {}]]
      ])
    })

    test('Break visit on command', async () => {
      const doc = parseDocument('- one\n- two\n- three\n')
      const Scalar = jest.fn((_, node) =>
        node.value === 'two' ? visit_.BREAK : undefined
      )
      await visit_(doc, { Scalar })
      expect(Scalar.mock.calls).toMatchObject([
        [0, { type: 'PLAIN', value: 'one' }, [{}, {}]],
        [1, { type: 'PLAIN', value: 'two' }, [{}, {}]]
      ])
    })

    test('Modify seq item', async () => {
      const doc = parseDocument('- one\n- two\n- three\n')
      const Scalar = jest.fn((_, node) =>
        node.value === 'two' ? doc.createNode(42) : undefined
      )
      await visit_(doc, { Scalar })
      expect(Scalar.mock.calls).toMatchObject([
        [0, { type: 'PLAIN', value: 'one' }, [{}, {}]],
        [1, { type: 'PLAIN', value: 'two' }, [{}, {}]],
        [1, { value: 42 }, [{}, {}]],
        [2, { type: 'PLAIN', value: 'three' }, [{}, {}]]
      ])
      expect(String(doc)).toBe('- one\n- 42\n- three\n')
    })

    test('Skip seq item', async () => {
      const doc = parseDocument('- one\n- two\n- three\n')
      const Scalar = jest.fn(key => (key === 0 ? 2 : undefined))
      await visit_(doc, { Scalar })
      expect(Scalar.mock.calls).toMatchObject([
        [0, { type: 'PLAIN', value: 'one' }, [{}, {}]],
        [2, { type: 'PLAIN', value: 'three' }, [{}, {}]]
      ])
    })

    test('Remove seq item', async () => {
      const doc = parseDocument('- one\n- two\n- three\n')
      const Scalar = jest.fn((_, node) =>
        node.value === 'two' ? visit_.REMOVE : undefined
      )
      await visit_(doc, { Scalar })
      expect(Scalar.mock.calls).toMatchObject([
        [0, { type: 'PLAIN', value: 'one' }, [{}, {}]],
        [1, { type: 'PLAIN', value: 'two' }, [{}, {}]],
        [1, { type: 'PLAIN', value: 'three' }, [{}, {}]]
      ])
      expect(String(doc)).toBe('- one\n- three\n')
    })

    test('Remove map value', async () => {
      const doc = parseDocument('one: 1\ntwo: 2\n')
      const Scalar = jest.fn((key, node) =>
        key === 'value' && node.value === 2 ? visit_.REMOVE : undefined
      )
      await visit_(doc, { Scalar })
      expect(Scalar.mock.calls).toMatchObject([
        ['key', { type: 'PLAIN', value: 'one' }, [{}, {}, {}]],
        ['value', { type: 'PLAIN', value: 1 }, [{}, {}, {}]],
        ['key', { type: 'PLAIN', value: 'two' }, [{}, {}, {}]],
        ['value', { type: 'PLAIN', value: 2 }, [{}, {}, {}]]
      ])
      expect(String(doc)).toBe('one: 1\ntwo: null\n')
    })

    test('Fail to replace root node', async () => {
      const doc = parseDocument('- one\n- two\n- three\n')
      const Seq = jest.fn(() => doc.createNode(42))
      if (visit_ === visit) {
        expect(() => visit_(doc.contents, { Seq })).toThrow(
          'Cannot replace node with scalar parent'
        )
      } else {
        await expect(visit_(doc.contents, { Seq })).rejects.toMatchObject({
          message: 'Cannot replace node with scalar parent'
        })
      }
    })
  })
}
eemeli-yaml-086fa6b/tests/yaml-test-suite/000077500000000000000000000000001511277410200205405ustar00rootroot00000000000000eemeli-yaml-086fa6b/tests/yaml-test-suite.ts000066400000000000000000000102041511277410200211050ustar00rootroot00000000000000import { readdirSync, readFileSync } from 'fs'
import { resolve } from 'path'

import type { Document } from 'yaml'
import { CST, Lexer, parse, parseAllDocuments, Parser } from 'yaml'
import { testEvents } from '../src/test-events.ts' // no public export

type TestCase = {
  yaml: string
  fail?: boolean
  tree?: string
  json?: string
  emit?: string
  dump?: string
}

type TestFile = [TestCase & { name: string; skip?: boolean }, ...TestCase[]]

const skip: Record = {
  '2JQS/0': ['test.event', 'errors'], // duplicate empty keys are invalid
  '9MMA/0': ['errors'], // allow stream with directive & no docs
  'SF5V/0': ['errors'] // allow duplicate %YAML directives
}

function testJsonMatch(docs: Document[], json: string) {
  if (!json) return
  const received = docs[0] ? docs.map(doc => doc.toJS()) : null
  const expected =
    docs.length > 1
      ? json
          .replace(/\n$/, '')
          .split('\n')
          .map(line => JSON.parse(line))
      : [JSON.parse(json)]
  expect(received).toEqual(expected)
}

const unescape = (text: string) =>
  text
    .replace(/␣/g, ' ')
    .replace(/—*»/g, '\t')
    .replace(/←/g, '\r')
    .replace(/⇔/g, 'x{FEFF}')
    .replace(/↵/g, '')
    .replace(/∎\n/g, '')

const testRoot = resolve(__dirname, 'yaml-test-suite', 'src')

for (const fn of readdirSync(testRoot)) {
  const [id, ext] = fn.split('.', 2)
  if (ext !== 'yaml') {
    console.warn(`Not a test file, skipping: ${fn}`)
    continue
  }
  const path = resolve(testRoot, fn)
  const file = readFileSync(path, 'utf8')
  const testData = parse(file) as TestFile
  if (!Array.isArray(testData)) throw new Error(`Unsupported test file: ${fn}`)
  if (testData[0].skip) continue

  const name = `${id}: ${testData[0].name}`
  for (let i = 0; i < testData.length; ++i) {
    const sd = skip[`${id}/${i}`] || null
    const test_ = (name: string, cb: () => void) => {
      if (sd === true || sd?.includes(name)) test.skip(name, cb)
      else test(name, cb)
    }

    describe(testData.length === 1 ? name : `${name} / ${i}`, () => {
      const yaml = unescape(testData[i].yaml)
      const { fail, tree, json, emit } = testData[i]

      test('lexer completes', () => {
        let n = 0
        for (const lex of new Lexer().lex(yaml.replace(/(? {
        let res = ''
        for (const tok of new Parser().parse(yaml)) res += CST.stringify(tok)
        expect(res).toBe(yaml)
      })

      // Too much variance in event stream length for error cases
      if (!fail && tree) {
        test_('test.event', () => {
          const res = testEvents(yaml)
          const exp = unescape(tree).replace(/^\s+/gm, '')
          expect(res.events.join('\n') + '\n').toBe(exp)
          expect(res.error).toBeNull()
        })
      }

      describe('document parsing', () => {
        let docs: Document.Parsed[]
        beforeAll(() => {
          docs = parseAllDocuments(yaml, { resolveKnownTags: false })
        })

        test_('errors', () => {
          let errors: Error[] = []
          for (const doc of docs) errors = errors.concat(doc.errors)
          if (fail) expect(errors).not.toHaveLength(0)
          else expect(errors).toHaveLength(0)
        })

        if (!fail) {
          if (json) {
            test_('in.json', () => testJsonMatch(docs, json))

            test_('stringfy+re-parse', () => {
              const src2 = docs.map(String).join('')
              const docs2 = parseAllDocuments(src2, { resolveKnownTags: false })
              testJsonMatch(docs2, json)
            })
          }

          if (emit) {
            test_('out.yaml', () => {
              const resDocs = parseAllDocuments(yaml)
              const resJson = resDocs.map(doc => doc.toJS({ mapAsMap: true }))
              const expDocs = parseAllDocuments(unescape(emit))
              const expJson = expDocs.map(doc => doc.toJS({ mapAsMap: true }))
              expect(resJson).toEqual(expJson)
            })
          }
        }
      })
    })
  }
}
eemeli-yaml-086fa6b/tsconfig.json000066400000000000000000000005451511277410200170430ustar00rootroot00000000000000{
  "compilerOptions": {
    "declaration": true,
    "module": "ESNext",
    "moduleResolution": "node",
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "outDir": "dist",
    "rewriteRelativeImportExtensions": true,
    "rootDir": "src",
    "strict": true,
    "target": "ES2020",
    "types": ["node"]
  },
  "include": ["src/**/*.ts"]
}
eemeli-yaml-086fa6b/util.js000066400000000000000000000001201511277410200156340ustar00rootroot00000000000000// Re-exporter for Node.js < 12.16.0
module.exports = require('./dist/util.js')