Gecko [ gandhischool.edu.np ]

Name	Size	Permission
browser	[ DIR ]	dr-xr-xr-x
dist	[ DIR ]	dr-xr-xr-x
types	[ DIR ]	dr-xr-xr-x
LICENSE	743 B	-rw-rw-rw-
README.md	4.43 KB	-rw-rw-rw-
index.d.ts	10.49 KB	-rw-rw-rw-
index.js	40 B	-rw-rw-rw-
map.js	114 B	-rw-rw-rw-
package.json	3.01 KB	-rw-rw-rw-
pair.js	111 B	-rw-rw-rw-
parse-cst.d.ts	4.41 KB	-rw-rw-rw-
parse-cst.js	51 B	-rw-rw-rw-
scalar.js	113 B	-rw-rw-rw-
schema.js	311 B	-rw-rw-rw-
seq.js	114 B	-rw-rw-rw-
types.d.ts	11.36 KB	-rw-rw-rw-
types.js	510 B	-rw-rw-rw-
types.mjs	578 B	-rw-rw-rw-
util.d.ts	2.03 KB	-rw-rw-rw-
util.js	511 B	-rw-rw-rw-
util.mjs	571 B	-rw-rw-rw-

Code Editor : parse-cst.d.ts

import { Type, YAMLSyntaxError } from './util'

export default function parseCST(str: string): ParsedCST

export interface ParsedCST extends Array<CST.Document> {
  setOrigRanges(): boolean
}

export namespace CST {
  interface Range {
    start: number
    end: number
    origStart?: number
    origEnd?: number
    isEmpty(): boolean
  }

interface ParseContext {
    /** Node starts at beginning of line */
    atLineStart: boolean
    /** true if currently in a collection context */
    inCollection: boolean
    /** true if currently in a flow context */
    inFlow: boolean
    /** Current level of indentation */
    indent: number
    /** Start of the current line */
    lineStart: number
    /** The parent of the node */
    parent: Node
    /** Source of the YAML document */
    src: string
  }

interface Node {
    context: ParseContext | null
    /** if not null, indicates a parser failure */
    error: YAMLSyntaxError | null
    /** span of context.src parsed into this node */
    range: Range | null
    valueRange: Range | null
    /** anchors, tags and comments */
    props: Range[]
    /** specific node type */
    type: Type
    /** if non-null, overrides source value */
    value: string | null

readonly anchor: string | null
    readonly comment: string | null
    readonly hasComment: boolean
    readonly hasProps: boolean
    readonly jsonLike: boolean
    readonly rangeAsLinePos: null | {
      start: { line: number; col: number }
      end?: { line: number; col: number }
    }
    readonly rawValue: string | null
    readonly tag:
      | null
      | { verbatim: string }
      | { handle: string; suffix: string }
    readonly valueRangeContainsNewline: boolean
  }

interface Alias extends Node {
    type: Type.ALIAS
    /** contain the anchor without the * prefix */
    readonly rawValue: string
  }

type Scalar = BlockValue | PlainValue | QuoteValue

interface BlockValue extends Node {
    type: Type.BLOCK_FOLDED | Type.BLOCK_LITERAL
    chomping: 'CLIP' | 'KEEP' | 'STRIP'
    blockIndent: number | null
    header: Range
    readonly strValue: string | null
  }

interface BlockFolded extends BlockValue {
    type: Type.BLOCK_FOLDED
  }

interface BlockLiteral extends BlockValue {
    type: Type.BLOCK_LITERAL
  }

interface PlainValue extends Node {
    type: Type.PLAIN
    readonly strValue: string | null
  }

interface QuoteValue extends Node {
    type: Type.QUOTE_DOUBLE | Type.QUOTE_SINGLE
    readonly strValue:
      | null
      | string
      | { str: string; errors: YAMLSyntaxError[] }
  }

interface QuoteDouble extends QuoteValue {
    type: Type.QUOTE_DOUBLE
  }

interface QuoteSingle extends QuoteValue {
    type: Type.QUOTE_SINGLE
  }

interface Comment extends Node {
    type: Type.COMMENT
    readonly anchor: null
    readonly comment: string
    readonly rawValue: null
    readonly tag: null
  }

interface BlankLine extends Node {
    type: Type.BLANK_LINE
  }

interface MapItem extends Node {
    type: Type.MAP_KEY | Type.MAP_VALUE
    node: ContentNode | null
  }

interface MapKey extends MapItem {
    type: Type.MAP_KEY
  }

interface MapValue extends MapItem {
    type: Type.MAP_VALUE
  }

interface Map extends Node {
    type: Type.MAP
    /** implicit keys are not wrapped */
    items: Array<BlankLine | Comment | Alias | Scalar | MapItem>
  }

interface SeqItem extends Node {
    type: Type.SEQ_ITEM
    node: ContentNode | null
  }

interface Seq extends Node {
    type: Type.SEQ
    items: Array<BlankLine | Comment | SeqItem>
  }

interface FlowChar {
    char: '{' | '}' | '[' | ']' | ',' | '?' | ':'
    offset: number
    origOffset?: number
  }

interface FlowCollection extends Node {
    type: Type.FLOW_MAP | Type.FLOW_SEQ
    items: Array<
      FlowChar | BlankLine | Comment | Alias | Scalar | FlowCollection
    >
  }

interface FlowMap extends FlowCollection {
    type: Type.FLOW_MAP
  }

interface FlowSeq extends FlowCollection {
    type: Type.FLOW_SEQ
  }

type ContentNode = Alias | Scalar | Map | Seq | FlowCollection

interface Directive extends Node {
    type: Type.DIRECTIVE
    name: string
    readonly anchor: null
    readonly parameters: string[]
    readonly tag: null
  }

interface Document extends Node {
    type: Type.DOCUMENT
    directives: Array<BlankLine | Comment | Directive>
    contents: Array<BlankLine | Comment | ContentNode>
    readonly anchor: null
    readonly comment: null
    readonly tag: null
  }
}

${this.title}

Code Editor : parse-cst.d.ts