@quilted/create 0.1.90 → 0.2.1

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

@@ -0,0 +1,157 @@
+import { isPair } from '../nodes/Node.mjs';
+import { Pair } from '../nodes/Pair.mjs';
+import { YAMLMap } from '../nodes/YAMLMap.mjs';
+import { YAMLSeq } from '../nodes/YAMLSeq.mjs';
+import { resolveEnd } from './resolve-end.mjs';
+import { resolveProps } from './resolve-props.mjs';
+import { containsNewline } from './util-contains-newline.mjs';
+import { mapIncludes } from './util-map-includes.mjs';
+
+const blockMsg = 'Block collections are not allowed within flow collections';
+const isBlock = token => token && (token.type === 'block-map' || token.type === 'block-seq');
+function resolveFlowCollection({
+  composeNode,
+  composeEmptyNode
+}, ctx, fc, onError) {
+  const isMap = fc.start.source === '{';
+  const fcName = isMap ? 'flow map' : 'flow sequence';
+  const coll = isMap ? new YAMLMap(ctx.schema) : new YAMLSeq(ctx.schema);
+  coll.flow = true;
+  const atRoot = ctx.atRoot;
+  if (atRoot) ctx.atRoot = false;
+  let offset = fc.offset + fc.start.source.length;
+  for (let i = 0; i < fc.items.length; ++i) {
+    const collItem = fc.items[i];
+    const {
+      start,
+      key,
+      sep,
+      value
+    } = collItem;
+    const props = resolveProps(start, {
+      flow: fcName,
+      indicator: 'explicit-key-ind',
+      next: key ?? sep?.[0],
+      offset,
+      onError,
+      startOnNewline: false
+    });
+    if (!props.found) {
+      if (!props.anchor && !props.tag && !sep && !value) {
+        if (i === 0 && props.comma) onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`);else if (i < fc.items.length - 1) onError(props.start, 'UNEXPECTED_TOKEN', `Unexpected empty item in ${fcName}`);
+        if (props.comment) {
+          if (coll.comment) coll.comment += '\n' + props.comment;else coll.comment = props.comment;
+        }
+        offset = props.end;
+        continue;
+      }
+      if (!isMap && ctx.options.strict && containsNewline(key)) onError(key,
+      // checked by containsNewline()
+      'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
+    }
+    if (i === 0) {
+      if (props.comma) onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`);
+    } else {
+      if (!props.comma) onError(props.start, 'MISSING_CHAR', `Missing , between ${fcName} items`);
+      if (props.comment) {
+        let prevItemComment = '';
+        loop: for (const st of start) {
+          switch (st.type) {
+            case 'comma':
+            case 'space':
+              break;
+            case 'comment':
+              prevItemComment = st.source.substring(1);
+              break loop;
+            default:
+              break loop;
+          }
+        }
+        if (prevItemComment) {
+          let prev = coll.items[coll.items.length - 1];
+          if (isPair(prev)) prev = prev.value ?? prev.key;
+          if (prev.comment) prev.comment += '\n' + prevItemComment;else prev.comment = prevItemComment;
+          props.comment = props.comment.substring(prevItemComment.length + 1);
+        }
+      }
+    }
+    if (!isMap && !sep && !props.found) {
+      // item is a value in a seq
+      // → key & sep are empty, start does not include ? or :
+      const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+      coll.items.push(valueNode);
+      offset = valueNode.range[2];
+      if (isBlock(value)) onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg);
+    } else {
+      // item is a key+value pair
+      // key value
+      const keyStart = props.end;
+      const keyNode = key ? composeNode(ctx, key, props, onError) : composeEmptyNode(ctx, keyStart, start, null, props, onError);
+      if (isBlock(key)) onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
+      // value properties
+      const valueProps = resolveProps(sep ?? [], {
+        flow: fcName,
+        indicator: 'map-value-ind',
+        next: value,
+        offset: keyNode.range[2],
+        onError,
+        startOnNewline: false
+      });
+      if (valueProps.found) {
+        if (!isMap && !props.found && ctx.options.strict) {
+          if (sep) for (const st of sep) {
+            if (st === valueProps.found) break;
+            if (st.type === 'newline') {
+              onError(st, 'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
+              break;
+            }
+          }
+          if (props.start < valueProps.found.offset - 1024) onError(valueProps.found, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit flow sequence key');
+        }
+      } else if (value) {
+        if ('source' in value && value.source && value.source[0] === ':') onError(value, 'MISSING_CHAR', `Missing space after : in ${fcName}`);else onError(valueProps.start, 'MISSING_CHAR', `Missing , or : between ${fcName} items`);
+      }
+      // value value
+      const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+      if (valueNode) {
+        if (isBlock(value)) onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg);
+      } else if (valueProps.comment) {
+        if (keyNode.comment) keyNode.comment += '\n' + valueProps.comment;else keyNode.comment = valueProps.comment;
+      }
+      const pair = new Pair(keyNode, valueNode);
+      if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+      if (isMap) {
+        const map = coll;
+        if (mapIncludes(ctx, map.items, keyNode)) onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
+        map.items.push(pair);
+      } else {
+        const map = new YAMLMap(ctx.schema);
+        map.flow = true;
+        map.items.push(pair);
+        coll.items.push(map);
+      }
+      offset = valueNode ? valueNode.range[2] : valueProps.end;
+    }
+  }
+  const expectedEnd = isMap ? '}' : ']';
+  const [ce, ...ee] = fc.end;
+  let cePos = offset;
+  if (ce && ce.source === expectedEnd) cePos = ce.offset + ce.source.length;else {
+    const name = fcName[0].toUpperCase() + fcName.substring(1);
+    const msg = atRoot ? `${name} must end with a ${expectedEnd}` : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
+    onError(offset, atRoot ? 'MISSING_CHAR' : 'BAD_INDENT', msg);
+    if (ce && ce.source.length !== 1) ee.unshift(ce);
+  }
+  if (ee.length > 0) {
+    const end = resolveEnd(ee, cePos, ctx.options.strict, onError);
+    if (end.comment) {
+      if (coll.comment) coll.comment += '\n' + end.comment;else coll.comment = end.comment;
+    }
+    coll.range = [fc.offset, cePos, end.offset];
+  } else {
+    coll.range = [fc.offset, cePos, cePos];
+  }
+  return coll;
+}
+
+export { resolveFlowCollection };

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

@@ -0,0 +1,215 @@
+import { Scalar } from '../nodes/Scalar.mjs';
+import { resolveEnd } from './resolve-end.mjs';
+
+function resolveFlowScalar(scalar, strict, onError) {
+  const {
+    offset,
+    type,
+    source,
+    end
+  } = scalar;
+  let _type;
+  let value;
+  const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
+  switch (type) {
+    case 'scalar':
+      _type = Scalar.PLAIN;
+      value = plainValue(source, _onError);
+      break;
+    case 'single-quoted-scalar':
+      _type = Scalar.QUOTE_SINGLE;
+      value = singleQuotedValue(source, _onError);
+      break;
+    case 'double-quoted-scalar':
+      _type = Scalar.QUOTE_DOUBLE;
+      value = doubleQuotedValue(source, _onError);
+      break;
+    /* istanbul ignore next should not happen */
+    default:
+      onError(scalar, 'UNEXPECTED_TOKEN', `Expected a flow scalar value, but found: ${type}`);
+      return {
+        value: '',
+        type: null,
+        comment: '',
+        range: [offset, offset + source.length, offset + source.length]
+      };
+  }
+  const valueEnd = offset + source.length;
+  const re = resolveEnd(end, valueEnd, strict, onError);
+  return {
+    value,
+    type: _type,
+    comment: re.comment,
+    range: [offset, valueEnd, re.offset]
+  };
+}
+function plainValue(source, onError) {
+  let badChar = '';
+  switch (source[0]) {
+    /* istanbul ignore next should not happen */
+    case '\t':
+      badChar = 'a tab character';
+      break;
+    case ',':
+      badChar = 'flow indicator character ,';
+      break;
+    case '%':
+      badChar = 'directive indicator character %';
+      break;
+    case '|':
+    case '>':
+      {
+        badChar = `block scalar indicator ${source[0]}`;
+        break;
+      }
+    case '@':
+    case '`':
+      {
+        badChar = `reserved character ${source[0]}`;
+        break;
+      }
+  }
+  if (badChar) onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
+  return foldLines(source);
+}
+function singleQuotedValue(source, onError) {
+  if (source[source.length - 1] !== "'" || source.length === 1) onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
+  return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+}
+function foldLines(source) {
+  /**
+   * The negative lookbehind here and in the `re` RegExp is to
+   * prevent causing a polynomial search time in certain cases.
+   *
+   * The try-catch is for Safari, which doesn't support this yet:
+   * https://caniuse.com/js-regexp-lookbehind
+   */
+  let first, line;
+  try {
+    first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
+    line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+  } catch (_) {
+    first = /(.*?)[ \t]*\r?\n/sy;
+    line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+  }
+  let match = first.exec(source);
+  if (!match) return source;
+  let res = match[1];
+  let sep = ' ';
+  let pos = first.lastIndex;
+  line.lastIndex = pos;
+  while (match = line.exec(source)) {
+    if (match[1] === '') {
+      if (sep === '\n') res += sep;else sep = '\n';
+    } else {
+      res += sep + match[1];
+      sep = ' ';
+    }
+    pos = line.lastIndex;
+  }
+  const last = /[ \t]*(.*)/sy;
+  last.lastIndex = pos;
+  match = last.exec(source);
+  return res + sep + (match?.[1] ?? '');
+}
+function doubleQuotedValue(source, onError) {
+  let res = '';
+  for (let i = 1; i < source.length - 1; ++i) {
+    const ch = source[i];
+    if (ch === '\r' && source[i + 1] === '\n') continue;
+    if (ch === '\n') {
+      const {
+        fold,
+        offset
+      } = foldNewline(source, i);
+      res += fold;
+      i = offset;
+    } else if (ch === '\\') {
+      let next = source[++i];
+      const cc = escapeCodes[next];
+      if (cc) res += cc;else if (next === '\n') {
+        // skip escaped newlines, but still trim the following line
+        next = source[i + 1];
+        while (next === ' ' || next === '\t') next = source[++i + 1];
+      } else if (next === '\r' && source[i + 1] === '\n') {
+        // skip escaped CRLF newlines, but still trim the following line
+        next = source[++i + 1];
+        while (next === ' ' || next === '\t') next = source[++i + 1];
+      } else if (next === 'x' || next === 'u' || next === 'U') {
+        const length = {
+          x: 2,
+          u: 4,
+          U: 8
+        }[next];
+        res += parseCharCode(source, i + 1, length, onError);
+        i += length;
+      } else {
+        const raw = source.substr(i - 1, 2);
+        onError(i - 1, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
+        res += raw;
+      }
+    } else if (ch === ' ' || ch === '\t') {
+      // trim trailing whitespace
+      const wsStart = i;
+      let next = source[i + 1];
+      while (next === ' ' || next === '\t') next = source[++i + 1];
+      if (next !== '\n' && !(next === '\r' && source[i + 2] === '\n')) res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
+    } else {
+      res += ch;
+    }
+  }
+  if (source[source.length - 1] !== '"' || source.length === 1) onError(source.length, 'MISSING_CHAR', 'Missing closing "quote');
+  return res;
+}
+/**
+ * Fold a single newline into a space, multiple newlines to N - 1 newlines.
+ * Presumes `source[offset] === '\n'`
+ */
+function foldNewline(source, offset) {
+  let fold = '';
+  let ch = source[offset + 1];
+  while (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+    if (ch === '\r' && source[offset + 2] !== '\n') break;
+    if (ch === '\n') fold += '\n';
+    offset += 1;
+    ch = source[offset + 1];
+  }
+  if (!fold) fold = ' ';
+  return {
+    fold,
+    offset
+  };
+}
+const escapeCodes = {
+  '0': '\0',
+  a: '\x07',
+  b: '\b',
+  e: '\x1b',
+  f: '\f',
+  n: '\n',
+  r: '\r',
+  t: '\t',
+  v: '\v',
+  N: '\u0085',
+  _: '\u00a0',
+  L: '\u2028',
+  P: '\u2029',
+  ' ': ' ',
+  '"': '"',
+  '/': '/',
+  '\\': '\\',
+  '\t': '\t'
+};
+function parseCharCode(source, offset, length, onError) {
+  const cc = source.substr(offset, length);
+  const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
+  const code = ok ? parseInt(cc, 16) : NaN;
+  if (isNaN(code)) {
+    const raw = source.substr(offset - 2, length + 2);
+    onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
+    return raw;
+  }
+  return String.fromCodePoint(code);
+}
+
+export { resolveFlowScalar };

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

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

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/util-contains-newline.mjs

@@ -0,0 +1,23 @@
+function containsNewline(key) {
+  if (!key) return null;
+  switch (key.type) {
+    case 'alias':
+    case 'scalar':
+    case 'double-quoted-scalar':
+    case 'single-quoted-scalar':
+      if (key.source.includes('\n')) return true;
+      if (key.end) for (const st of key.end) if (st.type === 'newline') return true;
+      return false;
+    case 'flow-collection':
+      for (const it of key.items) {
+        for (const st of it.start) if (st.type === 'newline') return true;
+        if (it.sep) for (const st of it.sep) if (st.type === 'newline') return true;
+        if (containsNewline(it.key) || containsNewline(it.value)) return true;
+      }
+      return false;
+    default:
+      return true;
+  }
+}
+
+export { containsNewline };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/util-empty-scalar-position.mjs

@@ -0,0 +1,26 @@
+function emptyScalarPosition(offset, before, pos) {
+  if (before) {
+    if (pos === null) pos = before.length;
+    for (let i = pos - 1; i >= 0; --i) {
+      let st = before[i];
+      switch (st.type) {
+        case 'space':
+        case 'comment':
+        case 'newline':
+          offset -= st.source.length;
+          continue;
+      }
+      // Technically, an empty scalar is immediately after the last non-empty
+      // node, but it's more useful to place it after any whitespace.
+      st = before[++i];
+      while (st?.type === 'space') {
+        offset += st.source.length;
+        st = before[++i];
+      }
+      break;
+    }
+  }
+  return offset;
+}
+
+export { emptyScalarPosition };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/util-flow-indent-check.mjs

@@ -0,0 +1,13 @@
+import { containsNewline } from './util-contains-newline.mjs';
+
+function flowIndentCheck(indent, fc, onError) {
+  if (fc?.type === 'flow-collection') {
+    const end = fc.end[0];
+    if (end.indent === indent && (end.source === ']' || end.source === '}') && containsNewline(fc)) {
+      const msg = 'Flow end indicator should be more indented than parent';
+      onError(end, 'BAD_INDENT', msg, true);
+    }
+  }
+}
+
+export { flowIndentCheck };

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

@@ -0,0 +1,12 @@
+import { isScalar } from '../nodes/Node.mjs';
+
+function mapIncludes(ctx, items, search) {
+  const {
+    uniqueKeys
+  } = ctx.options;
+  if (uniqueKeys === false) return false;
+  const isEqual = typeof uniqueKeys === 'function' ? uniqueKeys : (a, b) => a === b || isScalar(a) && isScalar(b) && a.value === b.value && !(a.value === '<<' && ctx.schema.merge);
+  return items.some(pair => isEqual(pair.key, search));
+}
+
+export { mapIncludes };