aboutsummaryrefslogtreecommitdiff
path: root/node_modules/yaml/browser/dist/parse/parser.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/yaml/browser/dist/parse/parser.js')
-rw-r--r--node_modules/yaml/browser/dist/parse/parser.js954
1 files changed, 0 insertions, 954 deletions
diff --git a/node_modules/yaml/browser/dist/parse/parser.js b/node_modules/yaml/browser/dist/parse/parser.js
deleted file mode 100644
index b14e677..0000000
--- a/node_modules/yaml/browser/dist/parse/parser.js
+++ /dev/null
@@ -1,954 +0,0 @@
-import { tokenType } from './cst.js';
-import { Lexer } from './lexer.js';
-
-function includesToken(list, type) {
- for (let i = 0; i < list.length; ++i)
- if (list[i].type === type)
- return true;
- return false;
-}
-function findNonEmptyIndex(list) {
- for (let i = 0; i < list.length; ++i) {
- switch (list[i].type) {
- case 'space':
- case 'comment':
- case 'newline':
- break;
- default:
- return i;
- }
- }
- return -1;
-}
-function isFlowToken(token) {
- switch (token === null || token === void 0 ? void 0 : token.type) {
- case 'alias':
- case 'scalar':
- case 'single-quoted-scalar':
- case 'double-quoted-scalar':
- case 'flow-collection':
- return true;
- default:
- return false;
- }
-}
-function getPrevProps(parent) {
- var _a;
- switch (parent.type) {
- case 'document':
- return parent.start;
- case 'block-map': {
- const it = parent.items[parent.items.length - 1];
- return (_a = it.sep) !== null && _a !== void 0 ? _a : it.start;
- }
- case 'block-seq':
- return parent.items[parent.items.length - 1].start;
- /* istanbul ignore next should not happen */
- default:
- return [];
- }
-}
-/** Note: May modify input array */
-function getFirstKeyStartProps(prev) {
- var _a;
- if (prev.length === 0)
- return [];
- let i = prev.length;
- loop: while (--i >= 0) {
- switch (prev[i].type) {
- case 'doc-start':
- case 'explicit-key-ind':
- case 'map-value-ind':
- case 'seq-item-ind':
- case 'newline':
- break loop;
- }
- }
- while (((_a = prev[++i]) === null || _a === void 0 ? void 0 : _a.type) === 'space') {
- /* loop */
- }
- return prev.splice(i, prev.length);
-}
-function fixFlowSeqItems(fc) {
- if (fc.start.type === 'flow-seq-start') {
- for (const it of fc.items) {
- if (it.sep &&
- !it.value &&
- !includesToken(it.start, 'explicit-key-ind') &&
- !includesToken(it.sep, 'map-value-ind')) {
- if (it.key)
- it.value = it.key;
- delete it.key;
- if (isFlowToken(it.value)) {
- if (it.value.end)
- Array.prototype.push.apply(it.value.end, it.sep);
- else
- it.value.end = it.sep;
- }
- else
- Array.prototype.push.apply(it.start, it.sep);
- delete it.sep;
- }
- }
- }
-}
-/**
- * A YAML concrete syntax tree (CST) parser
- *
- * ```ts
- * const src: string = ...
- * for (const token of new Parser().parse(src)) {
- * // token: Token
- * }
- * ```
- *
- * To use the parser with a user-provided lexer:
- *
- * ```ts
- * function* parse(source: string, lexer: Lexer) {
- * const parser = new Parser()
- * for (const lexeme of lexer.lex(source))
- * yield* parser.next(lexeme)
- * yield* parser.end()
- * }
- *
- * const src: string = ...
- * const lexer = new Lexer()
- * for (const token of parse(src, lexer)) {
- * // token: Token
- * }
- * ```
- */
-class Parser {
- /**
- * @param onNewLine - If defined, called separately with the start position of
- * each new line (in `parse()`, including the start of input).
- */
- constructor(onNewLine) {
- /** If true, space and sequence indicators count as indentation */
- this.atNewLine = true;
- /** If true, next token is a scalar value */
- this.atScalar = false;
- /** Current indentation level */
- this.indent = 0;
- /** Current offset since the start of parsing */
- this.offset = 0;
- /** On the same line with a block map key */
- this.onKeyLine = false;
- /** Top indicates the node that's currently being built */
- this.stack = [];
- /** The source of the current token, set in parse() */
- this.source = '';
- /** The type of the current token, set in parse() */
- this.type = '';
- // Must be defined after `next()`
- this.lexer = new Lexer();
- this.onNewLine = onNewLine;
- }
- /**
- * Parse `source` as a YAML stream.
- * If `incomplete`, a part of the last line may be left as a buffer for the next call.
- *
- * Errors are not thrown, but yielded as `{ type: 'error', message }` tokens.
- *
- * @returns A generator of tokens representing each directive, document, and other structure.
- */
- *parse(source, incomplete = false) {
- if (this.onNewLine && this.offset === 0)
- this.onNewLine(0);
- for (const lexeme of this.lexer.lex(source, incomplete))
- yield* this.next(lexeme);
- if (!incomplete)
- yield* this.end();
- }
- /**
- * Advance the parser by the `source` of one lexical token.
- */
- *next(source) {
- this.source = source;
- if (this.atScalar) {
- this.atScalar = false;
- yield* this.step();
- this.offset += source.length;
- return;
- }
- const type = tokenType(source);
- if (!type) {
- const message = `Not a YAML token: ${source}`;
- yield* this.pop({ type: 'error', offset: this.offset, message, source });
- this.offset += source.length;
- }
- else if (type === 'scalar') {
- this.atNewLine = false;
- this.atScalar = true;
- this.type = 'scalar';
- }
- else {
- this.type = type;
- yield* this.step();
- switch (type) {
- case 'newline':
- this.atNewLine = true;
- this.indent = 0;
- if (this.onNewLine)
- this.onNewLine(this.offset + source.length);
- break;
- case 'space':
- if (this.atNewLine && source[0] === ' ')
- this.indent += source.length;
- break;
- case 'explicit-key-ind':
- case 'map-value-ind':
- case 'seq-item-ind':
- if (this.atNewLine)
- this.indent += source.length;
- break;
- case 'doc-mode':
- case 'flow-error-end':
- return;
- default:
- this.atNewLine = false;
- }
- this.offset += source.length;
- }
- }
- /** Call at end of input to push out any remaining constructions */
- *end() {
- while (this.stack.length > 0)
- yield* this.pop();
- }
- get sourceToken() {
- const st = {
- type: this.type,
- offset: this.offset,
- indent: this.indent,
- source: this.source
- };
- return st;
- }
- *step() {
- const top = this.peek(1);
- if (this.type === 'doc-end' && (!top || top.type !== 'doc-end')) {
- while (this.stack.length > 0)
- yield* this.pop();
- this.stack.push({
- type: 'doc-end',
- offset: this.offset,
- source: this.source
- });
- return;
- }
- if (!top)
- return yield* this.stream();
- switch (top.type) {
- case 'document':
- return yield* this.document(top);
- case 'alias':
- case 'scalar':
- case 'single-quoted-scalar':
- case 'double-quoted-scalar':
- return yield* this.scalar(top);
- case 'block-scalar':
- return yield* this.blockScalar(top);
- case 'block-map':
- return yield* this.blockMap(top);
- case 'block-seq':
- return yield* this.blockSequence(top);
- case 'flow-collection':
- return yield* this.flowCollection(top);
- case 'doc-end':
- return yield* this.documentEnd(top);
- }
- /* istanbul ignore next should not happen */
- yield* this.pop();
- }
- peek(n) {
- return this.stack[this.stack.length - n];
- }
- *pop(error) {
- const token = error !== null && error !== void 0 ? error : this.stack.pop();
- /* istanbul ignore if should not happen */
- if (!token) {
- const message = 'Tried to pop an empty stack';
- yield { type: 'error', offset: this.offset, source: '', message };
- }
- else if (this.stack.length === 0) {
- yield token;
- }
- else {
- const top = this.peek(1);
- if (token.type === 'block-scalar') {
- // Block scalars use their parent rather than header indent
- token.indent = 'indent' in top ? top.indent : 0;
- }
- else if (token.type === 'flow-collection' && top.type === 'document') {
- // Ignore all indent for top-level flow collections
- token.indent = 0;
- }
- if (token.type === 'flow-collection')
- fixFlowSeqItems(token);
- switch (top.type) {
- case 'document':
- top.value = token;
- break;
- case 'block-scalar':
- top.props.push(token); // error
- break;
- case 'block-map': {
- const it = top.items[top.items.length - 1];
- if (it.value) {
- top.items.push({ start: [], key: token, sep: [] });
- this.onKeyLine = true;
- return;
- }
- else if (it.sep) {
- it.value = token;
- }
- else {
- Object.assign(it, { key: token, sep: [] });
- this.onKeyLine = !includesToken(it.start, 'explicit-key-ind');
- return;
- }
- break;
- }
- case 'block-seq': {
- const it = top.items[top.items.length - 1];
- if (it.value)
- top.items.push({ start: [], value: token });
- else
- it.value = token;
- break;
- }
- case 'flow-collection': {
- const it = top.items[top.items.length - 1];
- if (!it || it.value)
- top.items.push({ start: [], key: token, sep: [] });
- else if (it.sep)
- it.value = token;
- else
- Object.assign(it, { key: token, sep: [] });
- return;
- }
- /* istanbul ignore next should not happen */
- default:
- yield* this.pop();
- yield* this.pop(token);
- }
- if ((top.type === 'document' ||
- top.type === 'block-map' ||
- top.type === 'block-seq') &&
- (token.type === 'block-map' || token.type === 'block-seq')) {
- const last = token.items[token.items.length - 1];
- if (last &&
- !last.sep &&
- !last.value &&
- last.start.length > 0 &&
- findNonEmptyIndex(last.start) === -1 &&
- (token.indent === 0 ||
- last.start.every(st => st.type !== 'comment' || st.indent < token.indent))) {
- if (top.type === 'document')
- top.end = last.start;
- else
- top.items.push({ start: last.start });
- token.items.splice(-1, 1);
- }
- }
- }
- }
- *stream() {
- switch (this.type) {
- case 'directive-line':
- yield { type: 'directive', offset: this.offset, source: this.source };
- return;
- case 'byte-order-mark':
- case 'space':
- case 'comment':
- case 'newline':
- yield this.sourceToken;
- return;
- case 'doc-mode':
- case 'doc-start': {
- const doc = {
- type: 'document',
- offset: this.offset,
- start: []
- };
- if (this.type === 'doc-start')
- doc.start.push(this.sourceToken);
- this.stack.push(doc);
- return;
- }
- }
- yield {
- type: 'error',
- offset: this.offset,
- message: `Unexpected ${this.type} token in YAML stream`,
- source: this.source
- };
- }
- *document(doc) {
- if (doc.value)
- return yield* this.lineEnd(doc);
- switch (this.type) {
- case 'doc-start': {
- if (findNonEmptyIndex(doc.start) !== -1) {
- yield* this.pop();
- yield* this.step();
- }
- else
- doc.start.push(this.sourceToken);
- return;
- }
- case 'anchor':
- case 'tag':
- case 'space':
- case 'comment':
- case 'newline':
- doc.start.push(this.sourceToken);
- return;
- }
- const bv = this.startBlockValue(doc);
- if (bv)
- this.stack.push(bv);
- else {
- yield {
- type: 'error',
- offset: this.offset,
- message: `Unexpected ${this.type} token in YAML document`,
- source: this.source
- };
- }
- }
- *scalar(scalar) {
- if (this.type === 'map-value-ind') {
- const prev = getPrevProps(this.peek(2));
- const start = getFirstKeyStartProps(prev);
- let sep;
- if (scalar.end) {
- sep = scalar.end;
- sep.push(this.sourceToken);
- delete scalar.end;
- }
- else
- sep = [this.sourceToken];
- const map = {
- type: 'block-map',
- offset: scalar.offset,
- indent: scalar.indent,
- items: [{ start, key: scalar, sep }]
- };
- this.onKeyLine = true;
- this.stack[this.stack.length - 1] = map;
- }
- else
- yield* this.lineEnd(scalar);
- }
- *blockScalar(scalar) {
- switch (this.type) {
- case 'space':
- case 'comment':
- case 'newline':
- scalar.props.push(this.sourceToken);
- return;
- case 'scalar':
- scalar.source = this.source;
- // block-scalar source includes trailing newline
- this.atNewLine = true;
- this.indent = 0;
- if (this.onNewLine) {
- let nl = this.source.indexOf('\n') + 1;
- while (nl !== 0) {
- this.onNewLine(this.offset + nl);
- nl = this.source.indexOf('\n', nl) + 1;
- }
- }
- yield* this.pop();
- break;
- /* istanbul ignore next should not happen */
- default:
- yield* this.pop();
- yield* this.step();
- }
- }
- *blockMap(map) {
- var _a;
- const it = map.items[map.items.length - 1];
- // it.sep is true-ish if pair already has key or : separator
- switch (this.type) {
- case 'newline':
- this.onKeyLine = false;
- if (it.value) {
- const end = 'end' in it.value ? it.value.end : undefined;
- const last = Array.isArray(end) ? end[end.length - 1] : undefined;
- if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
- end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
- else
- map.items.push({ start: [this.sourceToken] });
- }
- else if (it.sep) {
- it.sep.push(this.sourceToken);
- }
- else {
- it.start.push(this.sourceToken);
- }
- return;
- case 'space':
- case 'comment':
- if (it.value) {
- map.items.push({ start: [this.sourceToken] });
- }
- else if (it.sep) {
- it.sep.push(this.sourceToken);
- }
- else {
- if (this.atIndentedComment(it.start, map.indent)) {
- const prev = map.items[map.items.length - 2];
- const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
- if (Array.isArray(end)) {
- Array.prototype.push.apply(end, it.start);
- end.push(this.sourceToken);
- map.items.pop();
- return;
- }
- }
- it.start.push(this.sourceToken);
- }
- return;
- }
- if (this.indent >= map.indent) {
- const atNextItem = !this.onKeyLine && this.indent === map.indent && it.sep;
- // For empty nodes, assign newline-separated not indented empty tokens to following node
- let start = [];
- if (atNextItem && it.sep && !it.value) {
- const nl = [];
- for (let i = 0; i < it.sep.length; ++i) {
- const st = it.sep[i];
- switch (st.type) {
- case 'newline':
- nl.push(i);
- break;
- case 'space':
- break;
- case 'comment':
- if (st.indent > map.indent)
- nl.length = 0;
- break;
- default:
- nl.length = 0;
- }
- }
- if (nl.length >= 2)
- start = it.sep.splice(nl[1]);
- }
- switch (this.type) {
- case 'anchor':
- case 'tag':
- if (atNextItem || it.value) {
- start.push(this.sourceToken);
- map.items.push({ start });
- this.onKeyLine = true;
- }
- else if (it.sep) {
- it.sep.push(this.sourceToken);
- }
- else {
- it.start.push(this.sourceToken);
- }
- return;
- case 'explicit-key-ind':
- if (!it.sep && !includesToken(it.start, 'explicit-key-ind')) {
- it.start.push(this.sourceToken);
- }
- else if (atNextItem || it.value) {
- start.push(this.sourceToken);
- map.items.push({ start });
- }
- else {
- this.stack.push({
- type: 'block-map',
- offset: this.offset,
- indent: this.indent,
- items: [{ start: [this.sourceToken] }]
- });
- }
- this.onKeyLine = true;
- return;
- case 'map-value-ind':
- if (includesToken(it.start, 'explicit-key-ind')) {
- if (!it.sep) {
- if (includesToken(it.start, 'newline')) {
- Object.assign(it, { key: null, sep: [this.sourceToken] });
- }
- else {
- const start = getFirstKeyStartProps(it.start);
- this.stack.push({
- type: 'block-map',
- offset: this.offset,
- indent: this.indent,
- items: [{ start, key: null, sep: [this.sourceToken] }]
- });
- }
- }
- else if (it.value) {
- map.items.push({ start: [], key: null, sep: [this.sourceToken] });
- }
- else if (includesToken(it.sep, 'map-value-ind')) {
- this.stack.push({
- type: 'block-map',
- offset: this.offset,
- indent: this.indent,
- items: [{ start, key: null, sep: [this.sourceToken] }]
- });
- }
- else if (isFlowToken(it.key) &&
- !includesToken(it.sep, 'newline')) {
- const start = getFirstKeyStartProps(it.start);
- const key = it.key;
- const sep = it.sep;
- sep.push(this.sourceToken);
- // @ts-expect-error type guard is wrong here
- delete it.key, delete it.sep;
- this.stack.push({
- type: 'block-map',
- offset: this.offset,
- indent: this.indent,
- items: [{ start, key, sep }]
- });
- }
- else if (start.length > 0) {
- // Not actually at next item
- it.sep = it.sep.concat(start, this.sourceToken);
- }
- else {
- it.sep.push(this.sourceToken);
- }
- }
- else {
- if (!it.sep) {
- Object.assign(it, { key: null, sep: [this.sourceToken] });
- }
- else if (it.value || atNextItem) {
- map.items.push({ start, key: null, sep: [this.sourceToken] });
- }
- else if (includesToken(it.sep, 'map-value-ind')) {
- this.stack.push({
- type: 'block-map',
- offset: this.offset,
- indent: this.indent,
- items: [{ start: [], key: null, sep: [this.sourceToken] }]
- });
- }
- else {
- it.sep.push(this.sourceToken);
- }
- }
- this.onKeyLine = true;
- return;
- case 'alias':
- case 'scalar':
- case 'single-quoted-scalar':
- case 'double-quoted-scalar': {
- const fs = this.flowScalar(this.type);
- if (atNextItem || it.value) {
- map.items.push({ start, key: fs, sep: [] });
- this.onKeyLine = true;
- }
- else if (it.sep) {
- this.stack.push(fs);
- }
- else {
- Object.assign(it, { key: fs, sep: [] });
- this.onKeyLine = true;
- }
- return;
- }
- default: {
- const bv = this.startBlockValue(map);
- if (bv) {
- if (atNextItem &&
- bv.type !== 'block-seq' &&
- includesToken(it.start, 'explicit-key-ind')) {
- map.items.push({ start });
- }
- this.stack.push(bv);
- return;
- }
- }
- }
- }
- yield* this.pop();
- yield* this.step();
- }
- *blockSequence(seq) {
- var _a;
- const it = seq.items[seq.items.length - 1];
- switch (this.type) {
- case 'newline':
- if (it.value) {
- const end = 'end' in it.value ? it.value.end : undefined;
- const last = Array.isArray(end) ? end[end.length - 1] : undefined;
- if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
- end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
- else
- seq.items.push({ start: [this.sourceToken] });
- }
- else
- it.start.push(this.sourceToken);
- return;
- case 'space':
- case 'comment':
- if (it.value)
- seq.items.push({ start: [this.sourceToken] });
- else {
- if (this.atIndentedComment(it.start, seq.indent)) {
- const prev = seq.items[seq.items.length - 2];
- const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
- if (Array.isArray(end)) {
- Array.prototype.push.apply(end, it.start);
- end.push(this.sourceToken);
- seq.items.pop();
- return;
- }
- }
- it.start.push(this.sourceToken);
- }
- return;
- case 'anchor':
- case 'tag':
- if (it.value || this.indent <= seq.indent)
- break;
- it.start.push(this.sourceToken);
- return;
- case 'seq-item-ind':
- if (this.indent !== seq.indent)
- break;
- if (it.value || includesToken(it.start, 'seq-item-ind'))
- seq.items.push({ start: [this.sourceToken] });
- else
- it.start.push(this.sourceToken);
- return;
- }
- if (this.indent > seq.indent) {
- const bv = this.startBlockValue(seq);
- if (bv) {
- this.stack.push(bv);
- return;
- }
- }
- yield* this.pop();
- yield* this.step();
- }
- *flowCollection(fc) {
- const it = fc.items[fc.items.length - 1];
- if (this.type === 'flow-error-end') {
- let top;
- do {
- yield* this.pop();
- top = this.peek(1);
- } while (top && top.type === 'flow-collection');
- }
- else if (fc.end.length === 0) {
- switch (this.type) {
- case 'comma':
- case 'explicit-key-ind':
- if (!it || it.sep)
- fc.items.push({ start: [this.sourceToken] });
- else
- it.start.push(this.sourceToken);
- return;
- case 'map-value-ind':
- if (!it || it.value)
- fc.items.push({ start: [], key: null, sep: [this.sourceToken] });
- else if (it.sep)
- it.sep.push(this.sourceToken);
- else
- Object.assign(it, { key: null, sep: [this.sourceToken] });
- return;
- case 'space':
- case 'comment':
- case 'newline':
- case 'anchor':
- case 'tag':
- if (!it || it.value)
- fc.items.push({ start: [this.sourceToken] });
- else if (it.sep)
- it.sep.push(this.sourceToken);
- else
- it.start.push(this.sourceToken);
- return;
- case 'alias':
- case 'scalar':
- case 'single-quoted-scalar':
- case 'double-quoted-scalar': {
- const fs = this.flowScalar(this.type);
- if (!it || it.value)
- fc.items.push({ start: [], key: fs, sep: [] });
- else if (it.sep)
- this.stack.push(fs);
- else
- Object.assign(it, { key: fs, sep: [] });
- return;
- }
- case 'flow-map-end':
- case 'flow-seq-end':
- fc.end.push(this.sourceToken);
- return;
- }
- const bv = this.startBlockValue(fc);
- /* istanbul ignore else should not happen */
- if (bv)
- this.stack.push(bv);
- else {
- yield* this.pop();
- yield* this.step();
- }
- }
- else {
- const parent = this.peek(2);
- if (parent.type === 'block-map' &&
- ((this.type === 'map-value-ind' && parent.indent === fc.indent) ||
- (this.type === 'newline' &&
- !parent.items[parent.items.length - 1].sep))) {
- yield* this.pop();
- yield* this.step();
- }
- else if (this.type === 'map-value-ind' &&
- parent.type !== 'flow-collection') {
- const prev = getPrevProps(parent);
- const start = getFirstKeyStartProps(prev);
- fixFlowSeqItems(fc);
- const sep = fc.end.splice(1, fc.end.length);
- sep.push(this.sourceToken);
- const map = {
- type: 'block-map',
- offset: fc.offset,
- indent: fc.indent,
- items: [{ start, key: fc, sep }]
- };
- this.onKeyLine = true;
- this.stack[this.stack.length - 1] = map;
- }
- else {
- yield* this.lineEnd(fc);
- }
- }
- }
- flowScalar(type) {
- if (this.onNewLine) {
- let nl = this.source.indexOf('\n') + 1;
- while (nl !== 0) {
- this.onNewLine(this.offset + nl);
- nl = this.source.indexOf('\n', nl) + 1;
- }
- }
- return {
- type,
- offset: this.offset,
- indent: this.indent,
- source: this.source
- };
- }
- startBlockValue(parent) {
- switch (this.type) {
- case 'alias':
- case 'scalar':
- case 'single-quoted-scalar':
- case 'double-quoted-scalar':
- return this.flowScalar(this.type);
- case 'block-scalar-header':
- return {
- type: 'block-scalar',
- offset: this.offset,
- indent: this.indent,
- props: [this.sourceToken],
- source: ''
- };
- case 'flow-map-start':
- case 'flow-seq-start':
- return {
- type: 'flow-collection',
- offset: this.offset,
- indent: this.indent,
- start: this.sourceToken,
- items: [],
- end: []
- };
- case 'seq-item-ind':
- return {
- type: 'block-seq',
- offset: this.offset,
- indent: this.indent,
- items: [{ start: [this.sourceToken] }]
- };
- case 'explicit-key-ind': {
- this.onKeyLine = true;
- const prev = getPrevProps(parent);
- const start = getFirstKeyStartProps(prev);
- start.push(this.sourceToken);
- return {
- type: 'block-map',
- offset: this.offset,
- indent: this.indent,
- items: [{ start }]
- };
- }
- case 'map-value-ind': {
- this.onKeyLine = true;
- const prev = getPrevProps(parent);
- const start = getFirstKeyStartProps(prev);
- return {
- type: 'block-map',
- offset: this.offset,
- indent: this.indent,
- items: [{ start, key: null, sep: [this.sourceToken] }]
- };
- }
- }
- return null;
- }
- atIndentedComment(start, indent) {
- if (this.type !== 'comment')
- return false;
- if (this.indent <= indent)
- return false;
- return start.every(st => st.type === 'newline' || st.type === 'space');
- }
- *documentEnd(docEnd) {
- if (this.type !== 'doc-mode') {
- if (docEnd.end)
- docEnd.end.push(this.sourceToken);
- else
- docEnd.end = [this.sourceToken];
- if (this.type === 'newline')
- yield* this.pop();
- }
- }
- *lineEnd(token) {
- switch (this.type) {
- case 'comma':
- case 'doc-start':
- case 'doc-end':
- case 'flow-seq-end':
- case 'flow-map-end':
- case 'map-value-ind':
- yield* this.pop();
- yield* this.step();
- break;
- case 'newline':
- this.onKeyLine = false;
- // fallthrough
- case 'space':
- case 'comment':
- default:
- // all other values are errors
- if (token.end)
- token.end.push(this.sourceToken);
- else
- token.end = [this.sourceToken];
- if (this.type === 'newline')
- yield* this.pop();
- }
- }
-}
-
-export { Parser };
© Floofi Systems, Some rights reserved. Powered by cgit.