diff --git a/.gitignore b/.gitignore index fed2c7e..e5fcbf9 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,5 @@ result /dst/ /tests/nimcache/ /tests/testresults/ +node_modules +sandbox.js diff --git a/src/js/bindings/react/react.nim b/src/js/bindings/react/react.nim new file mode 100644 index 0000000..92f6216 --- /dev/null +++ b/src/js/bindings/react/react.nim @@ -0,0 +1,2 @@ +import react16/react_hooks +import react16/react_dom, react16/react_types, react16/react_styles diff --git a/src/js/bindings/react/react_dom.nim b/src/js/bindings/react/react_dom.nim new file mode 100644 index 0000000..b1d9f25 --- /dev/null +++ b/src/js/bindings/react/react_dom.nim @@ -0,0 +1,187 @@ +import macros, dom, jsffi +import react_types +from react_globals import React + +{.experimental: "callOperator".} + +when not defined(js): + {.error: "React.nim is only available for the JS target".} + +type NodeOrString = ReactNode or seq[ReactNode] or cstring or string + +macro idString(x: untyped): auto = newStrLitNode($x) + +template tocstring(x: typed): auto = + when x is string: cstring(x) + else: x + +{.push importcpp.} +proc createElement*(react: ReactGlobal, tag: cstring, props: Attrs): ReactNode +proc createElement*(react: ReactGlobal, tag: cstring, props: Attrs, + n1: auto): ReactNode +{.pop.} + +template makeDomElement(x: untyped, name: string = "") = + const tag {.gensym.} = if name == "": cstring(idString(x)) else: name + const NIL: Attrs = nil + + proc x*(a: Attrs): ReactNode = + React.createElement(tag, a) + proc x*(a: Attrs, n1: NodeOrString): ReactNode = + let m1 = n1.tocstring + React.createElement(tag, a, m1) + proc x*(a: Attrs, n1, n2: NodeOrString): ReactNode = + let + m1 = n1.tocstring + m2 = n2.tocstring + React.createElement(tag, a, m1, m2) + proc x*(a: Attrs, n1, n2, n3: NodeOrString): ReactNode = + let + m1 = n1.tocstring + m2 = n2.tocstring + m3 = n3.tocstring + React.createElement(tag, a, m1, m2, m3) + proc x*(a: Attrs, n1, n2, n3, n4: NodeOrString): ReactNode = + let + m1 = n1.tocstring + m2 = n2.tocstring + m3 = n3.tocstring + m4 = n4.tocstring + React.createElement(tag, a, m1, m2, m3, m4) + + proc x*(n1: NodeOrString): ReactNode = + let m1 = n1.tocstring + React.createElement(tag, NIL, m1) + proc x*(n1, n2: NodeOrString): ReactNode = + let + m1 = n1.tocstring + m2 = n2.tocstring + React.createElement(tag, NIL, m1, m2) + proc x*(n1, n2, n3: NodeOrString): ReactNode = + let + m1 = n1.tocstring + m2 = n2.tocstring + m3 = n3.tocstring + React.createElement(tag, NIL, m1, m2, m3) + proc x*(n1, n2, n3, n4: NodeOrString): ReactNode = + let + m1 = n1.tocstring + m2 = n2.tocstring + m3 = n3.tocstring + m4 = n4.tocstring + React.createElement(tag, NIL, m1, m2, m3, m4) + +makeDomElement(a) +makeDomElement(abbr) +makeDomElement(address) +makeDomElement(area) +makeDomElement(article) +makeDomElement(aside) +makeDomElement(audio) +makeDomElement(b) +makeDomElement(base) +makeDomElement(bdi) +makeDomElement(bdo) +makeDomElement(big) +makeDomElement(blockquote) +makeDomElement(body) +makeDomElement(br) +makeDomElement(button) +makeDomElement(canvas) +makeDomElement(caption) +makeDomElement(cite) +makeDomElement(code) +makeDomElement(col) +makeDomElement(colgroup) +makeDomElement(data) +makeDomElement(datalist) +makeDomElement(dd) +makeDomElement(del) +makeDomElement(details) +makeDomElement(dfn) +makeDomElement(dialog) +makeDomElement(`div`, "div") +makeDomElement(dl) +makeDomElement(dt) +makeDomElement(em) +makeDomElement(embed) +makeDomElement(fieldset) +makeDomElement(figcaption) +makeDomElement(figure) +makeDomElement(footer) +makeDomElement(form) +makeDomElement(h1) +makeDomElement(h2) +makeDomElement(h3) +makeDomElement(h4) +makeDomElement(h5) +makeDomElement(h6) +makeDomElement(head) +makeDomElement(header) +makeDomElement(hgroup) +makeDomElement(hr) +makeDomElement(html) +makeDomElement(i) +makeDomElement(iframe) +makeDomElement(img) +makeDomElement(input) +makeDomElement(ins) +makeDomElement(kbd) +makeDomElement(keygen) +makeDomElement(label) +makeDomElement(legend) +makeDomElement(li) +makeDomElement(link) +makeDomElement(main) +makeDomElement(map) +makeDomElement(mark) +makeDomElement(menu) +makeDomElement(menuitem) +makeDomElement(meta) +makeDomElement(meter) +makeDomElement(nav) +makeDomElement(noscript) +makeDomElement(`object`) +makeDomElement(ol) +makeDomElement(optgroup) +makeDomElement(option) +makeDomElement(output) +makeDomElement(p) +makeDomElement(param) +makeDomElement(picture) +makeDomElement(pre) +makeDomElement(progress) +makeDomElement(q) +makeDomElement(rp) +makeDomElement(rt) +makeDomElement(ruby) +makeDomElement(s) +makeDomElement(samp) +makeDomElement(script) +makeDomElement(section) +makeDomElement(select) +makeDomElement(small) +makeDomElement(source) +makeDomElement(span) +makeDomElement(strong) +makeDomElement(style) +makeDomElement(sub) +makeDomElement(summary) +makeDomElement(sup) +makeDomElement(svg) +makeDomElement(table) +makeDomElement(tbody) +makeDomElement(td) +makeDomElement(textarea) +makeDomElement(tfoot) +makeDomElement(th) +makeDomElement(thead) +makeDomElement(time) +makeDomElement(title) +makeDomElement(tr) +makeDomElement(track) +makeDomElement(u) +makeDomElement(ul) +makeDomElement(`var`) +makeDomElement(video) +makeDomElement(wbr) diff --git a/src/js/bindings/react/react_globals.nim b/src/js/bindings/react/react_globals.nim new file mode 100644 index 0000000..fedcea2 --- /dev/null +++ b/src/js/bindings/react/react_globals.nim @@ -0,0 +1,15 @@ +import react_types + +when not defined(js): + {.error: "React.nim is only available for the JS target".} + +var + React*{.importc, nodecl.}: ReactGlobal + ReactDOM*{.importc, nodecl.}: ReactDOMGlobal + +type + Component*[P, S] = ref object of RootObj + props*: P + state*: S + setState*{.importcpp.}: proc(s: S) + StatelessComponent*[P] = Component[P, void] diff --git a/src/js/bindings/react/react_hooks.nim b/src/js/bindings/react/react_hooks.nim new file mode 100644 index 0000000..d1241d2 --- /dev/null +++ b/src/js/bindings/react/react_hooks.nim @@ -0,0 +1,33 @@ +import jsffi +import sugar + +type + Context* = JsObject + Reference* = ref object of JsObject + current*: auto + UseState*[S] = ref object of JsObject + getter*: S + setter*: S -> S + +proc myUseState*[S](initialState: S): UseState[S] {.importjs: "myUseState(#)".} +# proc useState*(react: ReactGlobal, initialState: State): seq[string] {.importjs: "#.useState(#)".} +# proc useState*(react: ReactGlobal, initialState: State): tuple[state: string, setterFn: proc(newState: JsObject)] {.importjs: "#.useState(#)".} + +# proc useEffect*(react: ReactGlobal, didUpdate: proc(), triggerDependencies: seq[auto]) {.importjs: "#.useEffect(#)".} +# proc useContext*(react: ReactGlobal, context: JsObject): Context +# proc useReducer*(react: ReactGlobal, reducer: proc(): auto, initialArg: auto, init: proc()) + +# proc useCallback*(react: ReactGlobal, callback: proc(), triggerDependencies: auto) +# proc useMemo*(react: ReactGlobal, createFn: proc(), recomputeDependencies: auto) +# proc useRef*(react: ReactGlobal, react2: ReactGlobal): Reference + +# proc useImperativeHandle*(react: ReactGlobal, reference: Reference, createHandle: proc(), +# dependencies: sea[auto]) + +# proc useLayoutEffect*(react: ReactGlobal, didUpdate: proc(), triggerDependencies: seq[auto]) +# proc useDebugValue*(react: ReactGlobal, initialState: auto): auto + +# concurrent mode hooks (experimental) - see https://reactjs.org/docs/concurrent-mode-reference.html +# proc useTransition*(react: ReactGlobal, suspenseConfig: JsObject): auto + +# proc useDeferredValue*(react: ReactGlobal, value: auto, suspenseConfig: JsObject): auto diff --git a/src/js/bindings/react/react_styles.nim b/src/js/bindings/react/react_styles.nim new file mode 100644 index 0000000..8404a18 --- /dev/null +++ b/src/js/bindings/react/react_styles.nim @@ -0,0 +1,188 @@ +type + Style* = ref object of RootObj + alignContent*, # Sets or returns the alignment between the lines inside a flexible container when the items do not use all available space 3 + alignItems*, # Sets or returns the alignment for items inside a flexible container 3 + alignSelf*, # Sets or returns the alignment for selected items inside a flexible container 3 + animation*, # A shorthand property for all the animation properties below, except the animationPlayState property 3 + animationDelay*, # Sets or returns when the animation will start 3 + animationDirection*, # Sets or returns whether or not the animation should play in reverse on alternate cycles 3 + animationDuration*, # Sets or returns how many seconds or milliseconds an animation takes to complete one cycle 3 + animationFillMode*, # Sets or returns what values are applied by the animation outside the time it is executing 3 + animationIterationCount*, # Sets or returns the number of times an animation should be played 3 + animationName*, # Sets or returns a name for the @keyframes animation 3 + animationTimingFunction*, # Sets or returns the speed curve of the animation 3 + animationPlayState*, # Sets or returns whether the animation is running or paused 3 + background*, # Sets or returns all the background properties in one declaration 1 + backgroundAttachment*, # Sets or returns whether a background-image is fixed or scrolls with the page 1 + backgroundColor*, # Sets or returns the background-color of an element 1 + backgroundImage*, # Sets or returns the background-image for an element 1 + backgroundPosition*, # Sets or returns the starting position of a background-image 1 + backgroundRepeat*, # Sets or returns how to repeat (tile) a background-image 1 + backgroundClip*, # Sets or returns the painting area of the background 3 + backgroundOrigin*, # Sets or returns the positioning area of the background images 3 + backgroundSize*, # Sets or returns the size of the background image 3 + backfaceVisibility*, # Sets or returns whether or not an element should be visible when not facing the screen 3 + border*, # Sets or returns borderWidth, borderStyle, and borderColor in one declaration 1 + borderBottom*, # Sets or returns all the borderBottom properties in one declaration 1 + borderBottomColor*, # Sets or returns the color of the bottom border 1 + borderBottomLeftRadius*, # Sets or returns the shape of the border of the bottom-left corner 3 + borderBottomRightRadius*, # Sets or returns the shape of the border of the bottom-right corner 3 + borderBottomStyle*, # Sets or returns the style of the bottom border 1 + borderBottomWidth*, # Sets or returns the width of the bottom border 1 + borderCollapse*, # Sets or returns whether the table border should be collapsed into a single border, or not 2 + borderColor*, # Sets or returns the color of an element's border (can have up to four values) 1 + borderImage*, # A shorthand property for setting or returning all the borderImage properties 3 + borderImageOutset*, # Sets or returns the amount by which the border image area extends beyond the border box 3 + borderImageRepeat*, # Sets or returns whether the image-border should be repeated, rounded or stretched 3 + borderImageSlice*, # Sets or returns the inward offsets of the image-border 3 + borderImageSource*, # Sets or returns the image to be used as a border 3 + borderImageWidth*, # Sets or returns the widths of the image-border 3 + borderLeft*, # Sets or returns all the borderLeft properties in one declaration 1 + borderLeftColor*, # Sets or returns the color of the left border 1 + borderLeftStyle*, # Sets or returns the style of the left border 1 + borderLeftWidth*, # Sets or returns the width of the left border 1 + borderRadius*, # A shorthand property for setting or returning all the four borderRadius properties 3 + borderRight*, # Sets or returns all the borderRight properties in one declaration 1 + borderRightColor*, # Sets or returns the color of the right border 1 + borderRightStyle*, # Sets or returns the style of the right border 1 + borderRightWidth*, # Sets or returns the width of the right border 1 + borderSpacing*, # Sets or returns the space between cells in a table 2 + borderStyle*, # Sets or returns the style of an element's border (can have up to four values) 1 + borderTop*, # Sets or returns all the borderTop properties in one declaration 1 + borderTopColor*, # Sets or returns the color of the top border 1 + borderTopLeftRadius*, # Sets or returns the shape of the border of the top-left corner 3 + borderTopRightRadius*, # Sets or returns the shape of the border of the top-right corner 3 + borderTopStyle*, # Sets or returns the style of the top border 1 + borderTopWidth*, # Sets or returns the width of the top border 1 + borderWidth*, # Sets or returns the width of an element's border (can have up to four values) 1 + bottom*, # Sets or returns the bottom position of a positioned element 2 + boxDecorationBreak*, # Sets or returns the behaviour of the background and border of an element at page-break, or, for in-line elements, at line-break. 3 + boxShadow*, # Attaches one or more drop-shadows to the box 3 + boxSizing*, # Allows you to define certain elements to fit an area in a certain way 3 + captionSide*, # Sets or returns the position of the table caption 2 + clear*, # Sets or returns the position of the element relative to floating objects 1 + clip*, # Sets or returns which part of a positioned element is visible 2 + color*, # Sets or returns the color of the text 1 + columnCount*, # Sets or returns the number of columns an element should be divided into 3 + columnFill*, # Sets or returns how to fill columns 3 + columnGap*, # Sets or returns the gap between the columns 3 + columnRule*, # A shorthand property for setting or returning all the columnRule properties 3 + columnRuleColor*, # Sets or returns the color of the rule between columns 3 + columnRuleStyle*, # Sets or returns the style of the rule between columns 3 + columnRuleWidth*, # Sets or returns the width of the rule between columns 3 + columns*, # A shorthand property for setting or returning columnWidth and columnCount 3 + columnSpan*, # Sets or returns how many columns an element should span across 3 + columnWidth*, # Sets or returns the width of the columns 3 + content*, # Used with the :before and :after pseudo-elements, to insert generated content 2 + counterIncrement*, # Increments one or more counters 2 + counterReset*, # Creates or resets one or more counters 2 + cursor*, # Sets or returns the type of cursor to display for the mouse pointer 2 + direction*, # Sets or returns the text direction 2 + display*, # Sets or returns an element's display type 1 + emptyCells*, # Setsor returns whether to show the border and background of empty cells, or not 2 + filter*, # Setsor returns image filters (visual effects, like blur and saturation) 3 + flex*, # Setsor returns the length of the item, relative to the rest 3 + flexBasis*, # Setsor returns the initial length of a flexible item 3 + flexDirection*, # Setsor returns the direction of the flexible items 3 + flexFlow*, # A shorthand property for the flexDirection and the flexWrap properties 3 + flexGrow*, # Setsor returns how much the item will grow relative to the rest 3 + flexShrink*, # Setsor returns how the item will shrink relative to the rest 3 + flexWrap*, # Setsor returns whether the flexible items should wrap or not 3 + cssFloat*, # Setsor returns the horizontal alignment of an element 1 + font*, # Setsor returns fontStyle, fontVariant, fontWeight, fontSize, lineHeight, and fontFamily in one declaration 1 + fontFamily*, # Setsor returns the font family for text 1 + fontSize*, # Setsor returns the font size of the text 1 + fontStyle*, # Setsor returns whether the style of the font is normal, italic or oblique 1 + fontVariant*, # Setsor returns whether the font should be displayed in small capital letters 1 + fontWeight*, # Setsor returns the boldness of the font 1 + fontSizeAdjust*, # Preserves the readability of text when font fallback occurs 3 + fontStretch*, # Selects a normal, condensed, or expanded face from a font family 3 + hangingPunctuation*, # Specifies whether a punctuation character may be placed outside the line box 3 + height*, # Setsor returns the height of an element 1 + hyphens*, # Setshow to split words to improve the layout of paragraphs 3 + icon*, # Provides the author the ability to style an element with an iconic equivalent 3 + imageOrientation*, # Specifies a rotation in the right or clockwise direction that a user agent applies to an image 3 + isolation*, # Defines whether an element must create a new stacking content 3 + justifyContent*, # Setsor returns the alignment between the items inside a flexible container when the items do not use all available space. 3 + left*, # Setsor returns the left position of a positioned element 2 + letterSpacing*, # Setsor returns the space between characters in a text 1 + lineHeight*, # Setsor returns the distance between lines in a text 1 + listStyle*, # Setsor returns listStyleImage, listStylePosition, and listStyleType in one declaration 1 + listStyleImage*, # Setsor returns an image as the list-item marker 1 + listStylePosition*, # Setsor returns the position of the list-item marker 1 + listStyleType*: cstring # Setsor returns the list-item marker type 1 + margin*, # Setsor returns the margins of an element (can have up to four values) 1 + marginBottom*, # Setsor returns the bottom margin of an element 1 + marginLeft*, # Setsor returns the left margin of an element 1 + marginRight*, # Setsor returns the right margin of an element 1 + marginTop*, # Setsor returns the top margin of an element 1 + maxHeight*, # Setsor returns the maximum height of an element 2 + maxWidth*, # Setsor returns the maximum width of an element 2 + minHeight*, # Setsor returns the minimum height of an element 2 + minWidth*: cint # Setsor returns the minimum width of an element 2 + + # navDown*, # Setsor returns where to navigate when using the arrow-down navigation key 3 + # navIndex*, # Setsor returns the tabbing order for an element 3 + # navLeft*, # Setsor returns where to navigate when using the arrow-left navigation key 3 + # navRight*, # Setsor returns where to navigate when using the arrow-right navigation key 3 + # navUp*, # Setsor returns where to navigate when using the arrow-up navigation key 3 + # objectFit*, # Specifies how the contents of a replaced element should be fitted to the box established by its used height and width 3 + # objectPosition*, # Specifies the alignment of the replaced element inside its box 3 + # opacity*, # Setsor returns the opacity level for an element 3 + # order*, # Setsor returns the order of the flexible item, relative to the rest 3 + # orphans*, # Setsor returns the minimum number of lines for an element that must be left at the bottom of a page when a page break occurs inside an element 2 + # outline*, # Setsor returns all the outline properties in one declaration 2 + # outlineColor*, # Setsor returns the color of the outline around a element 2 + # outlineOffset*, # Setsan outline, and draws it beyond the border edge 3 + # outlineStyle*, # Setsor returns the style of the outline around an element 2 + # outlineWidth*, # Setsor returns the width of the outline around an element 2 + # overflow*, # Setsor returns what to do with content that renders outside the element box 2 + # overflowX*, # Specifies what to do with the left/right edges of the content, if it overflows the element's content area 3 + # overflowY*, # Specifies what to do with the top/bottom edges of the content, if it overflows the element's content area 3 + # padding*, # Setsor returns the padding of an element (can have up to four values) 1 + # paddingBottom*, # Setsor returns the bottom padding of an element 1 + # paddingLeft*, # Setsor returns the left padding of an element 1 + # paddingRight*, # Setsor returns the right padding of an element 1 + # paddingTop*, # Setsor returns the top padding of an element 1 + # pageBreakAfter*, # Setsor returns the page-break behavior after an element 2 + # pageBreakBefore*, # Setsor returns the page-break behavior before an element 2 + # pageBreakInside*, # Setsor returns the page-break behavior inside an element 2 + # perspective*, # Setsor returns the perspective on how 3D elements are viewed 3 + # perspectiveOrigin*, # Setsor returns the bottom position of 3D elements 3 + # position*, # Setsor returns the type of positioning method used for an element (static, relative, absolute or fixed) 2 + # quotes*, # Setsor returns the type of quotation marks for embedded quotations 2 + # resize*, # Setsor returns whether or not an element is resizable by the user 3 + # right*, # Setsor returns the right position of a positioned element 2 + # tableLayout*, # Setsor returns the way to lay out table cells, rows, and columns 2 + # tabSize*, # Setsor returns the length of the tab-character 3 + # textAlign*, # Setsor returns the horizontal alignment of text 1 + # textAlignLast*, # Setsor returns how the last line of a block or a line right before a forced line break is aligned when text-align is "justify" 3 + # textDecoration*, # Setsor returns the decoration of a text 1 + # textDecorationColor*, # Setsor returns the color of the text-decoration 3 + # textDecorationLine*, # Setsor returns the type of line in a text-decoration 3 + # textDecorationStyle*, # Setsor returns the style of the line in a text decoration 3 + # textIndent*, # Setsor returns the indentation of the first line of text 1 + # textJustify*, # Setsor returns the justification method used when text-align is "justify" 3 + # textOverflow*, # Setsor returns what should happen when text overflows the containing element 3 + # textShadow*, # Setsor returns the shadow effect of a text 3 + # textTransform*, # Setsor returns the capitalization of a text 1 + # top*, # Setsor returns the top position of a positioned element 2 + # transform*, # Applies a 2D or 3D transformation to an element 3 + # transformOrigin*, # Setsor returns the position of transformed elements 3 + # transformStyle*, # Setsor returns how nested elements are rendered in 3D space 3 + # transition*, # A shorthand property for setting or returning the four transition properties 3 + # transitionProperty*, # Setsor returns the CSS property that the transition effect is for 3 + # transitionDuration*, # Setsor returns how many seconds or milliseconds a transition effect takes to complete 3 + # transitionTimingFunction*, # Setsor returns the speed curve of the transition effect 3 + # transitionDelay*, # Setsor returns when the transition effect will start 3 + # unicodeBidi*, # Setsor returns whether the text should be overridden to support multiple languages in the same document 2 + # userSelect*, # Setsor returns whether the text of an element can be selected or not 2 + # verticalAlign*, # Setsor returns the vertical alignment of the content in an element 1 + # visibility*, # Setsor returns whether an element should be visible 2 + # whiteSpace*, # Setsor returns how to handle tabs, line breaks and whitespace in a text 1 + # width*, # Setsor returns the width of an element 1 + # wordBreak*, # Setsor returns line breaking rules for non-CJK scripts 3 + # wordSpacing*, # Setsor returns the spacing between words in a text 1 + # wordWrap*, # Allows long, unbreakable words to be broken and wrap to the next line 3 + # widows*, # Setsor returns the minimum number of lines for an element that must be visible at the top of a page 2 + # zIndex*: cstring # Setsor returns the stack order of a positioned element 2 diff --git a/src/js/bindings/react/react_types.nim b/src/js/bindings/react/react_types.nim new file mode 100644 index 0000000..82ccc56 --- /dev/null +++ b/src/js/bindings/react/react_types.nim @@ -0,0 +1,58 @@ +import jsffi, react_styles + +type + Context*{.importc.} = JsObject + Consumer*{.importc.} = JsObject + Producer*{.importc.} = JsObject + ReactGlobal* {.importc.} = ref object of RootObj + version*: cstring + ReactDOMGlobal* {.importc.} = ref object of RootObj + version*: cstring + ReactDescriptor* [P, S] {.importcpp.} = ref object of RootObj + render*: proc(): ReactNode + componentWillMount*: proc(): void + componentWillUnmount*: proc(): void + componentDidMount*: proc(): void + componentWillReceiveProps*: proc(nextProps: P): void + shouldComponentUpdate*: proc(nextProps: P, nextState: S): bool + componentWillUpdate*: proc(nextProps: P, nextState: S): bool + componentDidUpdate*: proc(prevProps: P, prevState: S): bool + getInitialState*: proc(): S + ReactComponent* {.importc.} = ref object of RootObj + ReactNode* {.importc.} = ref object of RootObj + EventTarget* = ref object + value*: cstring + Event* = ref object + target*: EventTarget + `type`*: cstring + Attrs* = ref object of RootObj + onClick*, onChange*: proc(e: Event) + key*, `ref`*, dangerouslySetInnerHTML*: cstring + + accept*, acceptCharset*, accessKey*, action*, alt*, capture*, + cellPadding*, cellSpacing*, challenge*, charSet*, cite*, classID*, + className*, content*, contextMenu*, coords*, crossOrigin*, + data*, dateTime*, default*, dir*, download*, encType*, form*, + formAction*, formEncType*, formMethod*, formTarget*, frameBorder*, + headers*, href*, hrefLang*, htmlFor*, httpEquiv*, icon*, id*, inputMode*, + integrity*, keyParams*, keyType*, kind*, label*, lang*, list*, + manifest*, media*, mediaGroup*, `method`*, name*, nonce*, pattern*, + placeholder*, poster*, profile*, radioGroup*, rel*, role*, sandbox*, + scope*, scrolling*, seamless*, shape*, sizes*, span*, src*, srcDoc*, + srcLang*, srcSet*, summary*, tabIndex*, target*, title*, `type`*, + useMap*, value*, wmode*, wrap*: cstring + + allowFullScreen*, allowTransparency*, async*, autoComplete*, autoFocus*, + autoPlay*, checked*, contentEditable*, controls*, `defer`*, disabled*, + draggable*, formNoValidate*, hidden*, loop*, multiple*, muted*, + noValidate*, open*, preload*, readOnly*, required*, reversed*, + scoped*, selected*, spellCheck*: bool + + colSpan*, cols*, height*, high*, low*, marginHeight*, marginWidth*, max*, + maxLength*, min*, minLength*, optimum*, rowSpan*, rows*, size*, start*, + step*, width*: cint + + style*: react_styles.Style + # Style* = ref object + # color*, backgroundColor*: cstring + # marginTop*, marginBottom*, marginLeft*, marginRight*: int \ No newline at end of file diff --git a/src/js/example/index.html b/src/js/example/index.html new file mode 100644 index 0000000..f900937 --- /dev/null +++ b/src/js/example/index.html @@ -0,0 +1,33 @@ + + + + + + Nim on JS + + +
+ + + + + + + + + + + + + + diff --git a/src/js/example/nim.cfg b/src/js/example/nim.cfg new file mode 100644 index 0000000..72b8423 --- /dev/null +++ b/src/js/example/nim.cfg @@ -0,0 +1 @@ +path=".." diff --git a/src/js/example/package.json b/src/js/example/package.json new file mode 100644 index 0000000..413961c --- /dev/null +++ b/src/js/example/package.json @@ -0,0 +1,10 @@ +{ + "name": "org", + "version": "1.0.0", + "main": "index.js", + "license": "MIT", + "dependencies": { + "react": "^18.1.0", + "react-dom": "^18.1.0" + } +} diff --git a/src/js/example/sandbox.nim b/src/js/example/sandbox.nim new file mode 100644 index 0000000..21b3a7d --- /dev/null +++ b/src/js/example/sandbox.nim @@ -0,0 +1,48 @@ +import jsconsole, jsffi, strutils, sequtils, sugar +import sugar +import ../bindings/react/react_dom, + ../bindings/react/react_types, + ../bindings/react/react_styles, + ../bindings/react/react_hooks +import sequtils +import options +import strformat +import ../../org/org_block_heading +import ../../org/org_builder +import ../../org/org_types + +proc renderItems( + onClick: proc(e: react_types.Event): void, + count: Option[int], +): ReactNode = + `div`( + Attrs{ + onClick: onclick + }, + &"Add button {count.get(0)}" + ) + +proc makeTopLevel(): ReactNode {.exportc.} = + let text = myUseState[cstring]("") + + let val = text.getter + let orgItems: seq[string] = makeOrg($val) + .foldOrg() + + + console.log(orgItems) + + `div`( + Attrs{style: Style{marginTop: 50}}, + @[ + textarea( + Attrs{ + onchange: proc(e: react_types.Event): void = discard text.setter(e.target.value) + }, + ), + `div`( + Attrs{}, + $orgItems + ) + ] + ) diff --git a/src/js/example/yarn.lock b/src/js/example/yarn.lock new file mode 100644 index 0000000..bd43b13 --- /dev/null +++ b/src/js/example/yarn.lock @@ -0,0 +1,37 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"js-tokens@^3.0.0 || ^4.0.0": + version "4.0.0" + resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" + integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== + +loose-envify@^1.1.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf" + integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q== + dependencies: + js-tokens "^3.0.0 || ^4.0.0" + +react-dom@^18.1.0: + version "18.1.0" + resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-18.1.0.tgz#7f6dd84b706408adde05e1df575b3a024d7e8a2f" + integrity sha512-fU1Txz7Budmvamp7bshe4Zi32d0ll7ect+ccxNu9FlObT605GOEB8BfO4tmRJ39R5Zj831VCpvQ05QPBW5yb+w== + dependencies: + loose-envify "^1.1.0" + scheduler "^0.22.0" + +react@^18.1.0: + version "18.1.0" + resolved "https://registry.yarnpkg.com/react/-/react-18.1.0.tgz#6f8620382decb17fdc5cc223a115e2adbf104890" + integrity sha512-4oL8ivCz5ZEPyclFQXaNksK3adutVS8l2xzZU0cqEFrE9Sb7fC0EFK5uEk74wIreL1DERyjvsU915j1pcT2uEQ== + dependencies: + loose-envify "^1.1.0" + +scheduler@^0.22.0: + version "0.22.0" + resolved "https://registry.yarnpkg.com/scheduler/-/scheduler-0.22.0.tgz#83a5d63594edf074add9a7198b1bae76c3db01b8" + integrity sha512-6QAm1BgQI88NPYymgGQLCZgvep4FyePDWFpXVK+zNSUgHwlqpJy8VEh8Et0KxTACS4VWwMousBElAZOH9nkkoQ== + dependencies: + loose-envify "^1.1.0" diff --git a/src/org/index.html b/src/org/index.html new file mode 100644 index 0000000..7482075 --- /dev/null +++ b/src/org/index.html @@ -0,0 +1,26 @@ + + + + + + Untitled + + + + + + + + + + + + + + diff --git a/src/org/org_block_heading.js b/src/org/org_block_heading.js new file mode 100644 index 0000000..842a9f2 --- /dev/null +++ b/src/org/org_block_heading.js @@ -0,0 +1,5539 @@ +/* Generated by the Nim Compiler v1.6.2 */ +var framePtr = null; +var excHandler = 0; +var lastJSError = null; +var NTI788529239 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI788529466 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1275068421 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1275069021 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI788529624 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI788529769 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI788529845 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI788529497 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1442840915 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1442840914 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI788529496 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1509949569 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1509949571 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1526726812 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1526726798 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1526726797 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1526726795 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI1509949556 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1509949555 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1509949452 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1560281382 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1560281167 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1610612744 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1560281166 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1509949465 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1509949477 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1509949450 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1509949449 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1509949463 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1526726804 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1526726794 = {size: 0, kind: 14, base: null, node: null, finalizer: null}; +var NTI1509949501 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1275069127 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1560281092 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1291845683 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1291845682 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI1526726659 = {size: 0, kind: 14, base: null, node: null, finalizer: null}; +var NTI1526726663 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1526726662 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1526726660 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI1509949514 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI922748585 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1224736772 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI939524381 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1291845635 = {size: 0, kind: 14, base: null, node: null, finalizer: null}; +var NTI33555129 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555124 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1275068835 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1275068772 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1275068771 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1442840580 = {size: 0,kind: 2,base: null,node: null,finalizer: null}; +var NTI1442840582 = {size: 0, kind: 14, base: null, node: null, finalizer: null}; +var NTI1442840592 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1442840583 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI1442840594 = {size: 0, kind: 24, base: null, node: null, finalizer: null}; +var NTI1442840590 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1442840579 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI1442840593 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1442840584 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI1442840585 = {size: 0, kind: 14, base: null, node: null, finalizer: null}; +var NTI1442840596 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1442840586 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI33554466 = {size: 0,kind: 1,base: null,node: null,finalizer: null}; +var NTI1442840603 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1275068420 = {size: 0, kind: 19, base: null, node: null, finalizer: null}; +var NTI33554438 = {size: 0,kind: 2,base: null,node: null,finalizer: null}; +var NTI1459617871 = {size: 0, kind: 19, base: null, node: null, finalizer: null}; +var NTI33555114 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555125 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33554456 = {size: 0,kind: 31,base: null,node: null,finalizer: null}; +var NTI721430215 = {size: 0,kind: 31,base: null,node: null,finalizer: null}; +var NTI721430694 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI33555121 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555128 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555130 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555083 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555165 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI33554439 = {size: 0,kind: 28,base: null,node: null,finalizer: null}; +var NTI33554440 = {size: 0,kind: 29,base: null,node: null,finalizer: null}; +var NTI33555164 = {size: 0, kind: 22, base: null, node: null, finalizer: null}; +var NTI33555112 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555113 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555120 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI33555122 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NNI33555122 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555122.node = NNI33555122; +var NNI33555120 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555120.node = NNI33555120; +var NNI33555113 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555113.node = NNI33555113; +NTI33555164.base = NTI33555112; +NTI33555165.base = NTI33555112; +var NNI33555112 = {kind: 2, len: 5, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "parent", len: 0, typ: NTI33555164, name: "parent", sons: null}, +{kind: 1, offset: "name", len: 0, typ: NTI33554440, name: "name", sons: null}, +{kind: 1, offset: "message", len: 0, typ: NTI33554439, name: "msg", sons: null}, +{kind: 1, offset: "trace", len: 0, typ: NTI33554439, name: "trace", sons: null}, +{kind: 1, offset: "up", len: 0, typ: NTI33555165, name: "up", sons: null}]}; +NTI33555112.node = NNI33555112; +var NNI33555083 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555083.node = NNI33555083; +NTI33555112.base = NTI33555083; +NTI33555113.base = NTI33555112; +NTI33555120.base = NTI33555113; +NTI33555122.base = NTI33555120; +var NNI33555130 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555130.node = NNI33555130; +NTI33555130.base = NTI33555113; +var NNI33555128 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555128.node = NNI33555128; +NTI33555128.base = NTI33555113; +var NNI33555121 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555121.node = NNI33555121; +NTI33555121.base = NTI33555120; +var NNI721430694 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "a", len: 0, typ: NTI721430215, name: "a", sons: null}, +{kind: 1, offset: "b", len: 0, typ: NTI33554456, name: "b", sons: null}]}; +NTI721430694.node = NNI721430694; +var NNI33555125 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555125.node = NNI33555125; +var NNI33555114 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555114.node = NNI33555114; +NTI33555114.base = NTI33555112; +NTI33555125.base = NTI33555114; +NTI1459617871.base = NTI33554438; +NTI1275068420.base = NTI33554438; +var NNI1442840585 = {kind: 2, offset: 0, typ: null, name: null, len: 3, sons: {"0": {kind: 1, offset: 0, typ: NTI1442840585, name: "choiceMismatchErr", len: 0, sons: null}, +"1": {kind: 1, offset: 1, typ: NTI1442840585, name: "charMismatchErr", len: 0, sons: null}, +"2": {kind: 1, offset: 2, typ: NTI1442840585, name: "endOfStringErr", len: 0, sons: null}}}; +NTI1442840585.node = NNI1442840585; +var NNI1442840590 = {kind: 2, len: 3, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "stream", len: 0, typ: NTI33554439, name: "stream", sons: null}, +{kind: 1, offset: "position", len: 0, typ: NTI33554456, name: "position", sons: null}, +{kind: 1, offset: "lastPosition", len: 0, typ: NTI33554456, name: "lastPosition", sons: null}]}; +NTI1442840590.node = NNI1442840590; +NTI1442840579.base = NTI1442840590; +var NNI1442840582 = {kind: 2, offset: 0, typ: null, name: null, len: 2, sons: {"0": {kind: 1, offset: 0, typ: NTI1442840582, name: "parserTokenChar", len: 0, sons: null}, +"1": {kind: 1, offset: 1, typ: NTI1442840582, name: "parserTokenString", len: 0, sons: null}}}; +NTI1442840582.node = NNI1442840582; +var NNI1442840592 = {kind: 3, offset: "kind", len: 2, typ: NTI1442840582, name: "kind", sons: [[setConstr(0), {kind: 1, offset: "charValue", len: 0, typ: NTI1442840580, name: "charValue", sons: null}], +[setConstr(1), {kind: 1, offset: "stringValue", len: 0, typ: NTI33554439, name: "stringValue", sons: null}]]}; +NTI1442840592.node = NNI1442840592; +NTI1442840583.base = NTI1442840592; +NTI1442840594.base = NTI1442840583; +var NNI1442840593 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "state", len: 0, typ: NTI1442840579, name: "state", sons: null}, +{kind: 1, offset: "tokens", len: 0, typ: NTI1442840594, name: "tokens", sons: null}]}; +NTI1442840593.node = NNI1442840593; +NTI1442840584.base = NTI1442840593; +var NNI1442840596 = {kind: 2, len: 5, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "kind", len: 0, typ: NTI1442840585, name: "kind", sons: null}, +{kind: 1, offset: "unexpected", len: 0, typ: NTI33554439, name: "unexpected", sons: null}, +{kind: 1, offset: "expected", len: 0, typ: NTI33554439, name: "expected", sons: null}, +{kind: 1, offset: "index", len: 0, typ: NTI33554456, name: "index", sons: null}, +{kind: 1, offset: "parser", len: 0, typ: NTI1442840584, name: "parser", sons: null}]}; +NTI1442840596.node = NNI1442840596; +NTI1442840586.base = NTI1442840596; +var NNI1442840603 = {kind: 3, offset: "o", len: 2, typ: NTI33554466, name: "o", sons: [[setConstr(0), {kind: 1, offset: "e", len: 0, typ: NTI1442840586, name: "e", sons: null}], +[setConstr(1), {kind: 1, offset: "v", len: 0, typ: NTI1442840584, name: "v", sons: null}]]}; +NTI1442840603.node = NNI1442840603; +NTI1275068771.base = NTI1275068772; +NTI1275068835.base = NTI1442840603; +var NNI33555124 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555124.node = NNI33555124; +NTI33555124.base = NTI33555113; +var NNI33555129 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI33555129.node = NNI33555129; +NTI33555129.base = NTI33555113; +var NNI1291845635 = {kind: 2, offset: 0, typ: null, name: null, len: 2, sons: {"0": {kind: 1, offset: 0, typ: NTI1291845635, name: "okNothing", len: 0, sons: null}, +"1": {kind: 1, offset: 1, typ: NTI1291845635, name: "okJust", len: 0, sons: null}}}; +NTI1291845635.node = NNI1291845635; +var NNI939524381 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "a", len: 0, typ: NTI33554456, name: "a", sons: null}, +{kind: 1, offset: "b", len: 0, typ: NTI33554456, name: "b", sons: null}]}; +NTI939524381.node = NNI939524381; +var NNI1224736772 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1224736772.node = NNI1224736772; +NTI1224736772.base = NTI33555113; +var NNI922748585 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI922748585.node = NNI922748585; +NTI922748585.base = NTI33555114; +NTI1526726663.base = NTI1526726660; +var NNI1526726659 = {kind: 2, offset: 0, typ: null, name: null, len: 9, sons: {"0": {kind: 1, offset: 0, typ: NTI1526726659, name: "orgRawText", len: 0, sons: null}, +"1": {kind: 1, offset: 1, typ: NTI1526726659, name: "orgText", len: 0, sons: null}, +"2": {kind: 1, offset: 2, typ: NTI1526726659, name: "orgBoldText", len: 0, sons: null}, +"3": {kind: 1, offset: 3, typ: NTI1526726659, name: "orgItalicText", len: 0, sons: null}, +"4": {kind: 1, offset: 4, typ: NTI1526726659, name: "orgUnderlineText", len: 0, sons: null}, +"5": {kind: 1, offset: 5, typ: NTI1526726659, name: "orgVerbatimText", len: 0, sons: null}, +"6": {kind: 1, offset: 6, typ: NTI1526726659, name: "orgCodeText", len: 0, sons: null}, +"7": {kind: 1, offset: 7, typ: NTI1526726659, name: "orgStrikeThroughText", len: 0, sons: null}, +"8": {kind: 1, offset: 8, typ: NTI1526726659, name: "orgLink", len: 0, sons: null}}}; +NTI1526726659.node = NNI1526726659; +var NNI1291845683 = {kind: 3, offset: "kind", len: 2, typ: NTI1291845635, name: "kind", sons: [[setConstr(1), {kind: 1, offset: "value", len: 0, typ: NTI33554439, name: "value", sons: null}], +[setConstr(2), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}]]}; +NTI1291845683.node = NNI1291845683; +NTI1291845682.base = NTI1291845683; +var NNI1526726662 = {kind: 2, len: 3, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "children", len: 0, typ: NTI1526726663, name: "children", sons: null}, +{kind: 1, offset: "content", len: 0, typ: NTI33554439, name: "content", sons: null}, +{kind: 3, offset: "kind", len: 9, typ: NTI1526726659, name: "kind", sons: [[setConstr(0), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}], +[setConstr(1), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}], +[setConstr(2), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}], +[setConstr(3), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}], +[setConstr(4), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}], +[setConstr(5), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}], +[setConstr(6), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}], +[setConstr(7), {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}], +[setConstr(8), {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "linkUrl", len: 0, typ: NTI33554439, name: "linkUrl", sons: null}, +{kind: 1, offset: "linkDescription", len: 0, typ: NTI1291845682, name: "linkDescription", sons: null}]}]]}]}; +NTI1526726662.node = NNI1526726662; +NTI1526726660.base = NTI1526726662; +NTI1509949514.base = NTI1526726660; +var NNI1560281092 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1275069127, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI1509949501, name: "Field1", sons: null}]}; +NTI1560281092.node = NNI1560281092; +var NNI1526726794 = {kind: 2, offset: 0, typ: null, name: null, len: 1, sons: {"0": {kind: 1, offset: 0, typ: NTI1526726794, name: "orgHeading", len: 0, sons: null}}}; +NTI1526726794.node = NNI1526726794; +var NNI1526726804 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "val", len: 0, typ: NTI33554439, name: "val", sons: null}, +{kind: 1, offset: "has", len: 0, typ: NTI33554466, name: "has", sons: null}]}; +NTI1526726804.node = NNI1526726804; +NTI1509949450.base = NTI1526726660; +var NNI1509949449 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1442840584, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI1509949450, name: "Field1", sons: null}]}; +NTI1509949449.node = NNI1509949449; +var NNI1509949463 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1509949449, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI33554439, name: "Field1", sons: null}]}; +NTI1509949463.node = NNI1509949463; +NTI1509949477.base = NTI1526726660; +var NNI1509949465 = {kind: 3, offset: "o", len: 2, typ: NTI33554466, name: "o", sons: [[setConstr(0), {kind: 1, offset: "e", len: 0, typ: NTI1509949463, name: "e", sons: null}], +[setConstr(1), {kind: 1, offset: "v", len: 0, typ: NTI1509949449, name: "v", sons: null}]]}; +NTI1509949465.node = NNI1509949465; +var NNI1560281166 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1610612744, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI1560281167, name: "Field1", sons: null}]}; +NTI1560281166.node = NNI1560281166; +NTI1560281382.base = NTI1526726660; +NTI1509949452.base = NTI1526726660; +NTI1526726798.base = NTI1526726660; +NTI1526726812.base = NTI1526726660; +var NNI1526726797 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "children", len: 0, typ: NTI1526726798, name: "children", sons: null}, +{kind: 3, offset: "kind", len: 1, typ: NTI1526726794, name: "kind", sons: [[setConstr(0), {kind: 2, len: 4, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "level", len: 0, typ: NTI33554456, name: "level", sons: null}, +{kind: 1, offset: "todo", len: 0, typ: NTI1526726804, name: "todo", sons: null}, +{kind: 1, offset: "headlineContent", len: 0, typ: NTI1526726812, name: "headlineContent", sons: null}, +{kind: 1, offset: "headlineChildrenText", len: 0, typ: NTI33554439, name: "headlineChildrenText", sons: null}]}]]}]}; +NTI1526726797.node = NNI1526726797; +NTI1526726795.base = NTI1526726797; +NTI1509949556.base = NTI1526726795; +var NNI1509949555 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1442840584, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI1509949556, name: "Field1", sons: null}]}; +NTI1509949555.node = NNI1509949555; +var NNI1509949569 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1509949555, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI33554439, name: "Field1", sons: null}]}; +NTI1509949569.node = NNI1509949569; +var NNI1509949571 = {kind: 3, offset: "o", len: 2, typ: NTI33554466, name: "o", sons: [[setConstr(0), {kind: 1, offset: "e", len: 0, typ: NTI1509949569, name: "e", sons: null}], +[setConstr(1), {kind: 1, offset: "v", len: 0, typ: NTI1509949555, name: "v", sons: null}]]}; +NTI1509949571.node = NNI1509949571; +NTI1442840914.base = NTI1442840915; +var NNI788529496 = {kind: 2, len: 3, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1442840914, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI788529497, name: "Field1", sons: null}, +{kind: 1, offset: "Field2", len: 0, typ: NTI33554466, name: "Field2", sons: null}]}; +NTI788529496.node = NNI788529496; +NTI788529845.base = NTI1526726795; +NTI788529769.base = NTI1526726795; +NTI788529624.base = NTI1442840583; +NTI1275069021.base = NTI1275068421; +var NNI788529466 = {kind: 2, len: 3, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1275069021, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI788529239, name: "Field1", sons: null}, +{kind: 1, offset: "Field2", len: 0, typ: NTI33554466, name: "Field2", sons: null}]}; +NTI788529466.node = NNI788529466; + +function makeNimstrLit(c_33556802) { + var result = []; + for (var i = 0; i < c_33556802.length; ++i) { + result[i] = c_33556802.charCodeAt(i); + } + return result; + + + +} + +function toJSStr(s_33556808) { + var Temporary5; + var Temporary7; + + var result_33556809 = null; + + var res_33556843 = newSeq_33556826((s_33556808).length); + var i_33556844 = 0; + var j_33556845 = 0; + Label1: do { + Label2: while (true) { + if (!(i_33556844 < (s_33556808).length)) break Label2; + var c_33556846 = s_33556808[i_33556844]; + if ((c_33556846 < 128)) { + res_33556843[j_33556845] = String.fromCharCode(c_33556846); + i_33556844 += 1; + } + else { + var helper_33556858 = newSeq_33556826(0); + Label3: do { + Label4: while (true) { + if (!true) break Label4; + var code_33556859 = c_33556846.toString(16); + if ((((code_33556859) == null ? 0 : (code_33556859).length) == 1)) { + helper_33556858.push("%0");; + } + else { + helper_33556858.push("%");; + } + + helper_33556858.push(code_33556859);; + i_33556844 += 1; + if (((s_33556808).length <= i_33556844)) Temporary5 = true; else { Temporary5 = (s_33556808[i_33556844] < 128); } if (Temporary5) { + break Label3; + } + + c_33556846 = s_33556808[i_33556844]; + } + } while (false); +++excHandler; + Temporary7 = framePtr; + try { + res_33556843[j_33556845] = decodeURIComponent(helper_33556858.join("")); +--excHandler; +} catch (EXCEPTION) { + var prevJSError = lastJSError; + lastJSError = EXCEPTION; + --excHandler; + framePtr = Temporary7; + res_33556843[j_33556845] = helper_33556858.join(""); + lastJSError = prevJSError; + } finally { + framePtr = Temporary7; + } + } + + j_33556845 += 1; + } + } while (false); + if (res_33556843.length < j_33556845) { for (var i = res_33556843.length ; i < j_33556845 ; ++i) res_33556843.push(null); } + else { res_33556843.length = j_33556845; }; + result_33556809 = res_33556843.join(""); + + return result_33556809; + +} + +function raiseException(e_33556668, ename_33556669) { + e_33556668.name = ename_33556669; + if ((excHandler == 0)) { + unhandledException(e_33556668); + } + + throw e_33556668; + + +} + +function addInt(a_33556941, b_33556942) { + var result = a_33556941 + b_33556942; + checkOverflowInt(result); + return result; + + + +} + +function subInt(a_33556945, b_33556946) { + var result = a_33556945 - b_33556946; + checkOverflowInt(result); + return result; + + + +} + +function mnewString(len_33556894) { + return new Array(len_33556894); + + + +} + +function setConstr() { + var result = {}; + for (var i = 0; i < arguments.length; ++i) { + var x = arguments[i]; + if (typeof(x) == "object") { + for (var j = x[0]; j <= x[1]; ++j) { + result[j] = true; + } + } else { + result[x] = true; + } + } + return result; + + + +} +var ConstSet1 = setConstr(60, 62, 94); + +function chckRange(i_33557190, a_33557191, b_33557192) { + var Temporary1; + + var result_33557193 = 0; + + BeforeRet: do { + if (!(a_33557191 <= i_33557190)) Temporary1 = false; else { Temporary1 = (i_33557190 <= b_33557192); } if (Temporary1) { + result_33557193 = i_33557190; + break BeforeRet; + } + else { + raiseRangeError(); + } + + } while (false); + + return result_33557193; + +} +var ConstSet2 = setConstr(17, 16, 4, 18, 27, 19, 23, 22, 21); + +function nimCopy(dest_33557141, src_33557142, ti_33557143) { + var result_33557152 = null; + + switch (ti_33557143.kind) { + case 21: + case 22: + case 23: + case 5: + if (!(isFatPointer_33557132(ti_33557143))) { + result_33557152 = src_33557142; + } + else { + result_33557152 = [src_33557142[0], src_33557142[1]]; + } + + break; + case 19: + if (dest_33557141 === null || dest_33557141 === undefined) { + dest_33557141 = {}; + } + else { + for (var key in dest_33557141) { delete dest_33557141[key]; } + } + for (var key in src_33557142) { dest_33557141[key] = src_33557142[key]; } + result_33557152 = dest_33557141; + + break; + case 18: + case 17: + if (!((ti_33557143.base == null))) { + result_33557152 = nimCopy(dest_33557141, src_33557142, ti_33557143.base); + } + else { + if ((ti_33557143.kind == 17)) { + result_33557152 = (dest_33557141 === null || dest_33557141 === undefined) ? {m_type: ti_33557143} : dest_33557141; + } + else { + result_33557152 = (dest_33557141 === null || dest_33557141 === undefined) ? {} : dest_33557141; + } + } + nimCopyAux(result_33557152, src_33557142, ti_33557143.node); + break; + case 24: + case 4: + case 27: + case 16: + if (src_33557142 === null) { + result_33557152 = null; + } + else { + if (dest_33557141 === null || dest_33557141 === undefined || dest_33557141.length != src_33557142.length) { + dest_33557141 = new Array(src_33557142.length); + } + result_33557152 = dest_33557141; + for (var i = 0; i < src_33557142.length; ++i) { + result_33557152[i] = nimCopy(result_33557152[i], src_33557142[i], ti_33557143.base); + } + } + + break; + case 28: + if (src_33557142 !== null) { + result_33557152 = src_33557142.slice(0); + } + + break; + default: + result_33557152 = src_33557142; + break; + } + + return result_33557152; + +} + +function chckIndx(i_33557185, a_33557186, b_33557187) { + var Temporary1; + + var result_33557188 = 0; + + BeforeRet: do { + if (!(a_33557186 <= i_33557185)) Temporary1 = false; else { Temporary1 = (i_33557185 <= b_33557187); } if (Temporary1) { + result_33557188 = i_33557185; + break BeforeRet; + } + else { + raiseIndexError(i_33557185, a_33557186, b_33557187); + } + + } while (false); + + return result_33557188; + +} +var ConstSet3 = setConstr(60, 62, 94); +var ConstSet4 = setConstr(45, 43, 32); +var ConstSet5 = setConstr([48, 57]); +var ConstSet6 = setConstr([48, 57]); +var ConstSet7 = setConstr([48, 57]); + +function divInt(a_33556953, b_33556954) { + if (b_33556954 == 0) raiseDivByZero(); + if (b_33556954 == -1 && a_33556953 == 2147483647) raiseOverflow(); + return Math.trunc(a_33556953 / b_33556954); + + + +} + +function mulInt(a_33556949, b_33556950) { + var result = a_33556949 * b_33556950; + checkOverflowInt(result); + return result; + + + +} +var ConstSet8 = setConstr([65, 90], [97, 122]); + +function SetEq(a_33556900, b_33556901) { + for (var elem in a_33556900) { if (!b_33556901[elem]) return false; } + for (var elem in b_33556901) { if (!a_33556900[elem]) return false; } + return true; + + + +} +var ConstSet9 = setConstr([0, 255]); +var ConstSet10 = setConstr([48, 57]); +var ConstSet11 = setConstr([48, 57], [65, 70], [97, 102]); +var ConstSet12 = setConstr([65, 90], [97, 122]); +var ConstSet13 = setConstr(13, 10); +var ConstSet14 = setConstr(32, 9, 11, 13, 10, 12); + +function addChar(x_33557256, c_33557257) { + x_33557256.push(c_33557257); + + +} +var ConstSet15 = setConstr([0, 255]); +var ConstSet16 = setConstr(1); + +function raiseFieldError2(f_33556779, discVal_33556780) { + raiseException({message: (f_33556779 || []).concat(discVal_33556780 || [],makeNimstrLit("\'") || []), parent: null, m_type: NTI33555129, name: null, trace: [], up: null}, "FieldDefect"); + + +} + +function nimBoolToStr(x_33556515) { + var result_33556516 = []; + + if (x_33556515) { + result_33556516 = nimCopy(null, makeNimstrLit("true"), NTI33554439); + } + else { + result_33556516 = nimCopy(null, makeNimstrLit("false"), NTI33554439); + } + + + return result_33556516; + +} + +function reprDiscriminant(e_33557410, typ_33557411) { + var Temporary1; + + var result_33557412 = []; + + switch (typ_33557411.kind) { + case 14: + Temporary1 = reprEnum(e_33557410, typ_33557411); + break; + case 1: + Temporary1 = nimBoolToStr(!((e_33557410 == 0))); + break; + default: + Temporary1 = HEX24_335544323(e_33557410); + break; + } + result_33557412 = nimCopy(null, Temporary1, NTI33554439); + + return result_33557412; + +} +var ConstSet17 = setConstr(13, 10); + +function nimMax(a_33556999, b_33557000) { + var Temporary1; + + var result_33557001 = 0; + + BeforeRet: do { + if ((b_33557000 <= a_33556999)) { + Temporary1 = a_33556999; + } + else { + Temporary1 = b_33557000; + } + + result_33557001 = Temporary1; + break BeforeRet; + } while (false); + + return result_33557001; + +} + +function nimMin(a_33556995, b_33556996) { + var Temporary1; + + var result_33556997 = 0; + + BeforeRet: do { + if ((a_33556995 <= b_33556996)) { + Temporary1 = a_33556995; + } + else { + Temporary1 = b_33556996; + } + + result_33556997 = Temporary1; + break BeforeRet; + } while (false); + + return result_33556997; + +} + +function nimCharToStr(x_33556518) { + var result_33556519 = []; + + result_33556519 = nimCopy(null, mnewString(1), NTI33554439); + result_33556519[0] = x_33556518; + + return result_33556519; + +} +var ConstSet18 = setConstr(0); +var ConstSet19 = setConstr(1); +var ConstSet20 = setConstr(true); +var ConstSet21 = setConstr(false); +var ConstSet22 = setConstr(13, 10); +var ConstSet23 = setConstr(32, 9, 11, 13, 10, 12); +var ConstSet24 = setConstr(true); +var ConstSet25 = setConstr(false); +var ConstSet26 = setConstr(true); +var ConstSet27 = setConstr(false); +var ConstSet28 = setConstr(true); +var ConstSet29 = setConstr(false); +var ConstSet30 = setConstr(13, 10); +var ConstSet31 = setConstr(false); +var ConstSet32 = setConstr(true); +var ConstSet33 = setConstr([2, 2]); + +function eqStrings(a_33556932, b_33556933) { + if (a_33556932 == b_33556933) return true; + if (a_33556932 === null && b_33556933.length == 0) return true; + if (b_33556933 === null && a_33556932.length == 0) return true; + if ((!a_33556932) || (!b_33556933)) return false; + var alen = a_33556932.length; + if (alen != b_33556933.length) return false; + for (var i = 0; i < alen; ++i) + if (a_33556932[i] != b_33556933[i]) return false; + return true; + + + +} +var ConstSet34 = setConstr(1); +var ConstSet35 = setConstr(32, 9, 11, 13, 10, 12); +var ConstSet36 = setConstr(1); +var ConstSet37 = setConstr(0); +var ConstSet38 = setConstr(0); +var ConstSet39 = setConstr(true); +var ConstSet40 = setConstr(8); +var ConstSet41 = setConstr(1); +var ConstSet42 = setConstr(1); +var ConstSet43 = setConstr(8); +var ConstSet44 = setConstr(true); +var ConstSet45 = setConstr(false); +var ConstSet46 = setConstr(true); +var ConstSet47 = setConstr(false); +var ConstSet48 = setConstr(true); +var ConstSet49 = setConstr(true); +var ConstSet50 = setConstr(0); +var ConstSet51 = setConstr(true); +var ConstSet52 = setConstr(false); +var ConstSet53 = setConstr(true); +var ConstSet54 = setConstr(true); +var ConstSet55 = setConstr(true); +var ConstSet56 = setConstr(1); +var ConstSet57 = setConstr(1); +var ConstSet58 = setConstr(1); +var ConstSet59 = setConstr(true); +var ConstSet60 = setConstr(true); +var ConstSet61 = setConstr(false); +var ConstSet62 = setConstr(false); + +function rawEcho() { + var buf = ""; + for (var i = 0; i < arguments.length; ++i) { + buf += toJSStr(arguments[i]); + } + console.log(buf); + + + +} +var ConstSet63 = setConstr(true); +var ConstSet64 = setConstr(0); +var ConstSet65 = setConstr(0); +var ConstSet66 = setConstr(0); +var ConstSet67 = setConstr(0); +var ConstSet68 = setConstr(true); +var ConstSet69 = setConstr(false); +if (!Math.trunc) { + Math.trunc = function(v) { + v = +v; + if (!isFinite(v)) return v; + return (v - v % 1) || (v < 0 ? -0 : v === 0 ? v : 0); + }; +} + +var objectID_973078690 = [0]; + +function add_33556420(x_33556421, x_33556421_Idx, y_33556422) { + if (x_33556421[x_33556421_Idx] === null) { x_33556421[x_33556421_Idx] = []; } + var off = x_33556421[x_33556421_Idx].length; + x_33556421[x_33556421_Idx].length += y_33556422.length; + for (var i = 0; i < y_33556422.length; ++i) { + x_33556421[x_33556421_Idx][off+i] = y_33556422.charCodeAt(i); + } + + + +} + +function newSeq_33556826(len_33556828) { + var result_33556829 = []; + + result_33556829 = new Array(len_33556828); for (var i = 0 ; i < len_33556828 ; ++i) { result_33556829[i] = null; } + return result_33556829; + +} + +function unhandledException(e_33556664) { + var buf_33556665 = [[]]; + if (!(((e_33556664.message).length == 0))) { + buf_33556665[0].push.apply(buf_33556665[0], makeNimstrLit("Error: unhandled exception: "));; + buf_33556665[0].push.apply(buf_33556665[0], e_33556664.message);; + } + else { + buf_33556665[0].push.apply(buf_33556665[0], makeNimstrLit("Error: unhandled exception"));; + } + + buf_33556665[0].push.apply(buf_33556665[0], makeNimstrLit(" ["));; + add_33556420(buf_33556665, 0, e_33556664.name); + buf_33556665[0].push.apply(buf_33556665[0], makeNimstrLit("]\x0A"));; + var cbuf_33556666 = toJSStr(buf_33556665[0]); + framePtr = null; + if (typeof(Error) !== "undefined") { + throw new Error(cbuf_33556666); + } + else { + throw cbuf_33556666; + } + + + +} + +function raiseOverflow() { + raiseException({message: makeNimstrLit("over- or underflow"), parent: null, m_type: NTI33555122, name: null, trace: [], up: null}, "OverflowDefect"); + + +} + +function checkOverflowInt(a_33556939) { + if (a_33556939 > 2147483647 || a_33556939 < -2147483648) raiseOverflow(); + + + +} + +function raiseRangeError() { + raiseException({message: makeNimstrLit("value out of range"), parent: null, m_type: NTI33555130, name: null, trace: [], up: null}, "RangeDefect"); + + +} + +function addChars_251658415(result_251658417, result_251658417_Idx, x_251658418, start_251658419, n_251658420) { + var old_251658421 = (result_251658417[result_251658417_Idx]).length; + (result_251658417[result_251658417_Idx].length = chckRange(addInt(old_251658421, n_251658420), 0, 2147483647)); + Label1: do { + var iHEX60gensym4_251658435 = 0; + var i_1275068527 = 0; + Label2: do { + Label3: while (true) { + if (!(i_1275068527 < n_251658420)) break Label3; + iHEX60gensym4_251658435 = i_1275068527; + result_251658417[result_251658417_Idx][chckIndx(addInt(old_251658421, iHEX60gensym4_251658435), 0, (result_251658417[result_251658417_Idx]).length - 1)] = x_251658418.charCodeAt(chckIndx(addInt(start_251658419, iHEX60gensym4_251658435), 0, (x_251658418).length - 1)); + i_1275068527 = addInt(i_1275068527, 1); + } + } while (false); + } while (false); + + +} + +function addChars_251658411(result_251658413, result_251658413_Idx, x_251658414) { + addChars_251658415(result_251658413, result_251658413_Idx, x_251658414, 0, ((x_251658414) == null ? 0 : (x_251658414).length)); + + +} + +function addInt_251658436(result_251658437, result_251658437_Idx, x_251658438) { + addChars_251658411(result_251658437, result_251658437_Idx, ((x_251658438) + "")); + + +} + +function addInt_251658457(result_251658458, result_251658458_Idx, x_251658459) { + addInt_251658436(result_251658458, result_251658458_Idx, x_251658459); + + +} + +function HEX24_335544323(x_335544324) { + var result_335544325 = [[]]; + + addInt_251658457(result_335544325, 0, x_335544324); + + return result_335544325[0]; + +} + +function isFatPointer_33557132(ti_33557133) { + var result_33557134 = false; + + BeforeRet: do { + result_33557134 = !((ConstSet2[ti_33557133.base.kind] != undefined)); + break BeforeRet; + } while (false); + + return result_33557134; + +} + +function nimCopyAux(dest_33557145, src_33557146, n_33557147) { + switch (n_33557147.kind) { + case 0: + break; + case 1: + dest_33557145[n_33557147.offset] = nimCopy(dest_33557145[n_33557147.offset], src_33557146[n_33557147.offset], n_33557147.typ); + + break; + case 2: + for (var i = 0; i < n_33557147.sons.length; i++) { + nimCopyAux(dest_33557145, src_33557146, n_33557147.sons[i]); + } + + break; + case 3: + dest_33557145[n_33557147.offset] = nimCopy(dest_33557145[n_33557147.offset], src_33557146[n_33557147.offset], n_33557147.typ); + for (var i = 0; i < n_33557147.sons.length; ++i) { + nimCopyAux(dest_33557145, src_33557146, n_33557147.sons[i][1]); + } + + break; + } + + +} + +function raiseIndexError(i_33556755, a_33556756, b_33556757) { + var Temporary1; + + if ((b_33556757 < a_33556756)) { + Temporary1 = makeNimstrLit("index out of bounds, the container is empty"); + } + else { + Temporary1 = (makeNimstrLit("index ") || []).concat(HEX24_335544323(i_33556755) || [],makeNimstrLit(" not in ") || [],HEX24_335544323(a_33556756) || [],makeNimstrLit(" .. ") || [],HEX24_335544323(b_33556757) || []); + } + + raiseException({message: nimCopy(null, Temporary1, NTI33554439), parent: null, m_type: NTI33555128, name: null, trace: [], up: null}, "IndexDefect"); + + +} + +function raiseDivByZero() { + raiseException({message: makeNimstrLit("division by zero"), parent: null, m_type: NTI33555121, name: null, trace: [], up: null}, "DivByZeroDefect"); + + +} + +function parseSaturatedNatural_486539580(s_486539581, b_486539582, b_486539582_Idx, start_486539583) { + var Temporary1; + var Temporary4; + + var result_486539584 = 0; + + var i_486539585 = start_486539583; + if (((i_486539585 < (s_486539581).length) && (s_486539581[chckIndx(i_486539585, 0, (s_486539581).length - 1)] == 43))) { + i_486539585 = addInt(i_486539585, 1); + } + + if (!(i_486539585 < (s_486539581).length)) Temporary1 = false; else { Temporary1 = (ConstSet6[s_486539581[chckIndx(i_486539585, 0, (s_486539581).length - 1)]] != undefined); } if (Temporary1) { + b_486539582[b_486539582_Idx] = 0; + Label2: do { + Label3: while (true) { + if (!(i_486539585 < (s_486539581).length)) Temporary4 = false; else { Temporary4 = (ConstSet7[s_486539581[chckIndx(i_486539585, 0, (s_486539581).length - 1)]] != undefined); } if (!Temporary4) break Label3; + var c_486539604 = subInt(s_486539581[chckIndx(i_486539585, 0, (s_486539581).length - 1)], 48); + if ((b_486539582[b_486539582_Idx] <= divInt(subInt(2147483647, c_486539604), 10))) { + b_486539582[b_486539582_Idx] = addInt(mulInt(b_486539582[b_486539582_Idx], 10), c_486539604); + } + else { + b_486539582[b_486539582_Idx] = 2147483647; + } + + i_486539585 = addInt(i_486539585, 1); + Label5: do { + Label6: while (true) { + if (!((i_486539585 < (s_486539581).length) && (s_486539581[chckIndx(i_486539585, 0, (s_486539581).length - 1)] == 95))) break Label6; + i_486539585 = addInt(i_486539585, 1); + } + } while (false); + } + } while (false); + result_486539584 = subInt(i_486539585, start_486539583); + } + + + return result_486539584; + +} + +function HEX5BHEX5D_721423528(s_721423531, x_721423532) { + var result_721423533 = []; + + var a_721423535 = x_721423532.a; + var L_721423537 = addInt(subInt(subInt((s_721423531).length, x_721423532.b), a_721423535), 1); + result_721423533 = nimCopy(null, mnewString(chckRange(L_721423537, 0, 2147483647)), NTI33554439); + Label1: do { + var i_721423542 = 0; + var i_1442841208 = 0; + Label2: do { + Label3: while (true) { + if (!(i_1442841208 < L_721423537)) break Label3; + i_721423542 = i_1442841208; + result_721423533[chckIndx(i_721423542, 0, (result_721423533).length - 1)] = s_721423531[chckIndx(addInt(i_721423542, a_721423535), 0, (s_721423531).length - 1)]; + i_1442841208 = addInt(i_1442841208, 1); + } + } while (false); + } while (false); + + return result_721423533; + +} + +function HEX2EHEX2E_721423501(a_721423504, b_721423505) { + var result_721423508 = ({a: 0, b: 0}); + + result_721423508 = nimCopy(result_721423508, {a: a_721423504, b: b_721423505}, NTI721430694); + + return result_721423508; + +} + +function parseStandardFormatSpecifier_1107296314(s_1107296315, start_1107296316, ignoreUnknownSuffix_1107296317) { + var Temporary1; + var Temporary2; + var Temporary3; + + var result_1107296318 = ({fill: 0, align: 0, sign: 0, alternateForm: false, padWithZero: false, minimumWidth: 0, precision: 0, typ: 0, endPosition: 0}); + + result_1107296318.fill = 32; + result_1107296318.align = 0; + result_1107296318.sign = 45; + var i_1107296320 = start_1107296316; + if (((addInt(i_1107296320, 1) < (s_1107296315).length) && (ConstSet1[s_1107296315[chckIndx(addInt(i_1107296320, 1), 0, (s_1107296315).length - 1)]] != undefined))) { + result_1107296318.fill = s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)]; + result_1107296318.align = s_1107296315[chckIndx(addInt(i_1107296320, 1), 0, (s_1107296315).length - 1)]; + i_1107296320 = addInt(i_1107296320, 2); + } + else { + if (((i_1107296320 < (s_1107296315).length) && (ConstSet3[s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)]] != undefined))) { + result_1107296318.align = s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)]; + i_1107296320 = addInt(i_1107296320, 1); + } + } + if (((i_1107296320 < (s_1107296315).length) && (ConstSet4[s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)]] != undefined))) { + result_1107296318.sign = s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)]; + i_1107296320 = addInt(i_1107296320, 1); + } + + if (((i_1107296320 < (s_1107296315).length) && (s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)] == 35))) { + result_1107296318.alternateForm = true; + i_1107296320 = addInt(i_1107296320, 1); + } + + if (!((addInt(i_1107296320, 1) < (s_1107296315).length) && (s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)] == 48))) Temporary1 = false; else { Temporary1 = (ConstSet5[s_1107296315[chckIndx(addInt(i_1107296320, 1), 0, (s_1107296315).length - 1)]] != undefined); } if (Temporary1) { + result_1107296318.padWithZero = true; + i_1107296320 = addInt(i_1107296320, 1); + } + + var parsedLength_1107296357 = parseSaturatedNatural_486539580(s_1107296315, result_1107296318, "minimumWidth", i_1107296320); + i_1107296320 = addInt(i_1107296320, parsedLength_1107296357); + if (((i_1107296320 < (s_1107296315).length) && (s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)] == 46))) { + i_1107296320 = addInt(i_1107296320, 1); + var parsedLengthB_1107296366 = parseSaturatedNatural_486539580(s_1107296315, result_1107296318, "precision", i_1107296320); + i_1107296320 = addInt(i_1107296320, parsedLengthB_1107296366); + } + else { + result_1107296318.precision = -1; + } + + if (!(i_1107296320 < (s_1107296315).length)) Temporary2 = false; else { Temporary2 = (ConstSet8[s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)]] != undefined); } if (Temporary2) { + result_1107296318.typ = s_1107296315[chckIndx(i_1107296320, 0, (s_1107296315).length - 1)]; + i_1107296320 = addInt(i_1107296320, 1); + } + + result_1107296318.endPosition = i_1107296320; + if (!!((i_1107296320 == (s_1107296315).length))) Temporary3 = false; else { Temporary3 = !(ignoreUnknownSuffix_1107296317); } if (Temporary3) { + raiseException({message: (makeNimstrLit("invalid format string, cannot parse: ") || []).concat(HEX5BHEX5D_721423528(s_1107296315, HEX2EHEX2E_721423501(i_1107296320, 1)) || []), parent: null, m_type: NTI33555125, name: null, trace: [], up: null}, "ValueError"); + } + + + return result_1107296318; + +} + +function nucruneLen(s_721420298) { + var result_721420299 = 0; + + result_721420299 = 0; + var i_721420300 = 0; + Label1: do { + Label2: while (true) { + if (!(i_721420300 < (s_721420298).length)) break Label2; + if ((s_721420298[chckIndx(i_721420300, 0, (s_721420298).length - 1)] <= 127)) { + i_721420300 = addInt(i_721420300, 1); + } + else { + if (((s_721420298[chckIndx(i_721420300, 0, (s_721420298).length - 1)] >>> 5) == 6)) { + i_721420300 = addInt(i_721420300, 2); + } + else { + if (((s_721420298[chckIndx(i_721420300, 0, (s_721420298).length - 1)] >>> 4) == 14)) { + i_721420300 = addInt(i_721420300, 3); + } + else { + if (((s_721420298[chckIndx(i_721420300, 0, (s_721420298).length - 1)] >>> 3) == 30)) { + i_721420300 = addInt(i_721420300, 4); + } + else { + if (((s_721420298[chckIndx(i_721420300, 0, (s_721420298).length - 1)] >>> 2) == 62)) { + i_721420300 = addInt(i_721420300, 5); + } + else { + if (((s_721420298[chckIndx(i_721420300, 0, (s_721420298).length - 1)] >>> 1) == 126)) { + i_721420300 = addInt(i_721420300, 6); + } + else { + i_721420300 = addInt(i_721420300, 1); + } + }}}}} + result_721420299 = addInt(result_721420299, 1); + } + } while (false); + + return result_721420299; + +} + +function runeLenAt_721420353(s_721420354, i_721420355) { + var result_721420356 = 0; + + if ((s_721420354[chckIndx(i_721420355, 0, (s_721420354).length - 1)] <= 127)) { + result_721420356 = 1; + } + else { + if (((s_721420354[chckIndx(i_721420355, 0, (s_721420354).length - 1)] >>> 5) == 6)) { + result_721420356 = 2; + } + else { + if (((s_721420354[chckIndx(i_721420355, 0, (s_721420354).length - 1)] >>> 4) == 14)) { + result_721420356 = 3; + } + else { + if (((s_721420354[chckIndx(i_721420355, 0, (s_721420354).length - 1)] >>> 3) == 30)) { + result_721420356 = 4; + } + else { + if (((s_721420354[chckIndx(i_721420355, 0, (s_721420354).length - 1)] >>> 2) == 62)) { + result_721420356 = 5; + } + else { + if (((s_721420354[chckIndx(i_721420355, 0, (s_721420354).length - 1)] >>> 1) == 126)) { + result_721420356 = 6; + } + else { + result_721420356 = 1; + } + }}}}} + + return result_721420356; + +} + +function runeOffset_721420925(s_721420926, pos_721420927, start_721420928) { + var result_721420929 = 0; + + BeforeRet: do { + var i_721420930 = 0; + var o_721420931 = start_721420928; + Label1: do { + Label2: while (true) { + if (!(i_721420930 < pos_721420927)) break Label2; + o_721420931 = addInt(o_721420931, chckRange(runeLenAt_721420353(s_721420926, o_721420931), 0, 2147483647)); + if (((s_721420926).length <= o_721420931)) { + result_721420929 = -1; + break BeforeRet; + } + + i_721420930 = addInt(i_721420930, 1); + } + } while (false); + result_721420929 = o_721420931; + break BeforeRet; + } while (false); + + return result_721420929; + +} + +function validateUtf8_721420565(s_721420566) { + var Temporary3; + var Temporary4; + var Temporary5; + var Temporary6; + var Temporary7; + var Temporary8; + + var result_721420567 = 0; + + BeforeRet: do { + var i_721420568 = 0; + var L_721420569 = (s_721420566).length; + Label1: do { + Label2: while (true) { + if (!(i_721420568 < L_721420569)) break Label2; + if ((s_721420566[chckIndx(i_721420568, 0, (s_721420566).length - 1)] <= 127)) { + i_721420568 = addInt(i_721420568, 1); + } + else { + if (((s_721420566[chckIndx(i_721420568, 0, (s_721420566).length - 1)] >>> 5) == 6)) { + if ((s_721420566[chckIndx(i_721420568, 0, (s_721420566).length - 1)] < 194)) { + result_721420567 = i_721420568; + break BeforeRet; + } + + if (!(addInt(i_721420568, 1) < L_721420569)) Temporary3 = false; else { Temporary3 = ((s_721420566[chckIndx(addInt(i_721420568, 1), 0, (s_721420566).length - 1)] >>> 6) == 2); } if (Temporary3) { + i_721420568 = addInt(i_721420568, 2); + } + else { + result_721420567 = i_721420568; + break BeforeRet; + } + + } + else { + if (((s_721420566[chckIndx(i_721420568, 0, (s_721420566).length - 1)] >>> 4) == 14)) { + if (!(addInt(i_721420568, 2) < L_721420569)) Temporary5 = false; else { Temporary5 = ((s_721420566[chckIndx(addInt(i_721420568, 1), 0, (s_721420566).length - 1)] >>> 6) == 2); } if (!Temporary5) Temporary4 = false; else { Temporary4 = ((s_721420566[chckIndx(addInt(i_721420568, 2), 0, (s_721420566).length - 1)] >>> 6) == 2); } if (Temporary4) { + i_721420568 = addInt(i_721420568, 3); + } + else { + result_721420567 = i_721420568; + break BeforeRet; + } + + } + else { + if (((s_721420566[chckIndx(i_721420568, 0, (s_721420566).length - 1)] >>> 3) == 30)) { + if (!(addInt(i_721420568, 3) < L_721420569)) Temporary8 = false; else { Temporary8 = ((s_721420566[chckIndx(addInt(i_721420568, 1), 0, (s_721420566).length - 1)] >>> 6) == 2); } if (!Temporary8) Temporary7 = false; else { Temporary7 = ((s_721420566[chckIndx(addInt(i_721420568, 2), 0, (s_721420566).length - 1)] >>> 6) == 2); } if (!Temporary7) Temporary6 = false; else { Temporary6 = ((s_721420566[chckIndx(addInt(i_721420568, 3), 0, (s_721420566).length - 1)] >>> 6) == 2); } if (Temporary6) { + i_721420568 = addInt(i_721420568, 4); + } + else { + result_721420567 = i_721420568; + break BeforeRet; + } + + } + else { + result_721420567 = i_721420568; + break BeforeRet; + } + }}} + } + } while (false); + result_721420567 = -1; + break BeforeRet; + } while (false); + + return result_721420567; + +} + +function nsuRepeatChar(c_469763067, count_469763068) { + var result_469763069 = []; + + result_469763069 = nimCopy(null, mnewString(count_469763068), NTI33554439); + Label1: do { + var i_469763074 = 0; + var colontmp__1275068535 = 0; + colontmp__1275068535 = subInt(count_469763068, 1); + var res_1275068536 = 0; + Label2: do { + Label3: while (true) { + if (!(res_1275068536 <= colontmp__1275068535)) break Label3; + i_469763074 = res_1275068536; + result_469763069[chckIndx(i_469763074, 0, (result_469763069).length - 1)] = c_469763067; + res_1275068536 = addInt(res_1275068536, 1); + } + } while (false); + } while (false); + + return result_469763069; + +} + +function alignString_1107296276(s_1107296277, minimumWidth_1107296278, align_1107296279, fill_1107296280) { + var Temporary1; + + var result_1107296281 = []; + + if ((minimumWidth_1107296278 == 0)) { + result_1107296281 = nimCopy(null, s_1107296277, NTI33554439); + } + else { + if ((validateUtf8_721420565(s_1107296277) == -1)) { + Temporary1 = nucruneLen(s_1107296277); + } + else { + Temporary1 = (s_1107296277).length; + } + + var sRuneLen_1107296282 = Temporary1; + var toFill_1107296283 = subInt(minimumWidth_1107296278, sRuneLen_1107296282); + if ((toFill_1107296283 <= 0)) { + result_1107296281 = nimCopy(null, s_1107296277, NTI33554439); + } + else { + if (((align_1107296279 == 60) || (align_1107296279 == 0))) { + result_1107296281 = nimCopy(null, (s_1107296277 || []).concat(nsuRepeatChar(fill_1107296280, chckRange(toFill_1107296283, 0, 2147483647)) || []), NTI33554439); + } + else { + if ((align_1107296279 == 94)) { + var half_1107296284 = divInt(toFill_1107296283, 2); + result_1107296281 = nimCopy(null, (nsuRepeatChar(fill_1107296280, chckRange(half_1107296284, 0, 2147483647)) || []).concat(s_1107296277 || [],nsuRepeatChar(fill_1107296280, chckRange(subInt(toFill_1107296283, half_1107296284), 0, 2147483647)) || []), NTI33554439); + } + else { + result_1107296281 = nimCopy(null, (nsuRepeatChar(fill_1107296280, chckRange(toFill_1107296283, 0, 2147483647)) || []).concat(s_1107296277 || []), NTI33554439); + } + }} + } + + + return result_1107296281; + +} + +function formatValue_1107296418(result_1107296419, result_1107296419_Idx, value_1107296420, specifier_1107296421) { + var spec_1107296422 = parseStandardFormatSpecifier_1107296314(specifier_1107296421, 0, false); + var value_1107296423 = nimCopy(null, value_1107296420, NTI33554439); + switch (spec_1107296422.typ) { + case 115: + case 0: + break; + default: + raiseException({message: (makeNimstrLit("invalid type in format string for string, expected \'s\', but got ") || []).concat([spec_1107296422.typ]), parent: null, m_type: NTI33555125, name: null, trace: [], up: null}, "ValueError"); + break; + } + if (!((spec_1107296422.precision == -1))) { + if ((spec_1107296422.precision < nucruneLen(value_1107296423))) { + (value_1107296423.length = chckRange(runeOffset_721420925(value_1107296423, chckRange(spec_1107296422.precision, 0, 2147483647), 0), 0, 2147483647)); + } + + } + + result_1107296419[result_1107296419_Idx].push.apply(result_1107296419[result_1107296419_Idx], alignString_1107296276(value_1107296423, spec_1107296422.minimumWidth, spec_1107296422.align, spec_1107296422.fill));; + + +} + +function addEscapedChar_33557861(s_33557862, s_33557862_Idx, c_33557863) { + switch (c_33557863) { + case 7: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\a"));; + break; + case 8: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\b"));; + break; + case 9: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\t"));; + break; + case 10: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\n"));; + break; + case 11: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\v"));; + break; + case 12: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\f"));; + break; + case 13: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\r"));; + break; + case 27: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\e"));; + break; + case 92: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\\\"));; + break; + case 39: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\\'"));; + break; + case 34: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\\""));; + break; + case 32: + case 33: + case 35: + case 36: + case 37: + case 38: + case 40: + case 41: + case 42: + case 43: + case 44: + case 45: + case 46: + case 47: + case 48: + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 65: + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 91: + case 93: + case 94: + case 95: + case 96: + case 97: + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + case 123: + case 124: + case 125: + case 126: + addChar(s_33557862[s_33557862_Idx], c_33557863);; + break; + default: + s_33557862[s_33557862_Idx].push.apply(s_33557862[s_33557862_Idx], makeNimstrLit("\\x"));; + var n_33557873 = c_33557863; + addChar(s_33557862[s_33557862_Idx], makeNimstrLit("0123456789ABCDEF")[chckIndx(((n_33557873 & 240) >> 4), 0, (makeNimstrLit("0123456789ABCDEF")).length - 1)]);; + addChar(s_33557862[s_33557862_Idx], makeNimstrLit("0123456789ABCDEF")[chckIndx((n_33557873 & 15), 0, (makeNimstrLit("0123456789ABCDEF")).length - 1)]);; + break; + } + + +} + +function addQuoted_1459618121(s_1459618123, s_1459618123_Idx, x_1459618124) { + s_1459618123[s_1459618123_Idx].push.apply(s_1459618123[s_1459618123_Idx], makeNimstrLit("\'"));; + addEscapedChar_33557861(s_1459618123, s_1459618123_Idx, x_1459618124); + s_1459618123[s_1459618123_Idx].push.apply(s_1459618123[s_1459618123_Idx], makeNimstrLit("\'"));; + + +} + +function collectionToString_1459618089(x_1459618091, prefix_1459618092, separator_1459618093, suffix_1459618094) { + var result_1459618095 = [[]]; + + result_1459618095[0] = nimCopy(null, prefix_1459618092, NTI33554439); + var firstElement_1459618096 = true; + Label1: do { + var value_1459618117 = 0; + var i_1275068541 = 0; + Label2: do { + Label3: while (true) { + if (!(i_1275068541 <= 255)) break Label3; + if ((x_1459618091[i_1275068541] != undefined)) { + value_1459618117 = i_1275068541; + if (firstElement_1459618096) { + firstElement_1459618096 = false; + } + else { + result_1459618095[0].push.apply(result_1459618095[0], separator_1459618093);; + } + + addQuoted_1459618121(result_1459618095, 0, value_1459618117); + } + + i_1275068541 += 1; + } + } while (false); + } while (false); + result_1459618095[0].push.apply(result_1459618095[0], suffix_1459618094);; + + return result_1459618095[0]; + +} + +function HEX24_1459618085(x_1459618087) { + var result_1459618088 = []; + + result_1459618088 = nimCopy(null, collectionToString_1459618089(x_1459618087, makeNimstrLit("{"), makeNimstrLit(", "), makeNimstrLit("}")), NTI33554439); + + return result_1459618088; + +} + +function prettyExpectedSet_1459617900(x_1459617901) { + var Temporary2; + + var result_1459617902 = []; + + Label1: do { + var expr_1459617924 = nimCopy(null, x_1459617901, NTI1459617871); + var pos_1459618057 = 0; + var _ = pos_1459618057; + if (SetEq(expr_1459617924, ConstSet9)) { + Temporary2 = makeNimstrLit("AllChars {\'\x00\'..\'\xFF\'}"); + } + else { + if (SetEq(expr_1459617924, ConstSet10)) { + Temporary2 = makeNimstrLit("Digits {\'0\'..\'9\'}"); + } + else { + if (SetEq(expr_1459617924, ConstSet11)) { + Temporary2 = makeNimstrLit("HexDigits {\'0\'..\'9\', \'A\'..\'F\', \'a\'..\'f\'}"); + } + else { + if (SetEq(expr_1459617924, ConstSet12)) { + Temporary2 = makeNimstrLit("Letters {\'A\'..\'Z\', \'a\'..\'z\'}"); + } + else { + if (SetEq(expr_1459617924, ConstSet13)) { + Temporary2 = makeNimstrLit("Newlines {\'\x0D\', \'\x0A\'}"); + } + else { + if (SetEq(expr_1459617924, ConstSet14)) { + Temporary2 = makeNimstrLit("Whitespace {\' \', \'\x09\', \'\x0B\', \'\x0D\', \'\x0A\', \'\x0C\'}"); + } + else { + Temporary2 = HEX24_1459618085(x_1459617901); + } + }}}}} + } while (false); + result_1459617902 = nimCopy(null, Temporary2, NTI33554439); + + return result_1459617902; + +} + +function HEX26_1275068448(x_1275068450, y_1275068451) { + var result_1275068452 = []; + + result_1275068452 = new Array(chckRange(addInt((x_1275068450).length, 1), 0, 2147483647)); for (var i = 0 ; i < chckRange(addInt((x_1275068450).length, 1), 0, 2147483647) ; ++i) { result_1275068452[i] = null; } Label1: do { + var i_1275068467 = 0; + var colontmp__1275068544 = 0; + colontmp__1275068544 = subInt((x_1275068450).length, 1); + var res_1275068545 = 0; + Label2: do { + Label3: while (true) { + if (!(res_1275068545 <= colontmp__1275068544)) break Label3; + i_1275068467 = res_1275068545; + result_1275068452[chckIndx(i_1275068467, 0, (result_1275068452).length - 1)] = x_1275068450[chckIndx(i_1275068467, 0, (x_1275068450).length - 1)]; + res_1275068545 = addInt(res_1275068545, 1); + } + } while (false); + } while (false); + result_1275068452[chckIndx((x_1275068450).length, 0, (result_1275068452).length - 1)] = y_1275068451; + + return result_1275068452; + +} + +function initParserToken_1442840634(x_1442840635) { + var result_1442840636 = null; + + result_1442840636 = {kind: 0, charValue: x_1442840635, stringValue: []}; + + return result_1442840636; + +} + +function ch_1275068428(expectedChars_1275068429) { + expectedChars_1275068429 = nimCopy(null, expectedChars_1275068429, NTI1275068420); + +function HEX3Aanonymous_1275068433(parser_1275068434) { + var result_1275068435 = ({o: false, e: null, v: null}); + + BeforeRet: do { + var state_1275068436 = parser_1275068434.state; + var newIndex_1275068437 = addInt(state_1275068436.position, 1); + if ((subInt((state_1275068436.stream).length, 1) < newIndex_1275068437)) { + var fmtRes_1275068438 = [mnewString(0)]; + formatValue_1107296418(fmtRes_1275068438, 0, prettyExpectedSet_1459617900(expectedChars_1275068429), []); + result_1275068435 = nimCopy(result_1275068435, {o: false, e: {kind: 2, expected: nimCopy(null, fmtRes_1275068438[0], NTI33554439), index: newIndex_1275068437, parser: parser_1275068434, unexpected: []}, v: null}, NTI1442840603); + break BeforeRet; + } + else { + var foundChar_1275068443 = state_1275068436.stream[chckIndx(newIndex_1275068437, 0, (state_1275068436.stream).length - 1)]; + if ((expectedChars_1275068429[foundChar_1275068443] != undefined)) { + result_1275068435 = nimCopy(result_1275068435, {o: true, v: {state: {stream: nimCopy(null, state_1275068436.stream, NTI33554439), position: newIndex_1275068437, lastPosition: parser_1275068434.state.position}, tokens: HEX26_1275068448(parser_1275068434.tokens, initParserToken_1442840634(foundChar_1275068443))}, e: null}, NTI1442840603); + break BeforeRet; + } + else { + var fmtRes_1275068475 = mnewString(0); + addChar(fmtRes_1275068475, foundChar_1275068443);; + var fmtRes_1275068476 = [mnewString(0)]; + formatValue_1107296418(fmtRes_1275068476, 0, prettyExpectedSet_1459617900(expectedChars_1275068429), []); + result_1275068435 = nimCopy(result_1275068435, {o: false, e: {kind: 1, unexpected: nimCopy(null, fmtRes_1275068475, NTI33554439), expected: nimCopy(null, fmtRes_1275068476[0], NTI33554439), index: newIndex_1275068437, parser: parser_1275068434}, v: null}, NTI1442840603); + break BeforeRet; + } + + } + + } while (false); + + return result_1275068435; + + } + + var result_1275068432 = null; + + BeforeRet: do { + result_1275068432 = HEX3Aanonymous_1275068433; + break BeforeRet; + } while (false); + + return result_1275068432; + +} +var anyCh_1275068520 = ch_1275068428(ConstSet15); + +function newSeq_1275068900(len_1275068902) { + var result_1275068903 = []; + + result_1275068903 = new Array(len_1275068902); for (var i = 0 ; i < len_1275068902 ; ++i) { result_1275068903[i] = ({o: false, e: null, v: null}); } + return result_1275068903; + +} + +function Nothing_1275068918() { + var result_1275068922 = null; + + result_1275068922 = {kind: 0, value: ({o: false, e: null, v: null})}; + + return result_1275068922; + +} + +function Just_1275068962(value_1275068964) { + var result_1275068965 = null; + + result_1275068965 = {kind: 1, value: nimCopy(null, value_1275068964, NTI1442840603)}; + + return result_1275068965; + +} + +function just_1275068958(value_1275068960) { + var result_1275068961 = null; + + result_1275068961 = Just_1275068962(value_1275068960); + + return result_1275068961; + +} + +function HEX26_1275068967(x_1275068969, y_1275068970) { + var result_1275068971 = []; + + result_1275068971 = new Array(chckRange(addInt((x_1275068969).length, 1), 0, 2147483647)); for (var i = 0 ; i < chckRange(addInt((x_1275068969).length, 1), 0, 2147483647) ; ++i) { result_1275068971[i] = ({o: false, e: null, v: null}); } Label1: do { + var i_1275068987 = 0; + var colontmp__1275069283 = 0; + colontmp__1275069283 = subInt((x_1275068969).length, 1); + var res_1275069284 = 0; + Label2: do { + Label3: while (true) { + if (!(res_1275069284 <= colontmp__1275069283)) break Label3; + i_1275068987 = res_1275069284; + result_1275068971[chckIndx(i_1275068987, 0, (result_1275068971).length - 1)] = nimCopy(result_1275068971[chckIndx(i_1275068987, 0, (result_1275068971).length - 1)], x_1275068969[chckIndx(i_1275068987, 0, (x_1275068969).length - 1)], NTI1442840603); + res_1275069284 = addInt(res_1275069284, 1); + } + } while (false); + } while (false); + result_1275068971[chckIndx((x_1275068969).length, 0, (result_1275068971).length - 1)] = nimCopy(result_1275068971[chckIndx((x_1275068969).length, 0, (result_1275068971).length - 1)], y_1275068970, NTI1442840603); + + return result_1275068971; + +} + +function sysFatal_218103842(message_218103845) { + raiseException({message: nimCopy(null, message_218103845, NTI33554439), m_type: NTI33555124, parent: null, name: null, trace: [], up: null}, "AssertionDefect"); + + +} + +function raiseAssert_218103840(msg_218103841) { + sysFatal_218103842(msg_218103841); + + +} + +function failedAssertImpl_218103864(msg_218103865) { + raiseAssert_218103840(msg_218103865); + + +} + +function isEmpty_1275069123(o_1275069125) { + var result_1275069126 = false; + + result_1275069126 = (o_1275069125.kind == 0); + + return result_1275069126; + +} + +function isDefined_1275069117(o_1275069119) { + var result_1275069120 = false; + + result_1275069120 = !(isEmpty_1275069123(o_1275069119)); + + return result_1275069120; + +} + +function reprEnum(e_33557386, typ_33557387) { + var result_33557388 = []; + + var tmp_33557389 = false; + var item_33557390 = typ_33557387.node.sons[e_33557386]; + tmp_33557389 = item_33557390 !== undefined + if (tmp_33557389) { + result_33557388 = nimCopy(null, makeNimstrLit(item_33557390.name), NTI33554439); + } + else { + result_33557388 = nimCopy(null, (HEX24_335544323(e_33557386) || []).concat(makeNimstrLit(" (invalid data!)") || []), NTI33554439); + } + + + return result_33557388; + +} + +function fold_1275069107(v_1275069110, ifNothing_1275069111, ifJust_1275069113) { + var Temporary1; + var Temporary2; + + var result_1275069114 = ({o: false, e: null, v: null}); + + if (isDefined_1275069117(v_1275069110)) { + var Temporary2 = v_1275069110; + if (ConstSet16[Temporary2.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'value\' is not accessible for type \'Maybe\' using \'kind = "), reprDiscriminant(Temporary2.kind, NTI1291845635)); } + Temporary1 = ifJust_1275069113(Temporary2.value); + } + else { + Temporary1 = ifNothing_1275069111(); + } + + result_1275069114 = nimCopy(result_1275069114, Temporary1, NTI1442840603); + + return result_1275069114; + +} + +function map_1275069012(s_1275069015, op_1275069017) { + var result_1275069018 = []; + + result_1275069018 = new Array(chckRange((s_1275069015).length, 0, 2147483647)); for (var i = 0 ; i < chckRange((s_1275069015).length, 0, 2147483647) ; ++i) { result_1275069018[i] = []; } Label1: do { + var i_1275069034 = 0; + var colontmp__1275069287 = 0; + colontmp__1275069287 = (s_1275069015).length; + var i_1275069288 = 0; + Label2: do { + Label3: while (true) { + if (!(i_1275069288 < colontmp__1275069287)) break Label3; + i_1275069034 = i_1275069288; + result_1275069018[chckIndx(i_1275069034, 0, (result_1275069018).length - 1)] = nimCopy(null, op_1275069017(s_1275069015[chckIndx(i_1275069034, 0, (s_1275069015).length - 1)]), NTI33554439); + i_1275069288 = addInt(i_1275069288, 1); + } + } while (false); + } while (false); + + return result_1275069018; + +} + +function substr_33557907(s_33557908, first_33557909, last_33557910) { + var result_33557911 = []; + + var first_33557912 = nimMax(first_33557909, 0); + var L_33557913 = nimMax(addInt(subInt(nimMin(last_33557910, (s_33557908).length - 1), first_33557912), 1), 0); + result_33557911 = nimCopy(null, mnewString(chckRange(L_33557913, 0, 2147483647)), NTI33554439); + Label1: do { + var i_33557918 = 0; + var colontmp__1275069303 = 0; + colontmp__1275069303 = subInt(L_33557913, 1); + var res_1275069304 = 0; + Label2: do { + Label3: while (true) { + if (!(res_1275069304 <= colontmp__1275069303)) break Label3; + i_33557918 = res_1275069304; + result_33557911[chckIndx(i_33557918, 0, (result_33557911).length - 1)] = s_33557908[chckIndx(addInt(i_33557918, first_33557912), 0, (s_33557908).length - 1)]; + res_1275069304 = addInt(res_1275069304, 1); + } + } while (false); + } while (false); + + return result_33557911; + +} + +function nsuIndent(s_469763169, count_469763170, padding_469763171) { + var Temporary6; + + var result_469763172 = []; + + result_469763172 = nimCopy(null, [], NTI33554439); + var i_469763173 = 0; + Label1: do { + var line_469763174 = []; + var first_1275069297 = 0; + var last_1275069298 = 0; + var eolpos_1275069299 = 0; + Label2: do { + Label3: while (true) { + if (!true) break Label3; + Label4: do { + Label5: while (true) { + if (!((last_1275069298 < (s_469763169).length) && !((ConstSet17[s_469763169[chckIndx(last_1275069298, 0, (s_469763169).length - 1)]] != undefined)))) break Label5; + last_1275069298 = addInt(last_1275069298, 1); + } + } while (false); + eolpos_1275069299 = last_1275069298; + if ((last_1275069298 < (s_469763169).length)) { + if ((s_469763169[chckIndx(last_1275069298, 0, (s_469763169).length - 1)] == 10)) { + last_1275069298 = addInt(last_1275069298, 1); + } + else { + if ((s_469763169[chckIndx(last_1275069298, 0, (s_469763169).length - 1)] == 13)) { + last_1275069298 = addInt(last_1275069298, 1); + if (((last_1275069298 < (s_469763169).length) && (s_469763169[chckIndx(last_1275069298, 0, (s_469763169).length - 1)] == 10))) { + last_1275069298 = addInt(last_1275069298, 1); + } + + } + } + } + + if (false) { + Temporary6 = subInt(last_1275069298, 1); + } + else { + Temporary6 = subInt(eolpos_1275069299, 1); + } + + line_469763174 = substr_33557907(s_469763169, first_1275069297, Temporary6); + if (!((i_469763173 == 0))) { + result_469763172.push.apply(result_469763172, makeNimstrLit("\x0A"));; + } + + Label7: do { + var j_469763179 = 0; + var colontmp__1275069292 = 0; + colontmp__1275069292 = count_469763170; + var res_1275069293 = 1; + Label8: do { + Label9: while (true) { + if (!(res_1275069293 <= colontmp__1275069292)) break Label9; + j_469763179 = res_1275069293; + result_469763172.push.apply(result_469763172, padding_469763171);; + res_1275069293 = addInt(res_1275069293, 1); + } + } while (false); + } while (false); + result_469763172.push.apply(result_469763172, line_469763174);; + i_469763173 = addInt(i_469763173, 1); + if ((eolpos_1275069299 == last_1275069298)) { + break Label2; + } + + first_1275069297 = last_1275069298; + } + } while (false); + } while (false); + + return result_469763172; + +} + +function HEX24_469763312(x_469763315) { + var result_469763316 = []; + + result_469763316 = nimCopy(null, HEX24_335544323(x_469763315.a), NTI33554439); + result_469763316.push.apply(result_469763316, makeNimstrLit(" .. "));; + result_469763316.push.apply(result_469763316, HEX24_335544323(x_469763315.b));; + + return result_469763316; + +} + +function addQuoted_469763304(s_469763306, s_469763306_Idx, x_469763307) { + s_469763306[s_469763306_Idx].push.apply(s_469763306[s_469763306_Idx], HEX24_469763312(x_469763307));; + + +} + +function addQuoted_469763324(s_469763326, s_469763326_Idx, x_469763327) { + addInt_251658457(s_469763326, s_469763326_Idx, x_469763327); + + +} + +function HEX24_469763277(x_469763279) { + var result_469763280 = [[]]; + + result_469763280[0] = nimCopy(null, makeNimstrLit("("), NTI33554439); + var count_469763286 = 0; + if ((0 < count_469763286)) { + result_469763280[0].push.apply(result_469763280[0], makeNimstrLit(", "));; + } + + result_469763280[0].push.apply(result_469763280[0], makeNimstrLit("slice"));; + result_469763280[0].push.apply(result_469763280[0], makeNimstrLit(": "));; + count_469763286 += 1; + addQuoted_469763304(result_469763280, 0, x_469763279["Field0"]); + if ((0 < count_469763286)) { + result_469763280[0].push.apply(result_469763280[0], makeNimstrLit(", "));; + } + + result_469763280[0].push.apply(result_469763280[0], makeNimstrLit("len"));; + result_469763280[0].push.apply(result_469763280[0], makeNimstrLit(": "));; + count_469763286 += 1; + addQuoted_469763324(result_469763280, 0, x_469763279["Field1"]); + result_469763280[0].push.apply(result_469763280[0], makeNimstrLit(")"));; + + return result_469763280[0]; + +} + +function delete_469763271(s_469763272, s_469763272_Idx, slice_469763274) { + var Temporary1; + var Temporary2; + + if (!(slice_469763274.a < (s_469763272[s_469763272_Idx]).length)) Temporary2 = false; else { Temporary2 = (0 <= slice_469763274.a); } if (!Temporary2) Temporary1 = false; else { Temporary1 = (slice_469763274.b < (s_469763272[s_469763272_Idx]).length); } if (!(Temporary1)) { + raiseException({message: HEX24_469763277({Field0: nimCopy(null, slice_469763274, NTI939524381), Field1: (s_469763272[s_469763272_Idx]).length}), parent: null, m_type: NTI33555128, name: null, trace: [], up: null}, "IndexDefect"); + } + + if ((slice_469763274.a <= slice_469763274.b)) { + var i_469763330 = slice_469763274.a; + var j_469763331 = addInt(slice_469763274.b, 1); + var newLen_469763332 = addInt(subInt((s_469763272[s_469763272_Idx]).length, j_469763331), i_469763330); + Label3: do { + Label4: while (true) { + if (!(i_469763330 < newLen_469763332)) break Label4; + s_469763272[s_469763272_Idx][chckIndx(i_469763330, 0, (s_469763272[s_469763272_Idx]).length - 1)] = s_469763272[s_469763272_Idx][chckIndx(j_469763331, 0, (s_469763272[s_469763272_Idx]).length - 1)]; + i_469763330 = addInt(i_469763330, 1); + j_469763331 = addInt(j_469763331, 1); + } + } while (false); + (s_469763272[s_469763272_Idx].length = chckRange(newLen_469763332, 0, 2147483647)); + } + + + +} + +function HEX2EHEX2E_721421139(a_721421142, b_721421143) { + var result_721421144 = ({a: 0, b: 0}); + + result_721421144 = nimCopy(result_721421144, {a: a_721421142, b: b_721421143}, NTI939524381); + + return result_721421144; + +} + +function indentAfterNewline_1459617890(str_1459617891, count_1459617892) { + var result_1459617893 = []; + + var strDup_1459617894 = [nsuIndent(str_1459617891, chckRange(count_1459617892, 0, 2147483647), makeNimstrLit(" "))]; + delete_469763271(strDup_1459617894, 0, HEX2EHEX2E_721421139(0, subInt(count_1459617892, 1))); + result_1459617893 = nimCopy(null, strDup_1459617894[0], NTI33554439); + + return result_1459617893; + +} + +function mkDigit_1107296261(v_1107296262, typ_1107296263) { + var Temporary1; + + var result_1107296264 = []; + + if (!((v_1107296262 < 26))) { + failedAssertImpl_218103864(makeNimstrLit("strformat.nim:320:9 `v < 26` ")); + } + + if ((v_1107296262 < 10)) { + result_1107296264 = nimCopy(null, nimCharToStr(chckRange(addInt(48, v_1107296262), 0, 255)), NTI33554439); + } + else { + if ((typ_1107296263 == 120)) { + Temporary1 = 97; + } + else { + Temporary1 = 65; + } + + result_1107296264 = nimCopy(null, nimCharToStr(chckRange(subInt(addInt(Temporary1, v_1107296262), 10), 0, 255)), NTI33554439); + } + + + return result_1107296264; + +} + +function formatInt_922747084(n_922747086, radix_922747087, spec_922747088) { + var Temporary1; + var Temporary8; + + var result_922747089 = []; + + var n_922747092 = n_922747086; + var negative_922747093 = (n_922747092 < 0); + if (negative_922747093) { + Temporary1 = ((~(n_922747092) + 1) ); + } + else { + Temporary1 = n_922747092; + } + + var v_922747094 = Temporary1; + var xx_922747095 = []; + if (spec_922747088.alternateForm) { + switch (spec_922747088.typ) { + case 88: + xx_922747095 = nimCopy(null, makeNimstrLit("0x"), NTI33554439); + break; + case 120: + xx_922747095 = nimCopy(null, makeNimstrLit("0x"), NTI33554439); + break; + case 98: + xx_922747095 = nimCopy(null, makeNimstrLit("0b"), NTI33554439); + break; + case 111: + xx_922747095 = nimCopy(null, makeNimstrLit("0o"), NTI33554439); + break; + default: + break; + } + } + + if ((v_922747094 == 0)) { + result_922747089 = nimCopy(null, makeNimstrLit("0"), NTI33554439); + } + else { + result_922747089 = nimCopy(null, [], NTI33554439); + Label2: do { + Label3: while (true) { + if (!(0 < v_922747094)) break Label3; + var d_922747096 = (v_922747094 % radix_922747087); + v_922747094 = Math.trunc(((v_922747094 / radix_922747087) )); + result_922747089.push.apply(result_922747089, mkDigit_1107296261(chckRange(d_922747096, -2147483648, 2147483647), spec_922747088.typ));; + } + } while (false); + Label4: do { + var idx_922747101 = 0; + var colontmp__1275069309 = 0; + colontmp__1275069309 = divInt((result_922747089).length, 2); + var i_1275069310 = 0; + Label5: do { + Label6: while (true) { + if (!(i_1275069310 < colontmp__1275069309)) break Label6; + idx_922747101 = i_1275069310; + var Temporary7 = result_922747089[chckIndx(idx_922747101, 0, (result_922747089).length - 1)]; result_922747089[chckIndx(idx_922747101, 0, (result_922747089).length - 1)] = result_922747089[chckIndx(subInt(subInt((result_922747089).length, idx_922747101), 1), 0, (result_922747089).length - 1)]; result_922747089[chckIndx(subInt(subInt((result_922747089).length, idx_922747101), 1), 0, (result_922747089).length - 1)] = Temporary7; i_1275069310 = addInt(i_1275069310, 1); + } + } while (false); + } while (false); + } + + if (spec_922747088.padWithZero) { + if (negative_922747093) Temporary8 = true; else { Temporary8 = !((spec_922747088.sign == 45)); } var sign_922747106 = Temporary8; + var toFill_922747110 = subInt(subInt(subInt(spec_922747088.minimumWidth, (result_922747089).length), (xx_922747095).length), (sign_922747106 ? 1 : 0)); + if ((0 < toFill_922747110)) { + result_922747089 = nimCopy(null, (nsuRepeatChar(48, chckRange(toFill_922747110, 0, 2147483647)) || []).concat(result_922747089 || []), NTI33554439); + } + + } + + if (negative_922747093) { + result_922747089 = nimCopy(null, (makeNimstrLit("-") || []).concat(xx_922747095 || [],result_922747089 || []), NTI33554439); + } + else { + if (!((spec_922747088.sign == 45))) { + result_922747089 = nimCopy(null, [spec_922747088.sign].concat(xx_922747095 || [],result_922747089 || []), NTI33554439); + } + else { + result_922747089 = nimCopy(null, (xx_922747095 || []).concat(result_922747089 || []), NTI33554439); + } + } + if ((spec_922747088.align == 60)) { + Label9: do { + var i_922747115 = 0; + var colontmp__1275069313 = 0; + colontmp__1275069313 = (result_922747089).length; + var i_1275069314 = colontmp__1275069313; + Label10: do { + Label11: while (true) { + if (!(i_1275069314 < spec_922747088.minimumWidth)) break Label11; + i_922747115 = i_1275069314; + addChar(result_922747089, spec_922747088.fill);; + i_1275069314 = addInt(i_1275069314, 1); + } + } while (false); + } while (false); + } + else { + var toFill_922747116 = subInt(spec_922747088.minimumWidth, (result_922747089).length); + if ((spec_922747088.align == 94)) { + var half_922747117 = divInt(toFill_922747116, 2); + result_922747089 = nimCopy(null, (nsuRepeatChar(spec_922747088.fill, chckRange(half_922747117, 0, 2147483647)) || []).concat(result_922747089 || [],nsuRepeatChar(spec_922747088.fill, chckRange(subInt(toFill_922747116, half_922747117), 0, 2147483647)) || []), NTI33554439); + } + else { + if ((0 < toFill_922747116)) { + result_922747089 = nimCopy(null, (nsuRepeatChar(spec_922747088.fill, chckRange(toFill_922747116, 0, 2147483647)) || []).concat(result_922747089 || []), NTI33554439); + } + + } + + } + + + return result_922747089; + +} + +function formatValue_922747076(result_922747078, result_922747078_Idx, value_922747079, specifier_922747080) { + BeforeRet: do { + if (((specifier_922747080).length == 0)) { + result_922747078[result_922747078_Idx].push.apply(result_922747078[result_922747078_Idx], HEX24_335544323(value_922747079));; + break BeforeRet; + } + + var spec_922747081 = parseStandardFormatSpecifier_1107296314(specifier_922747080, 0, false); + var radix_922747082 = 10; + switch (spec_922747081.typ) { + case 120: + case 88: + radix_922747082 = 16; + break; + case 100: + case 0: + break; + case 98: + radix_922747082 = 2; + break; + case 111: + radix_922747082 = 8; + break; + default: + raiseException({message: (makeNimstrLit("invalid type in format string for number, expected one of \'x\', \'X\', \'b\', \'d\', \'o\' but got: ") || []).concat([spec_922747081.typ]), parent: null, m_type: NTI33555125, name: null, trace: [], up: null}, "ValueError"); + break; + } + result_922747078[result_922747078_Idx].push.apply(result_922747078[result_922747078_Idx], formatInt_922747084(value_922747079, radix_922747082, spec_922747081));; + } while (false); + + +} + +function HEX24_1442841005(x_1442841006) { + var result_1442841007 = []; + + var fmtRes_1442841008 = [mnewString(0)]; + fmtRes_1442841008[0].push.apply(fmtRes_1442841008[0], makeNimstrLit("ParserState(\x0A stream: \""));; + formatValue_1107296418(fmtRes_1442841008, 0, x_1442841006.stream, []); + fmtRes_1442841008[0].push.apply(fmtRes_1442841008[0], makeNimstrLit("\",\x0A position: "));; + formatValue_922747076(fmtRes_1442841008, 0, x_1442841006.position, []); + fmtRes_1442841008[0].push.apply(fmtRes_1442841008[0], makeNimstrLit(",\x0A lastPosition: "));; + formatValue_922747076(fmtRes_1442841008, 0, x_1442841006.lastPosition, []); + fmtRes_1442841008[0].push.apply(fmtRes_1442841008[0], makeNimstrLit(",\x0A)"));; + result_1442841007 = nimCopy(null, fmtRes_1442841008[0], NTI33554439); + + return result_1442841007; + +} + +function tokenStringValue_1442840754(x_1442840755) { + var Temporary1; + var Temporary2; + var Temporary3; + + var result_1442840756 = []; + + switch (x_1442840755.kind) { + case 0: + var Temporary2 = x_1442840755; + if (ConstSet18[Temporary2.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'charValue\' is not accessible for type \'ParserToken\' using \'kind = "), reprDiscriminant(Temporary2.kind, NTI1442840582)); } + Temporary1 = nimCharToStr(Temporary2.charValue); + break; + case 1: + var Temporary3 = x_1442840755; + if (ConstSet19[Temporary3.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'stringValue\' is not accessible for type \'ParserToken\' using \'kind = "), reprDiscriminant(Temporary3.kind, NTI1442840582)); } + Temporary1 = Temporary3.stringValue; + break; + } + result_1442840756 = nimCopy(null, Temporary1, NTI33554439); + + return result_1442840756; + +} + +function HEX24_1442841001(x_1442841002) { + var result_1442841003 = []; + + var fmtRes_1442841004 = [mnewString(0)]; + fmtRes_1442841004[0].push.apply(fmtRes_1442841004[0], makeNimstrLit("ParserToken(\x0A value: "));; + formatValue_1107296418(fmtRes_1442841004, 0, tokenStringValue_1442840754(x_1442841002), []); + fmtRes_1442841004[0].push.apply(fmtRes_1442841004[0], makeNimstrLit(",\x0A)"));; + result_1442841003 = nimCopy(null, fmtRes_1442841004[0], NTI33554439); + + return result_1442841003; + +} + +function addQuoted_1442841048(s_1442841050, s_1442841050_Idx, x_1442841051) { + s_1442841050[s_1442841050_Idx].push.apply(s_1442841050[s_1442841050_Idx], HEX24_1442841001(x_1442841051));; + + +} + +function collectionToString_1442841027(x_1442841029, prefix_1442841030, separator_1442841031, suffix_1442841032) { + var result_1442841033 = [[]]; + + result_1442841033[0] = nimCopy(null, prefix_1442841030, NTI33554439); + var firstElement_1442841034 = true; + Label1: do { + var value_1442841038 = null; + var value_1442841038_Idx = 0; + var i_1275069318 = 0; + var L_1275069319 = (x_1442841029).length; + Label2: do { + Label3: while (true) { + if (!(i_1275069318 < L_1275069319)) break Label3; + value_1442841038 = x_1442841029; value_1442841038_Idx = i_1275069318; + if (firstElement_1442841034) { + firstElement_1442841034 = false; + } + else { + result_1442841033[0].push.apply(result_1442841033[0], separator_1442841031);; + } + + if ((value_1442841038[value_1442841038_Idx] == null)) { + result_1442841033[0].push.apply(result_1442841033[0], makeNimstrLit("nil"));; + } + else { + addQuoted_1442841048(result_1442841033, 0, value_1442841038[value_1442841038_Idx]); + } + + i_1275069318 += 1; + if (!(((x_1442841029).length == L_1275069319))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1442841033[0].push.apply(result_1442841033[0], suffix_1442841032);; + + return result_1442841033[0]; + +} + +function HEX24_1442841023(x_1442841025) { + var result_1442841026 = []; + + result_1442841026 = nimCopy(null, collectionToString_1442841027(x_1442841025, makeNimstrLit("@["), makeNimstrLit(", "), makeNimstrLit("]")), NTI33554439); + + return result_1442841026; + +} + +function HEX24_1442841019(x_1442841020) { + var result_1442841021 = []; + + var fmtRes_1442841022 = [mnewString(0)]; + fmtRes_1442841022[0].push.apply(fmtRes_1442841022[0], makeNimstrLit("Parser(\x0A state: "));; + formatValue_1107296418(fmtRes_1442841022, 0, indentAfterNewline_1459617890(HEX24_1442841005(x_1442841020.state), 2), []); + fmtRes_1442841022[0].push.apply(fmtRes_1442841022[0], makeNimstrLit(",\x0A tokens: "));; + formatValue_1107296418(fmtRes_1442841022, 0, indentAfterNewline_1459617890(HEX24_1442841023(x_1442841020.tokens), 2), []); + fmtRes_1442841022[0].push.apply(fmtRes_1442841022[0], makeNimstrLit(",\x0A)"));; + result_1442841021 = nimCopy(null, fmtRes_1442841022[0], NTI33554439); + + return result_1442841021; + +} + +function raiseResultDefect_1275069006(m_1275069008, v_1275069009) { + raiseException({message: (m_1275069008 || []).concat(makeNimstrLit(": ") || [],HEX24_1442841019(v_1275069009) || []), m_type: NTI1224736772, parent: null, name: null, trace: [], up: null}, "ResultDefect"); + + +} + +function error_1275069001(self_1275069004) { + var Temporary1; + var Temporary2; + + var result_1275069005 = null; + + if (self_1275069004.o) { + var Temporary1 = self_1275069004; + if (ConstSet20[Temporary1.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary1.o, NTI33554466)); } + raiseResultDefect_1275069006(makeNimstrLit("Trying to access error when value is set"), Temporary1.v); + } + + var Temporary2 = self_1275069004; + if (ConstSet21[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + result_1275069005 = Temporary2.e; + + return result_1275069005; + +} + +function addQuoted_922747567(s_922747569, s_922747569_Idx, x_922747570) { + s_922747569[s_922747569_Idx].push.apply(s_922747569[s_922747569_Idx], makeNimstrLit("\""));; + Label1: do { + var c_922747571 = 0; + var i_1275069326 = 0; + var L_1275069327 = (x_922747570).length; + Label2: do { + Label3: while (true) { + if (!(i_1275069326 < L_1275069327)) break Label3; + c_922747571 = x_922747570[chckIndx(i_1275069326, 0, (x_922747570).length - 1)]; + if ((c_922747571 <= 127)) { + addEscapedChar_33557861(s_922747569, s_922747569_Idx, c_922747571); + } + else { + addChar(s_922747569[s_922747569_Idx], c_922747571);; + } + + i_1275069326 = addInt(i_1275069326, 1); + if (!(((x_922747570).length == L_1275069327))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:258:11 `len(a) == L` the length of the string changed while iterating over it")); + } + + } + } while (false); + } while (false); + s_922747569[s_922747569_Idx].push.apply(s_922747569[s_922747569_Idx], makeNimstrLit("\""));; + + +} + +function collectionToString_1275069053(x_1275069055, prefix_1275069056, separator_1275069057, suffix_1275069058) { + var result_1275069059 = [[]]; + + result_1275069059[0] = nimCopy(null, prefix_1275069056, NTI33554439); + var firstElement_1275069060 = true; + Label1: do { + var value_1275069064 = null; + var value_1275069064_Idx = 0; + var i_1275069322 = 0; + var L_1275069323 = (x_1275069055).length; + Label2: do { + Label3: while (true) { + if (!(i_1275069322 < L_1275069323)) break Label3; + value_1275069064 = x_1275069055; value_1275069064_Idx = i_1275069322; + if (firstElement_1275069060) { + firstElement_1275069060 = false; + } + else { + result_1275069059[0].push.apply(result_1275069059[0], separator_1275069057);; + } + + addQuoted_922747567(result_1275069059, 0, value_1275069064[value_1275069064_Idx]); + i_1275069322 += 1; + if (!(((x_1275069055).length == L_1275069323))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1275069059[0].push.apply(result_1275069059[0], suffix_1275069058);; + + return result_1275069059[0]; + +} + +function HEX24_1275069049(x_1275069051) { + var result_1275069052 = []; + + result_1275069052 = nimCopy(null, collectionToString_1275069053(x_1275069051, makeNimstrLit("@["), makeNimstrLit(", "), makeNimstrLit("]")), NTI33554439); + + return result_1275069052; + +} + +function formatValue_1275069044(result_1275069046, result_1275069046_Idx, value_1275069047, specifier_1275069048) { + formatValue_1107296418(result_1275069046, result_1275069046_Idx, HEX24_1275069049(value_1275069047), specifier_1275069048); + + +} + +function choice_1275068886(parsers_1275068889) { + parsers_1275068889 = nimCopy(null, parsers_1275068889, NTI1275068771); + +function HEX3Aanonymous_1275068893(parser_1275068894) { + +function HEX3Aanonymous_1275068993() { + +function HEX3Aanonymous_1275068995(x_1275068996) { + var result_1275068997 = []; + + result_1275068997 = nimCopy(null, error_1275069001(x_1275068996).expected, NTI33554439); + + return result_1275068997; + + } + + var result_1275068994 = ({o: false, e: null, v: null}); + + var prettyErrors_1275069035 = map_1275069012(errors_1275068917, HEX3Aanonymous_1275068995); + var fmtRes_1275069043 = [mnewString(0)]; + fmtRes_1275069043[0].push.apply(fmtRes_1275069043[0], makeNimstrLit("Choice ("));; + formatValue_1275069044(fmtRes_1275069043, 0, prettyErrors_1275069035, []); + fmtRes_1275069043[0].push.apply(fmtRes_1275069043[0], makeNimstrLit(")"));; + result_1275068994 = nimCopy(result_1275068994, {o: false, e: {kind: 0, index: addInt(parser_1275068894.state.position, 1), expected: nimCopy(null, fmtRes_1275069043[0], NTI33554439), unexpected: nimCopy(null, error_1275069001(errors_1275068917[chckIndx(0, 0, (errors_1275068917).length - 1)]).unexpected, NTI33554439), parser: parser_1275068894}, v: null}, NTI1442840603); + + return result_1275068994; + + } + +function HEX3Aanonymous_1275069103(x_1275069104) { + var result_1275069105 = ({o: false, e: null, v: null}); + + result_1275069105 = nimCopy(result_1275069105, x_1275069104, NTI1442840603); + + return result_1275069105; + + } + + var result_1275068895 = ({o: false, e: null, v: null}); + + BeforeRet: do { + var errors_1275068917 = newSeq_1275068900(0); + var found_1275068933 = Nothing_1275068918(); + Label1: do { + var fn_1275068955 = null; + var fn_1275068955_Idx = 0; + var i_1275069279 = 0; + var L_1275069280 = (parsers_1275068889).length; + Label2: do { + Label3: while (true) { + if (!(i_1275069279 < L_1275069280)) break Label3; + fn_1275068955 = parsers_1275068889; fn_1275068955_Idx = chckIndx(i_1275069279, 0, (parsers_1275068889).length - 1); + var fnResult_1275068956 = fn_1275068955[fn_1275068955_Idx](parser_1275068894); + if (fnResult_1275068956.o) { + found_1275068933 = just_1275068958(fnResult_1275068956); + break Label1; + } + else { + errors_1275068917 = nimCopy(null, HEX26_1275068967(errors_1275068917, fnResult_1275068956), NTI1275068835); + } + + i_1275069279 = addInt(i_1275069279, 1); + if (!(((parsers_1275068889).length == L_1275069280))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1275068895 = nimCopy(result_1275068895, fold_1275069107(found_1275068933, HEX3Aanonymous_1275068993, HEX3Aanonymous_1275069103), NTI1442840603); + break BeforeRet; + } while (false); + + return result_1275068895; + + } + + var result_1275068892 = null; + + BeforeRet: do { + result_1275068892 = HEX3Aanonymous_1275068893; + break BeforeRet; + } while (false); + + return result_1275068892; + +} + +function endOfStream_1275069241(parser_1275069242) { + var Temporary1; + + var result_1275069243 = ({o: false, e: null, v: null}); + + var index_1275069244 = addInt(parser_1275069242.state.position, 1); + if ((index_1275069244 == (parser_1275069242.state.stream).length)) { + Temporary1 = {o: true, v: parser_1275069242, e: null}; + } + else { + var fmtRes_1275069249 = mnewString(0); + fmtRes_1275069249.push.apply(fmtRes_1275069249, makeNimstrLit("EndOfString"));; + Temporary1 = {o: false, e: {kind: 2, expected: nimCopy(null, fmtRes_1275069249, NTI33554439), index: index_1275069244, parser: parser_1275069242, unexpected: []}, v: null}; + } + + result_1275069243 = nimCopy(result_1275069243, Temporary1, NTI1442840603); + + return result_1275069243; + +} +var newlineParser_1275069258 = choice_1275068886([ch_1275068428(ConstSet22), endOfStream_1275069241]); +var whitespaceParser_1275069392 = choice_1275068886([ch_1275068428(ConstSet23), newlineParser_1275069258]); + +function flatMap_1275068576(self_1275068580, f_1275068582) { + var Temporary1; + var Temporary2; + var Temporary3; + + var result_1275068583 = ({o: false, e: null, v: null}); + + if (self_1275068580.o) { + var Temporary2 = self_1275068580; + if (ConstSet24[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + Temporary1 = f_1275068582(Temporary2.v); + } + else { + var Temporary3 = self_1275068580; + if (ConstSet25[Temporary3.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary3.o, NTI33554466)); } + Temporary1 = {o: false, e: Temporary3.e, v: null}; + } + + result_1275068583 = nimCopy(result_1275068583, Temporary1, NTI1442840603); + + return result_1275068583; + +} + +function HEX2B_1275069169(parserFnA_1275069172, parserFnB_1275069175) { + +function HEX3Aanonymous_1275069179(parser_1275069180) { + var result_1275069181 = ({o: false, e: null, v: null}); + + result_1275069181 = nimCopy(result_1275069181, flatMap_1275068576(parserFnA_1275069172(parser_1275069180), parserFnB_1275069175), NTI1442840603); + + return result_1275069181; + + } + + var result_1275069178 = null; + + BeforeRet: do { + result_1275069178 = HEX3Aanonymous_1275069179; + break BeforeRet; + } while (false); + + return result_1275069178; + +} + +function map_1275068657(self_1275068661, f_1275068663) { + var Temporary1; + var Temporary2; + + var result_1275068664 = ({o: false, e: null, v: null}); + + if (self_1275068661.o) { + var Temporary1 = self_1275068661; + if (ConstSet26[Temporary1.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary1.o, NTI33554466)); } + result_1275068664 = nimCopy(result_1275068664, {o: true, v: f_1275068663(Temporary1.v), e: null}, NTI1442840603); + } + else { + var Temporary2 = self_1275068661; + if (ConstSet27[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + result_1275068664 = nimCopy(result_1275068664, {o: false, e: Temporary2.e, v: null}, NTI1442840603); + } + + + return result_1275068664; + +} + +function ignore_1275068608(parserFn_1275068611) { + +function HEX3Aanonymous_1275068615(parser_1275068616) { + +function HEX3Aanonymous_1275068632(x_1275068633) { + var result_1275068634 = null; + + result_1275068634 = {state: x_1275068633.state, tokens: nimCopy(null, parser_1275068616.tokens, NTI1442840594)}; + + return result_1275068634; + + } + + var result_1275068617 = ({o: false, e: null, v: null}); + + BeforeRet: do { + result_1275068617 = nimCopy(result_1275068617, map_1275068657(parserFn_1275068611(parser_1275068616), HEX3Aanonymous_1275068632), NTI1442840603); + break BeforeRet; + } while (false); + + return result_1275068617; + + } + + var result_1275068614 = null; + + BeforeRet: do { + result_1275068614 = HEX3Aanonymous_1275068615; + break BeforeRet; + } while (false); + + return result_1275068614; + +} + +function manyUntil_1275068815(acceptFn_1275068818, stopFn_1275068821) { + +function HEX3Aanonymous_1275068825(parser_1275068826) { + var result_1275068827 = ({o: false, e: null, v: null}); + + BeforeRet: do { + var res_1275068832 = nimCopy(null, {o: true, v: parser_1275068826, e: null}, NTI1442840603); + Label1: do { + Label2: while (true) { + if (!(res_1275068832.o && !(flatMap_1275068576(res_1275068832, stopFn_1275068821).o))) break Label2; + res_1275068832 = nimCopy(res_1275068832, flatMap_1275068576(res_1275068832, acceptFn_1275068818), NTI1442840603); + } + } while (false); + result_1275068827 = nimCopy(result_1275068827, res_1275068832, NTI1442840603); + break BeforeRet; + } while (false); + + return result_1275068827; + + } + + var result_1275068824 = null; + + BeforeRet: do { + result_1275068824 = HEX3Aanonymous_1275068825; + break BeforeRet; + } while (false); + + return result_1275068824; + +} + +function anyUntil_1275068879(stopFn_1275068882) { + var result_1275068885 = null; + + result_1275068885 = manyUntil_1275068815(anyCh_1275068520, stopFn_1275068882); + + return result_1275068885; + +} + +function mapErr_1275069352(self_1275069356, f_1275069358) { + var Temporary1; + var Temporary2; + + var result_1275069359 = ({o: false, e: null, v: null}); + + if (self_1275069356.o) { + var Temporary1 = self_1275069356; + if (ConstSet28[Temporary1.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary1.o, NTI33554466)); } + result_1275069359 = nimCopy(result_1275069359, {o: true, v: Temporary1.v, e: null}, NTI1442840603); + } + else { + var Temporary2 = self_1275069356; + if (ConstSet29[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + result_1275069359 = nimCopy(result_1275069359, {o: false, e: f_1275069358(Temporary2.e), v: null}, NTI1442840603); + } + + + return result_1275069359; + +} + +function setErrorExpectedField_1442840845(err_1442840846, expected_1442840847) { + var result_1442840848 = null; + + result_1442840848 = {kind: err_1442840846.kind, unexpected: nimCopy(null, err_1442840846.unexpected, NTI33554439), expected: nimCopy(null, expected_1442840847, NTI33554439), index: err_1442840846.index, parser: err_1442840846.parser}; + + return result_1442840848; + +} + +function whitespace_1275069393(parser_1275069394) { + +function HEX3Aanonymous_1275069399(x_1275069400) { + var result_1275069401 = null; + + result_1275069401 = setErrorExpectedField_1442840845(x_1275069400, makeNimstrLit("Whitespace")); + + return result_1275069401; + + } + + var result_1275069395 = ({o: false, e: null, v: null}); + + result_1275069395 = nimCopy(result_1275069395, mapErr_1275069352(whitespaceParser_1275069392(parser_1275069394), HEX3Aanonymous_1275069399), NTI1442840603); + + return result_1275069395; + +} + +function HEX3Aanonymous_1275069423(start_1275069426, stop_1275069429) { + var result_1275069432 = null; + + result_1275069432 = HEX2B_1275069169(HEX2B_1275069169(ignore_1275068608(start_1275069426), anyUntil_1275068879(HEX2B_1275069169(stop_1275069429, whitespace_1275069393))), ignore_1275068608(start_1275069426)); + + return result_1275069432; + +} + +function HEX3Aanonymous_1275069439(delimiterParser_1275069442) { + var result_1275069445 = null; + + result_1275069445 = parseBetweenDelimiter_1275069438(delimiterParser_1275069442, delimiterParser_1275069442); + + return result_1275069445; + +} +var parseBetweenDelimiter_1275069438 = HEX3Aanonymous_1275069423; +var parseBetweenPair_1275069446 = HEX3Aanonymous_1275069439; + +function ch_1275068490(expectedChar_1275068491) { + +function HEX3Aanonymous_1275068495(parser_1275068496) { + var result_1275068497 = ({o: false, e: null, v: null}); + + BeforeRet: do { + var state_1275068498 = parser_1275068496.state; + var newIndex_1275068499 = addInt(state_1275068498.position, 1); + if ((subInt((state_1275068498.stream).length, 1) < newIndex_1275068499)) { + var fmtRes_1275068500 = mnewString(0); + addChar(fmtRes_1275068500, expectedChar_1275068491);; + result_1275068497 = nimCopy(result_1275068497, {o: false, e: {kind: 2, expected: nimCopy(null, fmtRes_1275068500, NTI33554439), index: newIndex_1275068499, parser: parser_1275068496, unexpected: []}, v: null}, NTI1442840603); + break BeforeRet; + } + else { + var foundChar_1275068505 = state_1275068498.stream[chckIndx(newIndex_1275068499, 0, (state_1275068498.stream).length - 1)]; + if ((expectedChar_1275068491 == foundChar_1275068505)) { + result_1275068497 = nimCopy(result_1275068497, {o: true, v: {state: {stream: nimCopy(null, state_1275068498.stream, NTI33554439), position: newIndex_1275068499, lastPosition: parser_1275068496.state.position}, tokens: HEX26_1275068448(parser_1275068496.tokens, initParserToken_1442840634(foundChar_1275068505))}, e: null}, NTI1442840603); + break BeforeRet; + } + else { + var fmtRes_1275068514 = mnewString(0); + addChar(fmtRes_1275068514, foundChar_1275068505);; + var fmtRes_1275068515 = mnewString(0); + addChar(fmtRes_1275068515, expectedChar_1275068491);; + result_1275068497 = nimCopy(result_1275068497, {o: false, e: {kind: 1, unexpected: nimCopy(null, fmtRes_1275068514, NTI33554439), expected: nimCopy(null, fmtRes_1275068515, NTI33554439), index: newIndex_1275068499, parser: parser_1275068496}, v: null}, NTI1442840603); + break BeforeRet; + } + + } + + } while (false); + + return result_1275068497; + + } + + var result_1275068494 = null; + + BeforeRet: do { + result_1275068494 = HEX3Aanonymous_1275068495; + break BeforeRet; + } while (false); + + return result_1275068494; + +} + +function str_1275068547(s_1275068548) { + s_1275068548 = nimCopy(null, s_1275068548, NTI33554439); + +function HEX3Aanonymous_1275068552(parser_1275068553) { + var result_1275068554 = ({o: false, e: null, v: null}); + + BeforeRet: do { + var p_1275068559 = nimCopy(null, {o: true, v: parser_1275068553, e: null}, NTI1442840603); + Label1: do { + var c_1275068560 = 0; + var i_1543504239 = 0; + var L_1543504240 = (s_1275068548).length; + Label2: do { + Label3: while (true) { + if (!(i_1543504239 < L_1543504240)) break Label3; + c_1275068560 = s_1275068548[chckIndx(i_1543504239, 0, (s_1275068548).length - 1)]; + p_1275068559 = nimCopy(p_1275068559, flatMap_1275068576(p_1275068559, ch_1275068490(c_1275068560)), NTI1442840603); + i_1543504239 = addInt(i_1543504239, 1); + if (!(((s_1275068548).length == L_1543504240))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:258:11 `len(a) == L` the length of the string changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1275068554 = nimCopy(result_1275068554, p_1275068559, NTI1442840603); + break BeforeRet; + } while (false); + + return result_1275068554; + + } + + var result_1275068551 = null; + + BeforeRet: do { + result_1275068551 = HEX3Aanonymous_1275068552; + break BeforeRet; + } while (false); + + return result_1275068551; + +} + +function newline_1275069329(parser_1275069330) { + +function HEX3Aanonymous_1275069335(x_1275069336) { + var result_1275069337 = null; + + result_1275069337 = setErrorExpectedField_1442840845(x_1275069336, makeNimstrLit("Newline")); + + return result_1275069337; + + } + + var result_1275069331 = ({o: false, e: null, v: null}); + + result_1275069331 = nimCopy(result_1275069331, mapErr_1275069352(newlineParser_1275069258(parser_1275069330), HEX3Aanonymous_1275069335), NTI1442840603); + + return result_1275069331; + +} + +function optional_1275068592(parserFn_1275068595) { + +function HEX3Aanonymous_1275068599(parser_1275068600) { + var Temporary1; + + var result_1275068601 = ({o: false, e: null, v: null}); + + var newParser_1275068602 = parserFn_1275068595(parser_1275068600); + if (newParser_1275068602.o) { + Temporary1 = newParser_1275068602; + } + else { + Temporary1 = {o: true, v: parser_1275068600, e: null}; + } + + result_1275068601 = nimCopy(result_1275068601, Temporary1, NTI1442840603); + + return result_1275068601; + + } + + var result_1275068598 = null; + + BeforeRet: do { + result_1275068598 = HEX3Aanonymous_1275068599; + break BeforeRet; + } while (false); + + return result_1275068598; + +} + +function newSeq_1442840677(len_1442840679) { + var result_1442840680 = []; + + result_1442840680 = new Array(len_1442840679); for (var i = 0 ; i < len_1442840679 ; ++i) { result_1442840680[i] = null; } + return result_1442840680; + +} + +function emptyTokens_1442840824(parser_1442840825) { + var result_1442840826 = null; + + result_1442840826 = {state: parser_1442840825.state, tokens: newSeq_1442840677(0)}; + + return result_1442840826; + +} + +function flattenParserTokens_1442840796(parser_1442840797) { + var result_1442840798 = ({o: false, e: null, v: null}); + + BeforeRet: do { + var resultHEX60gensym5_1442840804 = []; + Label1: do { + var xHEX60gensym5_1442840808 = null; + var xHEX60gensym5_1442840808_Idx = 0; + var i_1543504243 = 0; + var L_1543504244 = (parser_1442840797.tokens).length; + Label2: do { + Label3: while (true) { + if (!(i_1543504243 < L_1543504244)) break Label3; + xHEX60gensym5_1442840808 = parser_1442840797.tokens; xHEX60gensym5_1442840808_Idx = chckIndx(i_1543504243, 0, (parser_1442840797.tokens).length - 1); + var a_1442840809 = nimCopy(null, resultHEX60gensym5_1442840804, NTI33554439); + var b_1442840810 = xHEX60gensym5_1442840808[xHEX60gensym5_1442840808_Idx]; + resultHEX60gensym5_1442840804 = nimCopy(null, (a_1442840809 || []).concat(tokenStringValue_1442840754(b_1442840810) || []), NTI33554439); + i_1543504243 = addInt(i_1543504243, 1); + if (!(((parser_1442840797.tokens).length == L_1543504244))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1442840798 = nimCopy(result_1442840798, {o: true, v: {state: parser_1442840797.state, tokens: [{kind: 1, stringValue: nimCopy(null, resultHEX60gensym5_1442840804, NTI33554439), charValue: 0}]}, e: null}, NTI1442840603); + break BeforeRet; + } while (false); + + return result_1442840798; + +} + +function nsuFindCharSet(s_469763590, chars_469763591, start_469763592, last_469763593) { + var Temporary1; + + var result_469763594 = 0; + + BeforeRet: do { + if ((last_469763593 == 0)) { + Temporary1 = (s_469763590).length - 1; + } + else { + Temporary1 = last_469763593; + } + + var last_469763595 = Temporary1; + Label2: do { + var i_469763600 = 0; + var colontmp__1543504248 = 0; + colontmp__1543504248 = start_469763592; + var res_1543504249 = colontmp__1543504248; + Label3: do { + Label4: while (true) { + if (!(res_1543504249 <= last_469763595)) break Label4; + i_469763600 = res_1543504249; + if ((chars_469763591[s_469763590[chckIndx(i_469763600, 0, (s_469763590).length - 1)]] != undefined)) { + result_469763594 = i_469763600; + break BeforeRet; + } + + res_1543504249 = addInt(res_1543504249, 1); + } + } while (false); + } while (false); + result_469763594 = -1; + break BeforeRet; + } while (false); + + return result_469763594; + +} + +function HEX24_1459617811(x_1459617813) { + var result_1459617814 = [[]]; + + result_1459617814[0] = nimCopy(null, makeNimstrLit("("), NTI33554439); + var count_1459617820 = 0; + if ((0 < count_1459617820)) { + result_1459617814[0].push.apply(result_1459617814[0], makeNimstrLit(", "));; + } + + count_1459617820 += 1; + addQuoted_469763324(result_1459617814, 0, x_1459617813["Field0"]); + if ((0 < count_1459617820)) { + result_1459617814[0].push.apply(result_1459617814[0], makeNimstrLit(", "));; + } + + count_1459617820 += 1; + addQuoted_469763324(result_1459617814, 0, x_1459617813["Field1"]); + if ((count_1459617820 == 1)) { + result_1459617814[0].push.apply(result_1459617814[0], makeNimstrLit(","));; + } + + result_1459617814[0].push.apply(result_1459617814[0], makeNimstrLit(")"));; + + return result_1459617814[0]; + +} + +function clamp_1459617851(x_1459617853, a_1459617854, b_1459617855) { + var result_1459617856 = 0; + + BeforeRet: do { + if ((x_1459617853 < a_1459617854)) { + result_1459617856 = a_1459617854; + break BeforeRet; + } + + if ((b_1459617855 < x_1459617853)) { + result_1459617856 = b_1459617855; + break BeforeRet; + } + + result_1459617856 = x_1459617853; + break BeforeRet; + } while (false); + + return result_1459617856; + +} + +function clamp_1459617806(val_1459617808, bounds_1459617809) { + var result_1459617810 = 0; + + if (!((bounds_1459617809.a <= bounds_1459617809.b))) { + failedAssertImpl_218103864((makeNimstrLit("math.nim:1255:10 `bounds.a <= bounds.b` ") || []).concat(HEX24_1459617811({Field0: bounds_1459617809.a, Field1: bounds_1459617809.b}) || [])); + } + + result_1459617810 = clamp_1459617851(val_1459617808, bounds_1459617809.a, bounds_1459617809.b); + + return result_1459617810; + +} + +function safeDelete_1459617796(str_1459617797, slice_1459617799) { + var Temporary1; + + var result_1459617800 = []; + + if ((subInt((str_1459617797).length, 1) < slice_1459617799.a)) { + Temporary1 = str_1459617797; + } + else { + var fromIndex_1459617857 = clamp_1459617806(slice_1459617799.a, HEX2EHEX2E_721421139(0, (str_1459617797).length)); + var toIndex_1459617867 = clamp_1459617806(slice_1459617799.b, HEX2EHEX2E_721421139(0, subInt((str_1459617797).length, 1))); + var strDup_1459617868 = [nimCopy(null, str_1459617797, NTI33554439)]; + delete_469763271(strDup_1459617868, 0, HEX2EHEX2E_721421139(fromIndex_1459617857, toIndex_1459617867)); + Temporary1 = strDup_1459617868[0]; + } + + result_1459617800 = nimCopy(null, Temporary1, NTI33554439); + + return result_1459617800; + +} + +function findAndDelete_1459617874(str_1459617875, chars_1459617876, start_1459617877, last_1459617878) { + var Temporary1; + var Temporary2; + var Temporary3; + + var result_1459617879 = []; + + if (!(0 <= start_1459617877)) Temporary2 = false; else { Temporary2 = (0 <= last_1459617878); } if (Temporary2) { + var startChar_1459617880 = nsuFindCharSet(str_1459617875, chars_1459617876, chckRange(start_1459617877, 0, 2147483647), last_1459617878); + if ((startChar_1459617880 == -1)) { + Temporary3 = str_1459617875; + } + else { + Temporary3 = safeDelete_1459617796(str_1459617875, HEX2EHEX2E_721421139(startChar_1459617880, last_1459617878)); + } + + Temporary1 = Temporary3; + } + else { + Temporary1 = str_1459617875; + } + + result_1459617879 = nimCopy(null, Temporary1, NTI33554439); + + return result_1459617879; + +} + +function deleteAfterNewline_1459617886(str_1459617887, start_1459617888) { + var result_1459617889 = []; + + result_1459617889 = nimCopy(null, findAndDelete_1459617874(str_1459617887, ConstSet30, start_1459617888, subInt((str_1459617887).length, 1)), NTI33554439); + + return result_1459617889; + +} + +function nsuRepeatStr(s_469763076, n_469763077) { + var result_469763078 = []; + + result_469763078 = nimCopy(null, mnewString(0), NTI33554439); + Label1: do { + var i_469763083 = 0; + var colontmp__1543504252 = 0; + colontmp__1543504252 = n_469763077; + var res_1543504253 = 1; + Label2: do { + Label3: while (true) { + if (!(res_1543504253 <= colontmp__1543504252)) break Label3; + i_469763083 = res_1543504253; + result_469763078.push.apply(result_469763078, s_469763076);; + res_1543504253 = addInt(res_1543504253, 1); + } + } while (false); + } while (false); + + return result_469763078; + +} + +function HEX24_1442841054(x_1442841055) { + var Temporary2; + var Temporary3; + var Temporary4; + var Temporary5; + var Temporary6; + var Temporary7; + var Temporary8; + var Temporary9; + var Temporary10; + var Temporary11; + var Temporary12; + + var result_1442841056 = []; + + Label1: do { + var expr_1442841057 = x_1442841055; + var pos_1442841160 = 0; + var _ = pos_1442841160; + var expected_1442841164 = []; + var parser_1442841166 = null; + var unexpected_1442841168 = []; + var index_1442841170 = 0; + if (!(expr_1442841057.kind == 1)) Temporary6 = false; else { expected_1442841164 = nimCopy(null, expr_1442841057.expected, NTI33554439); + Temporary6 = true; } if (!Temporary6) Temporary5 = false; else { parser_1442841166 = expr_1442841057.parser; + Temporary5 = true; } if (!Temporary5) Temporary4 = false; else { index_1442841170 = expr_1442841057.index; + Temporary4 = true; } if (!Temporary4) Temporary3 = false; else { unexpected_1442841168 = nimCopy(null, expr_1442841057.unexpected, NTI33554439); + Temporary3 = true; } if (Temporary3) { + var original_1442841215 = deleteAfterNewline_1459617886(parser_1442841166.state.stream, parser_1442841166.state.position); + var errSpace_1442841216 = nsuRepeatStr(makeNimstrLit(" "), chckRange(nimMax(0, index_1442841170), 0, 2147483647)); + var fmtRes_1442841217 = [mnewString(0)]; + fmtRes_1442841217[0].push.apply(fmtRes_1442841217[0], makeNimstrLit("Parsing Error (Character Mismatch Error):\x0A"));; + formatValue_1107296418(fmtRes_1442841217, 0, original_1442841215, []); + fmtRes_1442841217[0].push.apply(fmtRes_1442841217[0], makeNimstrLit("\x0A"));; + formatValue_1107296418(fmtRes_1442841217, 0, errSpace_1442841216, []); + fmtRes_1442841217[0].push.apply(fmtRes_1442841217[0], makeNimstrLit("^ Expected \'"));; + formatValue_1107296418(fmtRes_1442841217, 0, expected_1442841164, []); + fmtRes_1442841217[0].push.apply(fmtRes_1442841217[0], makeNimstrLit("\' but got \'"));; + formatValue_1107296418(fmtRes_1442841217, 0, unexpected_1442841168, []); + fmtRes_1442841217[0].push.apply(fmtRes_1442841217[0], makeNimstrLit("\'"));; + Temporary2 = fmtRes_1442841217[0]; + } + else { + var expected_1442841219 = []; + var parser_1442841221 = null; + var unexpected_1442841223 = []; + var index_1442841225 = 0; + if (!(expr_1442841057.kind == 0)) Temporary10 = false; else { expected_1442841219 = nimCopy(null, expr_1442841057.expected, NTI33554439); + Temporary10 = true; } if (!Temporary10) Temporary9 = false; else { parser_1442841221 = expr_1442841057.parser; + Temporary9 = true; } if (!Temporary9) Temporary8 = false; else { index_1442841225 = expr_1442841057.index; + Temporary8 = true; } if (!Temporary8) Temporary7 = false; else { unexpected_1442841223 = nimCopy(null, expr_1442841057.unexpected, NTI33554439); + Temporary7 = true; } if (Temporary7) { + var original_1442841230 = deleteAfterNewline_1459617886(parser_1442841221.state.stream, parser_1442841221.state.position); + var errSpace_1442841231 = nsuRepeatStr(makeNimstrLit(" "), chckRange(nimMax(0, index_1442841225), 0, 2147483647)); + var fmtRes_1442841232 = [mnewString(0)]; + fmtRes_1442841232[0].push.apply(fmtRes_1442841232[0], makeNimstrLit("Parsing Error (Character Mismatch Error):\x0A"));; + formatValue_1107296418(fmtRes_1442841232, 0, original_1442841230, []); + fmtRes_1442841232[0].push.apply(fmtRes_1442841232[0], makeNimstrLit("\x0A"));; + formatValue_1107296418(fmtRes_1442841232, 0, errSpace_1442841231, []); + fmtRes_1442841232[0].push.apply(fmtRes_1442841232[0], makeNimstrLit("^ Expected \'"));; + formatValue_1107296418(fmtRes_1442841232, 0, expected_1442841219, []); + fmtRes_1442841232[0].push.apply(fmtRes_1442841232[0], makeNimstrLit("\' but got \'"));; + formatValue_1107296418(fmtRes_1442841232, 0, unexpected_1442841223, []); + fmtRes_1442841232[0].push.apply(fmtRes_1442841232[0], makeNimstrLit("\'"));; + Temporary2 = fmtRes_1442841232[0]; + } + else { + var parser_1442841234 = null; + var index_1442841236 = 0; + if (!(expr_1442841057.kind == 2)) Temporary12 = false; else { parser_1442841234 = expr_1442841057.parser; + Temporary12 = true; } if (!Temporary12) Temporary11 = false; else { index_1442841236 = expr_1442841057.index; + Temporary11 = true; } if (Temporary11) { + var original_1442841241 = deleteAfterNewline_1459617886(parser_1442841234.state.stream, parser_1442841234.state.position); + var errSpace_1442841242 = nsuRepeatStr(makeNimstrLit(" "), chckRange(nimMax(0, index_1442841236), 0, 2147483647)); + var fmtRes_1442841243 = [mnewString(0)]; + fmtRes_1442841243[0].push.apply(fmtRes_1442841243[0], makeNimstrLit("Parsing Error (EndOfString Expected):\x0A"));; + formatValue_1107296418(fmtRes_1442841243, 0, original_1442841241, []); + fmtRes_1442841243[0].push.apply(fmtRes_1442841243[0], makeNimstrLit("\x0A"));; + formatValue_1107296418(fmtRes_1442841243, 0, errSpace_1442841242, []); + fmtRes_1442841243[0].push.apply(fmtRes_1442841243[0], makeNimstrLit("^ Expected \'EndOfString\' at "));; + formatValue_922747076(fmtRes_1442841243, 0, index_1442841236, []); + fmtRes_1442841243[0].push.apply(fmtRes_1442841243[0], makeNimstrLit(" but got "));; + formatValue_922747076(fmtRes_1442841243, 0, subInt((original_1442841241).length, 1), []); + Temporary2 = fmtRes_1442841243[0]; + } + else { + Temporary2 = makeNimstrLit("ParseError"); + } + }} + } while (false); + result_1442841056 = nimCopy(null, Temporary2, NTI33554439); + + return result_1442841056; + +} + +function raiseResultDefect_1543504031(m_1543504033, v_1543504034) { + raiseException({message: (m_1543504033 || []).concat(makeNimstrLit(": ") || [],HEX24_1442841054(v_1543504034) || []), m_type: NTI1224736772, parent: null, name: null, trace: [], up: null}, "ResultDefect"); + + +} + +function get_1543504024(self_1543504027) { + var Temporary1; + var Temporary2; + + var result_1543504028 = null; + + if (!(self_1543504027.o)) { + var Temporary1 = self_1543504027; + if (ConstSet31[Temporary1.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary1.o, NTI33554466)); } + raiseResultDefect_1543504031(makeNimstrLit("Trying to access value with err Result"), Temporary1.e); + } + + var Temporary2 = self_1543504027; + if (ConstSet32[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + result_1543504028 = Temporary2.v; + + return result_1543504028; + +} + +function HEX26_1543504140(x_1543504142, y_1543504143) { + var result_1543504144 = []; + + result_1543504144 = new Array(chckRange(addInt((x_1543504142).length, (y_1543504143).length), 0, 2147483647)); for (var i = 0 ; i < chckRange(addInt((x_1543504142).length, (y_1543504143).length), 0, 2147483647) ; ++i) { result_1543504144[i] = null; } Label1: do { + var i_1543504162 = 0; + var colontmp__1543504256 = 0; + colontmp__1543504256 = subInt((x_1543504142).length, 1); + var res_1543504257 = 0; + Label2: do { + Label3: while (true) { + if (!(res_1543504257 <= colontmp__1543504256)) break Label3; + i_1543504162 = res_1543504257; + result_1543504144[chckIndx(i_1543504162, 0, (result_1543504144).length - 1)] = x_1543504142[chckIndx(i_1543504162, 0, (x_1543504142).length - 1)]; + res_1543504257 = addInt(res_1543504257, 1); + } + } while (false); + } while (false); + Label4: do { + var i_1543504170 = 0; + var colontmp__1543504260 = 0; + colontmp__1543504260 = subInt((y_1543504143).length, 1); + var res_1543504261 = 0; + Label5: do { + Label6: while (true) { + if (!(res_1543504261 <= colontmp__1543504260)) break Label6; + i_1543504170 = res_1543504261; + result_1543504144[chckIndx(addInt(i_1543504170, (x_1543504142).length), 0, (result_1543504144).length - 1)] = y_1543504143[chckIndx(i_1543504170, 0, (y_1543504143).length - 1)]; + res_1543504261 = addInt(res_1543504261, 1); + } + } while (false); + } while (false); + + return result_1543504144; + +} + +function HEX3Aanonymous_1543503884(parser_1543503885) { + var Temporary2; + var Temporary3; + var Temporary4; + var Temporary5; + + var result_1543503886 = ({o: false, e: null, v: null}); + + var tokens_1543503887 = nimCopy(null, parser_1543503885.tokens, NTI1442840594); + var keyTokenParser_1543503909 = flatMap_1275068576(propertiesKeyParser_1543503882(emptyTokens_1442840824(parser_1543503885)), flattenParserTokens_1442840796); + var valueTokenParser_1543503979 = flatMap_1275068576(flatMap_1275068576(map_1275068657(keyTokenParser_1543503909, emptyTokens_1442840824), propertiesValueParser_1543503883), flattenParserTokens_1442840796); + Label1: do { + var expr_1543503980 = {Field0: nimCopy(null, keyTokenParser_1543503909, NTI1442840603), Field1: nimCopy(null, valueTokenParser_1543503979, NTI1442840603)}; + var pos_1543503998 = 0; + var _ = pos_1543503998; + var key_1543504036 = null; + var value_1543504065 = null; + if (!(expr_1543503980["Field0"].o == true)) Temporary4 = false; else { key_1543504036 = get_1543504024(expr_1543503980["Field0"]); + Temporary4 = true; } if (!Temporary4) Temporary3 = false; else { if (!(expr_1543503980["Field1"].o == true)) Temporary5 = false; else { value_1543504065 = get_1543504024(expr_1543503980["Field1"]); + Temporary5 = true; } Temporary3 = Temporary5; } if (Temporary3) { + Temporary2 = {o: true, v: {state: value_1543504065.state, tokens: HEX26_1543504140(tokens_1543503887, [key_1543504036.tokens[chckIndx(0, 0, (key_1543504036.tokens).length - 1)], value_1543504065.tokens[chckIndx(0, 0, (value_1543504065.tokens).length - 1)]])}, e: null}; + } + else { + Temporary2 = valueTokenParser_1543503979; + } + + } while (false); + result_1543503886 = nimCopy(result_1543503886, Temporary2, NTI1442840603); + + return result_1543503886; + +} +var propertiesKeyParser_1543503882 = HEX2B_1275069169(ignore_1275068608(ch_1275068490(58)), anyUntil_1275068879(choice_1275068886([str_1275068547(makeNimstrLit(": ")), HEX2B_1275069169(str_1275068547(makeNimstrLit(":")), newline_1275069329), newline_1275069329]))); +var propertiesValueParser_1543503883 = HEX2B_1275069169(HEX2B_1275069169(ignore_1275068608(HEX2B_1275069169(str_1275068547(makeNimstrLit(":")), optional_1275068592(ch_1275068490(32)))), optional_1275068592(anyUntil_1275068879(newline_1275069329))), ignore_1275068608(newline_1275069329)); +var propertiesParser_1543504220 = HEX3Aanonymous_1543503884; +var propertiesStartParser_1543504221 = HEX2B_1275069169(str_1275068547(makeNimstrLit(":PROPERTIES:")), newline_1275069329); +var propertiesEndParser_1543504222 = HEX2B_1275069169(str_1275068547(makeNimstrLit(":PROPERTIES_END:")), newline_1275069329); +var parseProperties_1543504227 = [ignore_1275068608(propertiesStartParser_1543504221), manyUntil_1275068815(propertiesParser_1543504220, propertiesEndParser_1543504222), ignore_1275068608(propertiesEndParser_1543504222)]; + +function HEX3Aanonymous_1577058322(parser_1577058323) { + var Temporary2; + var Temporary3; + var Temporary4; + var Temporary5; + + var result_1577058324 = ({o: false, e: null, v: null}); + + var linkUrl_1577058348 = flatMap_1275068576(linkStartParser_1577058320(parser_1577058323), flattenParserTokens_1442840796); + var linkValue_1577058424 = flatMap_1275068576(flatMap_1275068576(map_1275068657(linkUrl_1577058348, emptyTokens_1442840824), linkEndParser_1577058321), flattenParserTokens_1442840796); + Label1: do { + var expr_1577058425 = {Field0: nimCopy(null, linkUrl_1577058348, NTI1442840603), Field1: nimCopy(null, linkValue_1577058424, NTI1442840603)}; + var pos_1577058428 = 0; + var _ = pos_1577058428; + var key_1577058461 = null; + var value_1577058492 = null; + if (!(expr_1577058425["Field0"].o == true)) Temporary4 = false; else { key_1577058461 = get_1543504024(expr_1577058425["Field0"]); + Temporary4 = true; } if (!Temporary4) Temporary3 = false; else { if (!(expr_1577058425["Field1"].o == true)) Temporary5 = false; else { value_1577058492 = get_1543504024(expr_1577058425["Field1"]); + Temporary5 = true; } Temporary3 = Temporary5; } if (Temporary3) { + Temporary2 = {o: true, v: {state: value_1577058492.state, tokens: [key_1577058461.tokens[chckIndx(0, 0, (key_1577058461.tokens).length - 1)], value_1577058492.tokens[chckIndx(0, 0, (value_1577058492.tokens).length - 1)]]}, e: null}; + } + else { + Temporary2 = linkValue_1577058424; + } + + } while (false); + result_1577058324 = nimCopy(result_1577058324, Temporary2, NTI1442840603); + + return result_1577058324; + +} +var linkStartParser_1577058320 = HEX2B_1275069169(HEX2B_1275069169(ignore_1275068608(str_1275068547(makeNimstrLit("[["))), anyUntil_1275068879(choice_1275068886([str_1275068547(makeNimstrLit("][")), str_1275068547(makeNimstrLit("]]"))]))), optional_1275068592(ignore_1275068608(str_1275068547(makeNimstrLit("]["))))); +var linkEndParser_1577058321 = HEX2B_1275069169(anyUntil_1275068879(str_1275068547(makeNimstrLit("]]"))), ignore_1275068608(str_1275068547(makeNimstrLit("]]")))); +var linkParser_1577058579 = HEX3Aanonymous_1577058322; + +function map_1577058783(s_1577058786, op_1577058788) { + var result_1577058789 = []; + + result_1577058789 = new Array(chckRange((s_1577058786).length, 0, 2147483647)); for (var i = 0 ; i < chckRange((s_1577058786).length, 0, 2147483647) ; ++i) { result_1577058789[i] = []; } Label1: do { + var i_1577058805 = 0; + var colontmp__1577058968 = 0; + colontmp__1577058968 = (s_1577058786).length; + var i_1577058969 = 0; + Label2: do { + Label3: while (true) { + if (!(i_1577058969 < colontmp__1577058968)) break Label3; + i_1577058805 = i_1577058969; + result_1577058789[chckIndx(i_1577058805, 0, (result_1577058789).length - 1)] = nimCopy(null, op_1577058788(s_1577058786[chckIndx(i_1577058805, 0, (s_1577058786).length - 1)]), NTI33554439); + i_1577058969 = addInt(i_1577058969, 1); + } + } while (false); + } while (false); + + return result_1577058789; + +} + +function nsuStrip(s_469764315, leading_469764316, trailing_469764317, chars_469764318) { + var Temporary5; + + var result_469764319 = []; + + var first_469764320 = 0; + var last_469764321 = subInt((s_469764315).length, 1); + if (leading_469764316) { + Label1: do { + Label2: while (true) { + if (!((first_469764320 <= last_469764321) && (chars_469764318[s_469764315[chckIndx(first_469764320, 0, (s_469764315).length - 1)]] != undefined))) break Label2; + first_469764320 = addInt(first_469764320, 1); + } + } while (false); + } + + if (trailing_469764317) { + Label3: do { + Label4: while (true) { + if (!(first_469764320 <= last_469764321)) Temporary5 = false; else { Temporary5 = (chars_469764318[s_469764315[chckIndx(last_469764321, 0, (s_469764315).length - 1)]] != undefined); } if (!Temporary5) break Label4; + last_469764321 = subInt(last_469764321, 1); + } + } while (false); + } + + result_469764319 = nimCopy(null, substr_33557907(s_469764315, first_469764320, last_469764321), NTI33554439); + + return result_469764319; + +} + +function Nothing_1291845691() { + var result_1291845693 = null; + + result_1291845693 = {kind: 0, value: []}; + + return result_1291845693; + +} + +function nothing_1291845685() { + var result_1291845690 = null; + + result_1291845690 = Nothing_1291845691(); + + return result_1291845690; + +} + +function notEmpty_1291845673(o_1291845677) { + var Temporary1; + var Temporary2; + var Temporary3; + + var result_1291845679 = null; + + if (!(o_1291845677.kind == 1)) Temporary2 = false; else { var Temporary3 = o_1291845677; + if (ConstSet34[Temporary3.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'value\' is not accessible for type \'Maybe\' using \'kind = "), reprDiscriminant(Temporary3.kind, NTI1291845635)); } + Temporary2 = eqStrings(nsuStrip(Temporary3.value, true, true, ConstSet35), []); } if (Temporary2) { + Temporary1 = nothing_1291845685(); + } + else { + Temporary1 = o_1291845677; + } + + result_1291845679 = Temporary1; + + return result_1291845679; + +} + +function Just_1526726736(value_1526726738) { + var result_1526726739 = null; + + result_1526726739 = {kind: 1, value: nimCopy(null, value_1526726738, NTI33554439)}; + + return result_1526726739; + +} + +function just_1526726732(value_1526726734) { + var result_1526726735 = null; + + result_1526726735 = Just_1526726736(value_1526726734); + + return result_1526726735; + +} + +function isEmpty_1526726724(o_1526726726) { + var result_1526726727 = false; + + result_1526726727 = (o_1526726726.kind == 0); + + return result_1526726727; + +} + +function isDefined_1526726718(o_1526726720) { + var result_1526726721 = false; + + result_1526726721 = !(isEmpty_1526726724(o_1526726720)); + + return result_1526726721; + +} + +function isSome_1577058648(o_1577058650) { + var result_1577058651 = false; + + result_1577058651 = isDefined_1526726718(o_1577058650); + + return result_1577058651; + +} + +function get_1577058618(o_1577058620) { + var Temporary1; + + var result_1577058621 = []; + + if (!(isDefined_1526726718(o_1577058620))) { + failedAssertImpl_218103864(makeNimstrLit("maybe.nim:120:11 `o.isDefined` Can\'t get Maybe\'s value")); + } + + var Temporary1 = o_1577058620; + if (ConstSet36[Temporary1.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'value\' is not accessible for type \'Maybe\' using \'kind = "), reprDiscriminant(Temporary1.kind, NTI1291845635)); } + result_1577058621 = nimCopy(null, Temporary1.value, NTI33554439); + + return result_1577058621; + +} + +function isNone_1577058700(o_1577058702) { + var result_1577058703 = false; + + result_1577058703 = isEmpty_1526726724(o_1577058702); + + return result_1577058703; + +} + +function linkStringifier_1577058581(linkUrl_1577058582, linkDescription_1577058584) { + var Temporary2; + var Temporary3; + var Temporary4; + + var result_1577058585 = []; + + BeforeRet: do { + Label1: do { + var expr_1577058586 = {Field0: nimCopy(null, linkUrl_1577058582, NTI33554439), Field1: linkDescription_1577058584}; + var pos_1577058590 = 0; + var _ = pos_1577058590; + var linkDescription_1577058633 = []; + var linkUrl_1577058637 = []; + linkUrl_1577058637 = nimCopy(null, expr_1577058586["Field0"], NTI33554439); + if (!true) Temporary2 = false; else { if (!(isSome_1577058648(expr_1577058586["Field1"]) == true)) Temporary3 = false; else { linkDescription_1577058633 = nimCopy(null, get_1577058618(expr_1577058586["Field1"]), NTI33554439); + Temporary3 = true; } Temporary2 = Temporary3; } if (Temporary2) { + var fmtRes_1577058685 = [mnewString(0)]; + fmtRes_1577058685[0].push.apply(fmtRes_1577058685[0], makeNimstrLit("[["));; + formatValue_1107296418(fmtRes_1577058685, 0, linkUrl_1577058637, []); + fmtRes_1577058685[0].push.apply(fmtRes_1577058685[0], makeNimstrLit("]["));; + formatValue_1107296418(fmtRes_1577058685, 0, linkDescription_1577058633, []); + fmtRes_1577058685[0].push.apply(fmtRes_1577058685[0], makeNimstrLit("]]"));; + result_1577058585 = nimCopy(null, fmtRes_1577058685[0], NTI33554439); + break BeforeRet; + } + else { + var linkUrl_1577058689 = []; + linkUrl_1577058689 = nimCopy(null, expr_1577058586["Field0"], NTI33554439); + if (!true) Temporary4 = false; else { Temporary4 = (isNone_1577058700(expr_1577058586["Field1"]) == true); } if (Temporary4) { + var fmtRes_1577058709 = [mnewString(0)]; + fmtRes_1577058709[0].push.apply(fmtRes_1577058709[0], makeNimstrLit("[["));; + formatValue_1107296418(fmtRes_1577058709, 0, linkUrl_1577058689, []); + fmtRes_1577058709[0].push.apply(fmtRes_1577058709[0], makeNimstrLit("]]"));; + result_1577058585 = nimCopy(null, fmtRes_1577058709[0], NTI33554439); + break BeforeRet; + } + } + } while (false); + } while (false); + + return result_1577058585; + +} + +function linkTokenizer_1577058719(parserTokens_1577058720) { + var Temporary7; + var Temporary8; + var Temporary9; + var Temporary10; + + var result_1577058721 = null; + + BeforeRet: do { + var expr_1577058723 = map_1577058783(parserTokens_1577058720, tokenStringValue_1442840754); + var linkDescriptionWasSet_1577058806 = false; + var linkDescription_1577058823 = []; + var linkUrlWasSet_1577058824 = false; + var linkUrl_1577058841 = []; + var matched_1577058751 = false; + Label1: do { + var pos_1577058750 = 0; + var counter_1577058752 = 0; + if (!((ConstSet33[chckRange((expr_1577058723).length, 0, 65535)] != undefined))) { + raiseException({message: (makeNimstrLit("Match failure for pattern \x1B[4m[@linkUrl, @linkDescription]\x1B[24m. Expected length in range \'2 .. 2\', but `\x1B[4mparserTokens.map(tokenStringValue)\x1B[24m` has .len of ") || []).concat(HEX24_335544323((expr_1577058723).length) || [],makeNimstrLit(".") || []), m_type: NTI922748585, parent: null, name: null, trace: [], up: null}, "MatchError:ObjectType"); + } + + Label2: do { + Label3: do { + var elemId_1577058753 = null; + var elemId_1577058753_Idx = 0; + var i_1577058964 = 0; + var L_1577058965 = (expr_1577058723).length; + Label4: do { + Label5: while (true) { + if (!(i_1577058964 < L_1577058965)) break Label5; + elemId_1577058753 = expr_1577058723; elemId_1577058753_Idx = chckIndx(i_1577058964, 0, (expr_1577058723).length - 1); + Label6: do { + if ((counter_1577058752 == 0)) { + if (linkUrlWasSet_1577058824) { + if (eqStrings(linkUrl_1577058841, elemId_1577058753[elemId_1577058753_Idx])) { + Temporary8 = true; + } + else { + if (true) { + raiseException({message: (makeNimstrLit("Match failure: capture \'linkUrl\' is already set to \'") || []).concat(linkUrl_1577058841 || [],makeNimstrLit("\', and does not match with \'") || [],elemId_1577058753[elemId_1577058753_Idx] || [],makeNimstrLit("\'.") || []), m_type: NTI922748585, parent: null, name: null, trace: [], up: null}, "MatchError:ObjectType"); + } + + Temporary8 = false; + } + + Temporary7 = Temporary8; + } + else { + linkUrl_1577058841 = nimCopy(null, elemId_1577058753[elemId_1577058753_Idx], NTI33554439); + linkUrlWasSet_1577058824 = true; + Temporary7 = true; + } + + if (!(Temporary7)) { + raiseException({message: (makeNimstrLit("Match failure for pattern \'@linkUrl\'. Item at index ") || []).concat(HEX24_335544323(subInt(pos_1577058750, 1)) || [],makeNimstrLit(" failed") || []), m_type: NTI922748585, parent: null, name: null, trace: [], up: null}, "MatchError:ObjectType"); + } + + counter_1577058752 = addInt(counter_1577058752, 1); + pos_1577058750 = addInt(pos_1577058750, 1); + break Label6; + } + + if ((counter_1577058752 == 1)) { + if (linkDescriptionWasSet_1577058806) { + if (eqStrings(linkDescription_1577058823, elemId_1577058753[elemId_1577058753_Idx])) { + Temporary10 = true; + } + else { + if (true) { + raiseException({message: (makeNimstrLit("Match failure: capture \'linkDescription\' is already set to \'") || []).concat(linkDescription_1577058823 || [],makeNimstrLit("\', and does not match with \'") || [],elemId_1577058753[elemId_1577058753_Idx] || [],makeNimstrLit("\'.") || []), m_type: NTI922748585, parent: null, name: null, trace: [], up: null}, "MatchError:ObjectType"); + } + + Temporary10 = false; + } + + Temporary9 = Temporary10; + } + else { + linkDescription_1577058823 = nimCopy(null, elemId_1577058753[elemId_1577058753_Idx], NTI33554439); + linkDescriptionWasSet_1577058806 = true; + Temporary9 = true; + } + + if (!(Temporary9)) { + raiseException({message: (makeNimstrLit("Match failure for pattern \'@linkDescription\'. Item at index ") || []).concat(HEX24_335544323(subInt(pos_1577058750, 1)) || [],makeNimstrLit(" failed") || []), m_type: NTI922748585, parent: null, name: null, trace: [], up: null}, "MatchError:ObjectType"); + } + + counter_1577058752 = addInt(counter_1577058752, 1); + pos_1577058750 = addInt(pos_1577058750, 1); + break Label6; + } + + pos_1577058750 = addInt(pos_1577058750, 1); + } while (false); + i_1577058964 = addInt(i_1577058964, 1); + if (!(((expr_1577058723).length == L_1577058965))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + } while (false); + matched_1577058751 = true; + } while (false); + var okHEX60gensym76_1577058895 = matched_1577058751; + var _ = okHEX60gensym76_1577058895; + var maybeLinkDescription_1577058899 = notEmpty_1291845673(just_1526726732(linkDescription_1577058823)); + result_1577058721 = {kind: 8, content: linkStringifier_1577058581(linkUrl_1577058841, maybeLinkDescription_1577058899), linkUrl: nimCopy(null, linkUrl_1577058841, NTI33554439), linkDescription: maybeLinkDescription_1577058899, children: []}; + break BeforeRet; + } while (false); + + return result_1577058721; + +} + +function HEX3Aanonymous_1577058954(parserTokens_1577058955) { + var result_1577058956 = []; + + BeforeRet: do { + result_1577058956 = nimCopy(null, [linkTokenizer_1577058719(parserTokens_1577058955)], NTI1509949514); + break BeforeRet; + } while (false); + + return result_1577058956; + +} +var linkTokenizerSeq_1577058961 = HEX3Aanonymous_1577058954; + +function rawTextTokenizer_1509949558(kind_1509949559) { + +function HEX3Aanonymous_1509949563(content_1509949564) { + var result_1509949565 = null; + + BeforeRet: do { + result_1509949565 = {kind: kind_1509949559, content: nimCopy(null, content_1509949564, NTI33554439), children: [], linkUrl: [], linkDescription: null}; + break BeforeRet; + } while (false); + + return result_1509949565; + + } + + var result_1509949562 = null; + + BeforeRet: do { + result_1509949562 = HEX3Aanonymous_1509949563; + break BeforeRet; + } while (false); + + return result_1509949562; + +} + +function tokensToString_1442840757(tokens_1442840758) { + var result_1442840759 = []; + + var resultHEX60gensym1_1442840762 = []; + Label1: do { + var xHEX60gensym1_1442840784 = null; + var xHEX60gensym1_1442840784_Idx = 0; + var i_1560281149 = 0; + var L_1560281150 = (tokens_1442840758).length; + Label2: do { + Label3: while (true) { + if (!(i_1560281149 < L_1560281150)) break Label3; + xHEX60gensym1_1442840784 = tokens_1442840758; xHEX60gensym1_1442840784_Idx = chckIndx(i_1560281149, 0, (tokens_1442840758).length - 1); + var a_1442840785 = nimCopy(null, resultHEX60gensym1_1442840762, NTI33554439); + var b_1442840786 = xHEX60gensym1_1442840784[xHEX60gensym1_1442840784_Idx]; + resultHEX60gensym1_1442840762 = nimCopy(null, (a_1442840785 || []).concat(tokenStringValue_1442840754(b_1442840786) || []), NTI33554439); + i_1560281149 = addInt(i_1560281149, 1); + if (!(((tokens_1442840758).length == L_1560281150))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1442840759 = nimCopy(null, resultHEX60gensym1_1442840762, NTI33554439); + + return result_1442840759; + +} + +function textTokenizer_1509949507(kind_1509949508) { + +function HEX3Aanonymous_1509949512(tokens_1509949513) { + var result_1509949514 = []; + + BeforeRet: do { + result_1509949514 = nimCopy(null, [{kind: kind_1509949508, content: tokensToString_1442840757(tokens_1509949513), children: [], linkUrl: [], linkDescription: null}], NTI1509949514); + break BeforeRet; + } while (false); + + return result_1509949514; + + } + + var result_1509949511 = null; + + BeforeRet: do { + result_1509949511 = HEX3Aanonymous_1509949512; + break BeforeRet; + } while (false); + + return result_1509949511; + +} +var boldParser_1560281102 = parseBetweenPair_1275069446(ch_1275068490(42)); +var italicParser_1560281103 = parseBetweenPair_1275069446(ch_1275068490(47)); +var underlineParser_1560281104 = parseBetweenPair_1275069446(ch_1275068490(95)); +var verbatimParser_1560281105 = parseBetweenPair_1275069446(ch_1275068490(61)); +var codeParser_1560281106 = parseBetweenPair_1275069446(ch_1275068490(126)); +var strikeThroughParser_1560281107 = parseBetweenPair_1275069446(ch_1275068490(43)); +var rawTokenizer_1560281108 = rawTextTokenizer_1509949558(0); +var boldTokenizer_1560281109 = textTokenizer_1509949507(2); +var italicTokenizer_1560281110 = textTokenizer_1509949507(3); +var underlineTokenizer_1560281111 = textTokenizer_1509949507(4); +var verbatimTokenizer_1560281112 = textTokenizer_1509949507(5); +var codeTokenizer_1560281113 = textTokenizer_1509949507(6); +var strikeThroughTokenizer_1560281114 = textTokenizer_1509949507(7); +var tok_1560281115 = linkTokenizerSeq_1577058961; +var orgStyledTextBuilders_1560281120 = [nimCopy(null, {Field0: boldParser_1560281102, Field1: boldTokenizer_1560281109}, NTI1560281092), nimCopy(null, {Field0: italicParser_1560281103, Field1: italicTokenizer_1560281110}, NTI1560281092), nimCopy(null, {Field0: underlineParser_1560281104, Field1: underlineTokenizer_1560281111}, NTI1560281092), nimCopy(null, {Field0: verbatimParser_1560281105, Field1: verbatimTokenizer_1560281112}, NTI1560281092), nimCopy(null, {Field0: codeParser_1560281106, Field1: codeTokenizer_1560281113}, NTI1560281092), nimCopy(null, {Field0: strikeThroughParser_1560281107, Field1: strikeThroughTokenizer_1560281114}, NTI1560281092), nimCopy(null, {Field0: linkParser_1577058579, Field1: linkTokenizerSeq_1577058961}, NTI1560281092)]; +var parseHeadingStars_788529171 = [manyUntil_1275068815(ch_1275068490(42), ch_1275068490(32)), ignore_1275068608(ch_1275068490(32))]; + +function map_788529184(s_788529187, op_788529189) { + var result_788529190 = []; + + result_788529190 = new Array(chckRange((s_788529187).length, 0, 2147483647)); for (var i = 0 ; i < chckRange((s_788529187).length, 0, 2147483647) ; ++i) { result_788529190[i] = null; } Label1: do { + var i_788529205 = 0; + var colontmp__788529514 = 0; + colontmp__788529514 = (s_788529187).length; + var i_788529515 = 0; + Label2: do { + Label3: while (true) { + if (!(i_788529515 < colontmp__788529514)) break Label3; + i_788529205 = i_788529515; + result_788529190[chckIndx(i_788529205, 0, (result_788529190).length - 1)] = op_788529189(s_788529187[chckIndx(i_788529205, 0, (s_788529187).length - 1)]); + i_788529515 = addInt(i_788529515, 1); + } + } while (false); + } while (false); + + return result_788529190; + +} + +function createTodoKeywordParser_788529172(xs_788529173) { + +function HEX3Aanonymous_788529177(x_788529178) { + var result_788529179 = null; + + result_788529179 = HEX2B_1275069169(str_1275068547(x_788529178), ignore_1275068608(ch_1275068490(32))); + + return result_788529179; + + } + + var result_788529176 = null; + + result_788529176 = choice_1275068886(map_788529184(xs_788529173, HEX3Aanonymous_788529177)); + + return result_788529176; + +} + +function HEX5BHEX5D_721421164(s_721421167, x_721421168) { + var result_721421169 = []; + + var a_721421171 = x_721421168.a; + var L_721421173 = addInt(subInt(x_721421168.b, a_721421171), 1); + result_721421169 = nimCopy(null, mnewString(chckRange(L_721421173, 0, 2147483647)), NTI33554439); + Label1: do { + var i_721421178 = 0; + var i_788529519 = 0; + Label2: do { + Label3: while (true) { + if (!(i_788529519 < L_721421173)) break Label3; + i_721421178 = i_788529519; + result_721421169[chckIndx(i_721421178, 0, (result_721421169).length - 1)] = s_721421167[chckIndx(addInt(i_721421178, a_721421171), 0, (s_721421167).length - 1)]; + i_788529519 = addInt(i_788529519, 1); + } + } while (false); + } while (false); + + return result_721421169; + +} + +function manyUntilPerformant_1275068675(acceptFn_1275068678, stopFn_1275068681) { + +function HEX3Aanonymous_1275068685(parser_1275068686) { + +function HEX3Aanonymous_1275068754(p_1275068755) { + var result_1275068756 = null; + + result_1275068756 = {state: {stream: nimCopy(null, p_1275068755.state.stream, NTI33554439), position: p_1275068755.state.position, lastPosition: p_1275068755.state.lastPosition}, tokens: [{kind: 1, stringValue: HEX5BHEX5D_721421164(p_1275068755.state.stream, HEX2EHEX2E_721421139(subInt(startPosition_1275068688, 1), p_1275068755.state.position)), charValue: 0}]}; + + return result_1275068756; + + } + + var result_1275068687 = ({o: false, e: null, v: null}); + + BeforeRet: do { + var startPosition_1275068688 = parser_1275068686.state.position; + var res_1275068693 = nimCopy(null, {o: true, v: parser_1275068686, e: null}, NTI1442840603); + Label1: do { + Label2: while (true) { + if (!(res_1275068693.o && !(flatMap_1275068576(res_1275068693, stopFn_1275068681).o))) break Label2; + res_1275068693 = nimCopy(res_1275068693, flatMap_1275068576(res_1275068693, acceptFn_1275068678), NTI1442840603); + } + } while (false); + result_1275068687 = nimCopy(result_1275068687, map_1275068657(res_1275068693, HEX3Aanonymous_1275068754), NTI1442840603); + break BeforeRet; + } while (false); + + return result_1275068687; + + } + + var result_1275068684 = null; + + BeforeRet: do { + result_1275068684 = HEX3Aanonymous_1275068685; + break BeforeRet; + } while (false); + + return result_1275068684; + +} + +function anyUntilPerformant_1275068808(stopFn_1275068811) { + var result_1275068814 = null; + + result_1275068814 = manyUntilPerformant_1275068675(anyCh_1275068520, stopFn_1275068811); + + return result_1275068814; + +} + +function HEX3Aanonymous_788529255(tokens_788529256, org_788529257) { + var Temporary1; + + var result_788529258 = null; + + var Temporary1 = org_788529257; + if (ConstSet37[Temporary1.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'level\' is not accessible for type \'OrgBlock\' using \'kind = "), reprDiscriminant(Temporary1.kind, NTI1526726794)); } + Temporary1.level = (tokens_788529256).length; + result_788529258 = org_788529257; + + return result_788529258; + +} + +function some_788529267(val_788529269) { + var result_788529270 = ({val: [], has: false}); + + result_788529270.has = true; + result_788529270.val = nimCopy(null, val_788529269, NTI33554439); + + return result_788529270; + +} + +function HEX3Aanonymous_788529263(tokens_788529264, org_788529265) { + var Temporary1; + + var result_788529266 = null; + + var Temporary1 = org_788529265; + if (ConstSet38[Temporary1.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'todo\' is not accessible for type \'OrgBlock\' using \'kind = "), reprDiscriminant(Temporary1.kind, NTI1526726794)); } + Temporary1.todo = nimCopy(Temporary1.todo, some_788529267(tokensToString_1442840757(tokens_788529264)), NTI1526726804); + result_788529266 = org_788529265; + + return result_788529266; + +} + +function addQuoted_788529437(s_788529439, s_788529439_Idx, x_788529440) { + s_788529439[s_788529439_Idx].push.apply(s_788529439[s_788529439_Idx], HEX24_1442841019(x_788529440));; + + +} + +function HEX24_1526726683(x_1526726684) { + var Temporary1; + + var result_1526726685 = []; + + switch (x_1526726684) { + case 0: + Temporary1 = makeNimstrLit("Text (Raw)"); + break; + case 1: + Temporary1 = makeNimstrLit("Text"); + break; + case 2: + Temporary1 = makeNimstrLit("Text (Bold)"); + break; + case 3: + Temporary1 = makeNimstrLit("Text (Italic)"); + break; + case 4: + Temporary1 = makeNimstrLit("Text (Underline)"); + break; + case 5: + Temporary1 = makeNimstrLit("Text (Verbatim)"); + break; + case 6: + Temporary1 = makeNimstrLit("Text (Code)"); + break; + case 7: + Temporary1 = makeNimstrLit("Text (StrikeThrough)"); + break; + case 8: + Temporary1 = makeNimstrLit("Link"); + break; + } + result_1526726685 = nimCopy(null, Temporary1, NTI33554439); + + return result_1526726685; + +} + +function formatValue_1526726833(result_1526726835, result_1526726835_Idx, value_1526726836, specifier_1526726837) { + formatValue_1107296418(result_1526726835, result_1526726835_Idx, HEX24_1526726683(value_1526726836), specifier_1526726837); + + +} + +function getOrElse_1526726750(o_1526726752, d_1526726753) { + var Temporary1; + var Temporary2; + + var result_1526726754 = []; + + if (isDefined_1526726718(o_1526726752)) { + var Temporary2 = o_1526726752; + if (ConstSet41[Temporary2.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'value\' is not accessible for type \'Maybe\' using \'kind = "), reprDiscriminant(Temporary2.kind, NTI1291845635)); } + Temporary1 = Temporary2.value; + } + else { + Temporary1 = d_1526726753; + } + + result_1526726754 = nimCopy(null, Temporary1, NTI33554439); + + return result_1526726754; + +} + +function map_1526726709(o_1526726712, f_1526726714) { + var Temporary1; + var Temporary2; + + var result_1526726715 = null; + + if (isDefined_1526726718(o_1526726712)) { + var Temporary2 = o_1526726712; + if (ConstSet42[Temporary2.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'value\' is not accessible for type \'Maybe\' using \'kind = "), reprDiscriminant(Temporary2.kind, NTI1291845635)); } + Temporary1 = just_1526726732(f_1526726714(Temporary2.value)); + } + else { + Temporary1 = nothing_1291845685(); + } + + result_1526726715 = Temporary1; + + return result_1526726715; + +} + +function stringifySpecialFields_1526726686(x_1526726687) { + var Temporary1; + var Temporary2; + var Temporary3; + +function HEX3Aanonymous_1526726700(y_1526726703) { + var result_1526726706 = []; + + var fmtRes_1526726707 = [mnewString(0)]; + fmtRes_1526726707[0].push.apply(fmtRes_1526726707[0], makeNimstrLit("\x0AlinkValue: \""));; + formatValue_1107296418(fmtRes_1526726707, 0, y_1526726703, []); + fmtRes_1526726707[0].push.apply(fmtRes_1526726707[0], makeNimstrLit("\""));; + result_1526726706 = nimCopy(null, fmtRes_1526726707[0], NTI33554439); + + return result_1526726706; + + } + +function HEX3Aanonymous_1526726774(x_1526726777) { + var result_1526726780 = []; + + result_1526726780 = nimCopy(null, nsuIndent(x_1526726777, 2, makeNimstrLit(" ")), NTI33554439); + + return result_1526726780; + + } + +function HEX3Aanonymous_1526726798(x_1526726801) { + var result_1526726804 = []; + + result_1526726804 = nimCopy(null, (makeNimstrLit("\x0A") || []).concat(x_1526726801 || [],makeNimstrLit("\x0A") || []), NTI33554439); + + return result_1526726804; + + } + + var result_1526726688 = []; + + switch (x_1526726687.kind) { + case 8: + var fmtRes_1526726689 = [mnewString(0)]; + fmtRes_1526726689[0].push.apply(fmtRes_1526726689[0], makeNimstrLit("linkUrl: \""));; + var Temporary2 = x_1526726687; + if (ConstSet40[Temporary2.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'linkUrl\' is not accessible for type \'OrgInlineBlock\' using \'kind = "), reprDiscriminant(Temporary2.kind, NTI1526726659)); } + formatValue_1107296418(fmtRes_1526726689, 0, Temporary2.linkUrl, []); + fmtRes_1526726689[0].push.apply(fmtRes_1526726689[0], makeNimstrLit("\""));; + var Temporary3 = x_1526726687; + if (ConstSet43[Temporary3.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'linkDescription\' is not accessible for type \'OrgInlineBlock\' using \'kind = "), reprDiscriminant(Temporary3.kind, NTI1526726659)); } + Temporary1 = (fmtRes_1526726689[0] || []).concat(getOrElse_1526726750(map_1526726709(Temporary3.linkDescription, HEX3Aanonymous_1526726700), []) || []); + break; + default: + Temporary1 = []; + break; + } + var specialFields_1526726760 = nimCopy(null, Temporary1, NTI33554439); + result_1526726688 = nimCopy(null, getOrElse_1526726750(map_1526726709(map_1526726709(notEmpty_1291845673(just_1526726732(specialFields_1526726760)), HEX3Aanonymous_1526726774), HEX3Aanonymous_1526726798), []), NTI33554439); + + return result_1526726688; + +} + +function HEX24_1526726829(x_1526726830) { + var result_1526726831 = []; + + var fmtRes_1526726832 = [mnewString(0)]; + fmtRes_1526726832[0].push.apply(fmtRes_1526726832[0], makeNimstrLit("OrgInlineBlock(\x0A content: \""));; + formatValue_1107296418(fmtRes_1526726832, 0, x_1526726830.content, []); + fmtRes_1526726832[0].push.apply(fmtRes_1526726832[0], makeNimstrLit("\"\x0A kind: "));; + formatValue_1526726833(fmtRes_1526726832, 0, x_1526726830.kind, []); + result_1526726831 = nimCopy(null, (fmtRes_1526726832[0] || []).concat(stringifySpecialFields_1526726686(x_1526726830) || [],makeNimstrLit(")") || []), NTI33554439); + + return result_1526726831; + +} + +function addQuoted_1526726947(s_1526726949, s_1526726949_Idx, x_1526726950) { + s_1526726949[s_1526726949_Idx].push.apply(s_1526726949[s_1526726949_Idx], HEX24_1526726829(x_1526726950));; + + +} + +function collectionToString_1526726908(x_1526726910, prefix_1526726911, separator_1526726912, suffix_1526726913) { + var result_1526726914 = [[]]; + + result_1526726914[0] = nimCopy(null, prefix_1526726911, NTI33554439); + var firstElement_1526726915 = true; + Label1: do { + var value_1526726937 = null; + var value_1526726937_Idx = 0; + var i_788529523 = 0; + var L_788529524 = (x_1526726910).length; + Label2: do { + Label3: while (true) { + if (!(i_788529523 < L_788529524)) break Label3; + value_1526726937 = x_1526726910; value_1526726937_Idx = i_788529523; + if (firstElement_1526726915) { + firstElement_1526726915 = false; + } + else { + result_1526726914[0].push.apply(result_1526726914[0], separator_1526726912);; + } + + if ((value_1526726937[value_1526726937_Idx] == null)) { + result_1526726914[0].push.apply(result_1526726914[0], makeNimstrLit("nil"));; + } + else { + addQuoted_1526726947(result_1526726914, 0, value_1526726937[value_1526726937_Idx]); + } + + i_788529523 += 1; + if (!(((x_1526726910).length == L_788529524))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1526726914[0].push.apply(result_1526726914[0], suffix_1526726913);; + + return result_1526726914[0]; + +} + +function HEX24_1526726904(x_1526726906) { + var result_1526726907 = []; + + result_1526726907 = nimCopy(null, collectionToString_1526726908(x_1526726906, makeNimstrLit("@["), makeNimstrLit(", "), makeNimstrLit("]")), NTI33554439); + + return result_1526726907; + +} + +function addQuoted_788529456(s_788529458, s_788529458_Idx, x_788529459) { + s_788529458[s_788529458_Idx].push.apply(s_788529458[s_788529458_Idx], HEX24_1526726904(x_788529459));; + + +} + +function HEX24_788529411(x_788529413) { + var result_788529414 = [[]]; + + result_788529414[0] = nimCopy(null, makeNimstrLit("("), NTI33554439); + var count_788529420 = 0; + if ((0 < count_788529420)) { + result_788529414[0].push.apply(result_788529414[0], makeNimstrLit(", "));; + } + + result_788529414[0].push.apply(result_788529414[0], makeNimstrLit("parser"));; + result_788529414[0].push.apply(result_788529414[0], makeNimstrLit(": "));; + count_788529420 += 1; + if ((x_788529413["Field0"] == null)) { + result_788529414[0].push.apply(result_788529414[0], makeNimstrLit("nil"));; + } + else { + addQuoted_788529437(result_788529414, 0, x_788529413["Field0"]); + } + + if ((0 < count_788529420)) { + result_788529414[0].push.apply(result_788529414[0], makeNimstrLit(", "));; + } + + result_788529414[0].push.apply(result_788529414[0], makeNimstrLit("tree"));; + result_788529414[0].push.apply(result_788529414[0], makeNimstrLit(": "));; + count_788529420 += 1; + addQuoted_788529456(result_788529414, 0, x_788529413["Field1"]); + result_788529414[0].push.apply(result_788529414[0], makeNimstrLit(")"));; + + return result_788529414[0]; + +} + +function raiseResultDefect_788529335(m_788529337, v_788529338) { + raiseException({message: (m_788529337 || []).concat(makeNimstrLit(": ") || [],HEX24_788529411(v_788529338) || []), m_type: NTI1224736772, parent: null, name: null, trace: [], up: null}, "ResultDefect"); + + +} + +function error_788529330(self_788529333) { + var Temporary1; + var Temporary2; + + var result_788529334 = {Field0: {Field0: null, Field1: []}, Field1: []}; + + if (self_788529333.o) { + var Temporary1 = self_788529333; + if (ConstSet44[Temporary1.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary1.o, NTI33554466)); } + raiseResultDefect_788529335(makeNimstrLit("Trying to access error when value is set"), Temporary1.v); + } + + var Temporary2 = self_788529333; + if (ConstSet45[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + result_788529334 = nimCopy(result_788529334, Temporary2.e, NTI1509949463); + + return result_788529334; + +} + +function fold_788529309(self_788529313, onError_788529315, onSuccess_788529317) { + var Temporary1; + var Temporary2; + + var result_788529318 = []; + + if (self_788529313.o) { + if (!(self_788529313.o)) { + failedAssertImpl_218103864(makeNimstrLit("results.nim:725:10 `self.o` ")); + } + + var Temporary2 = self_788529313; + if (ConstSet39[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + Temporary1 = onSuccess_788529317(Temporary2.v); + } + else { + Temporary1 = onError_788529315(error_788529330(self_788529313)); + } + + result_788529318 = nimCopy(null, Temporary1, NTI1509949477); + + return result_788529318; + +} + +function flatMap_1560281578(self_1560281582, f_1560281584) { + var Temporary1; + var Temporary2; + var Temporary3; + + var result_1560281585 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + if (self_1560281582.o) { + var Temporary2 = self_1560281582; + if (ConstSet46[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + Temporary1 = f_1560281584(Temporary2.v); + } + else { + var Temporary3 = self_1560281582; + if (ConstSet47[Temporary3.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary3.o, NTI33554466)); } + Temporary1 = {o: false, e: nimCopy(null, Temporary3.e, NTI1509949463), v: {Field0: null, Field1: []}}; + } + + result_1560281585 = nimCopy(result_1560281585, Temporary1, NTI1509949465); + + return result_1560281585; + +} + +function initParser_1442840670(str_1442840671) { + var result_1442840672 = null; + + result_1442840672 = {state: {stream: nimCopy(null, str_1442840671, NTI33554439), position: -1, lastPosition: 0}, tokens: newSeq_1442840677(0)}; + + return result_1442840672; + +} + +function newSeq_1509949468(len_1509949470) { + var result_1509949471 = []; + + result_1509949471 = new Array(len_1509949470); for (var i = 0 ; i < len_1509949470 ; ++i) { result_1509949471[i] = null; } + return result_1509949471; + +} + +function initOrgInlineBuilder_1509949457(content_1509949458) { + var result_1509949459 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + BeforeRet: do { + result_1509949459 = nimCopy(result_1509949459, {o: true, v: nimCopy(null, {Field0: initParser_1442840670(content_1509949458), Field1: newSeq_1509949468(0)}, NTI1509949449), e: {Field0: {Field0: null, Field1: []}, Field1: []}}, NTI1509949465); + break BeforeRet; + } while (false); + + return result_1509949459; + +} + +function foldTokens_1560281388(parserResult_1560281390, onError_1560281392, onSuccess_1560281394) { + var Temporary1; + var Temporary2; + + var result_1560281395 = []; + + if (parserResult_1560281390.o) { + if (!(parserResult_1560281390.o)) { + failedAssertImpl_218103864(makeNimstrLit("results.nim:725:10 `parserResult.o` ")); + } + + var Temporary2 = parserResult_1560281390; + if (ConstSet49[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + Temporary1 = onSuccess_1560281394(Temporary2.v.tokens); + } + else { + var err_1560281415 = error_1275069001(parserResult_1560281390); + Temporary1 = onError_1560281392(err_1560281415); + } + + result_1560281395 = nimCopy(null, Temporary1, NTI1509949477); + + return result_1560281395; + +} + +function initBuilder_1560281447(t_1560281449, parser_1560281450, tree_1560281451) { + var result_1560281452 = {Field0: null, Field1: []}; + + result_1560281452 = nimCopy(result_1560281452, {Field0: parser_1560281450, Field1: nimCopy(null, tree_1560281451, NTI1560281382)}, NTI1509949449); + + return result_1560281452; + +} + +function tryParseBuild_1560281188(builder_1560281190, builderFns_1560281196, defaultBuilderFn_1560281198, stopAtParserFn_1560281199, concatFn_1560281252) { + var Temporary6; + +function HEX3Aanonymous_1560281377(__1560281380) { + var result_1560281383 = []; + + result_1560281383 = nimCopy(null, newSeq_1509949468(0), NTI1509949477); + + return result_1560281383; + + } + +function HEX3Aanonymous_1560281475(__1560281478) { + var result_1560281481 = []; + + result_1560281481 = nimCopy(null, newSeq_1509949468(0), NTI1509949477); + + return result_1560281481; + + } + + var result_1560281257 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + var colontmp__788529532 = nimCopy(null, builder_1560281190, NTI1509949449); + var parser_1560281258 = colontmp__788529532["Field0"]; + var tree_1560281259 = nimCopy(null, colontmp__788529532["Field1"], NTI1509949450); + var parserAcc_1560281263 = nimCopy(null, {o: true, v: parser_1560281258, e: null}, NTI1442840603); + var builderAcc_1560281265 = nimCopy(null, builder_1560281190, NTI1509949449); + Label1: do { + Label2: while (true) { + if (!(parserAcc_1560281263.o && !(flatMap_1275068576(parserAcc_1560281263, stopAtParserFn_1560281199).o))) break Label2; + var emptyParser_1560281317 = map_1275068657(parserAcc_1560281263, emptyTokens_1442840824); + var found_1560281318 = false; + Label3: do { + var fn_1560281340 = null; + var i_788529529 = 0; + var L_788529530 = (builderFns_1560281196).length; + Label4: do { + Label5: while (true) { + if (!(i_788529529 < L_788529530)) break Label5; + fn_1560281340 = builderFns_1560281196[chckIndx(i_788529529, 0, (builderFns_1560281196).length - 1)]; + var colontmp__788529533 = nimCopy(null, fn_1560281340, NTI1560281166); + var parserFn_1560281341 = colontmp__788529533["Field0"]; + var builderFn_1560281342 = colontmp__788529533["Field1"]; + var parseResult_1560281363 = flatMap_1275068576(emptyParser_1560281317, parserFn_1560281341); + if (parseResult_1560281363.o) { + if (!(parseResult_1560281363.o)) { + failedAssertImpl_218103864(makeNimstrLit("results.nim:725:10 `parseResult.o` ")); + } + + var Temporary6 = parseResult_1560281363; + if (ConstSet48[Temporary6.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary6.o, NTI33554466)); } + var okParser_1560281376 = Temporary6.v; + var defaultBuilderTokens_1560281416 = foldTokens_1560281388(parserAcc_1560281263, HEX3Aanonymous_1560281377, defaultBuilderFn_1560281198); + found_1560281318 = true; + parserAcc_1560281263 = nimCopy(parserAcc_1560281263, map_1275068657(parseResult_1560281363, emptyTokens_1442840824), NTI1442840603); + builderAcc_1560281265 = nimCopy(builderAcc_1560281265, initBuilder_1560281447(builder_1560281190, okParser_1560281376, concatFn_1560281252([nimCopy(null, builderAcc_1560281265.Field1, NTI1509949452), nimCopy(null, defaultBuilderTokens_1560281416, NTI1509949477), builderFn_1560281342(okParser_1560281376.tokens)])), NTI1509949449); + break Label3; + } + + i_788529529 = addInt(i_788529529, 1); + if (!(((builderFns_1560281196).length == L_788529530))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + if (!(found_1560281318)) { + parserAcc_1560281263 = nimCopy(parserAcc_1560281263, flatMap_1275068576(parserAcc_1560281263, anyCh_1275068520), NTI1442840603); + } + + } + } while (false); + var defaultBuilderTokens_1560281493 = foldTokens_1560281388(parserAcc_1560281263, HEX3Aanonymous_1560281475, defaultBuilderFn_1560281198); + result_1560281257 = nimCopy(result_1560281257, {o: true, v: nimCopy(null, initBuilder_1560281447(builder_1560281190, builderAcc_1560281265.Field0, concatFn_1560281252([nimCopy(null, builderAcc_1560281265.Field1, NTI1509949452), nimCopy(null, defaultBuilderTokens_1560281493, NTI1509949477)])), NTI1509949449), e: {Field0: {Field0: null, Field1: []}, Field1: []}}, NTI1509949465); + + return result_1560281257; + +} + +function makeRawTokenOrEmpty_1560281152(tokens_1560281153) { + var Temporary4; + + var result_1560281154 = []; + + var resultHEX60gensym0_1560281157 = []; + Label1: do { + var xHEX60gensym0_1560281161 = null; + var xHEX60gensym0_1560281161_Idx = 0; + var i_788529535 = 0; + var L_788529536 = (tokens_1560281153).length; + Label2: do { + Label3: while (true) { + if (!(i_788529535 < L_788529536)) break Label3; + xHEX60gensym0_1560281161 = tokens_1560281153; xHEX60gensym0_1560281161_Idx = chckIndx(i_788529535, 0, (tokens_1560281153).length - 1); + var a_1560281162 = nimCopy(null, resultHEX60gensym0_1560281157, NTI33554439); + var b_1560281163 = xHEX60gensym0_1560281161[xHEX60gensym0_1560281161_Idx]; + resultHEX60gensym0_1560281157 = nimCopy(null, (a_1560281162 || []).concat(tokenStringValue_1442840754(b_1560281163) || []), NTI33554439); + i_788529535 = addInt(i_788529535, 1); + if (!(((tokens_1560281153).length == L_788529536))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + var str_1560281164 = nimCopy(null, resultHEX60gensym0_1560281157, NTI33554439); + if (((str_1560281164).length == 0)) { + Temporary4 = []; + } + else { + Temporary4 = [rawTokenizer_1560281108(str_1560281164)]; + } + + result_1560281154 = nimCopy(null, Temporary4, NTI1509949514); + + return result_1560281154; + +} + +function concat_1560281201(seqs_1560281203) { + var result_1560281204 = []; + + var L_1560281205 = 0; + Label1: do { + var seqitm_1560281218 = null; + var seqitm_1560281218_Idx = 0; + var i_788529540 = 0; + Label2: do { + Label3: while (true) { + if (!(i_788529540 < (seqs_1560281203).length)) break Label3; + seqitm_1560281218 = seqs_1560281203; seqitm_1560281218_Idx = chckIndx(i_788529540, 0, (seqs_1560281203).length - 1); + L_1560281205 = addInt(L_1560281205, (seqitm_1560281218[seqitm_1560281218_Idx]).length); + i_788529540 = addInt(i_788529540, 1); + } + } while (false); + } while (false); + result_1560281204 = new Array(chckRange(L_1560281205, 0, 2147483647)); for (var i = 0 ; i < chckRange(L_1560281205, 0, 2147483647) ; ++i) { result_1560281204[i] = null; } var i_1560281230 = 0; + Label4: do { + var s_1560281234 = null; + var s_1560281234_Idx = 0; + var i_788529547 = 0; + Label5: do { + Label6: while (true) { + if (!(i_788529547 < (seqs_1560281203).length)) break Label6; + s_1560281234 = seqs_1560281203; s_1560281234_Idx = chckIndx(i_788529547, 0, (seqs_1560281203).length - 1); + Label7: do { + var itm_1560281238 = null; + var itm_1560281238_Idx = 0; + var i_788529544 = 0; + var L_788529545 = (s_1560281234[s_1560281234_Idx]).length; + Label8: do { + Label9: while (true) { + if (!(i_788529544 < L_788529545)) break Label9; + itm_1560281238 = s_1560281234[s_1560281234_Idx]; itm_1560281238_Idx = chckIndx(i_788529544, 0, (s_1560281234[s_1560281234_Idx]).length - 1); + result_1560281204[chckIndx(i_1560281230, 0, (result_1560281204).length - 1)] = itm_1560281238[itm_1560281238_Idx]; + i_1560281230 = addInt(i_1560281230, 1); + i_788529544 = addInt(i_788529544, 1); + if (!(((s_1560281234[s_1560281234_Idx]).length == L_788529545))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + i_788529547 = addInt(i_788529547, 1); + } + } while (false); + } while (false); + + return result_1560281204; + +} + +function tryBuildInline_1560281173(content_1560281174) { + +function HEX3Aanonymous_1560281182(builder_1560281183) { + var result_1560281184 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_1560281184 = nimCopy(result_1560281184, tryParseBuild_1560281188(builder_1560281183, orgStyledTextBuilders_1560281120, makeRawTokenOrEmpty_1560281152, newline_1275069329, concat_1560281201), NTI1509949465); + + return result_1560281184; + + } + + var result_1560281175 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_1560281175 = nimCopy(result_1560281175, flatMap_1560281578(initOrgInlineBuilder_1509949457(content_1560281174), HEX3Aanonymous_1560281182), NTI1509949465); + + return result_1560281175; + +} + +function HEX3Aanonymous_788529282(tokens_788529283, org_788529284) { + +function HEX3Aanonymous_788529290(x_788529293) { + var result_788529296 = []; + + result_788529296 = nimCopy(null, newSeq_1509949468(0), NTI1509949477); + + return result_788529296; + + } + +function HEX3Aanonymous_788529305(x_788529306) { + var result_788529307 = []; + + result_788529307 = nimCopy(null, x_788529306.Field1, NTI1509949452); + + return result_788529307; + + } + var Temporary1; + + var result_788529285 = null; + + var headlineString_788529286 = tokensToString_1442840757(tokens_788529283); + var tokens_788529465 = fold_788529309(tryBuildInline_1560281173(headlineString_788529286), HEX3Aanonymous_788529290, HEX3Aanonymous_788529305); + var Temporary1 = org_788529284; + if (ConstSet50[Temporary1.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'headlineContent\' is not accessible for type \'OrgBlock\' using \'kind = "), reprDiscriminant(Temporary1.kind, NTI1526726794)); } + Temporary1.headlineContent = nimCopy(null, tokens_788529465, NTI1509949477); + result_788529285 = org_788529284; + + return result_788529285; + +} + +function HEX3Aanonymous_788529494(tokens_788529495, org_788529496) { + var result_788529497 = null; + + result_788529497 = org_788529496; + + return result_788529497; + +} + +function HEX3Aanonymous_788529499(tokens_788529500, org_788529501) { + var result_788529502 = null; + + result_788529502 = org_788529501; + + return result_788529502; + +} +var todoKeywords_788529228 = [makeNimstrLit("TODO")]; +var doneKeywords_788529233 = [makeNimstrLit("DONE")]; +var parseTodoKeyword_788529234 = createTodoKeywordParser_788529172(todoKeywords_788529228); +var parseDoneKeyword_788529235 = createTodoKeywordParser_788529172(doneKeywords_788529233); +var parseContentText_788529244 = [anyUntilPerformant_1275068808(choice_1275068886([endOfStream_1275069241, str_1275068547(makeNimstrLit("\x0A*"))]))]; +var parseHeadlineNewline_788529249 = [ignore_1275068608(newline_1275069329)]; +var parseHeadingText_788529254 = [anyUntilPerformant_1275068808(newline_1275069329)]; +var buildStars_788529262 = HEX3Aanonymous_788529255; +var buildTodo_788529281 = HEX3Aanonymous_788529263; +var buildHeadlineContent_788529493 = HEX3Aanonymous_788529282; +var buildHeadlineChildren_788529498 = HEX3Aanonymous_788529494; +var buildHeadlineNewline_788529503 = HEX3Aanonymous_788529499; + +function newSeq_1509949597(len_1509949599) { + var result_1509949600 = []; + + result_1509949600 = new Array(len_1509949599); for (var i = 0 ; i < len_1509949599 ; ++i) { result_1509949600[i] = null; } + return result_1509949600; + +} + +function initOrgBuilder_1509949586(content_1509949587) { + var result_1509949588 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + BeforeRet: do { + result_1509949588 = nimCopy(result_1509949588, {o: true, v: nimCopy(null, {Field0: initParser_1442840670(content_1509949587), Field1: newSeq_1509949597(0)}, NTI1509949555), e: {Field0: {Field0: null, Field1: []}, Field1: []}}, NTI1509949571); + break BeforeRet; + } while (false); + + return result_1509949588; + +} + +function flatMap_788530125(self_788530129, f_788530131) { + var Temporary1; + var Temporary2; + var Temporary3; + + var result_788530132 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + if (self_788530129.o) { + var Temporary2 = self_788530129; + if (ConstSet51[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + Temporary1 = f_788530131(Temporary2.v); + } + else { + var Temporary3 = self_788530129; + if (ConstSet52[Temporary3.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary3.o, NTI33554466)); } + Temporary1 = {o: false, e: nimCopy(null, Temporary3.e, NTI1509949569), v: {Field0: null, Field1: []}}; + } + + result_788530132 = nimCopy(result_788530132, Temporary1, NTI1509949571); + + return result_788530132; + +} + +function foldTokens_788530078(parserResult_788530080, onError_788530082, onSuccess_788530084) { + var Temporary1; + var Temporary2; + + var result_788530085 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + if (parserResult_788530080.o) { + if (!(parserResult_788530080.o)) { + failedAssertImpl_218103864(makeNimstrLit("results.nim:725:10 `parserResult.o` ")); + } + + var Temporary2 = parserResult_788530080; + if (ConstSet53[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + Temporary1 = onSuccess_788530084(Temporary2.v.tokens); + } + else { + var err_788530105 = error_1275069001(parserResult_788530080); + Temporary1 = onError_788530082(err_788530105); + } + + result_788530085 = nimCopy(result_788530085, Temporary1, NTI1509949571); + + return result_788530085; + +} + +function tryParser_788530234(builder_788530236, parser_788530237) { + builder_788530236 = nimCopy(null, builder_788530236, NTI1509949555); + +function HEX3Aanonymous_788530268(err_788530269) { + var result_788530270 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788530270 = nimCopy(result_788530270, {o: false, e: nimCopy(null, {Field0: nimCopy(null, builder_788530236, NTI1509949555), Field1: makeNimstrLit("Error")}, NTI1509949569), v: {Field0: null, Field1: []}}, NTI1509949571); + + return result_788530270; + + } + +function HEX3Aanonymous_788530276(newTokens_788530277) { + var result_788530278 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788530278 = nimCopy(result_788530278, {o: true, v: nimCopy(null, builder_788530236, NTI1509949555), e: {Field0: {Field0: null, Field1: []}, Field1: []}}, NTI1509949571); + + return result_788530278; + + } + + var result_788530238 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788530238 = nimCopy(result_788530238, foldTokens_788530078(flatMap_1275068576({o: true, v: {state: builder_788530236["Field0"].state, tokens: []}, e: null}, parser_788530237), HEX3Aanonymous_788530268, HEX3Aanonymous_788530276), NTI1509949571); + + return result_788530238; + +} + +function tryParser_788530210(builder_788530212, parser_788530213) { + +function HEX3Aanonymous_788530221(x_788530223) { + var result_788530224 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788530224 = nimCopy(result_788530224, tryParser_788530234(x_788530223, parser_788530213), NTI1509949571); + + return result_788530224; + + } + + var result_788530214 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788530214 = nimCopy(result_788530214, flatMap_788530125(builder_788530212, HEX3Aanonymous_788530221), NTI1509949571); + + return result_788530214; + +} + +function parseSeq_1275069204(parser_1275069205, xs_1275069208) { + var result_1275069209 = ({o: false, e: null, v: null}); + + var resultHEX60gensym42_1275069212 = nimCopy(null, parser_1275069205, NTI1442840603); + Label1: do { + var xHEX60gensym42_1275069216 = null; + var xHEX60gensym42_1275069216_Idx = 0; + var i_788530578 = 0; + var L_788530579 = (xs_1275069208).length; + Label2: do { + Label3: while (true) { + if (!(i_788530578 < L_788530579)) break Label3; + xHEX60gensym42_1275069216 = xs_1275069208; xHEX60gensym42_1275069216_Idx = chckIndx(i_788530578, 0, (xs_1275069208).length - 1); + var a_1275069217 = nimCopy(null, resultHEX60gensym42_1275069212, NTI1442840603); + var b_1275069218 = xHEX60gensym42_1275069216[xHEX60gensym42_1275069216_Idx]; + resultHEX60gensym42_1275069212 = nimCopy(resultHEX60gensym42_1275069212, flatMap_1275068576(a_1275069217, b_1275069218), NTI1442840603); + i_788530578 = addInt(i_788530578, 1); + if (!(((xs_1275069208).length == L_788530579))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1275069209 = nimCopy(result_1275069209, resultHEX60gensym42_1275069212, NTI1442840603); + + return result_1275069209; + +} + +function initBuilder_788530060(t_788530062, parser_788530063, tree_788530064) { + var result_788530065 = {Field0: null, Field1: []}; + + result_788530065 = nimCopy(result_788530065, {Field0: parser_788530063, Field1: nimCopy(null, tree_788530064, NTI788529845)}, NTI1509949555); + + return result_788530065; + +} + +function isEmpty_788530052(o_788530054) { + var result_788530055 = false; + + result_788530055 = (o_788530054.kind == 0); + + return result_788530055; + +} + +function isDefined_788530046(o_788530048) { + var result_788530049 = false; + + result_788530049 = !(isEmpty_788530052(o_788530048)); + + return result_788530049; + +} + +function getOrElse_788530039(o_788530041, d_788530042) { + var Temporary1; + var Temporary2; + + var result_788530043 = []; + + if (isDefined_788530046(o_788530041)) { + var Temporary2 = o_788530041; + if (ConstSet56[Temporary2.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'value\' is not accessible for type \'Maybe\' using \'kind = "), reprDiscriminant(Temporary2.kind, NTI1291845635)); } + Temporary1 = Temporary2.value; + } + else { + Temporary1 = d_788530042; + } + + result_788530043 = nimCopy(null, Temporary1, NTI788529769); + + return result_788530043; + +} + +function isEmpty_788529908(o_788529910) { + var result_788529911 = false; + + result_788529911 = (o_788529910.kind == 0); + + return result_788529911; + +} + +function isDefined_788529902(o_788529904) { + var result_788529905 = false; + + result_788529905 = !(isEmpty_788529908(o_788529904)); + + return result_788529905; + +} + +function Just_788530008(value_788530010) { + var result_788530011 = null; + + result_788530011 = {kind: 1, value: nimCopy(null, value_788530010, NTI788529769)}; + + return result_788530011; + +} + +function just_788530004(value_788530006) { + var result_788530007 = null; + + result_788530007 = Just_788530008(value_788530006); + + return result_788530007; + +} + +function Nothing_788530028() { + var result_788530030 = null; + + result_788530030 = {kind: 0, value: []}; + + return result_788530030; + +} + +function nothing_788530022() { + var result_788530027 = null; + + result_788530027 = Nothing_788530028(); + + return result_788530027; + +} + +function map_788529990(o_788529993, f_788529995) { + var Temporary1; + var Temporary2; + + var result_788529998 = null; + + if (isDefined_788529902(o_788529993)) { + var Temporary2 = o_788529993; + if (ConstSet57[Temporary2.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'value\' is not accessible for type \'Maybe\' using \'kind = "), reprDiscriminant(Temporary2.kind, NTI1291845635)); } + Temporary1 = just_788530004(f_788529995(Temporary2.value)); + } + else { + Temporary1 = nothing_788530022(); + } + + result_788529998 = Temporary1; + + return result_788529998; + +} + +function orElse_788529928(o_788529930, d_788529931) { + var Temporary1; + + var result_788529932 = null; + + if (isDefined_788529902(o_788529930)) { + Temporary1 = o_788529930; + } + else { + Temporary1 = d_788529931; + } + + result_788529932 = Temporary1; + + return result_788529932; + +} + +function Nothing_788529815() { + var result_788529817 = null; + + result_788529817 = {kind: 0, value: null}; + + return result_788529817; + +} + +function nothing_788529809() { + var result_788529814 = null; + + result_788529814 = Nothing_788529815(); + + return result_788529814; + +} + +function filter_788529894(o_788529896, p_788529898) { + var Temporary1; + var Temporary2; + var Temporary3; + + var result_788529899 = null; + + if (!isDefined_788529902(o_788529896)) Temporary2 = false; else { var Temporary3 = o_788529896; + if (ConstSet58[Temporary3.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'value\' is not accessible for type \'Maybe\' using \'kind = "), reprDiscriminant(Temporary3.kind, NTI1291845635)); } + Temporary2 = p_788529898(Temporary3.value); } if (Temporary2) { + Temporary1 = o_788529896; + } + else { + Temporary1 = nothing_788529809(); + } + + result_788529899 = Temporary1; + + return result_788529899; + +} + +function Just_788529841(value_788529843) { + var result_788529844 = null; + + result_788529844 = {kind: 1, value: value_788529843}; + + return result_788529844; + +} + +function just_788529837(value_788529839) { + var result_788529840 = null; + + result_788529840 = Just_788529841(value_788529839); + + return result_788529840; + +} + +function HEX5BHEX5D_788529828(s_788529830, i_788529831) { + var result_788529832 = null; + + result_788529832 = s_788529830[chckIndx(subInt((s_788529830).length, i_788529831), 0, (s_788529830).length - 1)]; + + return result_788529832; + +} + +function last_788529800(xs_788529802) { + var Temporary1; + + var result_788529805 = null; + + if (((xs_788529802).length == 0)) { + Temporary1 = nothing_788529809(); + } + else { + Temporary1 = just_788529837(HEX5BHEX5D_788529828(xs_788529802, 1)); + } + + result_788529805 = Temporary1; + + return result_788529805; + +} + +function applyParsersToSingle_788529735(builder_788529737, parsers_788529738, tokenFoldFn_788529741, optional_788529742, initT_788529743, isFirst_788529744) { + builder_788529737 = nimCopy(null, builder_788529737, NTI1509949555); + +function HEX3Aanonymous_788529754(err_788529755) { + var result_788529756 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788529756 = nimCopy(result_788529756, {o: false, e: nimCopy(null, {Field0: nimCopy(null, builder_788529737, NTI1509949555), Field1: makeNimstrLit("foo")}, NTI1509949569), v: {Field0: null, Field1: []}}, NTI1509949571); + + return result_788529756; + + } + +function HEX3Aanonymous_788529771(newTokens_788529772) { + var Temporary1; + var Temporary2; + +function HEX3Aanonymous_788529866(x_788529885) { + var result_788529888 = false; + + result_788529888 = !(isFirst_788529744); + + return result_788529888; + + } + newTokens_788529772 = nimCopy(null, newTokens_788529772, NTI788529624); + +function HEX3Aanonymous_788529952(x_788529953) { + var result_788529954 = []; + + result_788529954 = nimCopy(null, [tokenFoldFn_788529741(newTokens_788529772, x_788529953)], NTI788529769); + + return result_788529954; + + } + + var result_788529773 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + if ((optional_788529742 && ((newTokens_788529772).length == 0))) { + Temporary1 = {o: true, v: nimCopy(null, builder_788529737, NTI1509949555), e: {Field0: {Field0: null, Field1: []}, Field1: []}}; + } + else { + if (!(newParser_788529753.o)) { + failedAssertImpl_218103864(makeNimstrLit("results.nim:725:10 `newParser.o` ")); + } + + var Temporary2 = newParser_788529753; + if (ConstSet55[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + Temporary1 = {o: true, v: nimCopy(null, initBuilder_788530060(builder_788529737, Temporary2.v, getOrElse_788530039(map_788529990(orElse_788529928(filter_788529894(last_788529800(builder_788529737.Field1), HEX3Aanonymous_788529866), just_788529837(initT_788529743)), HEX3Aanonymous_788529952), newSeq_1509949597(0))), NTI1509949555), e: {Field0: {Field0: null, Field1: []}, Field1: []}}; + } + + result_788529773 = nimCopy(result_788529773, Temporary1, NTI1509949571); + + return result_788529773; + + } + + var result_788529745 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + var newParser_788529753 = parseSeq_1275069204({o: true, v: {state: builder_788529737["Field0"].state, tokens: []}, e: null}, parsers_788529738); + result_788529745 = nimCopy(result_788529745, foldTokens_788530078(newParser_788529753, HEX3Aanonymous_788529754, HEX3Aanonymous_788529771), NTI1509949571); + + return result_788529745; + +} + +function HEX3DHEX3D_788529678(x_788529680, y_788529681) { + var result_788529682 = false; + + BeforeRet: do { + var sameObject_788529689 = false; + sameObject_788529689 = x_788529680 === y_788529681 + if (sameObject_788529689) { + result_788529682 = true; + break BeforeRet; + } + + if (!(((x_788529680).length == (y_788529681).length))) { + result_788529682 = false; + break BeforeRet; + } + + Label1: do { + var i_788529703 = 0; + var colontmp__788530582 = 0; + colontmp__788530582 = subInt((x_788529680).length, 1); + var res_788530583 = 0; + Label2: do { + Label3: while (true) { + if (!(res_788530583 <= colontmp__788530582)) break Label3; + i_788529703 = res_788530583; + if (!((x_788529680[chckIndx(i_788529703, 0, (x_788529680).length - 1)] == y_788529681[chckIndx(i_788529703, 0, (y_788529681).length - 1)]))) { + result_788529682 = false; + break BeforeRet; + } + + res_788530583 = addInt(res_788530583, 1); + } + } while (false); + } while (false); + result_788529682 = true; + break BeforeRet; + } while (false); + + return result_788529682; + +} + +function HEX3DHEX3D_788529664(x_788529666, y_788529667) { + var result_788529668 = false; + + BeforeRet: do { + if (!((x_788529666["Field0"] == y_788529667["Field0"]))) { + result_788529668 = false; + break BeforeRet; + } + + if (!(HEX3DHEX3D_788529678(x_788529666["Field1"], y_788529667["Field1"]))) { + result_788529668 = false; + break BeforeRet; + } + + result_788529668 = true; + break BeforeRet; + } while (false); + + return result_788529668; + +} + +function HEX3DHEX3D_788529708(x_788529710, y_788529711) { + var result_788529712 = false; + + BeforeRet: do { + if (!(HEX3DHEX3D_788529664(x_788529710["Field0"], y_788529711["Field0"]))) { + result_788529712 = false; + break BeforeRet; + } + + if (!(eqStrings(x_788529710["Field1"], y_788529711["Field1"]))) { + result_788529712 = false; + break BeforeRet; + } + + result_788529712 = true; + break BeforeRet; + } while (false); + + return result_788529712; + +} + +function HEX3DHEX3D_788529643(lhs_788529648, rhs_788529649) { + var Temporary1; + var Temporary2; + var Temporary3; + var Temporary4; + var Temporary5; + + var result_788529650 = false; + + if (!((lhs_788529648.o == rhs_788529649.o))) { + Temporary1 = false; + } + else { + if (lhs_788529648.o) { + var Temporary2 = lhs_788529648; + if (ConstSet59[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + var Temporary3 = rhs_788529649; + if (ConstSet60[Temporary3.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary3.o, NTI33554466)); } + Temporary1 = HEX3DHEX3D_788529664(Temporary2.v, Temporary3.v); + } + else { + var Temporary4 = lhs_788529648; + if (ConstSet61[Temporary4.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary4.o, NTI33554466)); } + var Temporary5 = rhs_788529649; + if (ConstSet62[Temporary5.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary5.o, NTI33554466)); } + Temporary1 = HEX3DHEX3D_788529708(Temporary4.e, Temporary5.e); + } + } + result_788529650 = Temporary1; + + return result_788529650; + +} + +function applyParsersSeqToSingle_788529571(builderResult_788529573, initT_788529574, xs_788529584) { + builderResult_788529573 = nimCopy(null, builderResult_788529573, NTI1509949571); + +function HEX3Aanonymous_788529619(builder_788529621) { + var result_788529622 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788529622 = nimCopy(result_788529622, applyParsersToSingle_788529735(builder_788529621, b_788529612.Field0, b_788529612.Field1, b_788529612.Field2, initT_788529574, HEX3DHEX3D_788529643(a_788529611, builderResult_788529573)), NTI1509949571); + + return result_788529622; + + } + + var result_788529585 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + var resultHEX60gensym4_788529588 = nimCopy(null, builderResult_788529573, NTI1509949571); + Label1: do { + var xHEX60gensym4_788529610 = null; + var i_788530574 = 0; + var L_788530575 = (xs_788529584).length; + Label2: do { + Label3: while (true) { + if (!(i_788530574 < L_788530575)) break Label3; + xHEX60gensym4_788529610 = xs_788529584[chckIndx(i_788530574, 0, (xs_788529584).length - 1)]; + var a_788529611 = nimCopy(null, resultHEX60gensym4_788529588, NTI1509949571); + var b_788529612 = nimCopy(null, xHEX60gensym4_788529610, NTI788529496); + resultHEX60gensym4_788529588 = nimCopy(resultHEX60gensym4_788529588, flatMap_788530125(a_788529611, HEX3Aanonymous_788529619), NTI1509949571); + i_788530574 = addInt(i_788530574, 1); + if (!(((xs_788529584).length == L_788530575))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_788529585 = nimCopy(result_788529585, resultHEX60gensym4_788529588, NTI1509949571); + + return result_788529585; + +} + +function tryBuildHeading_788529549(builder_788529550) { + var result_788529551 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788529551 = nimCopy(result_788529551, applyParsersSeqToSingle_788529571(builder_788529550, {kind: 0, children: [], level: 0, todo: ({val: [], has: false}), headlineContent: [], headlineChildrenText: []}, [nimCopy(null, {Field0: nimCopy(null, parseHeadingStars_788529171, NTI1275069021), Field1: buildStars_788529262, Field2: false}, NTI788529466), nimCopy(null, {Field0: [optional_1275068592(parseTodoKeyword_788529234)], Field1: buildTodo_788529281, Field2: true}, NTI788529466), nimCopy(null, {Field0: [optional_1275068592(parseDoneKeyword_788529235)], Field1: buildTodo_788529281, Field2: true}, NTI788529466), nimCopy(null, {Field0: nimCopy(null, parseHeadingText_788529254, NTI1275069021), Field1: buildHeadlineContent_788529493, Field2: false}, NTI788529466), nimCopy(null, {Field0: nimCopy(null, parseContentText_788529244, NTI1275069021), Field1: buildHeadlineChildren_788529498, Field2: true}, NTI788529466), nimCopy(null, {Field0: nimCopy(null, parseHeadlineNewline_788529249, NTI1275069021), Field1: buildHeadlineNewline_788529503, Field2: true}, NTI788529466), nimCopy(null, {Field0: nimCopy(null, parseHeadlineNewline_788529249, NTI1275069021), Field1: buildHeadlineNewline_788529503, Field2: false}, NTI788529466)]), NTI1509949571); + + return result_788529551; + +} + +function HEX26_788530346(x_788530348, y_788530349) { + var result_788530350 = []; + + result_788530350 = new Array(chckRange(addInt((x_788530348).length, (y_788530349).length), 0, 2147483647)); for (var i = 0 ; i < chckRange(addInt((x_788530348).length, (y_788530349).length), 0, 2147483647) ; ++i) { result_788530350[i] = null; } Label1: do { + var i_788530368 = 0; + var colontmp__788530586 = 0; + colontmp__788530586 = subInt((x_788530348).length, 1); + var res_788530587 = 0; + Label2: do { + Label3: while (true) { + if (!(res_788530587 <= colontmp__788530586)) break Label3; + i_788530368 = res_788530587; + result_788530350[chckIndx(i_788530368, 0, (result_788530350).length - 1)] = x_788530348[chckIndx(i_788530368, 0, (x_788530348).length - 1)]; + res_788530587 = addInt(res_788530587, 1); + } + } while (false); + } while (false); + Label4: do { + var i_788530376 = 0; + var colontmp__788530590 = 0; + colontmp__788530590 = subInt((y_788530349).length, 1); + var res_788530591 = 0; + Label5: do { + Label6: while (true) { + if (!(res_788530591 <= colontmp__788530590)) break Label6; + i_788530376 = res_788530591; + result_788530350[chckIndx(addInt(i_788530376, (x_788530348).length), 0, (result_788530350).length - 1)] = y_788530349[chckIndx(i_788530376, 0, (y_788530349).length - 1)]; + res_788530591 = addInt(res_788530591, 1); + } + } while (false); + } while (false); + + return result_788530350; + +} + +function formatValue_1526727035(result_1526727037, result_1526727037_Idx, value_1526727038, specifier_1526727039) { + formatValue_1107296418(result_1526727037, result_1526727037_Idx, reprEnum(value_1526727038, NTI1526726794), specifier_1526727039); + + +} + +function isSome_1526726886(self_1526726888) { + var result_1526726889 = false; + + result_1526726889 = self_1526726888.has; + + return result_1526726889; + +} + +function HEX24_1526726878(self_1526726880) { + var result_1526726881 = [[]]; + + if (isSome_1526726886(self_1526726880)) { + result_1526726881[0] = nimCopy(null, makeNimstrLit("some("), NTI33554439); + addQuoted_922747567(result_1526726881, 0, self_1526726880.val); + result_1526726881[0].push.apply(result_1526726881[0], makeNimstrLit(")"));; + } + else { + result_1526726881[0] = nimCopy(null, makeNimstrLit("none(string)"), NTI33554439); + } + + + return result_1526726881[0]; + +} + +function formatValue_1526726865(result_1526726867, result_1526726867_Idx, value_1526726868, specifier_1526726869) { + formatValue_1107296418(result_1526726867, result_1526726867_Idx, HEX24_1526726878(value_1526726868), specifier_1526726869); + + +} + +function formatValue_1526726899(result_1526726901, result_1526726901_Idx, value_1526726902, specifier_1526726903) { + formatValue_1107296418(result_1526726901, result_1526726901_Idx, HEX24_1526726904(value_1526726902), specifier_1526726903); + + +} + +function stringifySpecialFields_1526726856(x_1526726857) { + var Temporary1; + var Temporary2; + var Temporary3; + var Temporary4; + var Temporary5; + +function HEX3Aanonymous_1526726985(x_1526726988) { + var result_1526726991 = []; + + result_1526726991 = nimCopy(null, nsuIndent(x_1526726988, 2, makeNimstrLit(" ")), NTI33554439); + + return result_1526726991; + + } + +function HEX3Aanonymous_1526727009(x_1526727012) { + var result_1526727015 = []; + + result_1526727015 = nimCopy(null, (makeNimstrLit("\x0A") || []).concat(x_1526727012 || [],makeNimstrLit("\x0A") || []), NTI33554439); + + return result_1526727015; + + } + + var result_1526726858 = []; + + switch (x_1526726857.kind) { + case 0: + var fmtRes_1526726859 = [mnewString(0)]; + fmtRes_1526726859[0].push.apply(fmtRes_1526726859[0], makeNimstrLit("level: "));; + var Temporary2 = x_1526726857; + if (ConstSet64[Temporary2.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'level\' is not accessible for type \'OrgBlock\' using \'kind = "), reprDiscriminant(Temporary2.kind, NTI1526726794)); } + formatValue_922747076(fmtRes_1526726859, 0, Temporary2.level, []); + fmtRes_1526726859[0].push.apply(fmtRes_1526726859[0], makeNimstrLit("\x0Atodo: "));; + var Temporary3 = x_1526726857; + if (ConstSet65[Temporary3.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'todo\' is not accessible for type \'OrgBlock\' using \'kind = "), reprDiscriminant(Temporary3.kind, NTI1526726794)); } + formatValue_1526726865(fmtRes_1526726859, 0, Temporary3.todo, []); + fmtRes_1526726859[0].push.apply(fmtRes_1526726859[0], makeNimstrLit("\x0AheadlineContent: "));; + var Temporary4 = x_1526726857; + if (ConstSet66[Temporary4.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'headlineContent\' is not accessible for type \'OrgBlock\' using \'kind = "), reprDiscriminant(Temporary4.kind, NTI1526726794)); } + formatValue_1526726899(fmtRes_1526726859, 0, Temporary4.headlineContent, []); + fmtRes_1526726859[0].push.apply(fmtRes_1526726859[0], makeNimstrLit("\x0AheadlineChildrenText: "));; + var Temporary5 = x_1526726857; + if (ConstSet67[Temporary5.kind]===undefined) { raiseFieldError2(makeNimstrLit("field \'headlineChildrenText\' is not accessible for type \'OrgBlock\' using \'kind = "), reprDiscriminant(Temporary5.kind, NTI1526726794)); } + formatValue_1107296418(fmtRes_1526726859, 0, Temporary5.headlineChildrenText, []); + Temporary1 = fmtRes_1526726859[0]; + break; + default: + Temporary1 = []; + break; + } + var specialFields_1526726971 = nimCopy(null, Temporary1, NTI33554439); + result_1526726858 = nimCopy(null, getOrElse_1526726750(map_1526726709(map_1526726709(notEmpty_1291845673(just_1526726732(specialFields_1526726971)), HEX3Aanonymous_1526726985), HEX3Aanonymous_1526727009), []), NTI33554439); + + return result_1526726858; + +} + +function HEX24_1526727031(x_1526727032) { + var result_1526727033 = []; + + var fmtRes_1526727034 = [mnewString(0)]; + fmtRes_1526727034[0].push.apply(fmtRes_1526727034[0], makeNimstrLit("OrgBlock(\x0A kind: "));; + formatValue_1526727035(fmtRes_1526727034, 0, x_1526727032.kind, []); + var fmtRes_1526727043 = [mnewString(0)]; + fmtRes_1526727043[0].push.apply(fmtRes_1526727043[0], makeNimstrLit(" children: "));; + formatValue_1526726899(fmtRes_1526727043, 0, x_1526727032.children, []); + fmtRes_1526727043[0].push.apply(fmtRes_1526727043[0], makeNimstrLit("\x0A)\x0A"));; + result_1526727033 = nimCopy(null, (fmtRes_1526727034[0] || []).concat(stringifySpecialFields_1526726856(x_1526727032) || [],fmtRes_1526727043[0] || []), NTI33554439); + + return result_1526727033; + +} + +function addQuoted_1526727104(s_1526727106, s_1526727106_Idx, x_1526727107) { + s_1526727106[s_1526727106_Idx].push.apply(s_1526727106[s_1526727106_Idx], HEX24_1526727031(x_1526727107));; + + +} + +function collectionToString_1526727065(x_1526727067, prefix_1526727068, separator_1526727069, suffix_1526727070) { + var result_1526727071 = [[]]; + + result_1526727071[0] = nimCopy(null, prefix_1526727068, NTI33554439); + var firstElement_1526727072 = true; + Label1: do { + var value_1526727094 = null; + var value_1526727094_Idx = 0; + var i_788530595 = 0; + var L_788530596 = (x_1526727067).length; + Label2: do { + Label3: while (true) { + if (!(i_788530595 < L_788530596)) break Label3; + value_1526727094 = x_1526727067; value_1526727094_Idx = i_788530595; + if (firstElement_1526727072) { + firstElement_1526727072 = false; + } + else { + result_1526727071[0].push.apply(result_1526727071[0], separator_1526727069);; + } + + if ((value_1526727094[value_1526727094_Idx] == null)) { + result_1526727071[0].push.apply(result_1526727071[0], makeNimstrLit("nil"));; + } + else { + addQuoted_1526727104(result_1526727071, 0, value_1526727094[value_1526727094_Idx]); + } + + i_788530595 += 1; + if (!(((x_1526727067).length == L_788530596))) { + failedAssertImpl_218103864(makeNimstrLit("iterators.nim:240:11 `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while (false); + } while (false); + result_1526727071[0].push.apply(result_1526727071[0], suffix_1526727070);; + + return result_1526727071[0]; + +} + +function HEX24_1526727061(x_1526727063) { + var result_1526727064 = []; + + result_1526727064 = nimCopy(null, collectionToString_1526727065(x_1526727063, makeNimstrLit("@["), makeNimstrLit(", "), makeNimstrLit("]")), NTI33554439); + + return result_1526727064; + +} + +function addQuoted_788530455(s_788530457, s_788530457_Idx, x_788530458) { + s_788530457[s_788530457_Idx].push.apply(s_788530457[s_788530457_Idx], HEX24_1526727061(x_788530458));; + + +} + +function HEX24_788530412(x_788530414) { + var result_788530415 = [[]]; + + result_788530415[0] = nimCopy(null, makeNimstrLit("("), NTI33554439); + var count_788530421 = 0; + if ((0 < count_788530421)) { + result_788530415[0].push.apply(result_788530415[0], makeNimstrLit(", "));; + } + + result_788530415[0].push.apply(result_788530415[0], makeNimstrLit("parser"));; + result_788530415[0].push.apply(result_788530415[0], makeNimstrLit(": "));; + count_788530421 += 1; + if ((x_788530414["Field0"] == null)) { + result_788530415[0].push.apply(result_788530415[0], makeNimstrLit("nil"));; + } + else { + addQuoted_788529437(result_788530415, 0, x_788530414["Field0"]); + } + + if ((0 < count_788530421)) { + result_788530415[0].push.apply(result_788530415[0], makeNimstrLit(", "));; + } + + result_788530415[0].push.apply(result_788530415[0], makeNimstrLit("tree"));; + result_788530415[0].push.apply(result_788530415[0], makeNimstrLit(": "));; + count_788530421 += 1; + addQuoted_788530455(result_788530415, 0, x_788530414["Field1"]); + result_788530415[0].push.apply(result_788530415[0], makeNimstrLit(")"));; + + return result_788530415[0]; + +} + +function raiseResultDefect_788530498(m_788530500, v_788530501) { + raiseException({message: (m_788530500 || []).concat(makeNimstrLit(": ") || [],HEX24_788530412(v_788530501) || []), m_type: NTI1224736772, parent: null, name: null, trace: [], up: null}, "ResultDefect"); + + +} + +function error_788530493(self_788530496) { + var Temporary1; + var Temporary2; + + var result_788530497 = {Field0: {Field0: null, Field1: []}, Field1: []}; + + if (self_788530496.o) { + var Temporary1 = self_788530496; + if (ConstSet68[Temporary1.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary1.o, NTI33554466)); } + raiseResultDefect_788530498(makeNimstrLit("Trying to access error when value is set"), Temporary1.v); + } + + var Temporary2 = self_788530496; + if (ConstSet69[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'e\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + result_788530497 = nimCopy(result_788530497, Temporary2.e, NTI1509949569); + + return result_788530497; + +} + +function fold_788530472(self_788530476, onError_788530478, onSuccess_788530480) { + var Temporary1; + var Temporary2; + + var result_788530481 = []; + + if (self_788530476.o) { + if (!(self_788530476.o)) { + failedAssertImpl_218103864(makeNimstrLit("results.nim:725:10 `self.o` ")); + } + + var Temporary2 = self_788530476; + if (ConstSet63[Temporary2.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary2.o, NTI33554466)); } + Temporary1 = onSuccess_788530480(Temporary2.v); + } + else { + Temporary1 = onError_788530478(error_788530493(self_788530476)); + } + + result_788530481 = nimCopy(null, Temporary1, NTI33554439); + + return result_788530481; + +} + var Temporary53; + +function HEX3Aanonymous_788530339(x_788530340) { + var result_788530341 = ({o: false, e: {Field0: {Field0: null, Field1: []}, Field1: []}, v: {Field0: null, Field1: []}}); + + result_788530341 = nimCopy(result_788530341, {o: true, v: nimCopy(null, {Field0: x_788530340.Field0, Field1: HEX26_788530346(unsafeAcc_788530328.Field1, x_788530340.Field1)}, NTI1509949555), e: {Field0: {Field0: null, Field1: []}, Field1: []}}, NTI1509949571); + + return result_788530341; + +} + +function HEX3Aanonymous_788530396(err_788530399) { + var result_788530402 = []; + + result_788530402 = nimCopy(null, (err_788530399["Field1"] || []).concat(makeNimstrLit("\x0A") || [],HEX24_788530412(err_788530399["Field0"]) || []), NTI33554439); + + return result_788530402; + +} + +function HEX3Aanonymous_788530465(builder_788530466) { + var result_788530467 = []; + + result_788530467 = nimCopy(null, HEX24_1526727061(builder_788530466.Field1), NTI33554439); + + return result_788530467; + +} +var test1_788530197 = makeNimstrLit("* TODO Level 1\x0ASome stuff inbetween\x0A\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A** DONE Level 2\x0A"); +var test1_2_788530198 = makeNimstrLit("* TODO Failing\x0A\x0A*\x0A** Level 2"); +var acc_788530199 = [initOrgBuilder_1509949586(test1_788530197)]; +Label51: do { + Label52: while (true) { + if (!(acc_788530199[0].o && !(tryParser_788530210(acc_788530199[0], endOfStream_1275069241).o))) break Label52; + if (!(acc_788530199[0].o)) { + failedAssertImpl_218103864(makeNimstrLit("results.nim:725:10 `acc.o` ")); + } + + var Temporary53 = acc_788530199[0]; + if (ConstSet54[Temporary53.o]===undefined) { raiseFieldError2(makeNimstrLit("field \'v\' is not accessible for type \'Result\' using \'o = "), reprDiscriminant(Temporary53.o, NTI33554466)); } + var unsafeAcc_788530328 = nimCopy(null, Temporary53.v, NTI1509949555); + var item_788530392 = flatMap_788530125(tryBuildHeading_788529549(acc_788530199[0]), HEX3Aanonymous_788530339); + acc_788530199[0] = nimCopy(acc_788530199[0], item_788530392, NTI1509949571); + } +} while (false); +rawEcho(fold_788530472(acc_788530199[0], HEX3Aanonymous_788530396, HEX3Aanonymous_788530465)); diff --git a/src/org/org_block_heading.nim b/src/org/org_block_heading.nim index e51adcb..90ef254 100644 --- a/src/org/org_block_heading.nim +++ b/src/org/org_block_heading.nim @@ -32,7 +32,7 @@ let parseTodoKeyword = todoKeywords.createTodoKeywordParser() let parseDoneKeyword = doneKeywords.createTodoKeywordParser() let parseContentText = @[ - anyUntil(choice(@[endOfStream, str("\n*")])), + anyUntilPerformant(choice(@[endOfStream, str("\n*")])), ] let parseHeadlineNewline = @[ @@ -40,7 +40,7 @@ let parseHeadlineNewline = @[ ] let parseHeadingText = @[ - anyUntil(newline), + anyUntilPerformant(newline), ] # func buildStars(token: seq[ParserToken]): seq[ParserToken] = @@ -71,7 +71,7 @@ let buildHeadlineContent = func(tokens: seq[ParserToken], org: OrgBlock): OrgBlo let buildHeadlineChildren = func(tokens: seq[ParserToken], org: OrgBlock): OrgBlock {.closure.}= # let headlineString = tokens.tokensToString() - org.headlineChildrenText = tokens.tokensToString() + # org.headlineChildrenText = tokens.tokensToString() org let buildHeadlineNewline = func(tokens: seq[ParserToken], org: OrgBlock): OrgBlock {.closure.}= @@ -92,26 +92,20 @@ proc tryBuildHeading(builder: OrgBuilderResult): OrgBuilderResult = (parseContentText, buildHeadlineChildren, true), - (parseHeadlineNewline, buildHeadlineContent, true), - + (parseHeadlineNewline, buildHeadlineNewline, true), (parseHeadlineNewline, buildHeadlineNewline, false), ] ) -when isMainModule: - - - var acc = initOrgBuilder("""* TODO Level 1 -** TODO Level 2 -""") +proc makeOrg*(x: string): OrgBuilderResult = + var acc = initOrgBuilder(x) while acc.isOk() and acc.tryParser(endOfStream).isErr(): let unsafeAcc = acc.unsafeGet() let item = acc .tryBuildHeading() - .fold( - err => OrgBuilderResult.err((unsafeAcc, "Error")), + .flatMap( (x: OrgBuilder) => OrgBuilderResult.ok(OrgBuilder(( parser: x.parser, tree: unsafeAcc.tree & x.tree, @@ -120,35 +114,34 @@ when isMainModule: acc = item - echo acc + acc -# let sampleBuilder = StringBuilderResult -# .ok(StringBuilder(( -# parser: initParser("""**** TODO Some stars -# :PROPERTIES: -# :PROP_NAME: Value -# :PROP_NAME: Value -# :PROP_NAME: Value -# :PROP_NAME: Value -# :PROPERTIES_END: +proc foldOrg*(x: OrgBuilderResult): seq[string] = + x + .fold( + (err) => @["Error"], + (builder: OrgBuilder) => builder.tree.map((x: OrgBlock) => $x.headlineContent), + ) + # echo acc.unsafeGet().tree[^1] -# Foo -# """), -# tree: newSeq[StringBuilderT](), -# ))) -# .applyParsersSeq(@[ -# (parseHeadingStars, stringConcat("Stars: ")), +when isMainModule: + # import nimprof + # import timeit + + let test1 = """* TODO Level 1 +Some stuff inbetween -# (@[optional(parseTodoKeyword)], stringConcat("TODO: ")), -# (@[optional(parseDoneKeyword)], stringConcat("DONE: ")), +** DONE Level 2 """ -# (parseHeadingText, stringConcat("Text: ")), -# (parseProperties, stringConcat("Properties: ", seperator = ", ")), -# # (@[optional(choice(parseProperties))], stringConcat("Properties: ")), -# ]) -# .foldBuilder( -# err => &"Error Parsing: {err}", -# xs => "Parser Succesfull:\n" & xs.join("\n"), -# ) + let test1_2 = """* TODO Failing -# echo sampleBuilder +* +** Level 2""" + + # let test2 = readFile("/home/floscr/Documents/Org/Bookmarks/bookmarks.org") + # let test2 = readFile("/tmp/gtd.org") + + var acc = makeOrg(test1) + + echo acc .foldOrg() + # echo acc.unsafeGet().tree[^1] diff --git a/src/parser/parser_internals.nim b/src/parser/parser_internals.nim index bde6c2e..cc54e92 100644 --- a/src/parser/parser_internals.nim +++ b/src/parser/parser_internals.nim @@ -108,6 +108,32 @@ func ignore*(parserFn: Parser -> ParserResult): (Parser -> ParserResult) {.inlin tokens: parser.tokens, )) +func manyUntilPerformant*(acceptFn: Parser -> ParserResult, stopFn: Parser -> ParserResult): (Parser -> ParserResult) {.inline.} = + ## Parse characters but throw success tokens away + return proc(parser: Parser): ParserResult = + let startPosition = parser.state.position + var res: ParserResult = parser.ok() + + while res.isOk() and res.flatMap(stopFn).isErr(): + res = res.flatMap(acceptFn) + + return res.map((p: Parser) => Parser( + state: ParserState( + stream: p.state.stream, + position: p.state.position, + lastPosition: p.state.lastPosition, + ), + tokens: @[ + ParserToken( + kind: parserTokenString, + stringValue: p.state.stream[(startPosition - 1)..p.state.position], + ) + ] + )) + +proc anyUntilPerformant*(stopFn: Parser -> ParserResult): (Parser -> ParserResult) {.inline.} = + manyUntilPerformant(anyCh, stopFn) + func manyUntil*(acceptFn: Parser -> ParserResult, stopFn: Parser -> ParserResult): (Parser -> ParserResult) {.inline.} = ## Parse characters but throw success tokens away return proc(parser: Parser): ParserResult =