@quilted/create 0.1.90 → 0.2.1

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/composer.mjs

@@ -0,0 +1,209 @@
+import { Directives } from '../doc/directives.mjs';
+import { Document } from '../doc/Document.mjs';
+import { YAMLWarning, YAMLParseError } from '../errors.mjs';
+import { isCollection, isPair } from '../nodes/Node.mjs';
+import { composeDoc } from './compose-doc.mjs';
+import { resolveEnd } from './resolve-end.mjs';
+
+function getErrorPos(src) {
+  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) {
+  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)
+ * ```
+ */
+class Composer {
+  constructor(options = {}) {
+    this.doc = null;
+    this.atDirectives = false;
+    this.prelude = [];
+    this.errors = [];
+    this.warnings = [];
+    this.onError = (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));
+    };
+    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+    this.directives = new Directives({
+      version: options.version || '1.2'
+    });
+    this.options = options;
+  }
+  decorate(doc, afterDoc) {
+    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() {
+    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, forceDoc = false, endOffset = -1) {
+    for (const token of tokens) yield* this.next(token);
+    yield* this.end(forceDoc, endOffset);
+  }
+  /** Advance the composer by one CST token. */
+  *next(token) {
+    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) {
+    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);
+      if (this.atDirectives) this.onError(endOffset, 'MISSING_CHAR', 'Missing directives-end indicator line');
+      doc.range = [0, endOffset, endOffset];
+      this.decorate(doc, false);
+      yield doc;
+    }
+  }
+}
+
+export { Composer };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/resolve-block-map.mjs

@@ -0,0 +1,90 @@
+import { Pair } from '../nodes/Pair.mjs';
+import { YAMLMap } from '../nodes/YAMLMap.mjs';
+import { resolveProps } from './resolve-props.mjs';
+import { containsNewline } from './util-contains-newline.mjs';
+import { flowIndentCheck } from './util-flow-indent-check.mjs';
+import { mapIncludes } from './util-map-includes.mjs';
+
+const startColMsg = 'All mapping items must start at the same column';
+function resolveBlockMap({
+  composeNode,
+  composeEmptyNode
+}, ctx, bm, onError) {
+  const map = new YAMLMap(ctx.schema);
+  if (ctx.atRoot) ctx.atRoot = false;
+  let offset = bm.offset;
+  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,
+      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) {
+        // TODO: assert being at last item?
+        if (keyProps.comment) {
+          if (map.comment) map.comment += '\n' + keyProps.comment;else map.comment = keyProps.comment;
+        }
+        continue;
+      }
+      if (keyProps.hasNewlineAfterProp || 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
+    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);
+    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,
+      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 = new Pair(keyNode);
+      if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+      map.items.push(pair);
+    }
+  }
+  map.range = [bm.offset, offset, offset];
+  return map;
+}
+
+export { resolveBlockMap };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/resolve-block-scalar.mjs

@@ -0,0 +1,185 @@
+import { Scalar } from '../nodes/Scalar.mjs';
+
+function resolveBlockScalar(scalar, strict, onError) {
+  const start = scalar.offset;
+  const header = parseBlockScalarHeader(scalar, 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;
+      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
+}, strict, onError) {
+  /* 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];
+  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.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) {
+  const split = source.split(/\n( *)/);
+  const first = split[0];
+  const m = first.match(/^( *)/);
+  const line0 = 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;
+}
+
+export { resolveBlockScalar };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/resolve-block-seq.mjs

@@ -0,0 +1,42 @@
+import { YAMLSeq } from '../nodes/YAMLSeq.mjs';
+import { resolveProps } from './resolve-props.mjs';
+import { flowIndentCheck } from './util-flow-indent-check.mjs';
+
+function resolveBlockSeq({
+  composeNode,
+  composeEmptyNode
+}, ctx, bs, onError) {
+  const seq = new YAMLSeq(ctx.schema);
+  if (ctx.atRoot) ctx.atRoot = false;
+  let offset = bs.offset;
+  for (const {
+    start,
+    value
+  } of bs.items) {
+    const props = resolveProps(start, {
+      indicator: 'seq-item-ind',
+      next: value,
+      offset,
+      onError,
+      startOnNewline: true
+    });
+    offset = props.end;
+    if (!props.found) {
+      if (props.anchor || props.tag || value) {
+        if (value && value.type === 'block-seq') onError(offset, 'BAD_INDENT', 'All sequence items must start at the same column');else onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator');
+      } else {
+        // TODO: assert being at last item?
+        if (props.comment) seq.comment = props.comment;
+        continue;
+      }
+    }
+    const node = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, offset, 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, offset];
+  return seq;
+}
+
+export { resolveBlockSeq };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/resolve-end.mjs

@@ -0,0 +1,39 @@
+function resolveEnd(end, offset, reqSpace, onError) {
+  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
+  };
+}
+
+export { resolveEnd };