@quilted/create 0.1.55 → 0.1.57

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/Pair.mjs

@@ -0,0 +1,48 @@
+import { __exports as Pair$1 } from '../../../../../../../_virtual/Pair.mjs';
+export { __exports as default } from '../../../../../../../_virtual/Pair.mjs';
+import '../doc/createNode.mjs';
+import '../stringify/stringifyPair.mjs';
+import './addPairToJSMap.mjs';
+import './Node.mjs';
+import { __exports as createNode$1 } from '../../../../../../../_virtual/createNode.mjs';
+import { __exports as stringifyPair$1 } from '../../../../../../../_virtual/stringifyPair.mjs';
+import { __exports as addPairToJSMap$1 } from '../../../../../../../_virtual/addPairToJSMap.mjs';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.mjs';
+
+var createNode = createNode$1;
+var stringifyPair = stringifyPair$1;
+var addPairToJSMap = addPairToJSMap$1;
+var Node = Node$1;
+
+function createPair(key, value, ctx) {
+    const k = createNode.createNode(key, undefined, ctx);
+    const v = createNode.createNode(value, undefined, ctx);
+    return new Pair(k, v);
+}
+class Pair {
+    constructor(key, value = null) {
+        Object.defineProperty(this, Node.NODE_TYPE, { value: Node.PAIR });
+        this.key = key;
+        this.value = value;
+    }
+    clone(schema) {
+        let { key, value } = this;
+        if (Node.isNode(key))
+            key = key.clone(schema);
+        if (Node.isNode(value))
+            value = value.clone(schema);
+        return new Pair(key, value);
+    }
+    toJSON(_, ctx) {
+        const pair = ctx?.mapAsMap ? new Map() : {};
+        return addPairToJSMap.addPairToJSMap(ctx, pair, this);
+    }
+    toString(ctx, onComment, onChompKeep) {
+        return ctx?.doc
+            ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep)
+            : JSON.stringify(this);
+    }
+}
+
+Pair$1.Pair = Pair;
+Pair$1.createPair = createPair;

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/Scalar.mjs

@@ -0,0 +1,31 @@
+import { __exports as Scalar$1 } from '../../../../../../../_virtual/Scalar.mjs';
+export { __exports as default } from '../../../../../../../_virtual/Scalar.mjs';
+import './Node.mjs';
+import './toJS.mjs';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.mjs';
+import { __exports as toJS$1 } from '../../../../../../../_virtual/toJS.mjs';
+
+var Node = Node$1;
+var toJS = toJS$1;
+
+const isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');
+class Scalar extends Node.NodeBase {
+    constructor(value) {
+        super(Node.SCALAR);
+        this.value = value;
+    }
+    toJSON(arg, ctx) {
+        return ctx?.keep ? this.value : toJS.toJS(this.value, arg, ctx);
+    }
+    toString() {
+        return String(this.value);
+    }
+}
+Scalar.BLOCK_FOLDED = 'BLOCK_FOLDED';
+Scalar.BLOCK_LITERAL = 'BLOCK_LITERAL';
+Scalar.PLAIN = 'PLAIN';
+Scalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';
+Scalar.QUOTE_SINGLE = 'QUOTE_SINGLE';
+
+Scalar$1.Scalar = Scalar;
+Scalar$1.isScalarValue = isScalarValue;

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/YAMLMap.mjs

@@ -0,0 +1,132 @@
+import { __exports as YAMLMap$1 } from '../../../../../../../_virtual/YAMLMap.mjs';
+export { __exports as default } from '../../../../../../../_virtual/YAMLMap.mjs';
+import '../stringify/stringifyCollection.mjs';
+import './addPairToJSMap.mjs';
+import './Collection.mjs';
+import './Node.mjs';
+import './Pair.mjs';
+import './Scalar.mjs';
+import { __exports as stringifyCollection$1 } from '../../../../../../../_virtual/stringifyCollection.mjs';
+import { __exports as addPairToJSMap$1 } from '../../../../../../../_virtual/addPairToJSMap.mjs';
+import { __exports as Collection$1 } from '../../../../../../../_virtual/Collection.mjs';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.mjs';
+import { __exports as Pair$1 } from '../../../../../../../_virtual/Pair.mjs';
+import { __exports as Scalar$1 } from '../../../../../../../_virtual/Scalar.mjs';
+
+var stringifyCollection = stringifyCollection$1;
+var addPairToJSMap = addPairToJSMap$1;
+var Collection = Collection$1;
+var Node = Node$1;
+var Pair = Pair$1;
+var Scalar = Scalar$1;
+
+function findPair(items, key) {
+    const k = Node.isScalar(key) ? key.value : key;
+    for (const it of items) {
+        if (Node.isPair(it)) {
+            if (it.key === key || it.key === k)
+                return it;
+            if (Node.isScalar(it.key) && it.key.value === k)
+                return it;
+        }
+    }
+    return undefined;
+}
+class YAMLMap extends Collection.Collection {
+    constructor(schema) {
+        super(Node.MAP, schema);
+        this.items = [];
+    }
+    static get tagName() {
+        return 'tag:yaml.org,2002:map';
+    }
+    /**
+     * Adds a value to the collection.
+     *
+     * @param overwrite - If not set `true`, using a key that is already in the
+     *   collection will throw. Otherwise, overwrites the previous value.
+     */
+    add(pair, overwrite) {
+        let _pair;
+        if (Node.isPair(pair))
+            _pair = pair;
+        else if (!pair || typeof pair !== 'object' || !('key' in pair)) {
+            // In TypeScript, this never happens.
+            _pair = new Pair.Pair(pair, pair?.value);
+        }
+        else
+            _pair = new Pair.Pair(pair.key, pair.value);
+        const prev = findPair(this.items, _pair.key);
+        const sortEntries = this.schema?.sortMapEntries;
+        if (prev) {
+            if (!overwrite)
+                throw new Error(`Key ${_pair.key} already set`);
+            // For scalars, keep the old node & its comments and anchors
+            if (Node.isScalar(prev.value) && Scalar.isScalarValue(_pair.value))
+                prev.value.value = _pair.value;
+            else
+                prev.value = _pair.value;
+        }
+        else if (sortEntries) {
+            const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);
+            if (i === -1)
+                this.items.push(_pair);
+            else
+                this.items.splice(i, 0, _pair);
+        }
+        else {
+            this.items.push(_pair);
+        }
+    }
+    delete(key) {
+        const it = findPair(this.items, key);
+        if (!it)
+            return false;
+        const del = this.items.splice(this.items.indexOf(it), 1);
+        return del.length > 0;
+    }
+    get(key, keepScalar) {
+        const it = findPair(this.items, key);
+        const node = it?.value;
+        return (!keepScalar && Node.isScalar(node) ? node.value : node) ?? undefined;
+    }
+    has(key) {
+        return !!findPair(this.items, key);
+    }
+    set(key, value) {
+        this.add(new Pair.Pair(key, value), true);
+    }
+    /**
+     * @param ctx - Conversion context, originally set in Document#toJS()
+     * @param {Class} Type - If set, forces the returned collection type
+     * @returns Instance of Type, Map, or Object
+     */
+    toJSON(_, ctx, Type) {
+        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};
+        if (ctx?.onCreate)
+            ctx.onCreate(map);
+        for (const item of this.items)
+            addPairToJSMap.addPairToJSMap(ctx, map, item);
+        return map;
+    }
+    toString(ctx, onComment, onChompKeep) {
+        if (!ctx)
+            return JSON.stringify(this);
+        for (const item of this.items) {
+            if (!Node.isPair(item))
+                throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
+        }
+        if (!ctx.allNullValues && this.hasAllNullValues(false))
+            ctx = Object.assign({}, ctx, { allNullValues: true });
+        return stringifyCollection.stringifyCollection(this, ctx, {
+            blockItemPrefix: '',
+            flowChars: { start: '{', end: '}' },
+            itemIndent: ctx.indent || '',
+            onChompKeep,
+            onComment
+        });
+    }
+}
+
+YAMLMap$1.YAMLMap = YAMLMap;
+YAMLMap$1.findPair = findPair;

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/YAMLSeq.mjs

@@ -0,0 +1,110 @@
+import { __exports as YAMLSeq$1 } from '../../../../../../../_virtual/YAMLSeq.mjs';
+export { __exports as default } from '../../../../../../../_virtual/YAMLSeq.mjs';
+import '../stringify/stringifyCollection.mjs';
+import './Collection.mjs';
+import './Node.mjs';
+import './Scalar.mjs';
+import './toJS.mjs';
+import { __exports as stringifyCollection$1 } from '../../../../../../../_virtual/stringifyCollection.mjs';
+import { __exports as Collection$1 } from '../../../../../../../_virtual/Collection.mjs';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.mjs';
+import { __exports as Scalar$1 } from '../../../../../../../_virtual/Scalar.mjs';
+import { __exports as toJS$1 } from '../../../../../../../_virtual/toJS.mjs';
+
+var stringifyCollection = stringifyCollection$1;
+var Collection = Collection$1;
+var Node = Node$1;
+var Scalar = Scalar$1;
+var toJS = toJS$1;
+
+class YAMLSeq extends Collection.Collection {
+    constructor(schema) {
+        super(Node.SEQ, schema);
+        this.items = [];
+    }
+    static get tagName() {
+        return 'tag:yaml.org,2002:seq';
+    }
+    add(value) {
+        this.items.push(value);
+    }
+    /**
+     * Removes a value from the collection.
+     *
+     * `key` must contain a representation of an integer for this to succeed.
+     * It may be wrapped in a `Scalar`.
+     *
+     * @returns `true` if the item was found and removed.
+     */
+    delete(key) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            return false;
+        const del = this.items.splice(idx, 1);
+        return del.length > 0;
+    }
+    get(key, keepScalar) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            return undefined;
+        const it = this.items[idx];
+        return !keepScalar && Node.isScalar(it) ? it.value : it;
+    }
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     *
+     * `key` must contain a representation of an integer for this to succeed.
+     * It may be wrapped in a `Scalar`.
+     */
+    has(key) {
+        const idx = asItemIndex(key);
+        return typeof idx === 'number' && idx < this.items.length;
+    }
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     *
+     * If `key` does not contain a representation of an integer, this will throw.
+     * It may be wrapped in a `Scalar`.
+     */
+    set(key, value) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            throw new Error(`Expected a valid index, not ${key}.`);
+        const prev = this.items[idx];
+        if (Node.isScalar(prev) && Scalar.isScalarValue(value))
+            prev.value = value;
+        else
+            this.items[idx] = value;
+    }
+    toJSON(_, ctx) {
+        const seq = [];
+        if (ctx?.onCreate)
+            ctx.onCreate(seq);
+        let i = 0;
+        for (const item of this.items)
+            seq.push(toJS.toJS(item, String(i++), ctx));
+        return seq;
+    }
+    toString(ctx, onComment, onChompKeep) {
+        if (!ctx)
+            return JSON.stringify(this);
+        return stringifyCollection.stringifyCollection(this, ctx, {
+            blockItemPrefix: '- ',
+            flowChars: { start: '[', end: ']' },
+            itemIndent: (ctx.indent || '') + '  ',
+            onChompKeep,
+            onComment
+        });
+    }
+}
+function asItemIndex(key) {
+    let idx = Node.isScalar(key) ? key.value : key;
+    if (idx && typeof idx === 'string')
+        idx = Number(idx);
+    return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0
+        ? idx
+        : null;
+}
+
+YAMLSeq$1.YAMLSeq = YAMLSeq;

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/addPairToJSMap.mjs

@@ -0,0 +1,117 @@
+import { __exports as addPairToJSMap$1 } from '../../../../../../../_virtual/addPairToJSMap.mjs';
+export { __exports as default } from '../../../../../../../_virtual/addPairToJSMap.mjs';
+import '../log.mjs';
+import '../stringify/stringify.mjs';
+import './Node.mjs';
+import './Scalar.mjs';
+import './toJS.mjs';
+import { __exports as log$1 } from '../../../../../../../_virtual/log.mjs';
+import { __exports as stringify$1 } from '../../../../../../../_virtual/stringify.mjs';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.mjs';
+import { __exports as Scalar$1 } from '../../../../../../../_virtual/Scalar.mjs';
+import { __exports as toJS$1 } from '../../../../../../../_virtual/toJS.mjs';
+
+var log = log$1;
+var stringify = stringify$1;
+var Node = Node$1;
+var Scalar = Scalar$1;
+var toJS = toJS$1;
+
+const MERGE_KEY = '<<';
+function addPairToJSMap(ctx, map, { key, value }) {
+    if (ctx?.doc.schema.merge && isMergeKey(key)) {
+        value = Node.isAlias(value) ? value.resolve(ctx.doc) : value;
+        if (Node.isSeq(value))
+            for (const it of value.items)
+                mergeToJSMap(ctx, map, it);
+        else if (Array.isArray(value))
+            for (const it of value)
+                mergeToJSMap(ctx, map, it);
+        else
+            mergeToJSMap(ctx, map, value);
+    }
+    else {
+        const jsKey = toJS.toJS(key, '', ctx);
+        if (map instanceof Map) {
+            map.set(jsKey, toJS.toJS(value, jsKey, ctx));
+        }
+        else if (map instanceof Set) {
+            map.add(jsKey);
+        }
+        else {
+            const stringKey = stringifyKey(key, jsKey, ctx);
+            const jsValue = toJS.toJS(value, stringKey, ctx);
+            if (stringKey in map)
+                Object.defineProperty(map, stringKey, {
+                    value: jsValue,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            else
+                map[stringKey] = jsValue;
+        }
+    }
+    return map;
+}
+const isMergeKey = (key) => key === MERGE_KEY ||
+    (Node.isScalar(key) &&
+        key.value === MERGE_KEY &&
+        (!key.type || key.type === Scalar.Scalar.PLAIN));
+// If the value associated with a merge key is a single mapping node, each of
+// its key/value pairs is inserted into the current mapping, unless the key
+// already exists in it. If the value associated with the merge key is a
+// sequence, then this sequence is expected to contain mapping nodes and each
+// of these nodes is merged in turn according to its order in the sequence.
+// Keys in mapping nodes earlier in the sequence override keys specified in
+// later mapping nodes. -- http://yaml.org/type/merge.html
+function mergeToJSMap(ctx, map, value) {
+    const source = ctx && Node.isAlias(value) ? value.resolve(ctx.doc) : value;
+    if (!Node.isMap(source))
+        throw new Error('Merge sources must be maps or map aliases');
+    const srcMap = source.toJSON(null, ctx, Map);
+    for (const [key, value] of srcMap) {
+        if (map instanceof Map) {
+            if (!map.has(key))
+                map.set(key, value);
+        }
+        else if (map instanceof Set) {
+            map.add(key);
+        }
+        else if (!Object.prototype.hasOwnProperty.call(map, key)) {
+            Object.defineProperty(map, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
+    return map;
+}
+function stringifyKey(key, jsKey, ctx) {
+    if (jsKey === null)
+        return '';
+    if (typeof jsKey !== 'object')
+        return String(jsKey);
+    if (Node.isNode(key) && ctx && ctx.doc) {
+        const strCtx = stringify.createStringifyContext(ctx.doc, {});
+        strCtx.anchors = new Set();
+        for (const node of ctx.anchors.keys())
+            strCtx.anchors.add(node.anchor);
+        strCtx.inFlow = true;
+        strCtx.inStringifyKey = true;
+        const strKey = key.toString(strCtx);
+        if (!ctx.mapKeyWarned) {
+            let jsonStr = JSON.stringify(strKey);
+            if (jsonStr.length > 40)
+                jsonStr = jsonStr.substring(0, 36) + '..."';
+            log.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+            ctx.mapKeyWarned = true;
+        }
+        return strKey;
+    }
+    return JSON.stringify(jsKey);
+}
+
+addPairToJSMap$1.addPairToJSMap = addPairToJSMap;

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/toJS.mjs

@@ -0,0 +1,42 @@
+import { __exports as toJS$1 } from '../../../../../../../_virtual/toJS.mjs';
+export { __exports as default } from '../../../../../../../_virtual/toJS.mjs';
+import './Node.mjs';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.mjs';
+
+var Node = Node$1;
+
+/**
+ * Recursively convert any node or its contents to native JavaScript
+ *
+ * @param value - The input value
+ * @param arg - If `value` defines a `toJSON()` method, use this
+ *   as its first argument
+ * @param ctx - Conversion context, originally set in Document#toJS(). If
+ *   `{ keep: true }` is not set, output should be suitable for JSON
+ *   stringification.
+ */
+function toJS(value, arg, ctx) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    if (Array.isArray(value))
+        return value.map((v, i) => toJS(v, String(i), ctx));
+    if (value && typeof value.toJSON === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        if (!ctx || !Node.hasAnchor(value))
+            return value.toJSON(arg, ctx);
+        const data = { aliasCount: 0, count: 1, res: undefined };
+        ctx.anchors.set(value, data);
+        ctx.onCreate = res => {
+            data.res = res;
+            delete ctx.onCreate;
+        };
+        const res = value.toJSON(arg, ctx);
+        if (ctx.onCreate)
+            ctx.onCreate(res);
+        return res;
+    }
+    if (typeof value === 'bigint' && !ctx?.keep)
+        return Number(value);
+    return value;
+}
+
+toJS$1.toJS = toJS;