phantom-pr 0.2.2 → 0.2.4

package/node_modules/yaml/dist/parse/cst-visit.d.ts

@@ -0,0 +1,39 @@
+import type { BlockMap, BlockSequence, CollectionItem, Document, FlowCollection } from './cst';
+export type VisitPath = readonly ['key' | 'value', number][];
+export type Visitor = (item: CollectionItem, path: VisitPath) => number | symbol | Visitor | void;
+/**
+ * Apply a visitor to a CST document or item.
+ *
+ * Walks through the tree (depth-first) starting from the root, calling a
+ * `visitor` function with two arguments when entering each item:
+ *   - `item`: The current item, which included the following members:
+ *     - `start: SourceToken[]` – Source tokens before the key or value,
+ *       possibly including its anchor or tag.
+ *     - `key?: Token | null` – Set for pair values. May then be `null`, if
+ *       the key before the `:` separator is empty.
+ *     - `sep?: SourceToken[]` – Source tokens between the key and the value,
+ *       which should include the `:` map value indicator if `value` is set.
+ *     - `value?: Token` – The value of a sequence item, or of a map pair.
+ *   - `path`: The steps from the root to the current node, as an array of
+ *     `['key' | 'value', number]` tuples.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this token, continue with
+ *      next sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current item, then continue with the next one
+ *   - `number`: Set the index of the next step. This is useful especially if
+ *     the index of the current token has changed.
+ *   - `function`: Define the next visitor for this item. After the original
+ *     visitor is called on item entry, next visitors are called after handling
+ *     a non-empty `key` and when exiting the item.
+ */
+export declare function visit(cst: Document | CollectionItem, visitor: Visitor): void;
+export declare namespace visit {
+    var BREAK: symbol;
+    var SKIP: symbol;
+    var REMOVE: symbol;
+    var itemAtPath: (cst: Document | CollectionItem, path: VisitPath) => CollectionItem | undefined;
+    var parentCollection: (cst: Document | CollectionItem, path: VisitPath) => BlockMap | BlockSequence | FlowCollection;
+}

package/node_modules/yaml/dist/parse/cst-visit.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const BREAK = Symbol('break visit');
+const SKIP = Symbol('skip children');
+const REMOVE = Symbol('remove item');
+/**
+ * Apply a visitor to a CST document or item.
+ *
+ * Walks through the tree (depth-first) starting from the root, calling a
+ * `visitor` function with two arguments when entering each item:
+ *   - `item`: The current item, which included the following members:
+ *     - `start: SourceToken[]` – Source tokens before the key or value,
+ *       possibly including its anchor or tag.
+ *     - `key?: Token | null` – Set for pair values. May then be `null`, if
+ *       the key before the `:` separator is empty.
+ *     - `sep?: SourceToken[]` – Source tokens between the key and the value,
+ *       which should include the `:` map value indicator if `value` is set.
+ *     - `value?: Token` – The value of a sequence item, or of a map pair.
+ *   - `path`: The steps from the root to the current node, as an array of
+ *     `['key' | 'value', number]` tuples.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this token, continue with
+ *      next sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current item, then continue with the next one
+ *   - `number`: Set the index of the next step. This is useful especially if
+ *     the index of the current token has changed.
+ *   - `function`: Define the next visitor for this item. After the original
+ *     visitor is called on item entry, next visitors are called after handling
+ *     a non-empty `key` and when exiting the item.
+ */
+function visit(cst, visitor) {
+    if ('type' in cst && cst.type === 'document')
+        cst = { start: cst.start, value: cst.value };
+    _visit(Object.freeze([]), cst, visitor);
+}
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
+visit.BREAK = BREAK;
+/** Do not visit the children of the current item */
+visit.SKIP = SKIP;
+/** Remove the current item */
+visit.REMOVE = REMOVE;
+/** Find the item at `path` from `cst` as the root */
+visit.itemAtPath = (cst, path) => {
+    let item = cst;
+    for (const [field, index] of path) {
+        const tok = item?.[field];
+        if (tok && 'items' in tok) {
+            item = tok.items[index];
+        }
+        else
+            return undefined;
+    }
+    return item;
+};
+/**
+ * Get the immediate parent collection of the item at `path` from `cst` as the root.
+ *
+ * Throws an error if the collection is not found, which should never happen if the item itself exists.
+ */
+visit.parentCollection = (cst, path) => {
+    const parent = visit.itemAtPath(cst, path.slice(0, -1));
+    const field = path[path.length - 1][0];
+    const coll = parent?.[field];
+    if (coll && 'items' in coll)
+        return coll;
+    throw new Error('Parent collection not found');
+};
+function _visit(path, item, visitor) {
+    let ctrl = visitor(item, path);
+    if (typeof ctrl === 'symbol')
+        return ctrl;
+    for (const field of ['key', 'value']) {
+        const token = item[field];
+        if (token && 'items' in token) {
+            for (let i = 0; i < token.items.length; ++i) {
+                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK)
+                    return BREAK;
+                else if (ci === REMOVE) {
+                    token.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+            if (typeof ctrl === 'function' && field === 'key')
+                ctrl = ctrl(item, path);
+        }
+    }
+    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;
+}
+
+exports.visit = visit;

package/node_modules/yaml/dist/parse/cst.d.ts

@@ -0,0 +1,109 @@
+export { createScalarToken, resolveAsScalar, setScalarValue } from './cst-scalar';
+export { stringify } from './cst-stringify';
+export type { Visitor, VisitPath } from './cst-visit';
+export { visit } from './cst-visit';
+export interface SourceToken {
+    type: 'byte-order-mark' | 'doc-mode' | 'doc-start' | 'space' | 'comment' | 'newline' | 'directive-line' | 'anchor' | 'tag' | 'seq-item-ind' | 'explicit-key-ind' | 'map-value-ind' | 'flow-map-start' | 'flow-map-end' | 'flow-seq-start' | 'flow-seq-end' | 'flow-error-end' | 'comma' | 'block-scalar-header';
+    offset: number;
+    indent: number;
+    source: string;
+}
+export interface ErrorToken {
+    type: 'error';
+    offset: number;
+    source: string;
+    message: string;
+}
+export interface Directive {
+    type: 'directive';
+    offset: number;
+    source: string;
+}
+export interface Document {
+    type: 'document';
+    offset: number;
+    start: SourceToken[];
+    value?: Token;
+    end?: SourceToken[];
+}
+export interface DocumentEnd {
+    type: 'doc-end';
+    offset: number;
+    source: string;
+    end?: SourceToken[];
+}
+export interface FlowScalar {
+    type: 'alias' | 'scalar' | 'single-quoted-scalar' | 'double-quoted-scalar';
+    offset: number;
+    indent: number;
+    source: string;
+    end?: SourceToken[];
+}
+export interface BlockScalar {
+    type: 'block-scalar';
+    offset: number;
+    indent: number;
+    props: Token[];
+    source: string;
+}
+export interface BlockMap {
+    type: 'block-map';
+    offset: number;
+    indent: number;
+    items: Array<{
+        start: SourceToken[];
+        explicitKey?: true;
+        key?: never;
+        sep?: never;
+        value?: never;
+    } | {
+        start: SourceToken[];
+        explicitKey?: true;
+        key: Token | null;
+        sep: SourceToken[];
+        value?: Token;
+    }>;
+}
+export interface BlockSequence {
+    type: 'block-seq';
+    offset: number;
+    indent: number;
+    items: Array<{
+        start: SourceToken[];
+        key?: never;
+        sep?: never;
+        value?: Token;
+    }>;
+}
+export type CollectionItem = {
+    start: SourceToken[];
+    key?: Token | null;
+    sep?: SourceToken[];
+    value?: Token;
+};
+export interface FlowCollection {
+    type: 'flow-collection';
+    offset: number;
+    indent: number;
+    start: SourceToken;
+    items: CollectionItem[];
+    end: SourceToken[];
+}
+export type Token = SourceToken | ErrorToken | Directive | Document | DocumentEnd | FlowScalar | BlockScalar | BlockMap | BlockSequence | FlowCollection;
+export type TokenType = SourceToken['type'] | DocumentEnd['type'] | FlowScalar['type'];
+/** The byte order mark */
+export declare const BOM = "\uFEFF";
+/** Start of doc-mode */
+export declare const DOCUMENT = "\u0002";
+/** Unexpected end of flow-mode */
+export declare const FLOW_END = "\u0018";
+/** Next token is a scalar value */
+export declare const SCALAR = "\u001F";
+/** @returns `true` if `token` is a flow or block collection */
+export declare const isCollection: (token: Token | null | undefined) => token is BlockMap | BlockSequence | FlowCollection;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+export declare const isScalar: (token: Token | null | undefined) => token is FlowScalar | BlockScalar;
+/** Get a printable representation of a lexer token */
+export declare function prettyToken(token: string): string;
+/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+export declare function tokenType(source: string): TokenType | null;

package/node_modules/yaml/dist/parse/cst.js

@@ -0,0 +1,112 @@
+'use strict';
+
+var cstScalar = require('./cst-scalar.js');
+var cstStringify = require('./cst-stringify.js');
+var cstVisit = require('./cst-visit.js');
+
+/** The byte order mark */
+const BOM = '\u{FEFF}';
+/** Start of doc-mode */
+const DOCUMENT = '\x02'; // C0: Start of Text
+/** Unexpected end of flow-mode */
+const FLOW_END = '\x18'; // C0: Cancel
+/** Next token is a scalar value */
+const SCALAR = '\x1f'; // C0: Unit Separator
+/** @returns `true` if `token` is a flow or block collection */
+const isCollection = (token) => !!token && 'items' in token;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+const isScalar = (token) => !!token &&
+    (token.type === 'scalar' ||
+        token.type === 'single-quoted-scalar' ||
+        token.type === 'double-quoted-scalar' ||
+        token.type === 'block-scalar');
+/* istanbul ignore next */
+/** Get a printable representation of a lexer token */
+function prettyToken(token) {
+    switch (token) {
+        case BOM:
+            return '<BOM>';
+        case DOCUMENT:
+            return '<DOC>';
+        case FLOW_END:
+            return '<FLOW_END>';
+        case SCALAR:
+            return '<SCALAR>';
+        default:
+            return JSON.stringify(token);
+    }
+}
+/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+function tokenType(source) {
+    switch (source) {
+        case BOM:
+            return 'byte-order-mark';
+        case DOCUMENT:
+            return 'doc-mode';
+        case FLOW_END:
+            return 'flow-error-end';
+        case SCALAR:
+            return 'scalar';
+        case '---':
+            return 'doc-start';
+        case '...':
+            return 'doc-end';
+        case '':
+        case '\n':
+        case '\r\n':
+            return 'newline';
+        case '-':
+            return 'seq-item-ind';
+        case '?':
+            return 'explicit-key-ind';
+        case ':':
+            return 'map-value-ind';
+        case '{':
+            return 'flow-map-start';
+        case '}':
+            return 'flow-map-end';
+        case '[':
+            return 'flow-seq-start';
+        case ']':
+            return 'flow-seq-end';
+        case ',':
+            return 'comma';
+    }
+    switch (source[0]) {
+        case ' ':
+        case '\t':
+            return 'space';
+        case '#':
+            return 'comment';
+        case '%':
+            return 'directive-line';
+        case '*':
+            return 'alias';
+        case '&':
+            return 'anchor';
+        case '!':
+            return 'tag';
+        case "'":
+            return 'single-quoted-scalar';
+        case '"':
+            return 'double-quoted-scalar';
+        case '|':
+        case '>':
+            return 'block-scalar-header';
+    }
+    return null;
+}
+
+exports.createScalarToken = cstScalar.createScalarToken;
+exports.resolveAsScalar = cstScalar.resolveAsScalar;
+exports.setScalarValue = cstScalar.setScalarValue;
+exports.stringify = cstStringify.stringify;
+exports.visit = cstVisit.visit;
+exports.BOM = BOM;
+exports.DOCUMENT = DOCUMENT;
+exports.FLOW_END = FLOW_END;
+exports.SCALAR = SCALAR;
+exports.isCollection = isCollection;
+exports.isScalar = isScalar;
+exports.prettyToken = prettyToken;
+exports.tokenType = tokenType;

package/node_modules/yaml/dist/parse/lexer.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Splits an input string into lexical tokens, i.e. smaller strings that are
+ * easily identifiable by `tokens.tokenType()`.
+ *
+ * Lexing starts always in a "stream" context. Incomplete input may be buffered
+ * until a complete token can be emitted.
+ *
+ * In addition to slices of the original input, the following control characters
+ * may also be emitted:
+ *
+ * - `\x02` (Start of Text): A document starts with the next token
+ * - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
+ * - `\x1f` (Unit Separator): Next token is a scalar value
+ * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
+ */
+export declare class Lexer {
+    /**
+     * Flag indicating whether the end of the current buffer marks the end of
+     * all input
+     */
+    private atEnd;
+    /**
+     * Explicit indent set in block scalar header, as an offset from the current
+     * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not
+     * explicitly set.
+     */
+    private blockScalarIndent;
+    /**
+     * Block scalars that include a + (keep) chomping indicator in their header
+     * include trailing empty lines, which are otherwise excluded from the
+     * scalar's contents.
+     */
+    private blockScalarKeep;
+    /** Current input */
+    private buffer;
+    /**
+     * Flag noting whether the map value indicator : can immediately follow this
+     * node within a flow context.
+     */
+    private flowKey;
+    /** Count of surrounding flow collection levels. */
+    private flowLevel;
+    /**
+     * Minimum level of indentation required for next lines to be parsed as a
+     * part of the current scalar value.
+     */
+    private indentNext;
+    /** Indentation level of the current line. */
+    private indentValue;
+    /** Position of the next \n character. */
+    private lineEndPos;
+    /** Stores the state of the lexer if reaching the end of incpomplete input */
+    private next;
+    /** A pointer to `buffer`; the current position of the lexer. */
+    private pos;
+    /**
+     * Generate YAML tokens from the `source` string. If `incomplete`,
+     * a part of the last line may be left as a buffer for the next call.
+     *
+     * @returns A generator of lexical tokens
+     */
+    lex(source: string, incomplete?: boolean): Generator<string, void>;
+    private atLineEnd;
+    private charAt;
+    private continueScalar;
+    private getLine;
+    private hasChars;
+    private setNext;
+    private peek;
+    private parseNext;
+    private parseStream;
+    private parseLineStart;
+    private parseBlockStart;
+    private parseDocument;
+    private parseFlowCollection;
+    private parseQuotedScalar;
+    private parseBlockScalarHeader;
+    private parseBlockScalar;
+    private parsePlainScalar;
+    private pushCount;
+    private pushToIndex;
+    private pushIndicators;
+    private pushTag;
+    private pushNewline;
+    private pushSpaces;
+    private pushUntil;
+}