@quilted/create 0.1.55 → 0.1.57

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/doc/directives.esnext

@@ -0,0 +1,176 @@
+import { __exports as directives } from '../../../../../../../_virtual/directives.esnext';
+export { __exports as default } from '../../../../../../../_virtual/directives.esnext';
+import '../nodes/Node.esnext';
+import '../visit.esnext';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.esnext';
+import { __exports as visit$1 } from '../../../../../../../_virtual/visit.esnext';
+
+var Node = Node$1;
+var visit = visit$1;
+
+const escapeChars = {
+    '!': '%21',
+    ',': '%2C',
+    '[': '%5B',
+    ']': '%5D',
+    '{': '%7B',
+    '}': '%7D'
+};
+const escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, ch => escapeChars[ch]);
+class Directives {
+    constructor(yaml, tags) {
+        /**
+         * The directives-end/doc-start marker `---`. If `null`, a marker may still be
+         * included in the document's stringified representation.
+         */
+        this.docStart = null;
+        /** The doc-end marker `...`.  */
+        this.docEnd = false;
+        this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
+        this.tags = Object.assign({}, Directives.defaultTags, tags);
+    }
+    clone() {
+        const copy = new Directives(this.yaml, this.tags);
+        copy.docStart = this.docStart;
+        return copy;
+    }
+    /**
+     * During parsing, get a Directives instance for the current document and
+     * update the stream state according to the current version's spec.
+     */
+    atDocument() {
+        const res = new Directives(this.yaml, this.tags);
+        switch (this.yaml.version) {
+            case '1.1':
+                this.atNextDocument = true;
+                break;
+            case '1.2':
+                this.atNextDocument = false;
+                this.yaml = {
+                    explicit: Directives.defaultYaml.explicit,
+                    version: '1.2'
+                };
+                this.tags = Object.assign({}, Directives.defaultTags);
+                break;
+        }
+        return res;
+    }
+    /**
+     * @param onError - May be called even if the action was successful
+     * @returns `true` on success
+     */
+    add(line, onError) {
+        if (this.atNextDocument) {
+            this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' };
+            this.tags = Object.assign({}, Directives.defaultTags);
+            this.atNextDocument = false;
+        }
+        const parts = line.trim().split(/[ \t]+/);
+        const name = parts.shift();
+        switch (name) {
+            case '%TAG': {
+                if (parts.length !== 2) {
+                    onError(0, '%TAG directive should contain exactly two parts');
+                    if (parts.length < 2)
+                        return false;
+                }
+                const [handle, prefix] = parts;
+                this.tags[handle] = prefix;
+                return true;
+            }
+            case '%YAML': {
+                this.yaml.explicit = true;
+                if (parts.length !== 1) {
+                    onError(0, '%YAML directive should contain exactly one part');
+                    return false;
+                }
+                const [version] = parts;
+                if (version === '1.1' || version === '1.2') {
+                    this.yaml.version = version;
+                    return true;
+                }
+                else {
+                    const isValid = /^\d+\.\d+$/.test(version);
+                    onError(6, `Unsupported YAML version ${version}`, isValid);
+                    return false;
+                }
+            }
+            default:
+                onError(0, `Unknown directive ${name}`, true);
+                return false;
+        }
+    }
+    /**
+     * Resolves a tag, matching handles to those defined in %TAG directives.
+     *
+     * @returns Resolved tag, which may also be the non-specific tag `'!'` or a
+     *   `'!local'` tag, or `null` if unresolvable.
+     */
+    tagName(source, onError) {
+        if (source === '!')
+            return '!'; // non-specific tag
+        if (source[0] !== '!') {
+            onError(`Not a valid tag: ${source}`);
+            return null;
+        }
+        if (source[1] === '<') {
+            const verbatim = source.slice(2, -1);
+            if (verbatim === '!' || verbatim === '!!') {
+                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);
+                return null;
+            }
+            if (source[source.length - 1] !== '>')
+                onError('Verbatim tags must end with a >');
+            return verbatim;
+        }
+        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/);
+        if (!suffix)
+            onError(`The ${source} tag has no suffix`);
+        const prefix = this.tags[handle];
+        if (prefix)
+            return prefix + decodeURIComponent(suffix);
+        if (handle === '!')
+            return source; // local tag
+        onError(`Could not resolve tag: ${source}`);
+        return null;
+    }
+    /**
+     * Given a fully resolved tag, returns its printable string form,
+     * taking into account current tag prefixes and defaults.
+     */
+    tagString(tag) {
+        for (const [handle, prefix] of Object.entries(this.tags)) {
+            if (tag.startsWith(prefix))
+                return handle + escapeTagName(tag.substring(prefix.length));
+        }
+        return tag[0] === '!' ? tag : `!<${tag}>`;
+    }
+    toString(doc) {
+        const lines = this.yaml.explicit
+            ? [`%YAML ${this.yaml.version || '1.2'}`]
+            : [];
+        const tagEntries = Object.entries(this.tags);
+        let tagNames;
+        if (doc && tagEntries.length > 0 && Node.isNode(doc.contents)) {
+            const tags = {};
+            visit.visit(doc.contents, (_key, node) => {
+                if (Node.isNode(node) && node.tag)
+                    tags[node.tag] = true;
+            });
+            tagNames = Object.keys(tags);
+        }
+        else
+            tagNames = [];
+        for (const [handle, prefix] of tagEntries) {
+            if (handle === '!!' && prefix === 'tag:yaml.org,2002:')
+                continue;
+            if (!doc || tagNames.some(tn => tn.startsWith(prefix)))
+                lines.push(`%TAG ${handle} ${prefix}`);
+        }
+        return lines.join('\n');
+    }
+}
+Directives.defaultYaml = { explicit: false, version: '1.2' };
+Directives.defaultTags = { '!!': 'tag:yaml.org,2002:' };
+
+directives.Directives = Directives;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/errors.esnext

@@ -0,0 +1,63 @@
+import { __exports as errors } from '../../../../../../_virtual/errors.esnext';
+export { __exports as default } from '../../../../../../_virtual/errors.esnext';
+
+class YAMLError extends Error {
+    constructor(name, pos, code, message) {
+        super();
+        this.name = name;
+        this.code = code;
+        this.message = message;
+        this.pos = pos;
+    }
+}
+class YAMLParseError extends YAMLError {
+    constructor(pos, code, message) {
+        super('YAMLParseError', pos, code, message);
+    }
+}
+class YAMLWarning extends YAMLError {
+    constructor(pos, code, message) {
+        super('YAMLWarning', pos, code, message);
+    }
+}
+const prettifyError = (src, lc) => (error) => {
+    if (error.pos[0] === -1)
+        return;
+    error.linePos = error.pos.map(pos => lc.linePos(pos));
+    const { line, col } = error.linePos[0];
+    error.message += ` at line ${line}, column ${col}`;
+    let ci = col - 1;
+    let lineStr = src
+        .substring(lc.lineStarts[line - 1], lc.lineStarts[line])
+        .replace(/[\n\r]+$/, '');
+    // Trim to max 80 chars, keeping col position near the middle
+    if (ci >= 60 && lineStr.length > 80) {
+        const trimStart = Math.min(ci - 39, lineStr.length - 79);
+        lineStr = '…' + lineStr.substring(trimStart);
+        ci -= trimStart - 1;
+    }
+    if (lineStr.length > 80)
+        lineStr = lineStr.substring(0, 79) + '…';
+    // Include previous line in context if pointing at line start
+    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
+        // Regexp won't match if start is trimmed
+        let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
+        if (prev.length > 80)
+            prev = prev.substring(0, 79) + '…\n';
+        lineStr = prev + lineStr;
+    }
+    if (/[^ ]/.test(lineStr)) {
+        let count = 1;
+        const end = error.linePos[1];
+        if (end && end.line === line && end.col > col) {
+            count = Math.min(end.col - col, 80 - ci);
+        }
+        const pointer = ' '.repeat(ci) + '^'.repeat(count);
+        error.message += `:\n\n${lineStr}\n${pointer}\n`;
+    }
+};
+
+errors.YAMLError = YAMLError;
+errors.YAMLParseError = YAMLParseError;
+errors.YAMLWarning = YAMLWarning;
+errors.prettifyError = prettifyError;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/index.esnext

@@ -0,0 +1,85 @@
+import { __exports as dist } from '../../../../../../_virtual/index3.esnext';
+export { __exports as default } from '../../../../../../_virtual/index3.esnext';
+import './compose/composer.esnext';
+import './doc/Document.esnext';
+import './schema/Schema.esnext';
+import './errors.esnext';
+import './nodes/Alias.esnext';
+import './nodes/Node.esnext';
+import './nodes/Pair.esnext';
+import './nodes/Scalar.esnext';
+import './nodes/YAMLMap.esnext';
+import './nodes/YAMLSeq.esnext';
+import './parse/cst.esnext';
+import './parse/lexer.esnext';
+import './parse/line-counter.esnext';
+import './parse/parser.esnext';
+import './public-api.esnext';
+import './visit.esnext';
+import { __exports as composer$1 } from '../../../../../../_virtual/composer.esnext';
+import { __exports as Document$1 } from '../../../../../../_virtual/Document.esnext';
+import { __exports as Schema$1 } from '../../../../../../_virtual/Schema.esnext';
+import { __exports as errors$1 } from '../../../../../../_virtual/errors.esnext';
+import { __exports as Alias$1 } from '../../../../../../_virtual/Alias.esnext';
+import { __exports as Node$1 } from '../../../../../../_virtual/Node.esnext';
+import { __exports as Pair$1 } from '../../../../../../_virtual/Pair.esnext';
+import { __exports as Scalar$1 } from '../../../../../../_virtual/Scalar.esnext';
+import { __exports as YAMLMap$1 } from '../../../../../../_virtual/YAMLMap.esnext';
+import { __exports as YAMLSeq$1 } from '../../../../../../_virtual/YAMLSeq.esnext';
+import { __exports as cst$1 } from '../../../../../../_virtual/cst.esnext';
+import { __exports as lexer$1 } from '../../../../../../_virtual/lexer.esnext';
+import { __exports as lineCounter$1 } from '../../../../../../_virtual/line-counter.esnext';
+import { __exports as parser$1 } from '../../../../../../_virtual/parser.esnext';
+import { __exports as publicApi$1 } from '../../../../../../_virtual/public-api.esnext';
+import { __exports as visit$1 } from '../../../../../../_virtual/visit.esnext';
+
+var composer = composer$1;
+var Document = Document$1;
+var Schema = Schema$1;
+var errors = errors$1;
+var Alias = Alias$1;
+var Node = Node$1;
+var Pair = Pair$1;
+var Scalar = Scalar$1;
+var YAMLMap = YAMLMap$1;
+var YAMLSeq = YAMLSeq$1;
+var cst = cst$1;
+var lexer = lexer$1;
+var lineCounter = lineCounter$1;
+var parser = parser$1;
+var publicApi = publicApi$1;
+var visit = visit$1;
+
+
+
+var Composer = dist.Composer = composer.Composer;
+var Document_1 = dist.Document = Document.Document;
+var Schema_1 = dist.Schema = Schema.Schema;
+var YAMLError = dist.YAMLError = errors.YAMLError;
+var YAMLParseError = dist.YAMLParseError = errors.YAMLParseError;
+var YAMLWarning = dist.YAMLWarning = errors.YAMLWarning;
+var Alias_1 = dist.Alias = Alias.Alias;
+var isAlias = dist.isAlias = Node.isAlias;
+var isCollection = dist.isCollection = Node.isCollection;
+var isDocument = dist.isDocument = Node.isDocument;
+var isMap = dist.isMap = Node.isMap;
+var isNode = dist.isNode = Node.isNode;
+var isPair = dist.isPair = Node.isPair;
+var isScalar = dist.isScalar = Node.isScalar;
+var isSeq = dist.isSeq = Node.isSeq;
+var Pair_1 = dist.Pair = Pair.Pair;
+var Scalar_1 = dist.Scalar = Scalar.Scalar;
+var YAMLMap_1 = dist.YAMLMap = YAMLMap.YAMLMap;
+var YAMLSeq_1 = dist.YAMLSeq = YAMLSeq.YAMLSeq;
+var CST = dist.CST = cst;
+var Lexer = dist.Lexer = lexer.Lexer;
+var LineCounter = dist.LineCounter = lineCounter.LineCounter;
+var Parser = dist.Parser = parser.Parser;
+var parse = dist.parse = publicApi.parse;
+var parseAllDocuments = dist.parseAllDocuments = publicApi.parseAllDocuments;
+var parseDocument = dist.parseDocument = publicApi.parseDocument;
+var stringify = dist.stringify = publicApi.stringify;
+var visit_1 = dist.visit = visit.visit;
+var visitAsync = dist.visitAsync = visit.visitAsync;
+
+export { Alias_1 as Alias, CST, Composer, Document_1 as Document, Lexer, LineCounter, Pair_1 as Pair, Parser, Scalar_1 as Scalar, Schema_1 as Schema, YAMLError, YAMLMap_1 as YAMLMap, YAMLParseError, YAMLSeq_1 as YAMLSeq, YAMLWarning, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq, parse, parseAllDocuments, parseDocument, stringify, visit_1 as visit, visitAsync };

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/log.esnext

@@ -0,0 +1,18 @@
+import { __exports as log } from '../../../../../../_virtual/log.esnext';
+export { __exports as default } from '../../../../../../_virtual/log.esnext';
+
+function debug(logLevel, ...messages) {
+    if (logLevel === 'debug')
+        console.log(...messages);
+}
+function warn(logLevel, warning) {
+    if (logLevel === 'debug' || logLevel === 'warn') {
+        if (typeof process !== 'undefined' && process.emitWarning)
+            process.emitWarning(warning);
+        else
+            console.warn(warning);
+    }
+}
+
+log.debug = debug;
+log.warn = warn;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/Alias.esnext

@@ -0,0 +1,103 @@
+import { __exports as Alias$1 } from '../../../../../../../_virtual/Alias.esnext';
+export { __exports as default } from '../../../../../../../_virtual/Alias.esnext';
+import '../doc/anchors.esnext';
+import '../visit.esnext';
+import './Node.esnext';
+import { __exports as anchors$1 } from '../../../../../../../_virtual/anchors.esnext';
+import { __exports as visit$1 } from '../../../../../../../_virtual/visit.esnext';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.esnext';
+
+var anchors = anchors$1;
+var visit = visit$1;
+var Node = Node$1;
+
+class Alias extends Node.NodeBase {
+    constructor(source) {
+        super(Node.ALIAS);
+        this.source = source;
+        Object.defineProperty(this, 'tag', {
+            set() {
+                throw new Error('Alias nodes cannot have tags');
+            }
+        });
+    }
+    /**
+     * Resolve the value of this alias within `doc`, finding the last
+     * instance of the `source` anchor before this node.
+     */
+    resolve(doc) {
+        let found = undefined;
+        visit.visit(doc, {
+            Node: (_key, node) => {
+                if (node === this)
+                    return visit.visit.BREAK;
+                if (node.anchor === this.source)
+                    found = node;
+            }
+        });
+        return found;
+    }
+    toJSON(_arg, ctx) {
+        if (!ctx)
+            return { source: this.source };
+        const { anchors, doc, maxAliasCount } = ctx;
+        const source = this.resolve(doc);
+        if (!source) {
+            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+            throw new ReferenceError(msg);
+        }
+        const data = anchors.get(source);
+        /* istanbul ignore if */
+        if (!data || data.res === undefined) {
+            const msg = 'This should not happen: Alias anchor was not resolved?';
+            throw new ReferenceError(msg);
+        }
+        if (maxAliasCount >= 0) {
+            data.count += 1;
+            if (data.aliasCount === 0)
+                data.aliasCount = getAliasCount(doc, source, anchors);
+            if (data.count * data.aliasCount > maxAliasCount) {
+                const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                throw new ReferenceError(msg);
+            }
+        }
+        return data.res;
+    }
+    toString(ctx, _onComment, _onChompKeep) {
+        const src = `*${this.source}`;
+        if (ctx) {
+            anchors.anchorIsValid(this.source);
+            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+                throw new Error(msg);
+            }
+            if (ctx.implicitKey)
+                return `${src} `;
+        }
+        return src;
+    }
+}
+function getAliasCount(doc, node, anchors) {
+    if (Node.isAlias(node)) {
+        const source = node.resolve(doc);
+        const anchor = anchors && source && anchors.get(source);
+        return anchor ? anchor.count * anchor.aliasCount : 0;
+    }
+    else if (Node.isCollection(node)) {
+        let count = 0;
+        for (const item of node.items) {
+            const c = getAliasCount(doc, item, anchors);
+            if (c > count)
+                count = c;
+        }
+        return count;
+    }
+    else if (Node.isPair(node)) {
+        const kc = getAliasCount(doc, node.key, anchors);
+        const vc = getAliasCount(doc, node.value, anchors);
+        return Math.max(kc, vc);
+    }
+    return 1;
+}
+
+Alias$1.Alias = Alias;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/Collection.esnext

@@ -0,0 +1,156 @@
+import { __exports as Collection$1 } from '../../../../../../../_virtual/Collection.esnext';
+export { __exports as default } from '../../../../../../../_virtual/Collection.esnext';
+import '../doc/createNode.esnext';
+import './Node.esnext';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.esnext';
+import { __exports as createNode$1 } from '../../../../../../../_virtual/createNode.esnext';
+
+var createNode = createNode$1;
+var Node = Node$1;
+
+function collectionFromPath(schema, path, value) {
+    let v = value;
+    for (let i = path.length - 1; i >= 0; --i) {
+        const k = path[i];
+        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {
+            const a = [];
+            a[k] = v;
+            v = a;
+        }
+        else {
+            v = new Map([[k, v]]);
+        }
+    }
+    return createNode.createNode(v, undefined, {
+        aliasDuplicateObjects: false,
+        keepUndefined: false,
+        onAnchor: () => {
+            throw new Error('This should not happen, please report a bug.');
+        },
+        schema,
+        sourceObjects: new Map()
+    });
+}
+// Type guard is intentionally a little wrong so as to be more useful,
+// as it does not cover untypable empty non-string iterables (e.g. []).
+const isEmptyPath = (path) => path == null ||
+    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);
+class Collection extends Node.NodeBase {
+    constructor(type, schema) {
+        super(type);
+        Object.defineProperty(this, 'schema', {
+            value: schema,
+            configurable: true,
+            enumerable: false,
+            writable: true
+        });
+    }
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema) {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (schema)
+            copy.schema = schema;
+        copy.items = copy.items.map(it => Node.isNode(it) || Node.isPair(it) ? it.clone(schema) : it);
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /**
+     * Adds a value to the collection. For `!!map` and `!!omap` the value must
+     * be a Pair instance or a `{ key, value }` object, which may not have a key
+     * that already exists in the map.
+     */
+    addIn(path, value) {
+        if (isEmptyPath(path))
+            this.add(value);
+        else {
+            const [key, ...rest] = path;
+            const node = this.get(key, true);
+            if (Node.isCollection(node))
+                node.addIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn(path) {
+        const [key, ...rest] = path;
+        if (rest.length === 0)
+            return this.delete(key);
+        const node = this.get(key, true);
+        if (Node.isCollection(node))
+            return node.deleteIn(rest);
+        else
+            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+    }
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn(path, keepScalar) {
+        const [key, ...rest] = path;
+        const node = this.get(key, true);
+        if (rest.length === 0)
+            return !keepScalar && Node.isScalar(node) ? node.value : node;
+        else
+            return Node.isCollection(node) ? node.getIn(rest, keepScalar) : undefined;
+    }
+    hasAllNullValues(allowScalar) {
+        return this.items.every(node => {
+            if (!Node.isPair(node))
+                return false;
+            const n = node.value;
+            return (n == null ||
+                (allowScalar &&
+                    Node.isScalar(n) &&
+                    n.value == null &&
+                    !n.commentBefore &&
+                    !n.comment &&
+                    !n.tag));
+        });
+    }
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    hasIn(path) {
+        const [key, ...rest] = path;
+        if (rest.length === 0)
+            return this.has(key);
+        const node = this.get(key, true);
+        return Node.isCollection(node) ? node.hasIn(rest) : false;
+    }
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn(path, value) {
+        const [key, ...rest] = path;
+        if (rest.length === 0) {
+            this.set(key, value);
+        }
+        else {
+            const node = this.get(key, true);
+            if (Node.isCollection(node))
+                node.setIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+}
+Collection.maxFlowStringSingleLineLength = 60;
+
+Collection$1.Collection = Collection;
+Collection$1.collectionFromPath = collectionFromPath;
+Collection$1.isEmptyPath = isEmptyPath;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/nodes/Node.esnext

@@ -0,0 +1,67 @@
+import { __exports as Node } from '../../../../../../../_virtual/Node.esnext';
+export { __exports as default } from '../../../../../../../_virtual/Node.esnext';
+
+const ALIAS = Symbol.for('yaml.alias');
+const DOC = Symbol.for('yaml.document');
+const MAP = Symbol.for('yaml.map');
+const PAIR = Symbol.for('yaml.pair');
+const SCALAR = Symbol.for('yaml.scalar');
+const SEQ = Symbol.for('yaml.seq');
+const NODE_TYPE = Symbol.for('yaml.node.type');
+const isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;
+const isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;
+const isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;
+const isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;
+const isScalar = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR;
+const isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;
+function isCollection(node) {
+    if (node && typeof node === 'object')
+        switch (node[NODE_TYPE]) {
+            case MAP:
+            case SEQ:
+                return true;
+        }
+    return false;
+}
+function isNode(node) {
+    if (node && typeof node === 'object')
+        switch (node[NODE_TYPE]) {
+            case ALIAS:
+            case MAP:
+            case SCALAR:
+            case SEQ:
+                return true;
+        }
+    return false;
+}
+const hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;
+class NodeBase {
+    constructor(type) {
+        Object.defineProperty(this, NODE_TYPE, { value: type });
+    }
+    /** Create a copy of this node.  */
+    clone() {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+}
+
+Node.ALIAS = ALIAS;
+Node.DOC = DOC;
+Node.MAP = MAP;
+Node.NODE_TYPE = NODE_TYPE;
+Node.NodeBase = NodeBase;
+Node.PAIR = PAIR;
+Node.SCALAR = SCALAR;
+Node.SEQ = SEQ;
+Node.hasAnchor = hasAnchor;
+Node.isAlias = isAlias;
+Node.isCollection = isCollection;
+Node.isDocument = isDocument;
+Node.isMap = isMap;
+Node.isNode = isNode;
+Node.isPair = isPair;
+Node.isScalar = isScalar;
+Node.isSeq = isSeq;