@ohm-js/wasm 0.1.0

package/test/data/_liquid-html.ohm

@@ -0,0 +1,605 @@
+Helpers {
+  Node = (spaces TextNode)* spaces
+  TextNode = spaces AnyExceptPlus<openControl>
+  openControl = end
+
+  empty = /* nothing */
+  anyExcept<lit> = (~ lit any)
+  anyExceptStar<lit> = (~ lit any)*
+  anyExceptPlus<lit> = (~ lit any)+
+  AnyExcept<lit> =  (spaces ~ lit any)
+  AnyExceptPlus<lit> = (spaces ~ lit any)+
+  AnyExceptStar<lit> = (spaces ~ lit any)*
+  identifierCharacter = alnum | "_" | "-"
+
+  orderedListOf<a, b, sep> =
+    | nonemptyOrderedListOf<a, b, sep>
+    | emptyListOf<a, sep>
+  nonemptyOrderedListOf<a, b, sep> =
+    | nonemptyListOf<b, sep>
+    | nonemptyOrderedListOfBoth<a, b, sep>
+    | nonemptyListOf<a, sep>
+  nonemptyOrderedListOfBoth<a, b, sep> =
+    nonemptyListOf<a, sep> (sep nonemptyListOf<b, sep>)
+
+  singleQuote = "'" | "‘" | "’"
+  doubleQuote = "\"" | "“" | "”"
+  controls = "\u{007F}".."\u{009F}"
+  noncharacters = "\u{FDD0}".."\u{FDEF}"
+  newline = "\r"? "\n"
+}
+
+Liquid <: Helpers {
+  Node := (spaces (liquidNode | TextNode))*
+  openControl := "{{" | "{%"
+  endOfTagName = &("-%}" | "-}}" | "%}" | "}}")
+  endOfVarName = ~identifierCharacter
+  endOfIdentifier = endOfTagName | endOfVarName
+
+  liquidNode =
+  	| liquidDoc
+    | liquidBlockComment
+    | liquidRawTag
+    | liquidDrop
+    | liquidTagClose
+    | liquidTagOpen
+    | liquidTag
+    | liquidInlineComment
+
+  liquidTagStrict =
+    | liquidTagAssign
+    | liquidTagBreak
+    | liquidTagContinue
+    | liquidTagCycle
+    | liquidTagContentFor
+    | liquidTagDecrement
+    | liquidTagEcho
+    | liquidTagElse
+    | liquidTagElsif
+    | liquidTagInclude
+    | liquidTagIncrement
+    | liquidTagLayout
+    | liquidTagLiquid
+    | liquidTagRender
+    | liquidTagSection
+    | liquidTagSections
+    | liquidTagWhen
+
+  liquidTag =
+    | liquidTagStrict
+    | liquidTagBaseCase
+
+  liquidTagOpenStrict =
+    | liquidTagOpenCase
+    | liquidTagOpenCapture
+    | liquidTagOpenForm
+    | liquidTagOpenFor
+    | liquidTagOpenTablerow
+    | liquidTagOpenIf
+    | liquidTagOpenPaginate
+    | liquidTagOpenUnless
+
+  liquidTagOpen =
+    | liquidTagOpenStrict
+    | liquidTagOpenBaseCase
+
+  liquidTagClose = "{%" "-"? space* "end" blockName space* tagMarkup "-"? "%}"
+
+  // These two are the same but transformed differently
+  liquidTagRule<name, markup> =
+    "{%" "-"? space* (name endOfIdentifier) space* markup "-"? "%}"
+  liquidTagOpenRule<name, markup> =
+    "{%" "-"? space* (name endOfIdentifier) space* markup "-"? "%}"
+
+  liquidTagBaseCase = liquidTagRule<liquidTagName, tagMarkup>
+
+  liquidTagEcho = liquidTagRule<"echo", liquidTagEchoMarkup>
+  liquidTagEchoMarkup = liquidVariable<delimTag>
+
+  liquidTagAssign = liquidTagRule<"assign", liquidTagAssignMarkup>
+  liquidTagAssignMarkup = variableSegment space* "=" space* liquidVariable<delimTag>
+
+  liquidTagCycle = liquidTagRule<"cycle", liquidTagCycleMarkup>
+  liquidTagCycleMarkup = (liquidExpression<delimTag> ":")? space* nonemptyListOf<liquidExpression<delimTag>, argumentSeparator> space*
+
+  liquidTagIncrement = liquidTagRule<"increment", variableSegmentAsLookupMarkup>
+  liquidTagDecrement = liquidTagRule<"decrement", variableSegmentAsLookupMarkup>
+  liquidTagOpenCapture = liquidTagOpenRule<"capture", variableSegmentAsLookupMarkup>
+  variableSegmentAsLookupMarkup = variableSegmentAsLookup space*
+
+  liquidTagSection = liquidTagRule<"section", liquidTagSectionMarkup>
+  liquidTagSectionMarkup = liquidString<delimTag> space*
+
+  liquidTagSections = liquidTagRule<"sections", liquidTagSectionsMarkup>
+  liquidTagSectionsMarkup = liquidString<delimTag> space*
+
+  liquidTagLayout = liquidTagRule<"layout", liquidTagLayoutMarkup>
+  liquidTagLayoutMarkup = liquidExpression<delimTag> space*
+
+  // We'll black hole the statement and switch parser in the cst builder
+  // We do this because it's technically the same grammar (with minor redefinitions)
+  // and it would be a huge chore and maintenance hell to rewrite all the rules with
+  // hspace = " " | "\t"
+  //
+  // The alternative is that this grammar parses the {% liquid tagMarkup %} as its own string,
+  // and then we switch to the LiquidStatement grammar that
+  // redefines liquidTagOpenRule, liquidTagRule, and space.
+  liquidTagLiquid = liquidTagRule<"liquid", liquidTagLiquidMarkup>
+  liquidTagLiquidMarkup = tagMarkup
+
+  liquidTagContentFor = liquidTagRule<"content_for", liquidTagContentForMarkup>
+
+  liquidTagContentForMarkup =
+    contentForType (argumentSeparatorOptionalComma contentForTagArgument) (space* ",")? space*
+
+  contentForTagArgument = listOf<contentForNamedArgument<delimTag>, argumentSeparatorOptionalComma>
+  completionModeContentForTagArgument = listOf<contentForNamedArgument<delimTag>, argumentSeparatorOptionalComma> (argumentSeparator? (liquidVariableLookup<delimTag>))?
+  contentForNamedArgument<delim> = (variableSegment ("." variableSegment)*) space* ":" space* (liquidExpression<delim>)
+
+  contentForType = liquidString<delimTag>
+
+  liquidTagInclude = liquidTagRule<"include", liquidTagRenderMarkup>
+  liquidTagRender = liquidTagRule<"render", liquidTagRenderMarkup>
+  liquidTagRenderMarkup =
+    snippetExpression renderVariableExpression? renderAliasExpression? renderArguments
+
+  renderArguments = (argumentSeparatorOptionalComma tagArguments) (space* ",")? space*
+  completionModeRenderArguments = (argumentSeparatorOptionalComma tagArguments) (space* ",")? space* (argumentSeparator? liquidVariableLookup<delimTag> space*)?
+  snippetExpression = liquidString<delimTag> | variableSegmentAsLookup
+  renderVariableExpression = space+ ("for" | "with") space+ liquidExpression<delimTag>
+  renderAliasExpression = space+ "as" space+ variableSegment
+
+  liquidTagOpenBaseCase = liquidTagOpenRule<blockName, tagMarkup>
+
+  liquidTagOpenForm = liquidTagOpenRule<"form", liquidTagOpenFormMarkup>
+  liquidTagOpenFormMarkup = arguments<delimTag> (space* ",")? space*
+
+  liquidTagOpenFor = liquidTagOpenRule<"for", liquidTagOpenForMarkup>
+  liquidTagOpenForMarkup =
+    variableSegment space* "in" space* liquidExpression<delimTag>
+    (space* "reversed")? argumentSeparatorOptionalComma
+    tagArguments (space* ",")? space*
+
+  // It's the same, the difference is support for different named arguments<delim>
+  liquidTagOpenTablerow = liquidTagOpenRule<"tablerow", liquidTagOpenForMarkup>
+
+  liquidTagOpenCase = liquidTagOpenRule<"case", liquidTagOpenCaseMarkup>
+  liquidTagOpenCaseMarkup = liquidExpression<delimTag> space*
+
+  liquidTagWhen = liquidTagRule<"when", liquidTagWhenMarkup>
+  liquidTagWhenMarkup = nonemptyListOf<liquidExpression<delimTag>, whenMarkupSep> space*
+  whenMarkupSep = space* ("," | "or" ~identifier) space*
+
+  liquidTagOpenIf = liquidTagOpenRule<"if", liquidTagOpenConditionalMarkup>
+  liquidTagOpenUnless = liquidTagOpenRule<"unless", liquidTagOpenConditionalMarkup>
+  liquidTagElsif = liquidTagRule<"elsif", liquidTagOpenConditionalMarkup>
+
+  liquidTagBreak = liquidTagRule<"break", empty>
+  liquidTagContinue = liquidTagRule<"continue", empty>
+  liquidTagElse = liquidTagRule<"else", empty>
+
+  liquidTagOpenConditionalMarkup = nonemptyListOf<condition<delimTag>, conditionSeparator> space*
+  conditionSeparator = &logicalOperator
+  condition<delim> = logicalOperator? space* (comparison<delim> | liquidExpression<delim>) space*
+  logicalOperator = ("and" | "or") ~identifier
+  comparison<delim> = liquidExpression<delim> space* comparator space* liquidExpression<delim>
+  comparator =
+    ( "=="
+    | "!="
+    | ">="
+    | "<="
+    | ">"
+    | "<")
+    | ("contains" ~identifier)
+
+  liquidTagOpenPaginate = liquidTagOpenRule<"paginate", liquidTagOpenPaginateMarkup>
+  liquidTagOpenPaginateMarkup =
+    liquidExpression<delimTag> space+ "by" space+ liquidExpression<delimTag> argumentSeparatorOptionalComma tagArguments (space* ",")? space*
+
+  liquidDrop = "{{" "-"? space* liquidDropCases "-"? "}}"
+  liquidDropCases = liquidVariable<delimVO> | liquidDropBaseCase
+  liquidDropBaseCase = anyExceptStar<delimVO>
+  liquidInlineComment = "{%" "-"? space* "#" space? tagMarkup "-"? "%}"
+
+  liquidRawTag =
+    | liquidRawTagImpl<"raw">
+    | liquidRawTagImpl<"javascript">
+    | liquidRawTagImpl<"schema">
+    | liquidRawTagImpl<"stylesheet">
+    | liquidRawTagImpl<"style">
+  liquidRawTagImpl<name> =
+    "{%" "-"? space* (name endOfIdentifier) space* tagMarkup "-"? "%}"
+    anyExceptStar<liquidRawTagClose<name>>
+    "{%" "-"? space* "end" (name endOfIdentifier) space* "-"? "%}"
+  liquidRawTagClose<name> =
+    "{%" "-"? space* "end" (name endOfIdentifier) space* "-"? "%}"
+
+  liquidBlockComment =
+    commentBlockStart
+      (liquidBlockComment | anyExceptPlus<commentBlockStart> | anyExceptPlus<commentBlockEnd>)*
+    commentBlockEnd
+  commentBlockStart = "{%" "-"? space* ("comment"    endOfIdentifier) space* tagMarkup "-"? "%}"
+  commentBlockEnd   = "{%" "-"? space* ("endcomment" endOfIdentifier) space* tagMarkup "-"? "%}"
+
+  liquidDoc =
+    liquidDocStart
+      liquidDocBody
+    liquidDocEnd
+
+  liquidDocStart = "{%" "-"? space* ("doc" endOfIdentifier) space* tagMarkup "-"? "%}"
+  liquidDocEnd = "{%" "-"? space* ("enddoc" endOfIdentifier) space* tagMarkup "-"? "%}"
+  liquidDocBody = anyExceptStar<liquidDocStart> | anyExceptStar<liquidDocEnd>
+
+  // In order for the grammar to "fallback" to the base case, this
+  // rule must pass if and only if we support what we parse. This
+  // implies that—since we don't support filters yet—we have a
+  // positive lookahead on "-}}" or "}}" in the rule. We do this
+  // because we'd otherwise positively match the following string
+  // instead of falling back to the other rule:
+  // {{ 'string' | some_filter }}
+  liquidVariable<delim> = liquidExpression<delim> liquidFilter<delim>* space* &delim
+
+  liquidExpression<delim> =
+    | liquidString<delim>
+    | liquidNumber
+    | liquidLiteral
+    | liquidRange<delim>
+    | liquidVariableLookup<delim>
+
+  liquidString<delim> = liquidSingleQuotedString<delim> | liquidDoubleQuotedString<delim>
+  liquidSingleQuotedString<delim> = "'" (anyExceptStar<"'"> | anyExceptStar<delim>) "'"
+  liquidDoubleQuotedString<delim> = "\"" (anyExceptStar<"\""> | anyExceptStar<delim>) "\""
+
+  liquidNumber = liquidFloat | liquidInteger
+  liquidInteger = "-"? digit+
+  liquidFloat = "-"? digit+ "." digit+
+
+  liquidLiteral =
+    ( "true"
+    | "false"
+    | "blank"
+    | "empty"
+    | "nil"
+    | "null"
+    ) endOfIdentifier
+
+  liquidRange<delim> =
+    "(" space* liquidExpression<delim> space* ".." space* liquidExpression<delim> space* ")"
+
+  liquidVariableLookup<delim> =
+    | variableSegment lookup<delim>*
+    | empty lookup<delim>+
+  lookup<delim> =
+    | indexLookup<delim>
+    | dotLookup
+  indexLookup<delim> = space* "[" space* liquidExpression<delim> space* "]"
+  dotLookup = space* "." space* identifier
+
+  liquidFilter<delim> = space* "|" space* identifier (space* ":" space* arguments<delim> (space* ",")?)?
+
+  arguments<delim> = nonemptyOrderedListOf<positionalArgument<delim>, namedArgument<delim>, argumentSeparator>
+  argumentSeparator = space* "," space*
+  argumentSeparatorOptionalComma = space* ","? space*
+  positionalArgument<delim> = liquidExpression<delim> ~(space* ":")
+  namedArgument<delim> = variableSegment space* ":" space* liquidExpression<delim>
+  tagArguments = listOf<namedArgument<delimTag>, argumentSeparatorOptionalComma>
+  filterArguments<delim> =
+    | complexArguments<delim>
+    | simpleArgument<delim>
+  complexArguments<delim> = arguments<delim> (space* "," space* simpleArgument<delim>)?
+  simpleArgument<delim> = liquidVariableLookup<delim>
+
+  variableSegment = (letter | "_") (~endOfTagName identifierCharacter)*
+  variableSegmentAsLookup = variableSegment
+  identifier = variableSegment "?"?
+
+  tagMarkup = anyExceptStar<delimTag>
+
+  liquidTagName =
+    letter (alnum | "_")*
+
+  blockName =
+    // Shopify blocks
+    ( "form"
+    | "paginate"
+    // Base blocks
+    | "capture"
+    | "case"
+    | "for"
+    | "ifchanged"
+    | "if"
+    | "unless"
+    | "tablerow"
+    ) endOfIdentifier
+
+  delimTag = "-%}" | "%}"
+  delimVO = "-}}" | "}}"
+}
+
+LiquidStatement <: Liquid {
+  Node := spaces listOf<LiquidStatement, statementSep> (space | newline)* spaces
+
+  // This is the big brains moment: we redefine space to exclude newlines.
+  //
+  // Which means that all our other Liquid rules can be reused
+  // without modification(!)
+  //
+  // We don't need to maintain rules like this:
+  // - liquidVariable<space>
+  // - liquidExpression<space>
+  // - variableLookup<space>
+  // - ... long list of stuff that takes space as param
+  // - liquidString<space>
+  //
+  // All we need is this little, VERY IMPORTANT, part right here that
+  // make it so we can parse the same way in Liquid tags.
+  //
+  // I'm putting in this huge comment so that it's more obvious.
+  space := " " | "\t"
+
+  LiquidStatement =
+    | spaces liquidBlockComment
+    | spaces liquidRawTag
+    | spaces liquidTagClose
+    | spaces liquidTagOpen
+    | spaces liquidTag
+    | spaces liquidInlineComment
+
+  liquidTagOpenRule<name, markup>
+    := (name ~identifierCharacter) space* markup &liquidStatementEnd
+
+  liquidTagRule<name, markup>
+    := (name ~identifierCharacter) space* markup &liquidStatementEnd
+
+  liquidTagClose
+    := "end" (blockName ~identifierCharacter) space* tagMarkup &liquidStatementEnd
+
+  liquidRawTagImpl<name>
+    := (name ~identifierCharacter) space* tagMarkup newline
+      anyExceptStar<liquidRawTagClose<name>>
+      "end" name space* &liquidStatementEnd
+
+  liquidRawTagClose<name>
+    := "end" name space* &liquidStatementEnd
+
+  liquidBlockComment :=
+    commentBlockStart statementSep
+      (listOf<liquidCommentBlockStatement, statementSep> statementSep)?
+    commentBlockEnd
+
+  liquidCommentBlockStatement =
+    | liquidBlockComment
+    | nonTerminalCommentLine
+
+  commentBlockStart
+    := ("comment" ~identifierCharacter) space* tagMarkup
+
+  commentBlockEnd
+    := ("endcomment" ~identifierCharacter) space* tagMarkup
+
+  nonTerminalCommentLine
+    = ~commentBlockEnd anyExceptPlus<newline>
+
+  liquidInlineComment
+    := "#" space? tagMarkup &liquidStatementEnd
+
+  tagMarkup := anyExceptStar<liquidStatementEnd>
+
+  // trailing whitespace, newline, + anything else before the next tag
+  statementSep = space* newline (space | newline)*
+
+  liquidStatementEnd = newline | end
+  delimTag := liquidStatementEnd
+}
+
+LiquidDoc <: Helpers {
+  Node := spaces ImplicitDescription (spaces (LiquidDocNode | TextNode))* spaces
+  LiquidDocNode =
+    | paramNode
+    | exampleNode
+    | descriptionNode
+    | fallbackNode
+  
+  endOfDescription = strictSpace* openControl
+  descriptionContent = anyExceptStar<endOfDescription>
+  ImplicitDescription = descriptionContent
+    
+  // By default, space matches new lines as well. We override it here to make writing rules easier.
+  strictSpace = " " | "\t"
+  // We use this as an escape hatch to stop matching TextNode and try again when one of these characters is encountered
+  openControl:= "@" | end
+
+  descriptionNode = "@description" space* descriptionContent
+
+  paramNode = "@param" strictSpace* paramType? strictSpace* (optionalParamName | paramName) (strictSpace* "-")? strictSpace* paramDescription
+  paramType = "{" strictSpace* paramTypeContent strictSpace* "}"
+  paramTypeContent = anyExceptStar<("}"| strictSpace)>
+
+  paramName = textValue
+  optionalParamName = "[" strictSpace* textValue strictSpace* "]"
+  textValue = identifierCharacter+
+
+  paramDescription = (~"]" anyExceptStar<endOfParam>)
+  endOfParam = strictSpace* (newline | end)
+
+  exampleNode = "@example" space* exampleContent
+  exampleContent = anyExceptStar<endOfExample>
+  endOfExample =  strictSpace* ("@" | end)
+
+  fallbackNode = "@" anyExceptStar<endOfParam>
+}
+
+LiquidHTML <: Liquid {
+  Node := yamlFrontmatter? (spaces (HtmlNode | liquidNode | TextNode))*
+  openControl += "<"
+
+  yamlFrontmatter =
+    "---" newline anyExceptStar<"---"> "---" newline
+
+  HtmlNode =
+    | HtmlDoctype
+    | HtmlComment
+    | HtmlRawTag
+    | HtmlVoidElement
+    | HtmlSelfClosingElement
+    | HtmlTagClose
+    | HtmlTagOpen
+
+  // https://html.spec.whatwg.org/multipage/syntax.html#the-doctype
+  HtmlDoctype =
+    "<!" ("doctype"|"DOCTYPE") space+ ("html"|"HTML") spaces legacyDoctypeString? spaces ">"
+  legacyDoctypeString
+    = anyExceptPlus<">">
+
+  HtmlComment = "<!--" anyExceptStar<"-->"> "-->"
+
+  // These are black holes, we'll ignore what's in them
+  HtmlRawTag =
+    | HtmlRawTagImpl<"script">
+    | HtmlRawTagImpl<"style">
+    | HtmlRawTagImpl<"svg">
+
+  HtmlRawTagImpl<name> =
+    spaces TagStart<name>
+      (spaces (HtmlRawTagImpl<name> | AnyExceptPlus<TagStartorEnd<name>>))*
+    spaces TagEnd<name>
+  TagStart<name> = spaces "<" spaces name spaces AttrList spaces ">"
+  TagEnd<name> = spaces "</" spaces name spaces ">"
+  TagStartorEnd<name> = TagStart<name> | TagEnd<name>
+
+  HtmlVoidElement =
+    spaces "<" voidElementName &(space | "/" | ">") spaces AttrList spaces "/"? spaces ">"
+
+  HtmlSelfClosingElement =
+    spaces "<" tagName spaces AttrList spaces "/>"
+
+  HtmlTagOpen =
+    spaces "<" tagName spaces AttrList spaces ">"
+
+  HtmlTagClose =
+    spaces "</" tagName spaces ">"
+
+  tagName = leadingTagNamePart trailingTagNamePart*
+
+  // The difference here is that the first text part must start
+  // with a letter, but trailing text parts don't have that
+  // requirement
+  leadingTagNamePart =
+    | liquidDrop
+    | leadingTagNameTextNode
+
+  trailingTagNamePart =
+    | liquidDrop
+    | trailingTagNameTextNode
+
+  leadingTagNameTextNode = letter (alnum | "-" | ":")*
+  trailingTagNameTextNode = (alnum | "-" | ":")+
+
+  AttrList = (spaces Attr)*
+
+  Attr =
+    spaces (AttrSingleQuoted | AttrDoubleQuoted | AttrUnquoted | liquidNode | attrEmpty)
+
+  attrEmpty = attrName
+
+  AttrUnquoted = spaces attrName spaces "=" spaces attrUnquotedValue
+  AttrSingleQuoted = spaces attrName spaces "=" spaces singleQuote attrSingleQuotedValue singleQuote
+  AttrDoubleQuoted = spaces attrName spaces "=" spaces doubleQuote attrDoubleQuotedValue doubleQuote
+
+  attrName = (liquidDrop | attrNameTextNode)+
+
+  // https://html.spec.whatwg.org/#attributes-2
+  fake1 = space | quotes | "=" | ">" | "/>" | "{{" | "{%" | controls | noncharacters
+  attrNameTextNode = anyExceptPlus<fake1>
+  attrUnquotedValue = (liquidDrop | attrUnquotedTextNode)*
+  attrSingleQuotedValue = (liquidNode | attrSingleQuotedTextNode)*
+  attrDoubleQuotedValue = (liquidNode | attrDoubleQuotedTextNode)*
+
+  fake2 = space | quotes | "=" | "<" | ">" | "`" | "{{" | "{%"
+  attrUnquotedTextNode = anyExceptPlus<fake2>
+  fake3 = singleQuote | "{{" | "{%"
+  fake4 = doubleQuote | "{{" | "{%"
+  attrSingleQuotedTextNode = anyExceptPlus<fake3>
+  attrDoubleQuotedTextNode = anyExceptPlus<fake4>
+
+  quotes = singleQuote | doubleQuote
+
+  // https://www.w3.org/TR/2011/WD-html-markup-20110113/syntax.html#void-element
+  voidElementName =
+    ( "area"
+    | "base"
+    | "br"
+    | "col"
+    | "command"
+    | "embed"
+    | "hr"
+    | "img"
+    | "input"
+    | "keygen"
+    | "link"
+    | "meta"
+    | "param"
+    | "source"
+    | "track"
+    | "wbr"
+    ) ~identifierCharacter
+}
+
+StrictLiquid <: Liquid {
+  liquidTag := liquidTagStrict
+  liquidTagOpen := liquidTagOpenStrict
+}
+
+StrictLiquidStatement <: LiquidStatement {
+  liquidTag := liquidTagStrict
+  liquidTagOpen := liquidTagOpenStrict
+}
+
+StrictLiquidHTML <: LiquidHTML {
+  liquidTag := liquidTagStrict
+  liquidTagOpen := liquidTagOpenStrict
+}
+
+WithPlaceholderLiquid <: Liquid {
+  liquidFilter<delim> := space* "|" space* identifier (space* ":" space* filterArguments<delim> (space* ",")?)?
+  liquidTagContentForMarkup :=
+    contentForType (argumentSeparatorOptionalComma completionModeContentForTagArgument) (space* ",")? space*
+  liquidTagRenderMarkup :=
+    snippetExpression renderVariableExpression? renderAliasExpression? completionModeRenderArguments
+  liquidTagName := (letter | "█") (alnum | "_")*
+  variableSegment := (letter | "_" | "█") (identifierCharacter | "█")*
+  liquidDoc :=
+    liquidDocStart
+      liquidDocBody
+    liquidDocEnd?
+}
+
+WithPlaceholderLiquidStatement <: LiquidStatement {
+  liquidFilter<delim> := space* "|" space* identifier (space* ":" space* filterArguments<delim> (space* ",")?)?
+  liquidTagContentForMarkup :=
+    contentForType (argumentSeparatorOptionalComma completionModeContentForTagArgument) (space* ",")? space*
+  liquidTagRenderMarkup :=
+    snippetExpression renderVariableExpression? renderAliasExpression? completionModeRenderArguments
+  liquidTagName := (letter | "█") (alnum | "_")*
+  variableSegment := (letter | "_" | "█") (identifierCharacter | "█")*
+  liquidDoc :=
+    liquidDocStart
+      liquidDocBody
+    liquidDocEnd?
+}
+
+WithPlaceholderLiquidHTML <: LiquidHTML {
+  liquidFilter<delim> := space* "|" space* identifier (space* ":" space* filterArguments<delim> (space* ",")?)?
+  liquidTagContentForMarkup :=
+    contentForType (argumentSeparatorOptionalComma completionModeContentForTagArgument) (space* ",")? space*
+  liquidTagRenderMarkup :=
+    snippetExpression renderVariableExpression? renderAliasExpression? completionModeRenderArguments
+  liquidTagName := (letter | "█") (alnum | "_")*
+  variableSegment := (letter | "_" | "█") (identifierCharacter | "█")*
+  leadingTagNameTextNode := (letter | "█") (alnum | "-" | ":" | "█")*
+  trailingTagNameTextNode := (alnum | "-" | ":" | "█")+
+  liquidDoc :=
+    liquidDocStart
+      liquidDocBody
+    liquidDocEnd?
+}

package/test/go/README.md

@@ -0,0 +1,67 @@
+# Ohm-WASM Go Integration
+
+This directory contains a Go implementation for running Ohm grammars compiled to WebAssembly. It provides a simple API to load grammar modules, match input against them, and access the resulting concrete syntax trees.
+
+## Overview
+
+The implementation consists of two main components:
+
+1. **matcher.go**: A Go implementation of the JavaScript `WasmMatcher` class from the Ohm `wasm` package
+2. **testmain.go**: A command-line program that demonstrates how to use the WasmMatcher
+
+## WasmMatcher
+
+The `WasmMatcher` class provides a high-level API for working with Ohm grammars compiled to WebAssembly:
+
+```go
+// Create a new matcher
+matcher := NewWasmMatcher(ctx)
+
+// Load a grammar module
+err := matcher.LoadModule("path/to/grammar.wasm")
+
+// Set input text
+matcher.SetInput("text to match")
+
+// Match against the grammar
+success, err := matcher.Match()
+
+// Match against a specific rule
+success, err := matcher.MatchRule("specificRule")
+
+// Access the concrete syntax tree
+cstRoot, err := matcher.GetCstRoot()
+```
+
+## Command-Line Usage
+
+You can use the command-line program to test Ohm grammars:
+
+```
+# Test the simple add function (automatically detected)
+./testmain -wasm ../data/_add.wasm
+
+# Match input against a grammar
+./testmain -wasm path/to/grammar.wasm -input "text to match"
+
+# Specify a start rule
+./testmain -wasm path/to/grammar.wasm -input "text to match" -rule "StartRule"
+```
+
+### Example with ES5 Grammar
+
+```
+./testmain -wasm ../data/_es5.wasm -input "var x = 3;"
+```
+
+## Build Instructions
+
+Use the Makefile in the parent directory to build and test:
+
+```
+# Build the testmain program
+make test/go/testmain
+
+# Run the test with the ES5 grammar
+make go-test-es5
+```