@quilted/create 0.1.90 → 0.2.1

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/schema/yaml-1.1/omap.mjs

@@ -0,0 +1,70 @@
+import { YAMLSeq } from '../../nodes/YAMLSeq.mjs';
+import { toJS } from '../../nodes/toJS.mjs';
+import { isPair, isScalar } from '../../nodes/Node.mjs';
+import { YAMLMap } from '../../nodes/YAMLMap.mjs';
+import { resolvePairs, createPairs } from './pairs.mjs';
+
+class YAMLOMap extends YAMLSeq {
+  constructor() {
+    super();
+    this.add = YAMLMap.prototype.add.bind(this);
+    this.delete = YAMLMap.prototype.delete.bind(this);
+    this.get = YAMLMap.prototype.get.bind(this);
+    this.has = YAMLMap.prototype.has.bind(this);
+    this.set = YAMLMap.prototype.set.bind(this);
+    this.tag = YAMLOMap.tag;
+  }
+  /**
+   * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
+   * but TypeScript won't allow widening the signature of a child method.
+   */
+  toJSON(_, ctx) {
+    if (!ctx) return super.toJSON(_);
+    const map = new Map();
+    if (ctx?.onCreate) ctx.onCreate(map);
+    for (const pair of this.items) {
+      let key, value;
+      if (isPair(pair)) {
+        key = toJS(pair.key, '', ctx);
+        value = toJS(pair.value, key, ctx);
+      } else {
+        key = toJS(pair, '', ctx);
+      }
+      if (map.has(key)) throw new Error('Ordered maps must not include duplicate keys');
+      map.set(key, value);
+    }
+    return map;
+  }
+}
+YAMLOMap.tag = 'tag:yaml.org,2002:omap';
+const omap = {
+  collection: 'seq',
+  identify: value => value instanceof Map,
+  nodeClass: YAMLOMap,
+  default: false,
+  tag: 'tag:yaml.org,2002:omap',
+  resolve(seq, onError) {
+    const pairs = resolvePairs(seq, onError);
+    const seenKeys = [];
+    for (const {
+      key
+    } of pairs.items) {
+      if (isScalar(key)) {
+        if (seenKeys.includes(key.value)) {
+          onError(`Ordered maps must not include duplicate keys: ${key.value}`);
+        } else {
+          seenKeys.push(key.value);
+        }
+      }
+    }
+    return Object.assign(new YAMLOMap(), pairs);
+  },
+  createNode(schema, iterable, ctx) {
+    const pairs = createPairs(schema, iterable, ctx);
+    const omap = new YAMLOMap();
+    omap.items = pairs.items;
+    return omap;
+  }
+};
+
+export { YAMLOMap, omap };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.mjs

@@ -0,0 +1,61 @@
+import { isSeq, isPair, isMap } from '../../nodes/Node.mjs';
+import { Pair, createPair } from '../../nodes/Pair.mjs';
+import { Scalar } from '../../nodes/Scalar.mjs';
+import { YAMLSeq } from '../../nodes/YAMLSeq.mjs';
+
+function resolvePairs(seq, onError) {
+  if (isSeq(seq)) {
+    for (let i = 0; i < seq.items.length; ++i) {
+      let item = seq.items[i];
+      if (isPair(item)) continue;else if (isMap(item)) {
+        if (item.items.length > 1) onError('Each pair must have its own sequence indicator');
+        const pair = item.items[0] || new Pair(new Scalar(null));
+        if (item.commentBefore) pair.key.commentBefore = pair.key.commentBefore ? `${item.commentBefore}\n${pair.key.commentBefore}` : item.commentBefore;
+        if (item.comment) {
+          const cn = pair.value ?? pair.key;
+          cn.comment = cn.comment ? `${item.comment}\n${cn.comment}` : item.comment;
+        }
+        item = pair;
+      }
+      seq.items[i] = isPair(item) ? item : new Pair(item);
+    }
+  } else onError('Expected a sequence for this tag');
+  return seq;
+}
+function createPairs(schema, iterable, ctx) {
+  const {
+    replacer
+  } = ctx;
+  const pairs = new YAMLSeq(schema);
+  pairs.tag = 'tag:yaml.org,2002:pairs';
+  let i = 0;
+  if (iterable && Symbol.iterator in Object(iterable)) for (let it of iterable) {
+    if (typeof replacer === 'function') it = replacer.call(iterable, String(i++), it);
+    let key, value;
+    if (Array.isArray(it)) {
+      if (it.length === 2) {
+        key = it[0];
+        value = it[1];
+      } else throw new TypeError(`Expected [key, value] tuple: ${it}`);
+    } else if (it && it instanceof Object) {
+      const keys = Object.keys(it);
+      if (keys.length === 1) {
+        key = keys[0];
+        value = it[key];
+      } else throw new TypeError(`Expected { key: value } tuple: ${it}`);
+    } else {
+      key = it;
+    }
+    pairs.items.push(createPair(key, value, ctx));
+  }
+  return pairs;
+}
+const pairs = {
+  collection: 'seq',
+  default: false,
+  tag: 'tag:yaml.org,2002:pairs',
+  resolve: resolvePairs,
+  createNode: createPairs
+};
+
+export { createPairs, pairs, resolvePairs };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/schema/yaml-1.1/schema.mjs

@@ -0,0 +1,16 @@
+import { map } from '../common/map.mjs';
+import { nullTag } from '../common/null.mjs';
+import { seq } from '../common/seq.mjs';
+import { string } from '../common/string.mjs';
+import { binary } from './binary.mjs';
+import { trueTag, falseTag } from './bool.mjs';
+import { floatNaN, floatExp, float } from './float.mjs';
+import { intBin, intOct, int, intHex } from './int.mjs';
+import { omap } from './omap.mjs';
+import { pairs } from './pairs.mjs';
+import { set } from './set.mjs';
+import { intTime, floatTime, timestamp } from './timestamp.mjs';
+
+const schema = [map, seq, string, nullTag, trueTag, falseTag, intBin, intOct, int, intHex, floatNaN, floatExp, float, binary, omap, pairs, set, intTime, floatTime, timestamp];
+
+export { schema };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/schema/yaml-1.1/set.mjs

@@ -0,0 +1,69 @@
+import { isPair, isScalar, isMap } from '../../nodes/Node.mjs';
+import { Pair, createPair } from '../../nodes/Pair.mjs';
+import { YAMLMap, findPair } from '../../nodes/YAMLMap.mjs';
+
+class YAMLSet extends YAMLMap {
+  constructor(schema) {
+    super(schema);
+    this.tag = YAMLSet.tag;
+  }
+  add(key) {
+    let pair;
+    if (isPair(key)) pair = key;else if (typeof key === 'object' && 'key' in key && 'value' in key && key.value === null) pair = new Pair(key.key, null);else pair = new Pair(key, null);
+    const prev = findPair(this.items, pair.key);
+    if (!prev) this.items.push(pair);
+  }
+  /**
+   * If `keepPair` is `true`, returns the Pair matching `key`.
+   * Otherwise, returns the value of that Pair's key.
+   */
+  get(key, keepPair) {
+    const pair = findPair(this.items, key);
+    return !keepPair && isPair(pair) ? isScalar(pair.key) ? pair.key.value : pair.key : pair;
+  }
+  set(key, value) {
+    if (typeof value !== 'boolean') throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
+    const prev = findPair(this.items, key);
+    if (prev && !value) {
+      this.items.splice(this.items.indexOf(prev), 1);
+    } else if (!prev && value) {
+      this.items.push(new Pair(key));
+    }
+  }
+  toJSON(_, ctx) {
+    return super.toJSON(_, ctx, Set);
+  }
+  toString(ctx, onComment, onChompKeep) {
+    if (!ctx) return JSON.stringify(this);
+    if (this.hasAllNullValues(true)) return super.toString(Object.assign({}, ctx, {
+      allNullValues: true
+    }), onComment, onChompKeep);else throw new Error('Set items must all have null values');
+  }
+}
+YAMLSet.tag = 'tag:yaml.org,2002:set';
+const set = {
+  collection: 'map',
+  identify: value => value instanceof Set,
+  nodeClass: YAMLSet,
+  default: false,
+  tag: 'tag:yaml.org,2002:set',
+  resolve(map, onError) {
+    if (isMap(map)) {
+      if (map.hasAllNullValues(true)) return Object.assign(new YAMLSet(), map);else onError('Set items must all have null values');
+    } else onError('Expected a mapping for this tag');
+    return map;
+  },
+  createNode(schema, iterable, ctx) {
+    const {
+      replacer
+    } = ctx;
+    const set = new YAMLSet(schema);
+    if (iterable && Symbol.iterator in Object(iterable)) for (let value of iterable) {
+      if (typeof replacer === 'function') value = replacer.call(iterable, value, value);
+      set.items.push(createPair(value, null, ctx));
+    }
+    return set;
+  }
+};
+
+export { YAMLSet, set };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.mjs

@@ -0,0 +1,101 @@
+import { stringifyNumber } from '../../stringify/stringifyNumber.mjs';
+
+/** Internal types handle bigint as number, because TS can't figure it out. */
+function parseSexagesimal(str, asBigInt) {
+  const sign = str[0];
+  const parts = sign === '-' || sign === '+' ? str.substring(1) : str;
+  const num = n => asBigInt ? BigInt(n) : Number(n);
+  const res = parts.replace(/_/g, '').split(':').reduce((res, p) => res * num(60) + num(p), num(0));
+  return sign === '-' ? num(-1) * res : res;
+}
+/**
+ * hhhh:mm:ss.sss
+ *
+ * Internal types handle bigint as number, because TS can't figure it out.
+ */
+function stringifySexagesimal(node) {
+  let {
+    value
+  } = node;
+  let num = n => n;
+  if (typeof value === 'bigint') num = n => BigInt(n);else if (isNaN(value) || !isFinite(value)) return stringifyNumber(node);
+  let sign = '';
+  if (value < 0) {
+    sign = '-';
+    value *= num(-1);
+  }
+  const _60 = num(60);
+  const parts = [value % _60]; // seconds, including ms
+  if (value < 60) {
+    parts.unshift(0); // at least one : is required
+  } else {
+    value = (value - parts[0]) / _60;
+    parts.unshift(value % _60); // minutes
+    if (value >= 60) {
+      value = (value - parts[0]) / _60;
+      parts.unshift(value); // hours
+    }
+  }
+
+  return sign + parts.map(n => n < 10 ? '0' + String(n) : String(n)).join(':').replace(/000000\d*$/, '') // % 60 may introduce error
+  ;
+}
+
+const intTime = {
+  identify: value => typeof value === 'bigint' || Number.isInteger(value),
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  format: 'TIME',
+  test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
+  resolve: (str, _onError, {
+    intAsBigInt
+  }) => parseSexagesimal(str, intAsBigInt),
+  stringify: stringifySexagesimal
+};
+const floatTime = {
+  identify: value => typeof value === 'number',
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  format: 'TIME',
+  test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
+  resolve: str => parseSexagesimal(str, false),
+  stringify: stringifySexagesimal
+};
+const timestamp = {
+  identify: value => value instanceof Date,
+  default: true,
+  tag: 'tag:yaml.org,2002:timestamp',
+  // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part
+  // may be omitted altogether, resulting in a date format. In such a case, the time part is
+  // assumed to be 00:00:00Z (start of day, UTC).
+  test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' +
+  // YYYY-Mm-Dd
+  '(?:' +
+  // time is optional
+  '(?:t|T|[ \\t]+)' +
+  // t | T | whitespace
+  '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)' +
+  // Hh:Mm:Ss(.ss)?
+  '(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' +
+  // Z | +5 | -03:30
+  ')?$'),
+  resolve(str) {
+    const match = str.match(timestamp.test);
+    if (!match) throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd');
+    const [, year, month, day, hour, minute, second] = match.map(Number);
+    const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0;
+    let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
+    const tz = match[8];
+    if (tz && tz !== 'Z') {
+      let d = parseSexagesimal(tz, false);
+      if (Math.abs(d) < 30) d *= 60;
+      date -= 60000 * d;
+    }
+    return new Date(date);
+  },
+  stringify: ({
+    value
+  }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, '')
+};
+
+export { floatTime, intTime, timestamp };

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

@@ -0,0 +1,119 @@
+const FOLD_FLOW = 'flow';
+const FOLD_BLOCK = 'block';
+const FOLD_QUOTED = 'quoted';
+/**
+ * Tries to keep input at up to `lineWidth` characters, splitting only on spaces
+ * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
+ * terminated with `\n` and started with `indent`.
+ */
+function foldFlowLines(text, indent, mode = 'flow', {
+  indentAtStart,
+  lineWidth = 80,
+  minContentWidth = 20,
+  onFold,
+  onOverflow
+} = {}) {
+  if (!lineWidth || lineWidth < 0) return text;
+  const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
+  if (text.length <= endStep) return text;
+  const folds = [];
+  const escapedFolds = {};
+  let end = lineWidth - indent.length;
+  if (typeof indentAtStart === 'number') {
+    if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);else end = lineWidth - indentAtStart;
+  }
+  let split = undefined;
+  let prev = undefined;
+  let overflow = false;
+  let i = -1;
+  let escStart = -1;
+  let escEnd = -1;
+  if (mode === FOLD_BLOCK) {
+    i = consumeMoreIndentedLines(text, i);
+    if (i !== -1) end = i + endStep;
+  }
+  for (let ch; ch = text[i += 1];) {
+    if (mode === FOLD_QUOTED && ch === '\\') {
+      escStart = i;
+      switch (text[i + 1]) {
+        case 'x':
+          i += 3;
+          break;
+        case 'u':
+          i += 5;
+          break;
+        case 'U':
+          i += 9;
+          break;
+        default:
+          i += 1;
+      }
+      escEnd = i;
+    }
+    if (ch === '\n') {
+      if (mode === FOLD_BLOCK) i = consumeMoreIndentedLines(text, i);
+      end = i + endStep;
+      split = undefined;
+    } else {
+      if (ch === ' ' && prev && prev !== ' ' && prev !== '\n' && prev !== '\t') {
+        // space surrounded by non-space can be replaced with newline + indent
+        const next = text[i + 1];
+        if (next && next !== ' ' && next !== '\n' && next !== '\t') split = i;
+      }
+      if (i >= end) {
+        if (split) {
+          folds.push(split);
+          end = split + endStep;
+          split = undefined;
+        } else if (mode === FOLD_QUOTED) {
+          // white-space collected at end may stretch past lineWidth
+          while (prev === ' ' || prev === '\t') {
+            prev = ch;
+            ch = text[i += 1];
+            overflow = true;
+          }
+          // Account for newline escape, but don't break preceding escape
+          const j = i > escEnd + 1 ? i - 2 : escStart - 1;
+          // Bail out if lineWidth & minContentWidth are shorter than an escape string
+          if (escapedFolds[j]) return text;
+          folds.push(j);
+          escapedFolds[j] = true;
+          end = j + endStep;
+          split = undefined;
+        } else {
+          overflow = true;
+        }
+      }
+    }
+    prev = ch;
+  }
+  if (overflow && onOverflow) onOverflow();
+  if (folds.length === 0) return text;
+  if (onFold) onFold();
+  let res = text.slice(0, folds[0]);
+  for (let i = 0; i < folds.length; ++i) {
+    const fold = folds[i];
+    const end = folds[i + 1] || text.length;
+    if (fold === 0) res = `\n${indent}${text.slice(0, end)}`;else {
+      if (mode === FOLD_QUOTED && escapedFolds[fold]) res += `${text[fold]}\\`;
+      res += `\n${indent}${text.slice(fold + 1, end)}`;
+    }
+  }
+  return res;
+}
+/**
+ * Presumes `i + 1` is at the start of a line
+ * @returns index of last newline in more-indented block
+ */
+function consumeMoreIndentedLines(text, i) {
+  let ch = text[i + 1];
+  while (ch === ' ' || ch === '\t') {
+    do {
+      ch = text[i += 1];
+    } while (ch && ch !== '\n');
+    ch = text[i + 1];
+  }
+  return i;
+}
+
+export { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED, foldFlowLines };

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

@@ -0,0 +1,105 @@
+import { anchorIsValid } from '../doc/anchors.mjs';
+import { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/Node.mjs';
+import { stringifyComment } from './stringifyComment.mjs';
+import { stringifyString } from './stringifyString.mjs';
+
+function createStringifyContext(doc, options) {
+  const opt = Object.assign({
+    blockQuote: true,
+    commentString: stringifyComment,
+    defaultKeyType: null,
+    defaultStringType: 'PLAIN',
+    directives: null,
+    doubleQuotedAsJSON: false,
+    doubleQuotedMinMultiLineLength: 40,
+    falseStr: 'false',
+    indentSeq: true,
+    lineWidth: 80,
+    minContentWidth: 20,
+    nullStr: 'null',
+    simpleKeys: false,
+    singleQuote: null,
+    trueStr: 'true',
+    verifyAliasOrder: true
+  }, doc.schema.toStringOptions, options);
+  let inFlow;
+  switch (opt.collectionStyle) {
+    case 'block':
+      inFlow = false;
+      break;
+    case 'flow':
+      inFlow = true;
+      break;
+    default:
+      inFlow = null;
+  }
+  return {
+    anchors: new Set(),
+    doc,
+    indent: '',
+    indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',
+    inFlow,
+    options: opt
+  };
+}
+function getTagObject(tags, item) {
+  if (item.tag) {
+    const match = tags.filter(t => t.tag === item.tag);
+    if (match.length > 0) return match.find(t => t.format === item.format) ?? match[0];
+  }
+  let tagObj = undefined;
+  let obj;
+  if (isScalar(item)) {
+    obj = item.value;
+    const match = tags.filter(t => t.identify?.(obj));
+    tagObj = match.find(t => t.format === item.format) ?? match.find(t => !t.format);
+  } else {
+    obj = item;
+    tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
+  }
+  if (!tagObj) {
+    const name = obj?.constructor?.name ?? typeof obj;
+    throw new Error(`Tag not resolved for ${name} value`);
+  }
+  return tagObj;
+}
+// needs to be called before value stringifier to allow for circular anchor refs
+function stringifyProps(node, tagObj, {
+  anchors,
+  doc
+}) {
+  if (!doc.directives) return '';
+  const props = [];
+  const anchor = (isScalar(node) || isCollection(node)) && node.anchor;
+  if (anchor && anchorIsValid(anchor)) {
+    anchors.add(anchor);
+    props.push(`&${anchor}`);
+  }
+  const tag = node.tag ? node.tag : tagObj.default ? null : tagObj.tag;
+  if (tag) props.push(doc.directives.tagString(tag));
+  return props.join(' ');
+}
+function stringify(item, ctx, onComment, onChompKeep) {
+  if (isPair(item)) return item.toString(ctx, onComment, onChompKeep);
+  if (isAlias(item)) {
+    if (ctx.doc.directives) return item.toString(ctx);
+    if (ctx.resolvedAliases?.has(item)) {
+      throw new TypeError(`Cannot stringify circular structure without alias nodes`);
+    } else {
+      if (ctx.resolvedAliases) ctx.resolvedAliases.add(item);else ctx.resolvedAliases = new Set([item]);
+      item = item.resolve(ctx.doc);
+    }
+  }
+  let tagObj = undefined;
+  const node = isNode(item) ? item : ctx.doc.createNode(item, {
+    onTagObj: o => tagObj = o
+  });
+  if (!tagObj) tagObj = getTagObject(ctx.doc.schema.tags, node);
+  const props = stringifyProps(node, tagObj, ctx);
+  if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
+  const str = typeof tagObj.stringify === 'function' ? tagObj.stringify(node, ctx, onComment, onChompKeep) : isScalar(node) ? stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
+  if (!props) return str;
+  return isScalar(node) || str[0] === '{' || str[0] === '[' ? `${props} ${str}` : `${props}\n${ctx.indent}${str}`;
+}
+
+export { createStringifyContext, stringify };