@procedures/json 0.0.0-stage → 0.3.0

package/src/path.ts

@@ -0,0 +1,155 @@
+/**
+ * A simple path query: a small part of JSONPath, without filters and scripts.
+ *
+ * | Part | Meaning |
+ * |---|---|
+ * | `$` | The whole value. It is optional at the start. |
+ * | `.name` or `name` | The member `name` of an object. A name has letters, digits, `_`, `$` and `-`. |
+ * | `["a.b"]` or `['a.b']` | The member with any key. `\` escapes a quote or a backslash. |
+ * | `[2]` | The item 2 of an array. `[-1]` is the last item. |
+ * | `*` or `[*]` | Each member of an object, or each item of an array. |
+ * | `..name`, `..*`, `..[0]` | The same step on the value and on each value in it, at each depth. |
+ *
+ * A path that names `__proto__`, `constructor` or `prototype` is refused (roadmap R6).
+ */
+
+import { JsonError, PROTOTYPE_KEYS, hasOwn, type JsonValue } from "./value.js";
+
+/** One step of a path. */
+export type PathStep =
+  | { readonly kind: "key"; readonly key: string; readonly deep: boolean }
+  | { readonly kind: "index"; readonly index: number; readonly deep: boolean }
+  | { readonly kind: "wildcard"; readonly deep: boolean };
+
+/** One match of a path: its JSON Pointer tokens and its value. */
+export interface PathMatch {
+  readonly tokens: readonly (string | number)[];
+  readonly value: JsonValue;
+}
+
+const NAME_CHAR = /[A-Za-z0-9_$\-\u0080-￿]/;
+
+/** This function parses a path query. A bad path throws `INVALID_POINTER`. */
+export function parsePath(path: string): PathStep[] {
+  const steps: PathStep[] = [];
+  const fail = (at: number, message: string): never => {
+    throw new JsonError("INVALID_POINTER", `The path ${JSON.stringify(path)} is not valid at character ${at + 1}: ${message}`);
+  };
+  const key = (name: string, deep: boolean, at: number): PathStep => {
+    if (PROTOTYPE_KEYS.has(name)) {
+      throw new JsonError("PROTOTYPE_KEY", `The path ${JSON.stringify(path)} has the key "${name}" at character ${at + 1}, which reaches a prototype`);
+    }
+    return { kind: "key", key: name, deep };
+  };
+  let i = 0;
+  if (path.startsWith("$")) i = 1;
+  let first = true;
+  while (i < path.length) {
+    let deep = false;
+    const start = i;
+    if (path.startsWith("..", i)) {
+      deep = true;
+      i += 2;
+    } else if (path[i] === ".") {
+      i += 1;
+    } else if (path[i] !== "[" && !(first && i === 0)) {
+      fail(i, 'expected ".", ".." or "["');
+    }
+    first = false;
+    const char = path[i];
+    if (char === undefined) fail(i, "the path ends after a dot");
+    if (char === "*") {
+      steps.push({ kind: "wildcard", deep });
+      i += 1;
+    } else if (char === "[") {
+      if ((path[start] === "." && !deep)) fail(i, 'a "[" does not come after a single "."');
+      const close = (from: number): void => {
+        if (path[from] !== "]") fail(from, 'expected "]"');
+      };
+      const inner = path[i + 1];
+      if (inner === "*") {
+        close(i + 2);
+        steps.push({ kind: "wildcard", deep });
+        i += 3;
+      } else if (inner === '"' || inner === "'") {
+        let j = i + 2;
+        let name = "";
+        while (j < path.length && path[j] !== inner) {
+          if (path[j] === "\\") {
+            j += 1;
+            if (j >= path.length) break;
+          }
+          name += path[j];
+          j += 1;
+        }
+        if (j >= path.length) fail(i, "the quoted key has no end");
+        close(j + 1);
+        steps.push(key(name, deep, i));
+        i = j + 2;
+      } else {
+        const match = /^-?(0|[1-9][0-9]*)/.exec(path.slice(i + 1));
+        if (!match) fail(i + 1, "expected an index, a quoted key or *");
+        close(i + 1 + match![0].length);
+        steps.push({ kind: "index", index: Number(match![0]), deep });
+        i += match![0].length + 2;
+      }
+    } else {
+      let j = i;
+      while (j < path.length && NAME_CHAR.test(path[j]!)) j += 1;
+      if (j === i) fail(i, "expected a name, * or [");
+      steps.push(key(path.slice(i, j), deep, i));
+      i = j;
+    }
+  }
+  return steps;
+}
+
+/** The children of a value, in document order: members of an object, or items of an array. */
+function children(match: PathMatch): PathMatch[] {
+  const { value, tokens } = match;
+  if (Array.isArray(value)) return value.map((item, index) => ({ tokens: [...tokens, index], value: item }));
+  if (value !== null && typeof value === "object") return Object.keys(value).map((name) => ({ tokens: [...tokens, name], value: value[name]! }));
+  return [];
+}
+
+/** The value and each value in it, at each depth, in document order. */
+function descendants(match: PathMatch): PathMatch[] {
+  const out: PathMatch[] = [];
+  const visit = (current: PathMatch): void => {
+    out.push(current);
+    for (const child of children(current)) visit(child);
+  };
+  visit(match);
+  return out;
+}
+
+function stepOn(step: PathStep, match: PathMatch): PathMatch[] {
+  const { value, tokens } = match;
+  switch (step.kind) {
+    case "wildcard":
+      return children(match);
+    case "key":
+      return value !== null && typeof value === "object" && !Array.isArray(value) && hasOwn(value, step.key)
+        ? [{ tokens: [...tokens, step.key], value: value[step.key]! }]
+        : [];
+    case "index": {
+      if (!Array.isArray(value)) return [];
+      const index = step.index < 0 ? value.length + step.index : step.index;
+      return index >= 0 && index < value.length ? [{ tokens: [...tokens, index], value: value[index]! }] : [];
+    }
+  }
+}
+
+/** This function gives the matches of a path in a value, in document order. */
+export function queryPath(value: JsonValue, path: string): PathMatch[] {
+  let matches: PathMatch[] = [{ tokens: [], value }];
+  for (const step of parsePath(path)) {
+    const next: PathMatch[] = [];
+    for (const match of matches) {
+      const sources = step.deep ? descendants(match) : [match];
+      for (const source of sources) next.push(...stepOn(step, source));
+    }
+    matches = next;
+  }
+  return matches;
+}

package/src/pointer.ts

@@ -0,0 +1,70 @@
+/**
+ * JSON Pointer (RFC 6901): the parse, and the value at a pointer.
+ *
+ * A pointer is `""` (the whole value) or a list of reference tokens, each after a `/`. In a token,
+ * `~1` is `/` and `~0` is `~`. A pointer in the URI fragment form (`#/a/b`) is accepted too. A
+ * pointer that names `__proto__`, `constructor` or `prototype` is refused (roadmap R6).
+ */
+
+import { hasOwn, JsonError, PROTOTYPE_KEYS, type JsonValue } from "./value.js";
+
+/** This function gives the reference tokens of a pointer. A bad pointer throws `INVALID_POINTER`. */
+export function parsePointer(pointer: string, label = "pointer"): string[] {
+  let text = pointer;
+  let fragment = false;
+  if (text.startsWith("#")) {
+    fragment = true;
+    text = text.slice(1);
+  }
+  if (text === "") return [];
+  if (!text.startsWith("/")) {
+    throw new JsonError("INVALID_POINTER", `The ${label} ${JSON.stringify(pointer)} is not a JSON Pointer: it must be "" or start with "/"`);
+  }
+  return text
+    .slice(1)
+    .split("/")
+    .map((raw) => {
+      let token = raw;
+      if (fragment) {
+        try {
+          token = decodeURIComponent(raw);
+        } catch {
+          throw new JsonError("INVALID_POINTER", `The ${label} ${JSON.stringify(pointer)} has a bad percent escape`);
+        }
+      }
+      if (/~[^01]|~$/.test(token)) {
+        throw new JsonError("INVALID_POINTER", `The ${label} ${JSON.stringify(pointer)} has a "~" that is not "~0" or "~1"`);
+      }
+      token = token.replace(/~1/g, "/").replace(/~0/g, "~");
+      if (PROTOTYPE_KEYS.has(token)) {
+        throw new JsonError("PROTOTYPE_KEY", `The ${label} ${JSON.stringify(pointer)} has the token "${token}", which reaches a prototype`);
+      }
+      return token;
+    });
+}
+
+/** The index of an array token (`0`, or a digit 1 to 9 and more digits), or undefined. */
+export function arrayIndex(token: string): number | undefined {
+  return /^(0|[1-9][0-9]*)$/.test(token) ? Number(token) : undefined;
+}
+
+/** The result of a look-up: found, with the value, or not found. */
+export type Lookup = { readonly found: true; readonly value: JsonValue } | { readonly found: false };
+
+/** This function gives the value at the tokens of a pointer. Only own keys of an object count. */
+export function lookup(value: JsonValue, tokens: readonly string[]): Lookup {
+  let current: JsonValue = value;
+  for (const token of tokens) {
+    if (Array.isArray(current)) {
+      const index = arrayIndex(token);
+      if (index === undefined || index >= current.length) return { found: false };
+      current = current[index]!;
+    } else if (current !== null && typeof current === "object") {
+      if (!hasOwn(current, token)) return { found: false };
+      current = current[token]!;
+    } else {
+      return { found: false };
+    }
+  }
+  return { found: true, value: current };
+}

package/src/procedures/json/diff.ts

@@ -0,0 +1,19 @@
+/**
+ * json.diff procedure
+ *
+ * Give the RFC 6902 JSON Patch that changes one JSON value into another. `json.patch` with this
+ * patch on `from` gives a value equal to `to`.
+ */
+
+import { diffJson } from "../../diff.js";
+import { assertJson } from "../../value.js";
+import type { JsonDiffInput, JsonDiffOutput } from "../../types.js";
+
+/**
+ * Give the RFC 6902 JSON Patch that changes one JSON value into another
+ */
+export async function jsonDiff(input: JsonDiffInput): Promise<JsonDiffOutput> {
+  assertJson(input.from, "json.diff: from");
+  assertJson(input.to, "json.diff: to");
+  return { patch: diffJson(input.from, input.to) };
+}

package/src/procedures/json/index.ts

@@ -0,0 +1,5 @@
+export { jsonQuery } from "./query.js";
+export { jsonPatch } from "./patch.js";
+export { jsonDiff } from "./diff.js";
+export { jsonMerge } from "./merge.js";
+export { jsonValidate } from "./validate.js";

package/src/procedures/json/merge.ts

@@ -0,0 +1,19 @@
+/**
+ * json.merge procedure
+ *
+ * Apply an RFC 7386 JSON merge patch to a JSON value. A member with the value null removes its
+ * key. A patch that is not an object replaces the value.
+ */
+
+import { mergePatch } from "../../merge.js";
+import { assertJson } from "../../value.js";
+import type { JsonMergeInput, JsonMergeOutput } from "../../types.js";
+
+/**
+ * Apply an RFC 7386 JSON merge patch to a JSON value
+ */
+export async function jsonMerge(input: JsonMergeInput): Promise<JsonMergeOutput> {
+  assertJson(input.target, "json.merge: target");
+  assertJson(input.patch, "json.merge: patch");
+  return { value: mergePatch(input.target, input.patch) };
+}

package/src/procedures/json/patch.ts

@@ -0,0 +1,21 @@
+/**
+ * json.patch procedure
+ *
+ * Apply an RFC 6902 JSON Patch to a JSON value. All operations apply or none. A failed `test`
+ * operation is an error with the code `TEST_FAILED`.
+ */
+
+import { applyPatch } from "../../patch.js";
+import { assertJson } from "../../value.js";
+import type { JsonPatchInput, JsonPatchOutput } from "../../types.js";
+
+/**
+ * Apply an RFC 6902 JSON Patch to a JSON value
+ */
+export async function jsonPatch(input: JsonPatchInput): Promise<JsonPatchOutput> {
+  assertJson(input.value, "json.patch: value");
+  input.patch.forEach((operation, index) => {
+    if (operation.value !== undefined) assertJson(operation.value, `json.patch: the value of operation ${index}`);
+  });
+  return { value: applyPatch(input.value, input.patch) };
+}

package/src/procedures/json/query.ts

@@ -0,0 +1,29 @@
+/**
+ * json.query procedure
+ *
+ * Find the values at a JSON Pointer or a path in a JSON value. A pointer gives one match or none.
+ * A path query can give more matches, in document order. Each match has its JSON Pointer.
+ */
+
+import { queryPath } from "../../path.js";
+import { lookup, parsePointer } from "../../pointer.js";
+import { assertJson, formatPointer, JsonError } from "../../value.js";
+import type { JsonQueryInput, JsonQueryOutput } from "../../types.js";
+
+/**
+ * Find the values at a JSON Pointer or a path in a JSON value
+ */
+export async function jsonQuery(input: JsonQueryInput): Promise<JsonQueryOutput> {
+  assertJson(input.value, "json.query: value");
+  if ((input.pointer === undefined) === (input.path === undefined)) {
+    throw new JsonError("INVALID_POINTER", "json.query: give one of pointer and path");
+  }
+  if (input.pointer !== undefined) {
+    const tokens = parsePointer(input.pointer);
+    const found = lookup(input.value, tokens);
+    if (!found.found) return { found: false, matches: [] };
+    return { found: true, value: found.value, matches: [{ pointer: formatPointer(tokens), value: found.value }] };
+  }
+  const matches = queryPath(input.value, input.path!).map((match) => ({ pointer: formatPointer(match.tokens), value: match.value }));
+  return matches.length === 0 ? { found: false, matches } : { found: true, value: matches[0]!.value, matches };
+}

package/src/procedures/json/validate.ts

@@ -0,0 +1,20 @@
+/**
+ * json.validate procedure
+ *
+ * Examine a JSON value against a JSON Schema. The check is a subset of JSON Schema (see
+ * `schema.ts`): `unchecked` lists the keywords of the schema that the check does not examine.
+ */
+
+import { validateJson } from "../../schema.js";
+import { assertJson } from "../../value.js";
+import type { JsonValidateInput, JsonValidateOutput } from "../../types.js";
+
+/**
+ * Examine a JSON value against a JSON Schema
+ */
+export async function jsonValidate(input: JsonValidateInput): Promise<JsonValidateOutput> {
+  assertJson(input.value, "json.validate: value");
+  assertJson(input.schema, "json.validate: schema");
+  const result = validateJson(input.value, input.schema);
+  return { valid: result.valid, errors: [...result.errors], unchecked: [...result.unchecked] };
+}

package/src/procedures/yaml/index.ts

@@ -0,0 +1,2 @@
+export { yamlParse } from "./parse.js";
+export { yamlStringify } from "./stringify.js";

package/src/procedures/yaml/parse.ts

@@ -0,0 +1,16 @@
+/**
+ * yaml.parse procedure
+ *
+ * Parse YAML text into a JSON value. With `all`, the text can have more than one document, and
+ * the value is the list of documents.
+ */
+
+import { parseYaml } from "../../yaml.js";
+import type { YamlParseInput, YamlParseOutput } from "../../types.js";
+
+/**
+ * Parse YAML text into a JSON value
+ */
+export async function yamlParse(input: YamlParseInput): Promise<YamlParseOutput> {
+  return { value: parseYaml(input.text, { all: input.all }) };
+}

package/src/procedures/yaml/stringify.ts

@@ -0,0 +1,17 @@
+/**
+ * yaml.stringify procedure
+ *
+ * Write a JSON value as YAML text. `yaml.parse` of the text gives a value equal to the input.
+ */
+
+import { assertJson } from "../../value.js";
+import { stringifyYaml } from "../../yaml.js";
+import type { YamlStringifyInput, YamlStringifyOutput } from "../../types.js";
+
+/**
+ * Write a JSON value as YAML text
+ */
+export async function yamlStringify(input: YamlStringifyInput): Promise<YamlStringifyOutput> {
+  assertJson(input.value, "yaml.stringify: value");
+  return { text: stringifyYaml(input.value, { indent: input.indent, lineWidth: input.lineWidth, sortKeys: input.sortKeys }) };
+}

package/src/register.ts

@@ -0,0 +1,10 @@
+/**
+ * Importing this file registers the procedures of @procedures/json in the global registry:
+ * `import "@procedures/json/register"`. The package root registers nothing.
+ */
+
+import { registerJsonProcedures } from "./module.js";
+
+export * from "./module.js";
+
+registerJsonProcedures();

package/src/schema.ts

@@ -0,0 +1,104 @@
+/**
+ * The check of a JSON value against a JSON Schema (`json.validate`).
+ *
+ * The check uses the validator of `@procedures/compiler` (`checkShape`), the validator that
+ * `program.check` uses for the inputs of a program. It is a subset of JSON Schema:
+ *
+ * - Examined: `type`, `enum`, `const`, `$ref` to the same schema (`#/...`), `allOf`, `anyOf`,
+ *   `oneOf` (as `anyOf`), `properties`, `required`, `additionalProperties`, `patternProperties`,
+ *   `items`, `prefixItems`, `additionalItems`, `minItems`, `maxItems`, `minLength`, `maxLength`,
+ *   `pattern`, `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum` and `multipleOf`.
+ * - Annotations without a check, as the standard tells: `format`, `title`, `description`,
+ *   `default`, `examples` and the other annotations.
+ * - Not examined: `not`, `if`, `then`, `else`, `uniqueItems`, `contains`, `minProperties`,
+ *   `maxProperties`, `propertyNames`, `dependentRequired`, `dependentSchemas`, `unevaluated*`, a
+ *   `$ref` to another document, and the others of `NOT_EXAMINED`. The output lists them in
+ *   `unchecked`, so a caller knows that the verdict is not complete.
+ *
+ * `minLength` and `maxLength` count UTF-16 code units, not code points.
+ */
+
+import { checkShape } from "@procedures/compiler";
+import { isPlainObject, JsonError, type JsonValue } from "./value.js";
+
+/** One problem of a value. */
+export interface ValidationIssue {
+  /** The JSON Pointer of the part of the value. */
+  readonly pointer: string;
+  readonly message: string;
+}
+
+/** The verdict of a check. */
+export interface ValidationResult {
+  readonly valid: boolean;
+  readonly errors: readonly ValidationIssue[];
+  /** The keywords of the schema that the check does not examine, or examines only in part. */
+  readonly unchecked: readonly string[];
+}
+
+/** The assertion keywords of JSON Schema that the subset does not examine. */
+export const NOT_EXAMINED: readonly string[] = [
+  "not",
+  "if",
+  "then",
+  "else",
+  "uniqueItems",
+  "contains",
+  "minContains",
+  "maxContains",
+  "minProperties",
+  "maxProperties",
+  "propertyNames",
+  "dependentRequired",
+  "dependentSchemas",
+  "dependencies",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "$dynamicRef",
+  "$recursiveRef",
+  "nullable",
+];
+
+/** The keywords whose value is one schema. */
+const ONE_SCHEMA = ["additionalProperties", "additionalItems", "items", "not", "if", "then", "else", "contains", "propertyNames", "unevaluatedItems", "unevaluatedProperties"];
+/** The keywords whose value is a list of schemas. */
+const SCHEMA_LIST = ["allOf", "anyOf", "oneOf", "prefixItems", "items"];
+/** The keywords whose value is a map of schemas. */
+const SCHEMA_MAP = ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"];
+
+/** The keywords of a schema and its subschemas that the check does not examine fully. */
+function uncheckedKeywords(schema: unknown): string[] {
+  const found = new Set<string>();
+  const seen = new Set<object>();
+  const visit = (node: unknown): void => {
+    if (!isPlainObject(node) || seen.has(node)) return;
+    seen.add(node);
+    for (const keyword of Object.keys(node)) {
+      if (NOT_EXAMINED.includes(keyword)) found.add(keyword);
+    }
+    if (node["oneOf"] !== undefined) found.add("oneOf (examined as anyOf)");
+    const ref = node["$ref"];
+    if (typeof ref === "string" && !(ref === "#" || ref.startsWith("#/"))) found.add(`$ref ${ref}`);
+    for (const keyword of ONE_SCHEMA) visit(node[keyword]);
+    for (const keyword of SCHEMA_LIST) {
+      const list = node[keyword];
+      if (Array.isArray(list)) list.forEach(visit);
+    }
+    for (const keyword of SCHEMA_MAP) {
+      const map = node[keyword];
+      if (isPlainObject(map)) Object.values(map).forEach(visit);
+    }
+  };
+  visit(schema);
+  return [...found].sort();
+}
+
+/** This function examines a JSON value against a JSON Schema. A schema that is not an object or a boolean throws. */
+export function validateJson(value: JsonValue, schema: unknown): ValidationResult {
+  if (typeof schema !== "boolean" && !isPlainObject(schema)) {
+    throw new JsonError("INVALID_SCHEMA", "json.validate: the schema is not an object or a boolean");
+  }
+  const issues = checkShape({ kind: "known", value, pointer: "" }, schema);
+  const errors = issues.map((issue) => ({ pointer: issue.pointer, message: issue.message }));
+  return { valid: errors.length === 0, errors, unchecked: uncheckedKeywords(schema) };
+}

package/src/types.ts

@@ -0,0 +1,127 @@
+/**
+ * Type definitions of the procedures of this package
+ *
+ * mark procedure new adds the types of each new procedure here. The zod schemas are in
+ * `module.ts`: an exported schema needs a written type (isolatedDeclarations).
+ */
+
+import type { PatchOperation } from "./patch.js";
+
+export type { JsonValue } from "./value.js";
+export type { PatchOperation } from "./patch.js";
+
+// =============================================================================
+// json.query Types - Find the values at a JSON Pointer or a path in a JSON value
+// =============================================================================
+
+export interface JsonQueryInput {
+  /** The JSON value to search. */
+  value: unknown;
+  /** A JSON Pointer (RFC 6901): `/items/0/name`. Give `pointer` or `path`. */
+  pointer?: string | undefined;
+  /** A path query: `items[*].name`, `$..id`. Give `pointer` or `path`. */
+  path?: string | undefined;
+}
+
+export interface JsonQueryOutput {
+  /** True when one or more values match. */
+  found: boolean;
+  /** The value of the first match. */
+  value?: unknown;
+  /** Each match, in document order: its JSON Pointer and its value. */
+  matches: Array<{ pointer: string; value?: unknown }>;
+}
+
+// =============================================================================
+// json.patch Types - Apply an RFC 6902 JSON Patch to a JSON value
+// =============================================================================
+
+export interface JsonPatchInput {
+  value: unknown;
+  /** The operations, in order. */
+  patch: PatchOperation[];
+}
+
+export interface JsonPatchOutput {
+  /** The value after the patch. */
+  value?: unknown;
+}
+
+// =============================================================================
+// json.diff Types - Give the RFC 6902 JSON Patch that changes one JSON value into another
+// =============================================================================
+
+export interface JsonDiffInput {
+  from: unknown;
+  to: unknown;
+}
+
+export interface JsonDiffOutput {
+  /** The operations that change `from` into `to`. Equal values give an empty list. */
+  patch: PatchOperation[];
+}
+
+// =============================================================================
+// json.merge Types - Apply an RFC 7386 JSON merge patch to a JSON value
+// =============================================================================
+
+export interface JsonMergeInput {
+  /** The value to change. */
+  target: unknown;
+  /** The merge patch: an object of changes, where null removes a key. */
+  patch: unknown;
+}
+
+export interface JsonMergeOutput {
+  value?: unknown;
+}
+
+// =============================================================================
+// json.validate Types - Examine a JSON value against a JSON Schema
+// =============================================================================
+
+export interface JsonValidateInput {
+  value: unknown;
+  /** The JSON Schema: an object or a boolean. */
+  schema: unknown;
+}
+
+export interface JsonValidateOutput {
+  valid: boolean;
+  /** Each problem: the JSON Pointer of the part of the value, and a message. */
+  errors: Array<{ pointer: string; message: string }>;
+  /** The keywords of the schema that the check does not examine. Empty: the verdict is complete. */
+  unchecked: string[];
+}
+
+// =============================================================================
+// yaml.parse Types - Parse YAML text into a JSON value
+// =============================================================================
+
+export interface YamlParseInput {
+  text: string;
+  /** True: the text can have more than one document, and `value` is the list of documents. */
+  all?: boolean | undefined;
+}
+
+export interface YamlParseOutput {
+  value?: unknown;
+}
+
+// =============================================================================
+// yaml.stringify Types - Write a JSON value as YAML text
+// =============================================================================
+
+export interface YamlStringifyInput {
+  value: unknown;
+  /** The spaces of one level of indentation: 1 to 8. The default is 2. */
+  indent?: number | undefined;
+  /** The longest line before a fold. 0: no fold. The default is 80. */
+  lineWidth?: number | undefined;
+  /** True: the keys of each map in alphabetical order. */
+  sortKeys?: boolean | undefined;
+}
+
+export interface YamlStringifyOutput {
+  text: string;
+}