@quilted/create 0.1.89 → 0.2.0

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/stringify/stringifyCollection.mjs

@@ -0,0 +1,162 @@
+import { Collection } from '../nodes/Collection.mjs';
+import { isNode, isPair } from '../nodes/Node.mjs';
+import { stringify } from './stringify.mjs';
+import { lineComment, indentComment } from './stringifyComment.mjs';
+
+function stringifyCollection(collection, ctx, options) {
+  const flow = ctx.inFlow ?? collection.flow;
+  const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;
+  return stringify(collection, ctx, options);
+}
+function stringifyBlockCollection({
+  comment,
+  items
+}, ctx, {
+  blockItemPrefix,
+  flowChars,
+  itemIndent,
+  onChompKeep,
+  onComment
+}) {
+  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 = [];
+  for (let i = 0; i < items.length; ++i) {
+    const item = items[i];
+    let comment = 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;
+  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({
+  comment,
+  items
+}, ctx, {
+  flowChars,
+  itemIndent,
+  onComment
+}) {
+  const {
+    indent,
+    indentStep,
+    options: {
+      commentString
+    }
+  } = ctx;
+  itemIndent += indentStep;
+  const itemCtx = Object.assign({}, ctx, {
+    indent: itemIndent,
+    inFlow: true,
+    type: null
+  });
+  let reqNewline = false;
+  let linesAtValue = 0;
+  const lines = [];
+  for (let i = 0; i < items.length; ++i) {
+    const item = items[i];
+    let comment = 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 && 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;
+  }
+  let str;
+  const {
+    start,
+    end
+  } = flowChars;
+  if (lines.length === 0) {
+    str = start + end;
+  } else {
+    if (!reqNewline) {
+      const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
+      reqNewline = len > Collection.maxFlowStringSingleLineLength;
+    }
+    if (reqNewline) {
+      str = start;
+      for (const line of lines) str += line ? `\n${indentStep}${indent}${line}` : '\n';
+      str += `\n${indent}${end}`;
+    } else {
+      str = `${start} ${lines.join(' ')} ${end}`;
+    }
+  }
+  if (comment) {
+    str += lineComment(str, commentString(comment), indent);
+    if (onComment) onComment();
+  }
+  return str;
+}
+function addCommentBefore({
+  indent,
+  options: {
+    commentString
+  }
+}, lines, comment, chompKeep) {
+  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
+  }
+}
+
+export { stringifyCollection };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/stringify/stringifyComment.mjs

@@ -0,0 +1,15 @@
+/**
+ * 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 `#`.
+ */
+const stringifyComment = str => str.replace(/^(?!$)(?: $)?/gm, '#');
+function indentComment(comment, indent) {
+  if (/^\n+$/.test(comment)) return comment.substring(1);
+  return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
+}
+const lineComment = (str, indent, comment) => str.endsWith('\n') ? indentComment(comment, indent) : comment.includes('\n') ? '\n' + indentComment(comment, indent) : (str.endsWith(' ') ? '' : ' ') + comment;
+
+export { indentComment, lineComment, stringifyComment };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/stringify/stringifyDocument.mjs

@@ -0,0 +1,72 @@
+import { isNode } from '../nodes/Node.mjs';
+import { createStringifyContext, stringify } from './stringify.mjs';
+import { indentComment, lineComment } from './stringifyComment.mjs';
+
+function stringifyDocument(doc, options) {
+  const lines = [];
+  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 = 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';
+}
+
+export { stringifyDocument };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/stringify/stringifyNumber.mjs

@@ -0,0 +1,23 @@
+function stringifyNumber({
+  format,
+  minFractionDigits,
+  tag,
+  value
+}) {
+  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 = 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;
+}
+
+export { stringifyNumber };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/stringify/stringifyPair.mjs

@@ -0,0 +1,103 @@
+import { isNode, isCollection, isScalar, isSeq } from '../nodes/Node.mjs';
+import { Scalar } from '../nodes/Scalar.mjs';
+import { stringify } from './stringify.mjs';
+import { lineComment, indentComment } from './stringifyComment.mjs';
+
+function stringifyPair({
+  key,
+  value
+}, ctx, onComment, onChompKeep) {
+  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)) {
+      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 vcb = '';
+  let valueComment = null;
+  if (isNode(value)) {
+    if (value.spaceBefore) vcb = '\n';
+    if (value.commentBefore) {
+      const cs = commentString(value.commentBefore);
+      vcb += `\n${indentComment(cs, ctx.indent)}`;
+    }
+    valueComment = value.comment;
+  } else 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.substr(2);
+  }
+  let valueCommentDone = false;
+  const valueStr = stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true);
+  let ws = ' ';
+  if (vcb || keyComment) {
+    if (valueStr === '' && !ctx.inFlow) ws = vcb === '\n' ? '\n\n' : vcb;else ws = `${vcb}\n${ctx.indent}`;
+  } else if (!explicitKey && isCollection(value)) {
+    const flow = valueStr[0] === '[' || valueStr[0] === '{';
+    if (!flow || valueStr.includes('\n')) 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;
+}
+
+export { stringifyPair };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/stringify/stringifyString.mjs

@@ -0,0 +1,283 @@
+import { Scalar } from '../nodes/Scalar.mjs';
+import { foldFlowLines, FOLD_QUOTED, FOLD_FLOW, FOLD_BLOCK } from './foldFlowLines.mjs';
+
+const getFoldOptions = ctx => ({
+  indentAtStart: 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 => /^(%|---|\.\.\.)/m.test(str);
+function lineLengthOverLimit(str, lineWidth, indentLength) {
+  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, ctx) {
+  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));
+}
+function singleQuotedString(value, ctx) {
+  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));
+}
+function quotedString(value, ctx) {
+  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);
+}
+function blockString({
+  comment,
+  type,
+  value
+}, ctx, onComment, onChompKeep) {
+  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) || /^\s*$/.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;
+  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(/\n+(?!\n|$)/g, `$&${indent}`);
+  }
+  // determine indent indicator from whitespace at value start
+  let startWithSpace = false;
+  let startEnd;
+  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
+  let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
+  if (comment) {
+    header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' '));
+    if (onComment) onComment();
+  }
+  if (literal) {
+    value = value.replace(/\n+/g, `$&${indent}`);
+    return `${header}\n${indent}${start}${value}${end}`;
+  }
+  value = 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}`);
+  const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx));
+  return `${header}\n${indent}${body}`;
+}
+function plainString(item, ctx, onComment, onChompKeep) {
+  const {
+    type,
+    value
+  } = item;
+  const {
+    actualString,
+    implicitKey,
+    indent,
+    inFlow
+  } = ctx;
+  if (implicitKey && /[\n[\]{},]/.test(value) || inFlow && /[[\]{},]/.test(value)) {
+    return quotedString(value, ctx);
+  }
+  if (!value || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
+    // not allowed:
+    // - empty string, '-' 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 (indent === '' && containsDocumentMarker(value)) {
+    ctx.forceBlockIndent = true;
+    return blockString(item, ctx, onComment, onChompKeep);
+  }
+  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 => 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));
+}
+function stringifyString(item, ctx, onComment, onChompKeep) {
+  const {
+    implicitKey,
+    inFlow
+  } = ctx;
+  const ss = typeof item.value === 'string' ? item : 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 => {
+    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;
+}
+
+export { stringifyString };