projen 0.51.7 → 0.51.11

package/node_modules/yaml/dist/stringify/stringifyString.js

@@ -0,0 +1,316 @@
+'use strict';
+
+var Scalar = require('../nodes/Scalar.js');
+var foldFlowLines = require('./foldFlowLines.js');
+
+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.foldFlowLines(str, indent, foldFlowLines.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.foldFlowLines(res, indent, foldFlowLines.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.Scalar.BLOCK_FOLDED
+            ? false
+            : type === Scalar.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.foldFlowLines(`${start}${value}${end}`, indent, foldFlowLines.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.indexOf('\n') === -1
+            ? quotedString(value, ctx)
+            : blockString(item, ctx, onComment, onChompKeep);
+    }
+    if (!implicitKey &&
+        !inFlow &&
+        type !== Scalar.Scalar.PLAIN &&
+        value.indexOf('\n') !== -1) {
+        // 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) => { var _a; return tag.default && tag.tag !== 'tag:yaml.org,2002:str' && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(str)); };
+        const { compat, tags } = ctx.doc.schema;
+        if (tags.some(test) || (compat === null || compat === void 0 ? void 0 : compat.some(test)))
+            return quotedString(value, ctx);
+    }
+    return implicitKey
+        ? str
+        : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.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.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.Scalar.QUOTE_DOUBLE;
+    }
+    const _stringify = (_type) => {
+        switch (_type) {
+            case Scalar.Scalar.BLOCK_FOLDED:
+            case Scalar.Scalar.BLOCK_LITERAL:
+                return implicitKey || inFlow
+                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers
+                    : blockString(ss, ctx, onComment, onChompKeep);
+            case Scalar.Scalar.QUOTE_DOUBLE:
+                return doubleQuotedString(ss.value, ctx);
+            case Scalar.Scalar.QUOTE_SINGLE:
+                return singleQuotedString(ss.value, ctx);
+            case Scalar.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;
+}
+
+exports.stringifyString = stringifyString;

package/node_modules/yaml/dist/test-events.d.ts

@@ -0,0 +1,4 @@
+export declare function testEvents(src: string): {
+    events: string[];
+    error: unknown;
+};

package/node_modules/yaml/dist/test-events.js

@@ -1,162 +1,136 @@
 'use strict';
 
-var parseCst = require('./parse-cst.js');
-var Document = require('./Document-9b4560a1.js');
-require('./PlainValue-ec8e588e.js');
-require('./resolveSeq-d03cb037.js');
-require('./Schema-88e323a7.js');
-require('./warnings-1000a372.js');
-
-function testEvents(src, options) {
-  const opt = Object.assign({
-    keepCstNodes: true,
-    keepNodeTypes: true,
-    version: '1.2'
-  }, options);
-  const docs = parseCst.parse(src).map(cstDoc => new Document.Document(opt).parse(cstDoc));
-  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, rootEnd] = doc.range || [0, 0];
-      let e = doc.errors[0] && doc.errors[0].source;
-      if (e && e.type === 'SEQ_ITEM') e = e.node;
-      if (e && (e.type === 'DOCUMENT' || e.range.start < rootStart)) throw new Error();
-      let docStart = '+DOC';
-      const pre = src.slice(0, rootStart);
-      const explicitDoc = /---\s*$/.test(pre);
-      if (explicitDoc) docStart += ' ---';else if (!doc.contents) continue;
-      events.push(docStart);
-      addEvents(events, doc, e, root);
-      if (doc.contents && doc.contents.length > 1) throw new Error();
-      let docEnd = '-DOC';
-
-      if (rootEnd) {
-        const post = src.slice(rootEnd);
-        if (/^\.\.\./.test(post)) docEnd += ' ...';
-      }
-
-      events.push(docEnd);
+var Node = require('./nodes/Node.js');
+var publicApi = require('./public-api.js');
+var visit = require('./visit.js');
+
+const scalarChar = {
+    BLOCK_FOLDED: '>',
+    BLOCK_LITERAL: '|',
+    PLAIN: ':',
+    QUOTE_DOUBLE: '"',
+    QUOTE_SINGLE: "'"
+};
+function anchorExists(doc, anchor) {
+    let found = false;
+    visit.visit(doc, {
+        Value(_key, node) {
+            if (node.anchor === anchor) {
+                found = true;
+                return visit.visit.BREAK;
+            }
+        }
+    });
+    return found;
+}
+// test harness for yaml-test-suite event tests
+function testEvents(src) {
+    var _a;
+    const docs = publicApi.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];
+            // eslint-disable-next-line no-sparse-arrays
+            const [rootStart, , rootEnd] = doc.range || [0, , 0];
+            const error = doc.errors[0];
+            if (error && (!error.pos || error.pos[0] < rootStart))
+                throw new Error();
+            let docStart = '+DOC';
+            if (doc.directives.marker)
+                docStart += ' ---';
+            else if (doc.contents && doc.contents.range[2] === doc.contents.range[0])
+                continue;
+            events.push(docStart);
+            addEvents(events, doc, (_a = error === null || error === void 0 ? void 0 : error.pos[0]) !== null && _a !== void 0 ? _a : -1, root);
+            let docEnd = '-DOC';
+            if (rootEnd) {
+                const post = src.slice(rootStart, rootEnd);
+                if (/^\.\.\.($|\s)/m.test(post))
+                    docEnd += ' ...';
+            }
+            events.push(docEnd);
+        }
     }
-  } catch (e) {
-    return {
-      events,
-      error: error || e
-    };
-  }
-
-  events.push('-STR');
-  return {
-    events,
-    error
-  };
+    catch (e) {
+        return { events, error: error || e };
+    }
+    events.push('-STR');
+    return { events, error };
 }
-
-function addEvents(events, doc, e, node) {
-  if (!node) {
-    events.push('=VAL :');
-    return;
-  }
-
-  if (e && node.cstNode === e) throw new Error();
-  let props = '';
-  let anchor = doc.anchors.getName(node);
-
-  if (anchor) {
-    if (/\d$/.test(anchor)) {
-      const alt = anchor.replace(/\d$/, '');
-      if (doc.anchors.getNode(alt)) anchor = alt;
+function addEvents(events, doc, errPos, node) {
+    if (!node) {
+        events.push('=VAL :');
+        return;
     }
-
-    props = ` &${anchor}`;
-  }
-
-  if (node.cstNode && node.cstNode.tag) {
-    const {
-      handle,
-      suffix
-    } = node.cstNode.tag;
-    props += handle === '!' && !suffix ? ' <!>' : ` <${node.tag}>`;
-  }
-
-  let scalar = null;
-
-  switch (node.type) {
-    case 'ALIAS':
-      {
-        let alias = doc.anchors.getName(node.source);
-
-        if (/\d$/.test(alias)) {
-          const alt = alias.replace(/\d$/, '');
-          if (doc.anchors.getNode(alt)) alias = alt;
+    if (errPos !== -1 && Node.isNode(node) && node.range[0] >= errPos)
+        throw new Error();
+    let props = '';
+    let anchor = Node.isScalar(node) || 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 (Node.isNode(node) && node.tag)
+        props += ` <${node.tag}>`;
+    if (Node.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 (Node.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 (Node.isPair(node)) {
+        events.push(`+MAP${props}`);
+        addEvents(events, doc, errPos, node.key);
+        addEvents(events, doc, errPos, node.value);
+        events.push('-MAP');
+    }
+    else if (Node.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}`);
-      }
-      break;
-
-    case 'BLOCK_FOLDED':
-      scalar = '>';
-      break;
-
-    case 'BLOCK_LITERAL':
-      scalar = '|';
-      break;
-
-    case 'PLAIN':
-      scalar = ':';
-      break;
-
-    case 'QUOTE_DOUBLE':
-      scalar = '"';
-      break;
-
-    case 'QUOTE_SINGLE':
-      scalar = "'";
-      break;
-
-    case 'PAIR':
-      events.push(`+MAP${props}`);
-      addEvents(events, doc, e, node.key);
-      addEvents(events, doc, e, node.value);
-      events.push('-MAP');
-      break;
-
-    case 'FLOW_SEQ':
-    case 'SEQ':
-      events.push(`+SEQ${props}`);
-      node.items.forEach(item => {
-        addEvents(events, doc, e, item);
-      });
-      events.push('-SEQ');
-      break;
-
-    case 'FLOW_MAP':
-    case 'MAP':
-      events.push(`+MAP${props}`);
-      node.items.forEach(({
-        key,
-        value
-      }) => {
-        addEvents(events, doc, e, key);
-        addEvents(events, doc, e, value);
-      });
-      events.push('-MAP');
-      break;
-
-    default:
-      throw new Error(`Unexpected node type ${node.type}`);
-  }
-
-  if (scalar) {
-    const value = node.cstNode.strValue.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}`);
-  }
+    }
+    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}`);
+    }
 }
 
 exports.testEvents = testEvents;

package/node_modules/yaml/dist/util.d.ts

@@ -0,0 +1,9 @@
+export { debug, LogLevelId, warn } from './log.js';
+export { findPair } from './nodes/YAMLMap.js';
+export { toJS, ToJSContext } from './nodes/toJS.js';
+export { map as mapTag } from './schema/common/map.js';
+export { seq as seqTag } from './schema/common/seq.js';
+export { string as stringTag } from './schema/common/string.js';
+export { foldFlowLines } from './stringify/foldFlowLines';
+export { stringifyNumber } from './stringify/stringifyNumber.js';
+export { stringifyString } from './stringify/stringifyString.js';

package/node_modules/yaml/dist/util.js

@@ -1,19 +1,24 @@
 'use strict';
 
-var resolveSeq = require('./resolveSeq-d03cb037.js');
-var PlainValue = require('./PlainValue-ec8e588e.js');
+var log = require('./log.js');
+var YAMLMap = require('./nodes/YAMLMap.js');
+var toJS = require('./nodes/toJS.js');
+var map = require('./schema/common/map.js');
+var seq = require('./schema/common/seq.js');
+var string = require('./schema/common/string.js');
+var foldFlowLines = require('./stringify/foldFlowLines.js');
+var stringifyNumber = require('./stringify/stringifyNumber.js');
+var stringifyString = require('./stringify/stringifyString.js');
 
 
 
-exports.findPair = resolveSeq.findPair;
-exports.parseMap = resolveSeq.resolveMap;
-exports.parseSeq = resolveSeq.resolveSeq;
-exports.stringifyNumber = resolveSeq.stringifyNumber;
-exports.stringifyString = resolveSeq.stringifyString;
-exports.toJSON = resolveSeq.toJSON;
-exports.Type = PlainValue.Type;
-exports.YAMLError = PlainValue.YAMLError;
-exports.YAMLReferenceError = PlainValue.YAMLReferenceError;
-exports.YAMLSemanticError = PlainValue.YAMLSemanticError;
-exports.YAMLSyntaxError = PlainValue.YAMLSyntaxError;
-exports.YAMLWarning = PlainValue.YAMLWarning;
+exports.debug = log.debug;
+exports.warn = log.warn;
+exports.findPair = YAMLMap.findPair;
+exports.toJS = toJS.toJS;
+exports.mapTag = map.map;
+exports.seqTag = seq.seq;
+exports.stringTag = string.string;
+exports.foldFlowLines = foldFlowLines.foldFlowLines;
+exports.stringifyNumber = stringifyNumber.stringifyNumber;
+exports.stringifyString = stringifyString.stringifyString;