wesl 0.6.0-pre2

package/dist/minified.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minified.js","sources":["../src/ImportTree.ts","../src/debug/ImportToString.ts","../src/debug/LineWrapper.ts","../src/debug/ASTtoString.ts","../src/debug/ScopeToString.ts","../../mini-parse/src/ParserUtil.ts","../../mini-parse/src/ParserCombinator.ts","../../mini-parse/src/ParserCollect.ts","../../mini-parse/src/Parser.ts","../../mini-parse/src/ParserTracing.ts","../../mini-parse/src/ParserLogging.ts","../../mini-parse/src/MatchingLexer.ts","../../mini-parse/src/SrcMap.ts","../../mini-parse/src/SrcMapBuilder.ts","../../mini-parse/src/TokenMatcher.ts","../src/WESLTokens.ts","../src/Scope.ts","../src/WESLCollect.ts","../src/ImportGrammar.ts","../src/CommentsGrammar.ts","../src/WESLGrammar.ts","../src/FlattenTreeImport.ts","../src/ParseWESL.ts","../src/StandardTypes.ts","../src/Util.ts","../src/BindIdents.ts","../src/LowerAndEmit.ts","../src/PathUtil.ts","../src/ParsedRegistry.ts","../src/Linker.ts"],"sourcesContent":["export class ImportTree {\n  /** segments in path order */\n  constructor(public segments: PathSegment[]) {}\n}\n\nexport type PathSegment = SimpleSegment | ImportTree | SegmentList;\n\nexport class SimpleSegment {\n  constructor(\n    public name: string,\n    public as?: string,\n    public args?: string[], // generic args (only allowed on final segment). TODO drop\n  ) {}\n}\n\n/** or choices for this path segment */\nexport class SegmentList {\n  constructor(public list: PathSegment[]) {}\n}\n","import { ImportTree, PathSegment, SegmentList, SimpleSegment } from \"../ImportTree.ts\";\n\nexport function importToString(tree: ImportTree): string {\n  return tree.segments.map(s => segmentToString(s)).join(\"/\");\n}\n\nfunction segmentToString(segment: PathSegment): string {\n  if (segment instanceof SimpleSegment) {\n    const { name, as, args } = segment;\n    const asMsg = as ? ` as ${as}` : \"\";\n    const argsMsg = args ? `(${args.join(\", \")})` : \"\";\n    return `${name}${argsMsg}${asMsg}`;\n  }\n  if (segment instanceof SegmentList) {\n    return `{${segment.list.map(s => segmentToString(s)).join(\", \")}}`;\n  }\n  if (segment instanceof ImportTree) {\n    return `(${importToString(segment)})`;\n  }\n  return `|unknown segment type ${(segment as any).constructor.name}|`;\n}\n","/** debug utility for constructing strings that wrap at a fixed column width\n * text beyond the column width is wrapped to start on the next line\n */\nexport class LineWrapper {\n  #fragments: string[] = [];\n  #column = 0;\n  #spc: string;\n  #oneLine = true;\n  #isHanging = false;\n  #hangingSpc: string;\n\n  constructor(\n    readonly indent = 0,\n    readonly maxWidth = 60,\n    readonly hangingIndent = 2,\n  ) {\n    this.#spc = \" \".repeat(indent);\n    this.#hangingSpc = \" \".repeat(hangingIndent);\n  }\n\n  /** add a new line to the constructed string */\n  nl() {\n    this.#fragments.push(\"\\n\");\n    this.#column = 0;\n    this.#oneLine = false;\n    this.#isHanging = false;\n  }\n\n  /** add a string, wrapping to the next line if necessary */\n  add(s: string) {\n    if (this.#column + s.length > this.maxWidth) {\n      this.hangingNl();\n    }\n    if (this.#column === 0) {\n      this.#fragments.push(this.#spc);\n      if (this.#isHanging) {\n        this.#fragments.push(this.#hangingSpc);\n      }\n      this.#column = this.indent;\n    }\n    this.#fragments.push(s);\n    this.#column += s.length;\n  }\n\n  /** add a raw block of text with no wrapping */\n  addBlock(s: string, andNewLine = true) {\n    this.#fragments.push(s);\n    if (andNewLine) this.nl();\n  }\n\n  /** @return the constructed string */\n  get result(): string {\n    return this.#fragments.join(\"\");\n  }\n\n  /** true if the result contains no newlines */\n  get oneLine(): boolean {\n    return this.#oneLine;\n  }\n\n  private hangingNl() {\n    this.nl();\n    this.#isHanging = true;\n  }\n}\n","import { AbstractElem, ModuleElem } from \"../AbstractElems.ts\";\nimport { importToString } from \"./ImportToString.ts\";\nimport { LineWrapper } from \"./LineWrapper.ts\";\n\nexport function astToString(elem: AbstractElem, indent = 0): string {\n  const { kind, contents } = elem as ModuleElem;\n  const str = new LineWrapper(indent);\n  str.add(kind);\n  addElemFields(elem, str);\n  let childStrings: string[] = [];\n  if (contents) {\n    childStrings = contents.map(e => astToString(e, indent + 2));\n  }\n  if (childStrings.length) {\n    str.nl();\n    str.addBlock(childStrings.join(\"\\n\"), false);\n  }\n\n  return str.result;\n}\n\nexport function elemToString(elem: AbstractElem): string {\n  const { kind } = elem as ModuleElem;\n  const str = new LineWrapper();\n  str.add(kind);\n  addElemFields(elem, str);\n  let childStrings: string[] = [];\n  if (childStrings.length) {\n    str.nl();\n    str.addBlock(childStrings.join(\"\\n\"), false);\n  }\n  return str.result;\n}\n\nfunction addElemFields(elem: AbstractElem, str: LineWrapper): void {\n  addTextFields(elem, str) ||\n    addVarishFields(elem, str) ||\n    addStructFields(elem, str) ||\n    addNameFields(elem, str) ||\n    addFnFields(elem, str) ||\n    addAliasFields(elem, str) ||\n    addImport(elem, str) ||\n    addRefIdent(elem, str) ||\n    addDeclIdent(elem, str);\n}\n\nfunction addVarishFields(\n  elem: AbstractElem,\n  str: LineWrapper,\n): true | undefined {\n  const { kind } = elem;\n  if (\n    kind === \"var\" ||\n    kind === \"gvar\" ||\n    kind === \"const\" ||\n    kind === \"override\"\n  ) {\n    str.add(\" \" + elem.name.ident.originalName);\n    if (elem.typeRef) {\n      str.add(\":\" + elem.typeRef.ident.originalName);\n    }\n    return true;\n  }\n}\n\nfunction addTextFields(\n  elem: AbstractElem,\n  str: LineWrapper,\n): true | undefined {\n  if (elem.kind === \"text\") {\n    const { srcModule, start, end } = elem;\n    str.add(` '${srcModule.src.slice(start, end)}'`);\n    return true;\n  }\n}\n\nfunction addRefIdent(elem: AbstractElem, str: LineWrapper): true | undefined {\n  if (elem.kind === \"ref\") {\n    str.add(\" \" + elem.ident.originalName);\n    return true;\n  }\n}\n\nfunction addDeclIdent(elem: AbstractElem, str: LineWrapper): true | undefined {\n  if (elem.kind === \"decl\") {\n    str.add(\" %\" + elem.ident.originalName);\n    return true;\n  }\n}\n\nfunction addAliasFields(\n  elem: AbstractElem,\n  str: LineWrapper,\n): true | undefined {\n  if (elem.kind === \"alias\") {\n    const { name, typeRef } = elem;\n    const prefix = name.ident.kind === \"decl\" ? \"%\" : \"\";\n    str.add(\" \" + prefix + name.ident.originalName);\n    str.add(\"=\" + typeRef.ident.originalName);\n    return true;\n  }\n}\n\nfunction addStructFields(\n  elem: AbstractElem,\n  str: LineWrapper,\n): true | undefined {\n  if (elem.kind === \"struct\") {\n    str.add(\" \" + elem.name.ident.originalName);\n    return true;\n  }\n}\n\nfunction addImport(elem: AbstractElem, str: LineWrapper): true | undefined {\n  if (elem.kind === \"import\") {\n    str.add(\" \" + importToString(elem.imports));\n    return true;\n  }\n}\n\nfunction addNameFields(\n  elem: AbstractElem,\n  str: LineWrapper,\n): true | undefined {\n  if (elem.kind === \"name\") {\n    str.add(\" \" + elem.name);\n    return true;\n  }\n}\n\nfunction addFnFields(elem: AbstractElem, str: LineWrapper): true | undefined {\n  if (elem.kind === \"fn\") {\n    const { name, params, returnType } = elem;\n    str.add(\" \" + name.ident.originalName);\n\n    str.add(\"(\");\n    const paramStrs = params\n      .map(p => p.name.ident.originalName + \": \" + p.typeRef.ident.originalName)\n      .join(\", \");\n    str.add(paramStrs);\n    str.add(\")\");\n\n    if (returnType) {\n      str.add(\" -> \" + returnType.ident.originalName);\n    }\n\n    return true;\n  }\n}\n","import { LineWrapper } from \"./LineWrapper.ts\";\nimport { Ident, Scope } from \"../Scope.ts\";\n\n/** A debugging print of the scope tree with identifiers in nested brackets */\nexport function scopeToString(scope: Scope, indent = 0): string {\n  const { children } = scope;\n  let childStrings: string[] = [];\n  if (children.length)\n    childStrings = children.map(c => scopeToString(c, indent + 2));\n\n  // list of identifiers, with decls prefixed with '%'\n  const identStrings = scope.idents.map(({ kind, originalName }) => {\n    const prefix = kind === \"decl\" ? \"%\" : \"\";\n    return `${prefix}${originalName}`;\n  });\n\n  const str = new LineWrapper(indent);\n  str.add(\"{ \");\n\n  const last = identStrings.length - 1;\n  identStrings.forEach((s, i) => {\n    const element = i < last ? s + \", \" : s;\n    str.add(element);\n  });\n\n  if (childStrings.length) {\n    str.nl();\n    str.addBlock(childStrings.join(\"\\n\"));\n  }\n\n  if (str.oneLine) {\n    str.add(\" }\");\n  } else {\n    if (!childStrings.length) str.nl();\n    str.add(\"}\");\n  }\n\n  return str.result;\n}\n\nexport function identToString(ident?: Ident): string {\n  if (!ident) return JSON.stringify(ident);\n  const { kind, originalName } = ident;\n  const idStr = ident.id ? `#${ident.id}` : \"\";\n  if (kind === \"ref\") {\n    const ref = identToString(ident.refersTo!);\n    return `${originalName} ${idStr} -> ${ref}`;\n  } else {\n    return `%${originalName} ${idStr} (${ident.mangledName})`;\n  }\n}\n","/** merge two objects containing arrays, arrays in liked named keys are concatenated */\nexport function mergeTags(\n  a: Record<string | symbol, any[] | undefined>,\n  b: Record<string | symbol, any[] | undefined>,\n): Record<string, any[]> {\n  const aKeys = Reflect.ownKeys(a); // captures symbols\n  const sharedKeys = aKeys.filter(k => b[k]);\n  // combine arrays from liked named keys\n  const sharedEntries = sharedKeys.map(k => [\n    k,\n    [...(a[k] ?? []), ...(b[k] ?? [])],\n  ]);\n  const shared = Object.fromEntries(sharedEntries);\n  return { ...a, ...b, ...shared }; // shared keys overwritten with combined arrays\n}\n","import {\n  CombinatorArg,\n  OrParser,\n  ParserFromArg,\n  ParserFromRepeatArg,\n  ResultFromArg,\n  SeqParser,\n  SeqValues,\n  TagsFromArg,\n} from \"./CombinatorTypes.js\";\nimport { quotedText } from \"./MatchingLexer.js\";\nimport {\n  ExtendedResult,\n  NoTags,\n  OptParserResult,\n  Parser,\n  parser,\n  ParserContext,\n  ParserResult,\n  runExtended,\n  simpleParser,\n  TagRecord,\n  tokenSkipSet,\n  trackChildren,\n} from \"./Parser.js\";\nimport {\n  closeArray,\n  pushOpenArray,\n} from \"./ParserCollect.js\";\nimport { ctxLog } from \"./ParserLogging.js\";\nimport { tracing } from \"./ParserTracing.js\";\nimport { mergeTags } from \"./ParserUtil.js\";\nimport { Token, TokenMatcher } from \"./TokenMatcher.js\";\n\n/** Parsing Combinators\n *\n * The basic idea is that parsers are contructed heirarchically from other parsers.\n * Each parser is independently testable and reusable with combinators like or() and seq().\n *\n * Each parser is a function that recognizes tokens produced by a lexer\n * and returns a result.\n *  Returning null indicate failure. Tokens are not consumed on failure.\n *  Users can also use the .tag() method to tag results from a stage. Tagged results\n *    propagate up to containing parsers for convenience in selecting results.\n *\n * Built in parsers and combinators are available:\n *  kind() recognizes tokens of a particular type.\n *  or(), seq(), opt(), map() and repeat() combine other stages.\n *\n * Users construct their own parsers by combining other parser stages\n * and typically use map() to report results. Results can be stored\n * in the array app[], which is provided by the user and available for\n * all user constructed parsers.\n */\n\nexport class ParseError extends Error {\n  constructor(msg?: string) {\n    super(msg);\n  }\n}\n\n/** Parse for a particular kind of token,\n * @return the matching text */\nexport function kind(kindStr: string): Parser<string> {\n  return simpleParser(\n    `kind '${kindStr}'`,\n    (state: ParserContext): string | null => {\n      const next = state.lexer.next();\n      return next?.kind === kindStr ? next.text : null;\n    },\n  );\n}\n\n/** Parse for a token containing a text value\n * @return the kind of token that matched */\nexport function text(value: string): Parser<string, NoTags> {\n  return simpleParser(\n    `${quotedText(value)}`,\n    (state: ParserContext): string | null => {\n      const next = state.lexer.next();\n      return next?.text === value ? next.text : null;\n    },\n  );\n}\n\n/** Parse a sequence of parsers\n * @return an array of all parsed results, or null if any parser fails */\nexport function seq<P extends CombinatorArg[]>(...args: P): SeqParser<P> {\n  const parsers = args.map(parserArg);\n  const seqParser = parser(\"seq\", (ctx: ParserContext) => {\n    const values = [];\n    let tagged = {};\n    let failed = false;\n    for (const p of parsers) {\n      const result = p._run(ctx);\n      if (result === null) {\n        failed = true;\n        break;\n      }\n\n      tagged = mergeTags(tagged, result.tags);\n      values.push(result.value);\n    }\n    if (failed) return null;\n    return { value: values, tags: tagged };\n  }).collect({ before: pushOpenArray, after: closeArray });\n\n  trackChildren(seqParser, ...parsers);\n\n  return seqParser as SeqParser<P>;\n}\n\n/** Try parsing with one or more parsers,\n *  @return the first successful parse */\nexport function or<P extends CombinatorArg[]>(...args: P): OrParser<P> {\n  const parsers = args.map(parserArg);\n  const orParser = parser(\"or\", (state: ParserContext) => {\n    for (const p of parsers) {\n      const result = p._run(state);\n      if (result !== null) {\n        return result;\n      }\n    }\n    return null;\n  });\n\n  trackChildren(orParser, ...parsers);\n\n  return orParser as OrParser<P>;\n}\n\nconst undefinedResult: ParserResult<undefined, NoTags> = {\n  value: undefined,\n  tags: {},\n};\n\nexport type UndefinedParser = Parser<undefined, NoTags>;\n/** Try a parser.\n *\n * If the parse succeeds, return the result.\n * If the parser fails, return false and don't advance the input. Returning false\n * indicates a successful parse, so combinators like seq() will succeed.\n */\nexport function opt<P extends CombinatorArg>(\n  arg: P,\n): ParserFromArg<P> | UndefinedParser {\n  const p = parserArg(arg);\n\n  const optParser: ParserFromArg<P> | UndefinedParser = parser(\n    \"opt\",\n    (state: ParserContext) => {\n      const result = p._run(state);\n      // If parsing fails, we return instead a success\n      // with 'undefined' as a value\n\n      // cast the undefined result here and recover type with the ascription above\n      type PR = ParserResult<ResultFromArg<P>, TagsFromArg<P>>;\n      return result || (undefinedResult as PR);\n    },\n  );\n  trackChildren(optParser, p);\n  return optParser;\n}\n\n/** return true if the provided parser _doesn't_ match\n * does not consume any tokens */\nexport function not(arg: CombinatorArg): Parser<true> {\n  const p = parserArg(arg);\n  const notParser: Parser<true> = parser(\"not\", (state: ParserContext) => {\n    const pos = state.lexer.position();\n    const result = p._run(state);\n    if (!result) {\n      return { value: true, tags: {} };\n    }\n    state.lexer.position(pos);\n    return null;\n  });\n  trackChildren(notParser, p);\n\n  return notParser;\n}\n\n/** yield next token, any token */\nexport function any(): Parser<Token> {\n  return simpleParser(\"any\", (state: ParserContext): Token | null => {\n    const next = state.lexer.next();\n    return next || null;\n  });\n}\n\n/** yield next token if the provided parser doesn't match */\nexport function anyNot(arg: CombinatorArg): Parser<Token> {\n  return seq(not(arg), any())\n    .map(r => r.value[1])\n    .traceName(\"anyNot\");\n}\n\n/** match everything until a terminator (and the terminator too) */\nexport function anyThrough<A extends CombinatorArg>(\n  arg: A,\n): Parser<[...any, ResultFromArg<A>], TagsFromArg<A>> {\n  const p = parserArg<A>(arg);\n  const anyParser = seq(repeat(anyNot(p)), p).traceName(\n    `anyThrough ${p.debugName}`,\n  );\n  trackChildren(anyParser, p);\n  type V = typeof anyParser extends Parser<infer V, any> ? V : never;\n  return anyParser as Parser<V, any>;\n\n  // LATER TS not sure why this doesn't work\n  // type T = TagsFromArg<A>;\n  // return result as Parser<V, T>;\n}\n\n/** match zero or more instances of a parser */\nexport function repeat<A extends CombinatorArg>(\n  arg: A,\n): ParserFromRepeatArg<A> {\n  const p = parserArg(arg);\n  const repeatParser = parser(\"repeat\", repeatWhileFilter(p));\n  trackChildren(repeatParser, p);\n  return repeatParser;\n}\n\n/** match one or more instances of a parser */\nexport function repeatPlus<A extends CombinatorArg>(\n  arg: A,\n): ParserFromRepeatArg<A> {\n  const p = parserArg(arg);\n  const repeatParser = seq(p, repeat(p))\n    .map(r => [r.value[0], ...r.value[1]])\n    .traceName(\"repeatPlus\");\n  trackChildren(repeatParser, p);\n  return repeatParser;\n}\n\ntype ResultFilterFn<T> = (\n  result: ExtendedResult<T | string, any>,\n) => boolean | undefined;\n\nexport function repeatWhile<A extends CombinatorArg>(\n  arg: A,\n  filterFn: ResultFilterFn<ResultFromArg<A>>,\n): ParserFromRepeatArg<A> {\n  const p = parserArg(arg);\n  const result = parser(\"repeatWhile\", repeatWhileFilter(p, filterFn));\n  trackChildren(result, p);\n  return result;\n}\n\ntype RepeatWhileResult<A extends CombinatorArg> = OptParserResult<\n  SeqValues<A[]>,\n  TagsFromArg<A>\n>;\n\nfunction repeatWhileFilter<T, A extends CombinatorArg>(\n  p: ParserFromArg<A>,\n  filterFn: ResultFilterFn<ResultFromArg<A>> = () => true,\n): (ctx: ParserContext) => RepeatWhileResult<A> {\n  return (ctx: ParserContext): RepeatWhileResult<A> => {\n    const values: ResultFromArg<A>[] = [];\n    let tags = {};\n    for (;;) {\n      const result = runExtended<ResultFromArg<A>, TagsFromArg<A>>(ctx, p);\n\n      // continue acccumulating until we get a null or the filter tells us to stop\n      if (result !== null && filterFn(result)) {\n        values.push(result.value);\n        tags = mergeTags(tags, result.tags);\n      } else {\n        // always return succcess\n        const r = { value: values, tags: tags as TagsFromArg<A> };\n        return r;\n      }\n    }\n  };\n}\n\n/** yields true if parsing has reached the end of input */\nexport function eof(): Parser<true> {\n  return simpleParser(\n    \"eof\",\n    (state: ParserContext) => state.lexer.eof() || null,\n  );\n}\n\n/** if parsing fails, log an error and abort parsing */\nexport function req<A extends CombinatorArg>(\n  arg: A,\n  msg?: string,\n): ParserFromArg<A> {\n  const p = parserArg(arg);\n  const reqParser = parser(\"req\", (ctx: ParserContext) => {\n    const result = p._run(ctx);\n    if (result === null) {\n      const deepName = ctx._debugNames.join(\" > \"); // TODO DRY this\n      ctxLog(ctx, msg ?? `expected ${p.debugName} ${deepName}`);\n      throw new ParseError();\n    }\n    return result;\n  });\n  trackChildren(reqParser, p);\n  return reqParser;\n}\n\n/** always succeeds, does not consume any tokens */\nexport function yes(): Parser<true> {\n  return simpleParser(\"yes\", () => true);\n}\n\n/** always fails, does not consume any tokens */\nexport function no(): Parser<null> {\n  return simpleParser(\"no\", () => null);\n}\n\nexport interface WithSepOptions {\n  /** if true, allow an optional trailing separator (default true) */\n  trailing?: boolean;\n  /** if true, require at least one element (default false) */\n  requireOne?: boolean;\n}\n\n/** match an optional series of elements separated by a delimiter (e.g. a comma) */\nexport function withSep<P extends CombinatorArg>(\n  sep: CombinatorArg,\n  p: P,\n  opts: WithSepOptions = {},\n): Parser<ResultFromArg<P>[], TagsFromArg<P>> {\n  const { trailing = true, requireOne = false } = opts;\n  const parser = parserArg(p);\n  const sepParser = parserArg(sep);\n  const pTagged = or(parser).tag(\"_sepTag\");\n  const first = requireOne ? pTagged : opt(pTagged);\n  const last = trailing ? opt(sepParser) : yes();\n\n  const withSepParser = seq(first, repeat(seq(sepParser, pTagged)), last)\n    .map(r => {\n      const result = r.tags._sepTag;\n      delete r.tags._sepTag;\n      return result;\n    })\n    .traceName(\"withSep\") as any;\n\n  trackChildren(withSepParser, parser, sepParser);\n\n  return withSepParser;\n}\n\n/** match an series of one or more elements separated by a delimiter (e.g. a comma) */\nexport function withSepPlus<P extends CombinatorArg>(\n  sep: CombinatorArg,\n  p: P,\n): Parser<ResultFromArg<P>[], TagsFromArg<P>> {\n  return withSep(sep, p, { requireOne: true }).traceName(\"withSepPlus\");\n}\n\n/** run a parser with a provided token matcher (i.e. use a temporary lexing mode) */\nexport function tokens<A extends CombinatorArg>(\n  matcher: TokenMatcher,\n  arg: A,\n): ParserFromArg<A> {\n  const p = parserArg(arg);\n  const tokensParser = parser(\n    `tokens ${matcher._debugName}`,\n    (state: ParserContext) => {\n      return state.lexer.withMatcher(matcher, () => {\n        return p._run(state);\n      });\n    },\n  );\n\n  trackChildren(tokensParser, p);\n  return tokensParser;\n}\n\n/** return a parser that matches end of line, or end of file,\n * optionally preceded by white space\n * @param ws should not match \\n */\n// TODO make arguments optional\nexport function makeEolf(matcher: TokenMatcher, ws: string): Parser<any> {\n  // prettier-ignore\n  return tokens(matcher, \n      tokenSkipSet(null, // disable automatic ws skipping so we can match newline\n        seq(\n          opt(kind(ws)), \n          or(\"\\n\", eof())\n        )\n      )\n    )\n   .traceName(\"eolf\");\n}\n\n/** convert naked string arguments into text() parsers and functions into fn() parsers */\nexport function parserArg<A extends CombinatorArg>(arg: A): ParserFromArg<A> {\n  if (typeof arg === \"string\") {\n    return text(arg) as ParserFromArg<A>; // LATER fix cast\n  } else if (arg instanceof Parser) {\n    return arg as Parser<ResultFromArg<A>, TagsFromArg<A>>;\n  }\n  return fn(arg as () => ParserFromArg<A>);\n}\n\n/** A delayed parser definition, for making recursive parser definitions.  */\nexport function fn<T, N extends TagRecord>(\n  fn: () => Parser<T, N>,\n): Parser<T, N> {\n  const fp = parser(\"fn()\", (state: ParserContext): OptParserResult<T, N> => {\n    if (!fn) {\n      const deepName = state._debugNames.join(\".\");\n      throw new Error(`fn parser called before definition: ${deepName}`);\n    }\n    const stage = fn();\n    return stage._run(state);\n  });\n  if (tracing) (fp as any)._fn = fn; // tricksy hack for pretty printing contained fns\n  return fp;\n}\n\n/** @return a replacement parser that doesn't propagate any tags */\nexport function withTags<A extends CombinatorArg>(\n  arg: A,\n): Parser<ResultFromArg<A>, NoTags> {\n  const p = parserArg(arg);\n  const tagsParser = parser(\"withTags\", (ctx: ParserContext) => {\n    const result = p._run(ctx);\n    return result ? { value: result.value, tags: {} } : null;\n  });\n  trackChildren(tagsParser, p);\n  return tagsParser;\n}\n","import { dlog } from \"berry-pretty\";\nimport { Lexer } from \"./MatchingLexer.js\";\nimport {\n  AppState,\n  NoTags,\n  OptParserResult,\n  parser,\n  Parser,\n  ParserContext,\n  TagRecord,\n  trackChildren,\n} from \"./Parser.js\";\nimport { parserArg } from \"./ParserCombinator.js\";\nimport { CombinatorArg, ResultFromArg } from \"./CombinatorTypes.js\";\n\n/** an entry in the table of deferred functions for collect() and tag() */\nexport interface CollectFnEntry<V> {\n  collectFn: CollectFn<V>;\n  srcPosition: CollectPosition;\n  debugName?: string;\n}\n\n/** location in the source where a collection occurred */\nexport interface CollectPosition {\n  start: number;\n  end: number;\n}\n\n/** info passed to the collect fn */\nexport interface CollectContext extends CollectPosition {\n  tags: TagRecord;\n  src: string;\n  app: AppState<any, any>;\n  _values: CollectValue[];\n}\n\n/** a stack of collected values  */\ninterface CollectValue {\n  value: any;\n  openArray: any[] | undefined;\n}\n\n/** a user supplied function for collecting info from the parse */\nexport type CollectFn<V> = (ctx: CollectContext) => V;\n\n/** a user supplied pair functions for collecting info from the parse */\nexport interface CollectPair<V> {\n  before: CollectFn<void>;\n  after: CollectFn<V>;\n}\n\n/** Queue a collection function that runs later, when a commit() is parsed.\n * Collection functions are dropped with parser backtracking, so\n * only succsessful parses are collected.\n *\n * optionally tag the collection results\n * */\nexport function collect<N extends TagRecord, T, V>(\n  p: Parser<T, N>,\n  collectFn: CollectFn<V> | CollectPair<V>,\n  ctag?: string,\n): Parser<T, N> {\n  const origAfter: CollectFn<V> =\n    (collectFn as CollectPair<V>).after ?? collectFn;\n  const beforeFn = (collectFn as Partial<CollectPair<V>>).before;\n\n  let afterFn = origAfter;\n  if (ctag) {\n    afterFn = (cc: CollectContext) => {\n      const result = origAfter(cc);\n      addTagValue(cc.tags, ctag, result);\n      return result;\n    };\n  }\n\n  const debugName = ctag ? `${p.debugName}-${ctag}` : `${p.debugName}`;\n\n  const collectParser = parser(\n    `collect`,\n    (ctx: ParserContext): OptParserResult<T, N> => {\n      // if (tracing && ctx._trace) {\n      // const deepName = ctx._debugNames.join(\" > \");\n      // ctxLog(ctx, `collect ${deepName}`);\n      // }\n      const origStart = ctx.lexer.position();\n      if (beforeFn) {\n        queueCollectFn(ctx, origStart, beforeFn, `${debugName}.before`);\n      }\n\n      return runAndCollectAfter(p, ctx, afterFn, debugName);\n    },\n  );\n  collectParser._collection = true;\n  trackChildren(collectParser, p);\n  return collectParser;\n}\n\nexport function tagScope<A extends CombinatorArg>(\n  arg: A,\n): Parser<ResultFromArg<A>, NoTags> {\n  const p = parserArg(arg);\n  const sp = parser(\n    `tagScope`,\n    (ctx: ParserContext): OptParserResult<ResultFromArg<A>, any> => {\n      const origStart = ctx.lexer.position();\n      let origTags: TagRecord;\n      queueCollectFn(\n        ctx,\n        origStart,\n        (cc: CollectContext) => {\n          origTags = cloneTags(cc.tags);\n          cc.tags = {};\n        },\n        `scope.before ${p.debugName}`,\n      );\n      return runAndCollectAfter(\n        p,\n        ctx,\n        (cc: CollectContext) => {\n          cc.tags = origTags;\n        },\n        `tagScope`,\n      );\n    },\n  );\n  trackChildren(sp, p);\n  return sp;\n}\n\n/** duplicate a tags record */\nfunction cloneTags(tags: TagRecord): TagRecord {\n  const cloned = Object.entries(tags).map(([tag, values]) => {\n    return [tag, [...values!]];\n  });\n  return Object.fromEntries(cloned);\n}\n\n/** tag most recent collect result with a name that can be\n * referenced in later collection. */\nexport function ctag<N extends TagRecord, T>(\n  p: Parser<T, N>,\n  name: string,\n): Parser<T, N> {\n  const cp = parser(`ctag`, (ctx: ParserContext): OptParserResult<T, N> => {\n    return runAndCollectAfter(\n      p,\n      ctx,\n      (cc: CollectContext) => {\n        const valueEntry = last(cc._values);\n        addTagValue(cc.tags, name, valueEntry.value);\n      },\n      `ctag ${name}`,\n    );\n  });\n  trackChildren(cp, p);\n  return cp;\n}\n\n/** run the parser and if it succeeds, queue a provided function to run\n * during commit() */\nfunction runAndCollectAfter<T, N extends TagRecord>(\n  p: Parser<T, N>,\n  ctx: ParserContext,\n  collectFn: CollectFn<any>,\n  debugName: string = \"\",\n): OptParserResult<T, N> {\n  const origStart = ctx.lexer.position();\n  const result = p._run(ctx);\n  if (result) {\n    queueCollectFn(ctx, origStart, collectFn, debugName);\n  }\n  return result;\n}\n\nfunction queueCollectFn<T, N extends TagRecord>(\n  ctx: ParserContext,\n  origStart: number,\n  collectFn: CollectFn<any>,\n  debugName: string,\n) {\n  const srcPosition = refinePosition(ctx.lexer, origStart);\n  ctx._collect.push({\n    srcPosition,\n    collectFn,\n    debugName,\n  });\n}\n\nexport function pushOpenArray(cc: CollectContext): void {\n  cc._values.push({ value: null, openArray: [] });\n}\n\nexport function closeArray(cc: CollectContext): void {\n  const lastValue = last(cc._values);\n  if (lastValue.openArray === undefined)\n    console.log(\"---closeArray: no open array\");\n  cc._values.pop();\n  saveCollectValue(cc, lastValue.openArray);\n}\n\n/** tag parse results results with a name that can be\n * referenced in later collection. */\nexport function ptag<N extends TagRecord, T>(\n  p: Parser<T, N>,\n  name: string,\n): Parser<T, N> {\n  const cp = parser(`ptag`, (ctx: ParserContext): OptParserResult<T, N> => {\n    const origStart = ctx.lexer.position();\n    const result = p._run(ctx);\n\n    // tag the parser resuts\n    if (result) {\n      const tagFn = (ctx: CollectContext) =>\n        addTagValue(ctx.tags, name, result.value);\n      queueCollectFn(ctx, origStart, tagFn, `ptag ${name}`);\n    }\n    return result;\n  });\n  trackChildren(cp, p);\n  return cp;\n}\n\n/** add a tagged value to a TagRecord */\nfunction addTagValue(tags: TagRecord, name: string, value: any) {\n  if (tags[name] === undefined) {\n    tags[name] = [];\n  }\n  tags[name].push(value);\n}\n\n/** When the provided parser succeeds,\n * run any pending collect() fns */\nexport function runCollection(\n  _collect: CollectFnEntry<any>[],\n  app: AppState<any, any>,\n  lexer: Lexer,\n) {\n  const tags: Record<string, any> = {};\n  const { src } = lexer;\n  const _values: CollectValue[] = [{ value: null, openArray: undefined }];\n  // ctx._collect.forEach(entry => {\n  //   dlog(\"collect-list\", entry.debugName)\n  // });\n  const collectContext: CollectContext = {\n    tags,\n    src,\n    start: -1,\n    end: -1,\n    app,\n    _values,\n  };\n  _collect.forEach(entry => {\n    // dlog(\"commit\", {\n    //   entryName: entry.debugName,\n    //   entryFn: entry.collectFn,\n    // });\n    const { collectFn, srcPosition } = entry;\n    collectContext.start = srcPosition.start;\n    collectContext.end = srcPosition.end;\n    const collectResult = collectFn(collectContext);\n    saveCollectValue(collectContext, collectResult);\n  });\n}\n\nfunction saveCollectValue(cc: CollectContext, value: any) {\n  if (value !== undefined) {\n    const valueEntry = last(cc._values);\n    if (!valueEntry) console.log(\"----saveCollectValue: no valueEntry\");\n    if (valueEntry) valueEntry.value = value;\n    if (valueEntry?.openArray !== undefined) {\n      valueEntry.openArray.push(value);\n    }\n  }\n}\n\nfunction last<T>(elems: T[]): T {\n  return elems[elems.length - 1];\n}\n\n/** We've succeeded in a parse, so refine the start position to skip past ws\n * (we don't consume ws earlier, in case an inner parser wants to use different ws skipping)\n */\nfunction refinePosition(lexer: Lexer, origStart: number): CollectPosition {\n  const end = lexer.position();\n  lexer.position(origStart);\n  const start = lexer.skipIgnored();\n  lexer.position(end);\n  return { start: start, end };\n}\n","import { CombinatorArg, ParserFromArg } from \"./CombinatorTypes.js\";\nimport { Lexer } from \"./MatchingLexer.js\";\nimport {\n  collect,\n  CollectFn,\n  CollectFnEntry,\n  CollectPair,\n  ctag,\n  ptag,\n  runCollection,\n} from \"./ParserCollect.js\";\nimport { ParseError, parserArg } from \"./ParserCombinator.js\";\nimport { srcLog } from \"./ParserLogging.js\";\nimport {\n  debugNames,\n  parserLog,\n  TraceContext,\n  TraceOptions,\n  tracing,\n  withTraceLogging,\n} from \"./ParserTracing.js\";\nimport { mergeTags } from \"./ParserUtil.js\";\nimport { SrcMap } from \"./SrcMap.js\";\n\nexport interface AppState<C, S> {\n  /**\n   * Context for user written parsers while parsing. e.g. for nested #if state\n   * The context value is reset to its original value if the parser fails.\n   * Set context to a new immutable value to update (don't internally mutate context)\n   */\n  context: C;\n\n  /** typical place for user written parsers to accumulate results, e.g. syntax tree */\n  stable: S;\n}\n\nexport interface ParserInit<C = any, S = any> {\n  /** supply tokens to the parser*/\n  lexer: Lexer;\n\n  /** application specific context and result storage, shared with every parser */\n  appState?: AppState<C, S>;\n\n  /** set this to avoid infinite looping by failing after more than this many parsing steps */\n  maxParseCount?: number;\n\n  /** if this text was preprocessed */\n  srcMap?: SrcMap;\n}\n\n/* Information passed to the parsers during parsing */\nexport interface ParserContext<C = any, S = any> {\n  lexer: Lexer;\n\n  app: AppState<C, S>;\n\n  maxParseCount?: number;\n\n  /** during execution, debug trace logging */\n  _trace?: TraceContext;\n\n  /** during execution, count parse attempts to avoid infinite looping */\n  _parseCount: number;\n\n  _preParse: Parser<unknown>[];\n\n  /** positions where the preparse has failed to match, so no need to retry */\n  _preCacheFails: Map<Parser<unknown>, Set<number>>;\n\n  srcMap?: SrcMap; // TODO can we remove this and just use the one in the lexer?\n\n  /** current parser stack or parent parsers that called this one */\n  _debugNames: string[];\n\n  _collect: CollectFnEntry<any>[];\n}\n\nexport type TagRecord = Record<string | symbol, any[] | undefined>;\nexport type NoTags = Record<string | symbol, never>;\n\n/** Result from a parser */\nexport interface ParserResult<T, N extends TagRecord> {\n  /** result from this stage */\n  value: T;\n\n  /** tagged results from this stage and all child stages*/\n  tags: N;\n}\n\nexport interface ExtendedResult<\n  T,\n  N extends TagRecord = NoTags,\n  C = any,\n  S = any,\n> extends ParserResult<T, N> {\n  src: string;\n  srcMap?: SrcMap;\n  start: number;\n  end: number;\n  app: AppState<C, S>;\n  ctx: ParserContext<C, S>;\n}\n\n/** parsers return null if they don't match */\n// prettier-ignore\nexport type OptParserResult<T, N extends TagRecord> = \n    ParserResult<T, N> \n  | null;\n\n/** Internal parsing functions return a value and also a set of tagged results from contained parser  */\ntype ParseFn<T, N extends TagRecord> = (\n  context: ParserContext,\n) => OptParserResult<T, N>;\n\n/** options for creating a core parser */\nexport interface ParserArgs {\n  /** name to use for result in tagged results */\n  tag?: string | symbol;\n\n  /** name to use for trace logging */\n  traceName?: string;\n\n  /** use the debugName from this source parser for trace logging */\n  traceSrc?: Parser<any, any>;\n\n  /** enable trace logging */\n  trace?: TraceOptions;\n\n  /** true for elements without children like kind(), and text(),\n   * (to avoid intro log statement while tracing) */\n  terminal?: boolean;\n\n  /** true if preparsing should be disabled in this parser (and its descendants) */\n  preDisabled?: true; // LATER just detect preParse combinator?, rather than a flag here..\n\n  /** true if this is a collect parser (which .tag handles specially, to tag collect time results) */\n  _collection?: true;\n\n  /** set if the collection results are tagged */\n  _children?: Parser<any, any>[];\n}\n\ninterface ConstructArgs<T, N extends TagRecord> extends ParserArgs {\n  fn: ParseFn<T, N>;\n}\n\nexport type AnyParser = Parser<any, any>;\n\n/** a composable parsing element */\nexport class Parser<T, N extends TagRecord = NoTags> {\n  _traceName: string | undefined;\n  traceSrc: Parser<any, any> | undefined;\n  tagName: string | symbol | undefined;\n  traceOptions: TraceOptions | undefined;\n  terminal: boolean | undefined;\n  preDisabled: true | undefined;\n  _collection: true | undefined;\n  _children: Parser<any, any>[] | undefined;\n  fn: ParseFn<T, N>;\n\n  constructor(args: ConstructArgs<T, N>) {\n    this._traceName = args.traceName;\n    this.tagName = args.tag;\n    this.traceOptions = args.trace;\n    this.terminal = args.terminal;\n    this.traceSrc = args.traceSrc;\n    this.preDisabled = args.preDisabled;\n    this._collection = args._collection;\n    this._children = args._children;\n    this.fn = args.fn;\n  }\n\n  /** copy this parser with slightly different settings */\n  _cloneWith(p: Partial<ConstructArgs<T, N>>): Parser<T, N> {\n    return new Parser({\n      traceName: this._traceName,\n      traceSrc: this.traceSrc,\n      tag: this.tagName,\n      trace: this.traceOptions,\n      terminal: this.terminal,\n      preDisabled: this.preDisabled,\n      _collection: this._collection,\n      _children: this._children,\n      fn: this.fn,\n      ...p,\n    });\n  }\n\n  /** run the parser given an already created parsing context */\n  _run(context: ParserContext): OptParserResult<T, N> {\n    return runParser(this, context);\n  }\n\n  /**\n   * tag results with a name,\n   *\n   * tagged results can be retrived with map(r => r.tags.myName)\n   * note that tagged results are collected into an array,\n   * multiple matches with the same name (even from different nested parsers) accumulate\n   */\n  tag<K extends string | symbol>(name: K): Parser<T, N & { [key in K]: T[] }> {\n    const p = this._cloneWith({\n      tag: name,\n      traceSrc: this,\n      traceName: undefined,\n    });\n    return p as Parser<T, N & { [key in K]: T[] }>;\n  }\n\n  /** tag parse results */\n  ptag<K extends string>(name: K): Parser<T, N & { [key in K]: T[] }> {\n    return ptag(this, name) as Parser<T, N & { [key in K]: T[] }>;\n  }\n\n  /** tag collect results */\n  ctag<K extends string>(name: K): Parser<T, N & { [key in K]: T[] }> {\n    return ctag(this, name) as Parser<T, N & { [key in K]: T[] }>;\n  }\n\n  /** record a name for debug tracing */\n  traceName(name: string): Parser<T, N> {\n    return this._cloneWith({ traceName: name });\n  }\n\n  /** trigger tracing for this parser (and by default also this parsers descendants) */\n  trace(opts: TraceOptions = {}): Parser<T, N> {\n    return this._cloneWith({ trace: opts });\n  }\n\n  /** map results to a new value, or add to app state as a side effect.\n   * Return null to cause the parser to fail.\n   */\n  map<U>(fn: ParserMapFn<T, N, U>): Parser<U, N> {\n    return map(this, fn);\n  }\n\n  /** Queue a function that runs later, typically to collect AST elements from the parse.\n   * when a commit() is parsed.\n   * Collection functions are dropped with parser backtracking, so\n   * only succsessful parses are collected. */\n  collect<U>(fn: CollectFn<U> | CollectPair<U>, ctag?: string): Parser<T, N> {\n    return collect(this, fn, ctag);\n  }\n\n  /** switch next parser based on results */\n  toParser<U, V extends TagRecord>(\n    fn: ToParserFn<T, N, U, V>,\n  ): Parser<T | U, N & V> {\n    return toParser(this, fn);\n  }\n\n  /** start parsing */\n  parse(init: ParserInit): OptParserResult<T, N> {\n    try {\n      const {\n        lexer,\n        maxParseCount,\n        srcMap,\n        appState: app = { context: {}, stable: [] },\n      } = init;\n      const _collect: CollectFnEntry<any>[] = [];\n      const result = this._run({\n        lexer,\n        app,\n        srcMap,\n        _preParse: [],\n        _parseCount: 0,\n        _preCacheFails: new Map(),\n        maxParseCount,\n        _collect,\n        _debugNames: [],\n      });\n      if (result) runCollection(_collect, app, lexer);\n      return result;\n    } catch (e) {\n      if (e instanceof ParseError) {\n        return null;\n      }\n      throw e;\n    }\n  }\n\n  /** name of this parser for debugging/tracing */\n  get debugName(): string {\n    return (\n      this._traceName ??\n      this.traceSrc?._traceName ??\n      this.tagName?.toString() ??\n      \"parser\"\n    );\n  }\n}\n\n/** Create a Parser from a ParseFn\n * @param fn the parser function\n * @param args static arguments provided by the user as the parser is constructed\n */\nexport function parser<T, N extends TagRecord>(\n  traceName: string,\n  fn: ParseFn<T, N>,\n  terminal?: boolean,\n): Parser<T, N> {\n  const terminalArg = terminal ? { terminal } : {};\n  return new Parser<T, N>({ fn, traceName, ...terminalArg });\n}\n\n/** Create a Parser from a function that parses and returns a value (w/no child parsers) */\nexport function simpleParser<T>(\n  traceName: string,\n  fn: (ctx: ParserContext) => T | null | undefined,\n): Parser<T, NoTags> {\n  const parserFn: ParseFn<T, NoTags> = (ctx: ParserContext) => {\n    const r = fn(ctx);\n    if (r == null || r === undefined) return null;\n\n    return { value: r, tags: {} };\n  };\n\n  return parser(traceName, parserFn, true);\n}\n\n/** modify the trace name of this parser */\nexport function setTraceName(\n  parser: Parser<any, TagRecord>,\n  traceName: string,\n): void {\n  const origName = parser._traceName;\n  parser._traceName = `${traceName} (${origName})`;\n}\n\n/**\n * Execute a parser by running the core parsing fn given the parsing context\n * also:\n * . check for infinite loops\n * . log if tracing is enabled\n * . merge tagged results\n * . backtrack on failure\n * . rollback context on failure\n */\nfunction runParser<T, N extends TagRecord>(\n  p: Parser<T, N>,\n  context: ParserContext,\n): OptParserResult<T, N> {\n  const { lexer, _parseCount = 0, maxParseCount } = context;\n\n  // check for infinite looping\n  context._parseCount = _parseCount + 1;\n  // LATER counting tokens isn't so great to check for infinite looping. Possibly a count per parser per src position?\n  if (maxParseCount && _parseCount > maxParseCount) {\n    srcLog(lexer.src, lexer.position(), \"infinite loop? \", p.debugName);\n    return null;\n  }\n\n  const origAppContext = context.app.context;\n\n  // setup trace logging if enabled and active for this parser\n  const result = withTraceLogging<OptParserResult<T, N>>()(\n    context,\n    p.traceOptions,\n    runInContext,\n  );\n\n  return result;\n\n  function runInContext(ctx: ParserContext): OptParserResult<T, N> {\n    const origPosition = lexer.position();\n    const origCollectLength = ctx._collect.length;\n\n    if (debugNames) ctx._debugNames.push(p.debugName);\n    const traceSuccessOnly = ctx._trace?.successOnly;\n    if (!p.terminal && tracing && !traceSuccessOnly)\n      parserLog(`..${p.debugName}`);\n\n    const savePreParse = ctx._preParse;\n    if (!p.preDisabled) {\n      execPreParsers(ctx);\n    } else {\n      ctx._preParse = [];\n    }\n\n    // run the parser function for this stage\n    let result = p.fn(ctx);\n\n    if (debugNames) ctx._debugNames.pop();\n\n    if (result === null || result === undefined) {\n      // parser failed\n      if (tracing && !traceSuccessOnly) parserLog(`x ${p.debugName}`);\n      lexer.position(origPosition);\n      context.app.context = origAppContext;\n      result = null;\n      // if (ctx._collect.length > origCollectLength) {\n      //   const obsolete = ctx._collect.slice(origCollectLength);\n      //   const collectNames = obsolete.map(c => c.debugName);\n      //   dlog(\"removing\", { collectNames, inParser: p.debugName });\n      // }\n      ctx._collect.length = origCollectLength;\n    } else {\n      // parser succeeded\n      if (tracing) parserLog(`✓ ${p.debugName}`);\n      const value = result.value;\n      let tags;\n      if (p.tagName && result.value !== undefined) {\n        // merge tagged result (if user set a name for this stage's result)\n        tags = mergeTags(result.tags, {\n          [p.tagName]: [result.value],\n        }) as N;\n      } else {\n        tags = result.tags;\n      }\n      result = { value, tags };\n    }\n\n    ctx._preParse = savePreParse;\n\n    return result;\n  }\n}\n\nfunction execPreParsers(ctx: ParserContext): void {\n  const { _preParse, lexer } = ctx;\n\n  const ctxNoPre = { ...ctx, _preParse: [] };\n  _preParse.forEach(pre => {\n    const checkedCache = getPreParserCheckedCache(ctx, pre);\n\n    // exec each pre-parser until it fails\n    let position: number;\n    let preResult: OptParserResult<unknown, NoTags>;\n    do {\n      position = lexer.position();\n      if (checkedCache.has(position)) break;\n\n      preResult = pre._run(ctxNoPre);\n    } while (preResult !== null && preResult !== undefined);\n\n    checkedCache.add(position);\n    lexer.position(position); // reset position to end of last successful parse\n  });\n}\n\n/** get the cache of already checked positions for this pre-parser */\nfunction getPreParserCheckedCache(\n  ctx: ParserContext,\n  pre: Parser<unknown>,\n): Set<number> {\n  let cache = ctx._preCacheFails.get(pre);\n  if (!cache) {\n    cache = new Set();\n    ctx._preCacheFails.set(pre, cache);\n  }\n  return cache;\n}\n\ntype ParserMapFn<T, N extends TagRecord, U> = (\n  results: ExtendedResult<T, N>,\n) => U | null;\n\n/** return a parser that maps the current results */\nfunction map<T, N extends TagRecord, U>(\n  p: Parser<T, N>,\n  fn: ParserMapFn<T, N, U>,\n): Parser<U, N> {\n  const mapParser = parser(\n    `map`,\n    (ctx: ParserContext): OptParserResult<U, N> => {\n      const extended = runExtended(ctx, p);\n      if (!extended) return null;\n\n      const mappedValue = fn(extended);\n      if (mappedValue === null) return null;\n\n      return { value: mappedValue, tags: extended.tags };\n    },\n  );\n\n  trackChildren(mapParser, p);\n  return mapParser;\n}\n\ntype ToParserFn<T, N extends TagRecord, X, Y extends TagRecord> = (\n  results: ExtendedResult<T, N>,\n) => Parser<X, Y> | undefined;\n\nfunction toParser<T, N extends TagRecord, O, Y extends TagRecord>(\n  p: Parser<T, N>,\n  toParserFn: ToParserFn<T, N, O, Y>,\n): Parser<T | O, N & Y> {\n  const newParser: Parser<T | O, N & Y> = parser(\n    \"toParser\",\n    (ctx: ParserContext) => {\n      const extended = runExtended(ctx, p);\n      if (!extended) return null;\n\n      // run the supplied function to get a parser\n      const newParser = toParserFn(extended);\n\n      if (newParser === undefined) {\n        return extended;\n      }\n\n      // run the parser returned by the supplied function\n      const nextResult = newParser._run(ctx);\n      // TODO merge names record from p to newParser\n      return nextResult as any; // TODO fix typing\n    },\n  );\n  trackChildren(newParser, p);\n  return newParser;\n}\n\nconst emptySet = new Set<string>();\n\n/** set which token kinds to ignore while executing this parser and its descendants.\n * If no parameters are provided, no tokens are ignored. */\nexport function tokenSkipSet<T, N extends TagRecord>(\n  ignore: Set<string> | undefined | null,\n  p: Parser<T, N>,\n): Parser<T, N> {\n  const ignoreSet = ignore ?? emptySet;\n  const ignoreValues = [...ignoreSet.values()].toString() || \"(null)\";\n  const ignoreParser = parser(\n    `tokenSkipSet ${ignoreValues}`,\n    (ctx: ParserContext): OptParserResult<T, N> =>\n      ctx.lexer.withIgnore(ignoreSet, () => p._run(ctx)),\n  );\n\n  trackChildren(ignoreParser, p);\n  return ignoreParser;\n}\n\n/** attach a pre-parser to try parsing before this parser runs.\n * (e.g. to recognize comments that can appear almost anywhere in the main grammar) */\nexport function preParse<T, N extends TagRecord>(\n  pre: Parser<unknown>,\n  p: Parser<T, N>,\n): Parser<T, N> {\n  const newParser = parser(\n    \"preParse\",\n    (ctx: ParserContext): OptParserResult<T, N> => {\n      const newCtx = { ...ctx, _preParse: [pre, ...ctx._preParse] };\n      return p._run(newCtx);\n    },\n  );\n  trackChildren(newParser, pre, p);\n  return newParser;\n}\n\n/** disable a previously attached pre-parser,\n * e.g. to disable a comment preparser in a quoted string parser */\nexport function disablePreParse<A extends CombinatorArg>(\n  arg: A,\n): ParserFromArg<A> {\n  const parser = parserArg(arg);\n  return parser._cloneWith({ preDisabled: true });\n}\n\n/** run parser, return enriched results (to support map(), toParser()) */\nexport function runExtended<T, N extends TagRecord>(\n  ctx: ParserContext,\n  p: Parser<T, N>,\n): ExtendedResult<T, N> | null {\n  const origStart = ctx.lexer.position();\n\n  const origResults = p._run(ctx);\n  if (origResults === null) {\n    ctx.lexer.position(origStart);\n    return null;\n  }\n  const end = ctx.lexer.position();\n  const src = ctx.lexer.src;\n\n  // we've succeeded, so refine the start position to skip past ws\n  // (we don't consume ws earlier, in case an inner parser wants to use different ws skipping)\n  ctx.lexer.position(origStart);\n  const start = ctx.lexer.skipIgnored();\n  ctx.lexer.position(end);\n  const { app, srcMap } = ctx;\n\n  return { ...origResults, start, end, app, src, srcMap, ctx };\n}\n\n/** for pretty printing, track subsidiary parsers */\nexport function trackChildren(p: AnyParser, ...args: CombinatorArg[]) {\n  if (tracing) {\n    const kids = args.map(parserArg);\n    p._children = kids;\n  }\n}\n","import { Parser, ParserContext, setTraceName } from \"./Parser.js\";\n\n/** true if parser tracing is enabled */\nexport let tracing = false;\n\n/** true if tracing/logging messages should show character positions */\nexport let tracePos = false;\n\n/** true if parser debug names are enabled */\nexport let debugNames = false;\n\n/** base logger. (can be overriden to a capturing logger for tests) */\nexport let logger = console.log;\n\n/** no-op logger, for when tracing is disabled */\nconst noLog: typeof console.log = () => {};\n\n/** logger while tracing is active, otherwise noop */\nexport let parserLog: typeof console.log = noLog;\n\n/** enable tracing of parser activity via .trace() */\nexport function enableTracing(enable = true): void {\n  tracing = enable;\n  debugNames = enable;\n}\n\n/** for tests, to show character positions in log messages */\nexport function enableTracePos(enable = true): void {\n  tracePos = enable;\n}\n\n/** mutate the provided to set their trace names (if tracing is enabled) */\nexport function setTraceNames(parsers: Record<string, Parser<any, any>>): void {\n  if (tracing) {\n    Object.entries(parsers).forEach(([name, parser]) => {\n      setTraceName(parser, name);\n    });\n  }\n}\n\n/** options to .trace() on a parser stage */\nexport interface TraceOptions {\n  /** trace this parser, but not children */\n  shallow?: boolean;\n\n  /** don't trace this parser or its children, even if the parent is tracing */\n  hide?: boolean;\n\n  /** start tracing at this character position.\n   * Note that start should include ws skipped prior to the first token you want to see in the trace. */\n  start?: number;\n\n  end?: number;\n  /** trace less info */\n  successOnly?: boolean;\n}\n\n/** runtime stack info about currently active trace logging */\nexport interface TraceContext {\n  indent: number;\n  start?: number;\n  end?: number;\n  successOnly?: boolean;\n}\n\n/** use temporary logger for tests */\nexport function _withBaseLogger<T>(logFn: typeof console.log, fn: () => T): T {\n  const orig = logger;\n  try {\n    logger = logFn;\n    return fn();\n  } finally {\n    logger = orig;\n  }\n}\n\nexport interface TraceLogging {\n  tstate: ParserContext;\n}\n\ntype TraceLoggingFn<T> = (\n  ctx: any,\n  trace: TraceOptions | undefined,\n  fn: (ctx: ParserContext) => T,\n) => T;\n\nexport const withTraceLogging = <T>(): TraceLoggingFn<T> =>\n  tracing ? withTraceLoggingInternal : stubTraceLogging;\n\nfunction stubTraceLogging<T>(\n  ctx: any,\n  trace: TraceOptions | undefined,\n  fn: (ctx: ParserContext) => T,\n): T {\n  return fn(ctx);\n}\n\n/** setup trace logging inside a parser stage */\nfunction withTraceLoggingInternal<T>(\n  // _trace has trace settings from parent\n  ctx: ParserContext,\n  // trace has trace options set on this stage\n  trace: TraceOptions | undefined,\n  fn: (ctxWithTracing: ParserContext) => T,\n): T {\n  let { _trace } = ctx;\n\n  // log if we're starting or inheriting a trace and we're inside requested position range\n  let logging: boolean = (!!_trace || !!trace) && !trace?.hide;\n  if (logging) {\n    const { start = 0, end = 1e20 } = { ..._trace, ...trace };\n    const pos = ctx.lexer.position();\n    if (pos < start || pos > end) {\n      logging = false;\n    }\n  }\n\n  // if we're inheriting a trace, but this one is marked hide, stop inheriting further\n  if (_trace && (trace?.hide || trace?.shallow)) {\n    _trace = undefined;\n  }\n\n  // start inheriting tracing if deep trace is set on this stage\n  if (!_trace && trace && !trace?.shallow && !trace?.hide) {\n    _trace = { indent: 0, ...trace };\n  }\n\n  // setup appropriate logging for this stage\n  let tlog = noLog;\n  if (logging) {\n    const pad = currentIndent(_trace);\n    tlog = (...msgs: any[]) => {\n      logger(`${pad}${msgs[0]}`, ...msgs.slice(1));\n    };\n  }\n\n  // indent further for nested stages\n  if (_trace) {\n    _trace = { ..._trace, indent: _trace.indent + 1 };\n  }\n\n  return withLogger(tlog, () => fn({ ...ctx, _trace }));\n}\n\n/** padding for current indent level */\nfunction currentIndent(ctx?: TraceContext): string {\n  return \"  \".repeat(ctx?.indent || 0);\n}\n\n/** use temporary logger, to turn tracing on/off */\nfunction withLogger<T>(logFn: typeof console.log, fn: () => T): T {\n  const orig = parserLog;\n  try {\n    parserLog = logFn;\n    return fn();\n  } finally {\n    parserLog = orig;\n  }\n}\n","import { ExtendedResult, ParserContext } from \"./Parser.js\";\nimport { logger, parserLog, tracePos, tracing } from \"./ParserTracing.js\";\nimport { SrcMap } from \"./SrcMap.js\";\n\n/** log an message along with the source line and a caret indicating the error position in the line\n * @param pos is the position the source string, or if src is a SrcMap, then\n *  pos is the position in the dest (e.g. preprocessed) text\n */\nexport function srcLog(\n  src: string | SrcMap,\n  pos: number | [number, number],\n  ...msgs: any[]\n): void {\n  logInternal(logger, src, pos, ...msgs);\n}\n\n/** log a message along with src line, but only if tracing is active in the current parser */\nexport function srcTrace(\n  src: string | SrcMap,\n  pos: number | [number, number],\n  ...msgs: any[]\n): void {\n  logInternal(parserLog, src, pos, ...msgs);\n}\n\nexport function resultLog(\n  result: ExtendedResult<any, any>,\n  ...msgs: any[]\n): void {\n  const { src, srcMap, start, end } = result;\n  srcLog(srcMap ?? src, [start, end - 1], ...msgs);\n}\n\nexport function ctxLog(ctx: ParserContext, ...msgs: any[]): void {\n  const src = ctx.srcMap ?? ctx.lexer.src;\n  srcLog(src, ctx.lexer.position(), ...msgs);\n}\n\n/**\n * @param destPos  - position in the dest (e.g. preprocessed) text\n */\nfunction logInternal(\n  log: typeof console.log,\n  srcOrSrcMap: string | SrcMap,\n  destPos: number | [number, number],\n  ...msgs: any[]\n): void {\n  if (typeof srcOrSrcMap === \"string\") {\n    logInternalSrc(log, srcOrSrcMap, destPos, ...msgs);\n    return;\n  }\n  const { src, positions } = mapSrcPositions(srcOrSrcMap, destPos);\n\n  logInternalSrc(log, src, positions, ...msgs);\n}\n\ninterface SrcPositions {\n  positions: number | [number, number];\n  src: string;\n}\n\nfunction mapSrcPositions(\n  srcMap: SrcMap,\n  destPos: number | [number, number],\n): SrcPositions {\n  const srcPos = srcMap.mapPositions(...[destPos].flat());\n  const { src } = srcPos[0];\n\n  let positions: [number, number] | number;\n  if (srcPos[1]?.src === src) {\n    positions = srcPos.map(p => p.position) as [number, number];\n  } else {\n    positions = srcPos[0].position;\n  }\n\n  return { src, positions };\n}\n\nfunction logInternalSrc(\n  log: typeof console.log,\n  src: string,\n  pos: number | [number, number],\n  ...msgs: any[]\n): void {\n  log(...msgs);\n  const { line, lineNum, linePos, linePos2 } = srcLine(src, pos);\n  if (tracing && tracePos) {\n    // removed on production build\n    const posStr = tracePos ? `  Pos ${pos}` : \"\";\n    log(line, `  Ln ${lineNum}${posStr}`);\n  } else {\n    log(line, `  Ln ${lineNum}`);\n  }\n  const caret = carets(linePos, linePos2);\n  log(caret);\n}\n\nfunction carets(linePos: number, linePos2?: number): string {\n  const firstCaret = \" \".repeat(linePos) + \"^\";\n  let secondCaret = \"\";\n  if (linePos2 && linePos2 > linePos) {\n    secondCaret = \" \".repeat(linePos2 - linePos - 1) + \"^\";\n  }\n  return firstCaret + secondCaret;\n}\n\n// map from src strings to line start positions\nconst startCache = new Map<string, number[]>();\n\ninterface SrcLine {\n  /** src line w/o newline */\n  line: string;\n\n  /** requested position relative to line start */\n  linePos: number;\n\n  /** requested position2 relative to line start */\n  linePos2?: number;\n\n  /** line number in the src (first line is #1) */\n  lineNum: number;\n}\n\n/** return the line in the src containing a given character postion */\nexport function srcLine(\n  src: string,\n  position: number | [number, number],\n): SrcLine {\n  let pos: number;\n  let pos2: number | undefined;\n  if (typeof position === \"number\") {\n    pos = position;\n  } else {\n    [pos, pos2] = position;\n  }\n  const starts = getStarts(src);\n\n  let start = 0;\n  let end = starts.length - 1;\n\n  // short circuit search if pos is after last line start\n  if (pos >= starts[end]) {\n    start = end;\n  }\n\n  // binary search to find start,end positions that surround provided pos\n  while (start + 1 < end) {\n    const mid = (start + end) >> 1;\n    if (pos >= starts[mid]) {\n      start = mid;\n    } else {\n      end = mid;\n    }\n  }\n\n  let linePos2: number | undefined;\n  if (pos2 !== undefined && pos2 >= starts[start] && pos2 < starts[end]) {\n    linePos2 = pos2 - starts[start];\n  }\n\n  // get line with possible trailing newline\n  const lineNl = src.slice(starts[start], starts[start + 1] || src.length);\n\n  // return line without trailing newline\n  const line = lineNl.slice(-1) === \"\\n\" ? lineNl.slice(0, -1) : lineNl;\n\n  return { line, linePos: pos - starts[start], linePos2, lineNum: start + 1 };\n}\n\n/** return an array of the character positions of the start of each line in the src.\n * cached to avoid recomputation */\nfunction getStarts(src: string): number[] {\n  const found = startCache.get(src);\n  if (found) return found;\n  const starts = [...src.matchAll(/\\n/g)].map(m => m.index! + 1);\n  starts.unshift(0);\n  startCache.set(src, starts);\n\n  return starts;\n}\n","import { srcTrace } from \"./ParserLogging.js\";\nimport { tracing } from \"./ParserTracing.js\";\nimport { SrcMap } from \"./SrcMap.js\";\nimport { Token, TokenMatcher } from \"./TokenMatcher.js\";\n\nexport interface Lexer {\n  /** return the next token, advancing the the current position */\n  next(): Token | undefined;\n\n  /** run a function with a substitute tokenMatcher */\n  withMatcher<T>(newMatcher: TokenMatcher, fn: () => T): T;\n\n  /** run a function with a substitute set of token kinds to ignore */\n  withIgnore<T>(newIgnore: Set<string>, fn: () => T): T;\n\n  /** get or set the current position in the src */\n  position(pos?: number): number;\n\n  /** true if the parser is at the end of the src string */\n  eof(): boolean;\n\n  /** skip past any ignored tokens and return the current position in the src */\n  skipIgnored(): number;\n\n  /** src text */\n  src: string;\n}\n\ninterface MatcherStackElem {\n  matcher: TokenMatcher;\n  ignore: Set<string>;\n}\n\nexport function matchingLexer(\n  src: string,\n  rootMatcher: TokenMatcher,\n  ignore = new Set([\"ws\"]),\n  srcMap?: SrcMap,\n): Lexer {\n  let matcher = rootMatcher;\n  const matcherStack: MatcherStackElem[] = [];\n\n  matcher.start(src);\n\n  function next(): Token | undefined {\n    const start = matcher.position();\n    const { token } = toNextToken();\n    if (token && tracing) {\n      const text = quotedText(token?.text);\n      srcTrace(srcMap ?? src, start, `: ${text} (${token?.kind})`);\n    }\n    return token;\n  }\n\n  function skipIgnored(): number {\n    const { p } = toNextToken();\n\n    // back up to the position before the first non-ignored token\n    matcher.position(p);\n    return p;\n  }\n\n  /** Advance to the next token\n   * @return the token, and the position at the start of the token (after ignored ws) */\n  function toNextToken(): { p: number; token?: Token } {\n    let p = matcher.position();\n    if (eof()) return { p };\n\n    // advance til we find a token we're not ignoring\n    let token = matcher.next();\n    while (token && ignore.has(token.kind)) {\n      p = matcher.position(); // save position before the token\n      if (eof()) return { p };\n      token = matcher.next();\n    }\n    return { p, token };\n  }\n\n  function pushMatcher(newMatcher: TokenMatcher, newIgnore: Set<string>): void {\n    const position = matcher.position();\n    matcherStack.push({ matcher, ignore });\n    newMatcher.start(src, position);\n    matcher = newMatcher;\n    ignore = newIgnore;\n  }\n\n  function popMatcher(): void {\n    const position = matcher.position();\n    const elem = matcherStack.pop();\n    if (!elem) {\n      console.error(\"too many pops\");\n      return;\n    }\n    matcher = elem.matcher;\n    ignore = elem.ignore;\n\n    matcher.position(position);\n  }\n\n  function position(pos?: number): number {\n    if (pos !== undefined) {\n      matcher.start(src, pos);\n    }\n    return matcher.position();\n  }\n\n  function withMatcher<T>(newMatcher: TokenMatcher, fn: () => T): T {\n    return withMatcherIgnore(newMatcher, ignore, fn);\n  }\n\n  function withIgnore<T>(newIgnore: Set<string>, fn: () => T): T {\n    return withMatcherIgnore(matcher, newIgnore, fn);\n  }\n\n  function withMatcherIgnore<T>(\n    tokenMatcher: TokenMatcher,\n    ignore: Set<string>,\n    fn: () => T,\n  ): T {\n    pushMatcher(tokenMatcher, ignore);\n    const result = fn();\n    popMatcher();\n    return result;\n  }\n\n  function eof(): boolean {\n    return matcher.position() === src.length;\n  }\n\n  return {\n    next,\n    position,\n    withMatcher,\n    withIgnore,\n    eof,\n    skipIgnored,\n    src,\n  };\n}\n\nexport function quotedText(text?: string): string {\n  return text ? `'${text.replace(/\\n/g, \"\\\\n\")}'` : \"\";\n}\n","// TODO add file or path name to src\n\nexport interface SrcMapEntry {\n  src: string;\n  srcStart: number;\n  srcEnd: number;\n  destStart: number;\n  destEnd: number;\n}\n\nexport interface SrcPosition {\n  src: string;\n  position: number;\n}\n\n/** map text ranges in multiple src texts to a single dest text */\nexport class SrcMap {\n  entries: SrcMapEntry[];\n  dest: string;\n\n  constructor(dest: string, entries: SrcMapEntry[] = []) {\n    this.dest = dest;\n    this.entries = entries;\n  }\n\n  /** add a new mapping from src to dest ranges.\n   * entries must be non-overlapping in the destination\n   */\n  addEntries(newEntries: SrcMapEntry[]): void {\n    this.entries.push(...newEntries);\n  }\n\n  /** given positions in the dest string,\n   * @return corresponding positions in the src strings */\n  mapPositions(...positions: number[]): SrcPosition[] {\n    return positions.map(p => this.destToSrc(p));\n  }\n\n  /** internally compress adjacent entries where possible */\n  compact(): void {\n    if (!this.entries.length) return;\n    let prev = this.entries[0];\n    const newEntries: SrcMapEntry[] = [prev];\n\n    for (let i = 1; i < this.entries.length; i++) {\n      const e = this.entries[i];\n      if (\n        e.src === prev.src &&\n        prev.destEnd === e.destStart &&\n        prev.srcEnd === e.srcStart\n      ) {\n        // combine adjacent range entries into one\n        prev.destEnd = e.destEnd;\n        prev.srcEnd = e.srcEnd;\n      } else {\n        newEntries.push(e);\n        prev = e;\n      }\n    }\n    this.entries = newEntries;\n  }\n\n  /** sort in destination order */\n  sort(): void {\n    this.entries.sort((a, b) => a.destStart - b.destStart);\n  }\n\n  /** This SrcMap's destination is a src for the other srcmap,\n   * so combine the two and return the result.\n   */\n  merge(other: SrcMap): SrcMap {\n    if (other === this) return this;\n\n    const mappedEntries = other.entries.filter(e => e.src === this.dest);\n    if (mappedEntries.length === 0) {\n      console.log(\"other source map does not link to this one\");\n      // dlog({ this: this });\n      // dlog({ other });\n      return other;\n    }\n    sortSrc(mappedEntries);\n    const newEntries = mappedEntries.map(e => {\n      const { src, position: srcStart } = this.destToSrc(e.srcStart);\n      const { src: endSrc, position: srcEnd } = this.destToSrc(e.srcEnd);\n      if (endSrc !== src) throw new Error(\"NYI, need to split\");\n      const newEntry: SrcMapEntry = {\n        src,\n        srcStart,\n        srcEnd,\n        destStart: e.destStart,\n        destEnd: e.destEnd,\n      };\n      // dlog({ newEntry });\n      return newEntry;\n    });\n\n    const otherSources = other.entries.filter(e => e.src !== this.dest);\n\n    const newMap = new SrcMap(other.dest, [...otherSources, ...newEntries]);\n    newMap.sort();\n    return newMap;\n  }\n\n  /**\n   * @param entries should be sorted in destStart order\n   * @return the source position corresponding to a provided destination position\n   *\n   */\n  destToSrc(destPos: number): SrcPosition {\n    const entry = this.entries.find(\n      e => e.destStart <= destPos && e.destEnd >= destPos,\n    );\n    if (!entry) {\n      /* TODO this console.log triggers during debugging, now that preprocessing doesn't produce a real srcMap. \n        remove the warning or fix the reason for the warning?\n       */\n\n      // console.log(`no SrcMapEntry for dest position: ${destPos}`);\n      return {\n        src: this.dest,\n        position: destPos,\n      };\n    }\n    return {\n      src: entry.src,\n      position: entry.srcStart + destPos - entry.destStart,\n    };\n  }\n}\n\n/** sort entries in place by src start position */\nfunction sortSrc(entries: SrcMapEntry[]): void {\n  entries.sort((a, b) => a.srcStart - b.srcStart);\n}\n","import { SrcMap, SrcMapEntry } from \"./SrcMap.js\";\nimport { dlog } from \"berry-pretty\";\n\n// TODO untested\n\n/**\n * Incrementally append to a string, tracking source references\n */\nexport class SrcMapBuilder {\n  #fragments: string[] = [];\n  #destLength = 0;\n  #entries: SrcMapEntry[] = [];\n\n  /** append a string fragment to the destination string */\n  // TODO allow for src file name not just string (e.g. SrcModule)\n  add(fragment: string, src: string, srcStart: number, srcEnd: number): void {\n    // dlog({fragment})\n    const destStart = this.#destLength;\n    this.#destLength += fragment.length;\n    const destEnd = this.#destLength;\n\n    this.#fragments.push(fragment);\n    this.#entries.push({ src, srcStart, srcEnd, destStart, destEnd });\n  }\n\n  /** append a synthetic newline, mapped to previous source location */\n  addNl(): void {\n    const lastEntry = this.#entries.slice(-1)[0] ?? {};\n    const { src = \"?\", srcStart = 0, srcEnd = 0 } = lastEntry;\n    this.add(\"\\n\", src, srcStart, srcEnd);\n  }\n\n  /** copy a string fragment from the src to the destination string */\n  addCopy(src: string, srcStart: number, srcEnd: number): void {\n    const fragment = src.slice(srcStart, srcEnd);\n    this.add(fragment, src, srcStart, srcEnd);\n  }\n\n  /** return a SrcMap */\n  build(): SrcMap {\n    // dlog({ fragments: this.#fragments });\n    const map = new SrcMap(this.#fragments.join(\"\"), this.#entries);\n    map.compact();\n    return map;\n  }\n}\n","import { srcLog } from \"./ParserLogging.js\";\n\nexport interface Token {\n  kind: string;\n  text: string;\n}\n\n/** a TokenMatcher with each token kind exposed as a string property */\nexport type FullTokenMatcher<T> = TokenMatcher & {\n  [Property in keyof T]: string;\n};\n\nexport interface TokenMatcher {\n  start(src: string, position?: number): void;\n  next(): Token | undefined;\n  position(position?: number): number;\n  _debugName?: string;\n}\n\n/** size limited key value cache */\nclass Cache<K, V> extends Map<K, V> {\n  constructor(private readonly max: number) {\n    super();\n  }\n\n  set(k: K, v: V): this {\n    if (this.size > this.max) {\n      const first = this.keys().next().value;\n      if (first) this.delete(first);\n    }\n    return super.set(k, v);\n  }\n}\n\nexport function tokenMatcher<T extends Record<string, string | RegExp>>(\n  matchers: T,\n  debugName = \"matcher\",\n): FullTokenMatcher<T> {\n  const groups: string[] = Object.keys(matchers);\n  let src: string;\n  // cache of tokens by position, so we don't have to reparse after backtracking\n  const cache = new Cache<number, Token>(5);\n  const expParts = Object.entries(matchers).map(toRegexSource).join(\"|\");\n  const exp = new RegExp(expParts, \"midgu\");\n\n  function start(text: string, position = 0): void {\n    if (src !== text) {\n      cache.clear();\n    }\n    src = text;\n    exp.lastIndex = position;\n  }\n\n  function next(): Token | undefined {\n    if (src === undefined) {\n      throw new Error(\"start() first\");\n    }\n    const startPos = exp.lastIndex;\n    const found = cache.get(startPos);\n    if (found) {\n      exp.lastIndex += found.text.length;\n      return found;\n    }\n\n    const matches = exp.exec(src);\n    const matchedIndex = findGroupDex(matches?.indices);\n    if (matchedIndex) {\n      const { startEnd, groupDex } = matchedIndex;\n      const kind = groups[groupDex];\n      const text = src.slice(startEnd[0], startEnd[1]);\n      const token = { kind, text };\n      if (startPos != startEnd[0]) {\n        // TODO report filename as well\n        // regex didn't recognize some characters and skipped ahead to match\n        srcLog(\n          src,\n          startPos,\n          `tokens ${debugName} skipped: '${src.slice(startPos, startEnd[0])}' to get to: '${text}'`,\n        );\n        throw new Error(\"token matcher should match all input\");\n      }\n      cache.set(startPos, token);\n      return token;\n    }\n  }\n\n  function position(pos?: number): number {\n    if (pos !== undefined) {\n      exp.lastIndex = pos;\n    }\n    return exp.lastIndex;\n  }\n\n  const keyEntries = groups.map(k => [k, k]);\n  const keys = Object.fromEntries(keyEntries);\n  return {\n    ...keys,\n    start,\n    next,\n    position,\n    _debugName: debugName,\n  } as FullTokenMatcher<T>;\n}\n\ninterface MatchedIndex {\n  startEnd: [number, number];\n  groupDex: number;\n}\n\nfunction findGroupDex(\n  indices: RegExpIndicesArray | undefined,\n): MatchedIndex | undefined {\n  if (indices) {\n    for (let i = 1; i < indices.length; i++) {\n      const startEnd = indices[i];\n      if (startEnd) {\n        return { startEnd, groupDex: i - 1 };\n      }\n    }\n  }\n}\n\nfunction toRegexSource(nameExp: [string, RegExp | string]): string {\n  const [name, e] = nameExp;\n  if (typeof e === \"string\") {\n    const expSrc = `(${escapeRegex(e)})`;\n    verifyNonCapturing(name, new RegExp(expSrc));\n    return expSrc;\n  } else {\n    verifyNonCapturing(name, e);\n    return `(${e.source})`;\n  }\n}\n\nfunction verifyNonCapturing(name: string, exp: RegExp): void {\n  const willMatch = new RegExp(\"|\" + exp.source);\n  const result = willMatch.exec(\"\")!;\n  if (result.length > 1) {\n    throw new Error(\n      `match expression groups must be non-capturing: ${name}: /${exp.source}/. Use (?:...) instead.`,\n    );\n  }\n}\n\nconst regexSpecials = /[$+*.?|(){}[\\]\\\\/^]/g;\n\nexport function escapeRegex(s: string): string {\n  return s.replace(regexSpecials, \"\\\\$&\");\n}\n\n/** @return a regexp to match any of the space separated tokens in the provided string.\n *\n * regex special characters are escaped in strings are escaped, and the matchers\n * are sorted by length so that longer matches are preferred.\n */\nexport function matchOneOf(syms: string): RegExp {\n  const symbolList = syms.split(\" \").sort((a, b) => b.length - a.length);\n  const escaped = symbolList.filter(s => s).map(escapeRegex);\n  return new RegExp(escaped.join(\"|\"));\n}\n","import { matchOneOf, tokenMatcher } from \"mini-parse\";\n\n// https://www.w3.org/TR/WGSL/#blankspace-and-line-breaks\n/** New lines */\nexport const eol = /[\\n\\v\\f\\u{0085}\\u{2028}\\u{2029}]|\\r\\n?/u;\n/** Whitespaces including new lines */\nexport const blankspaces =\n  /[ \\t\\n\\v\\f\\r\\u{0085}\\u{200E}\\u{200F}\\u{2028}\\u{2029}]+/u;\n\nexport const directive = /#[a-zA-Z_]\\w*/;\n\nconst symbolSet =\n  \"& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - --\" +\n  \" . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^=\" +\n  // For the _ = expr; syntax\n  \" _\";\n\nconst symbol = matchOneOf(symbolSet);\nconst quote = /[\"']/;\n\nexport const ident =\n  /(?:(?:[_\\p{XID_Start}][\\p{XID_Continue}]+)|(?:[\\p{XID_Start}]))/u;\n\nexport const digits = new RegExp(\n  // decimal_float_literal\n  /(?:0[fh])|(?:[1-9][0-9]*[fh])/.source +\n    /|(?:[0-9]*\\.[0-9]+(?:[eE][+-]?[0-9]+)?[fh]?)/.source +\n    /|(?:[0-9]+\\.[0-9]*(?:[eE][+-]?[0-9]+)?[fh]?)/.source +\n    /|(?:[0-9]+[eE][+-]?[0-9]+[fh]?)/.source +\n    // hex_float_literal\n    /|(?:0[xX][0-9a-fA-F]*\\.[0-9a-fA-F]+(?:[pP][+-]?[0-9]+[fh]?)?)/.source +\n    /|(?:0[xX][0-9a-fA-F]+\\.[0-9a-fA-F]*(?:[pP][+-]?[0-9]+[fh]?)?)/.source +\n    /|(?:0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?)/.source +\n    // hex_int_literal\n    /|(?:0[xX][0-9a-fA-F]+[iu]?)/.source +\n    // decimal_int_literal\n    /|(?:0[iu]?)|(?:[1-9][0-9]*[iu]?)/.source,\n);\n\nconst textureStorage = matchOneOf(\n  \"texture_strorage_1d texture_storage_2d texture_storage_2d_array texture_storage_3d\",\n);\n\n/** main set of tokens for WGSL */\nexport const mainTokens = tokenMatcher(\n  {\n    directive,\n    textureStorage,\n    ident,\n    digits,\n    symbol,\n    quote,\n    ws: blankspaces,\n  },\n  \"main\",\n);\n\nexport const bracketTokens = tokenMatcher(\n  {\n    bracket: /<|>/,\n    ws: blankspaces,\n    other: /[^<>]+/,\n  },\n  \"bracket\",\n);\n\n/** matching tokens at the start of a '//' line comment that might contain #directives */\nexport const lineCommentTokens = tokenMatcher(\n  {\n    ws: /[ \\t]+/, // note ws must be before notEol\n    notEol: /[^\\n]+/,\n    eol,\n  },\n  \"lineComment\",\n);\n\n/** matching tokens while parsing directive parameters #export foo(param1, param2) */\nexport const argsTokens = tokenMatcher(\n  {\n    directive,\n    quote,\n    relPath: /[.][/\\w._-]+/,\n    arg: /[\\w._-]+/,\n    symbol,\n    ws: /[ \\t]+/, // don't include \\n, so we can find eol separately\n    eol,\n  },\n  \"argsTokens\",\n);\n\nexport const rootWs = tokenMatcher(\n  {\n    blanks: /\\s+/,\n    other: /[^\\s]+/,\n  },\n  \"rootWs\",\n);\n","import { DeclarationElem, RefIdentElem } from \"./AbstractElems.ts\";\nimport { WeslAST } from \"./ParseWESL.ts\";\n\nexport interface SrcModule {\n  /** module path \"rand_pkg::sub::foo\", or \"package::main\" */\n  modulePath: string; // TODO drop this?\n\n  /** file path to the module for user error reporting e.g \"rand_pkg:sub/foo.wesl\", or \"./sub/foo.wesl\" */\n  filePath: string;\n\n  /** original src for module */\n  src: string;\n}\n\n/** a src declaration or reference to an ident */\nexport type Ident = DeclIdent | RefIdent;\n\nexport type Conditions = Record<string, boolean>;\n\ninterface IdentBase {\n  originalName: string; // name in the source code for ident matching (may be mangled in the output)\n  conditions?: Conditions; // conditions under which this ident is valid (combined from all containing elems)\n  id?: number; // for debugging\n}\n\nexport interface RefIdent extends IdentBase {\n  kind: \"ref\";\n  refersTo?: Ident; // import or decl ident in scope to which this ident refers. undefined before binding\n  std?: true; // true if this is a standard wgsl identifier (like sin, or u32)\n  ast: WeslAST; // AST from module that contains this ident (to find imports during decl binding)\n  scope: Scope; // scope containing this reference (bind to decls starting from this scope)\n  refIdentElem?: RefIdentElem; // for error reporting\n}\n\nexport interface DeclIdent extends IdentBase {\n  kind: \"decl\";\n  mangledName?: string; // name in the output code\n  declElem?: DeclarationElem; // link to AST so that we can traverse scopes and know what elems to emit // TODO make separate GlobalDecl kind with this required\n  scope: Scope; // scope for the references within this declaration\n}\n\nexport type ScopeKind =\n  | \"module-scope\" // root scope for a module (file)\n  | \"body-scope\"; // a scope inside the module (fn body, nested block, etc.)\n\n/** tree of ident references, organized by lexical scope */\nexport interface Scope {\n  id?: number; // for debugging\n  idents: Ident[]; // idents found in lexical order in this scope\n  parent: Scope | null; // null for root scope in a module\n  children: Scope[];\n  kind: ScopeKind;\n}\n\nexport function resetScopeIds() {\n  // for debugging\n  scopeId = 0;\n}\n\nlet scopeId = 0; // for debugging\n\n/** make a new Scope object */\nexport function makeScope(s: Omit<Scope, \"id\">): Scope {\n  return { ...s, id: scopeId++ };\n}\n\nexport interface RootAndScope {\n  rootScope: Scope;\n  scope: Scope;\n}\n\nexport function emptyScope(kind: ScopeKind): Scope {\n  return makeScope({ idents: [], parent: null, children: [], kind });\n}\n\nexport function emptyBodyScope(parent: Scope): Scope {\n  return makeScope({ kind: \"body-scope\", idents: [], parent, children: [] });\n}\n\n/** For debugging,\n * @return true if a scope is in the rootScope tree somewhere */\nexport function containsScope(rootScope: Scope, scope: Scope): boolean {\n  if (scope === rootScope) {\n    return true;\n  }\n  for (const child of rootScope.children) {\n    if (containsScope(child, scope)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function exportDecl(scope: Scope, name: string): DeclIdent | undefined {\n  for (const ident of scope.idents) {\n    if (ident.originalName === name && ident.kind === \"decl\") {\n      return ident;\n    }\n  }\n}\n","import { CollectContext, CollectPair, tracing } from \"mini-parse\";\nimport {\n  AbstractElem,\n  AliasElem,\n  ConstElem,\n  DeclarationElem,\n  DeclIdentElem,\n  ElemWithContents,\n  FnElem,\n  GlobalVarElem,\n  ImportElem,\n  ModuleElem,\n  NameElem,\n  OverrideElem,\n  ParamElem,\n  RefIdentElem,\n  StructElem,\n  StructMemberElem,\n  TextElem,\n  VarElem,\n} from \"./AbstractElems.ts\";\nimport {\n  ImportTree,\n  PathSegment,\n  SegmentList,\n  SimpleSegment,\n} from \"./ImportTree.ts\";\nimport {\n  StableState,\n  WeslAST,\n  WeslParseContext,\n  WeslParseState,\n} from \"./ParseWESL.ts\";\nimport { DeclIdent, emptyBodyScope, RefIdent, Scope } from \"./Scope.ts\";\n\n/** add an elem to the .contents array of the currently containing element */\nfunction addToOpenElem(cc: CollectContext, elem: AbstractElem): void {\n  const weslContext: WeslParseContext = cc.app.context;\n  const { openElems } = weslContext;\n  if (openElems && openElems.length) {\n    const open = openElems[openElems.length - 1];\n    open.contents.push(elem);\n  }\n}\n\n/** create reference Ident and add to context */\nexport function refIdent(cc: CollectContext): RefIdentElem {\n  const { src, start, end } = cc;\n  const app = cc.app as WeslParseState;\n  const { scope } = app.context;\n  const { srcModule } = app.stable;\n  const originalName = src.slice(start, end);\n\n  const kind = \"ref\";\n  const ident: RefIdent = { kind, originalName, ast: cc.app.stable, scope };\n  const identElem: RefIdentElem = { kind, start, end, srcModule, ident };\n  ident.refIdentElem = identElem;\n\n  saveIdent(cc, identElem);\n  return identElem;\n}\n\n/** create declaration Ident and add to context */\nexport function declIdentElem(cc: CollectContext): DeclIdentElem {\n  const { src, start, end } = cc;\n  const app = cc.app as WeslParseState;\n  const { srcModule } = app.stable;\n  const originalName = src.slice(start, end);\n\n  const kind = \"decl\";\n  const declElem = null as any; // we'll set declElem later\n  const ident: DeclIdent = { kind, originalName, scope: null as any, declElem }; // we'll set declElem later\n  const identElem: DeclIdentElem = { kind, start, end, srcModule, ident };\n\n  saveIdent(cc, identElem);\n  return identElem;\n}\n\nlet identId = 0;\n/** add Ident to current open scope, add IdentElem to current open element */\nfunction saveIdent(\n  cc: CollectContext,\n  identElem: RefIdentElem | DeclIdentElem,\n) {\n  const { ident } = identElem;\n  ident.id = identId++;\n  const weslContext: WeslParseContext = cc.app.context;\n  weslContext.scope.idents.push(ident);\n  addToOpenElem(cc, identElem);\n}\n\n/** start a new child Scope */\nfunction startScope(cc: CollectContext) {\n  const { scope } = cc.app.context as WeslParseContext;\n  const newScope = emptyBodyScope(scope);\n  scope.children.push(newScope);\n  cc.app.context.scope = newScope;\n  // srcLog(cc.src, cc.start, \"startScope\", newScope.id);\n}\n\n/* close current Scope and set current scope to parent */\nfunction completeScope(cc: CollectContext): Scope {\n  const weslContext = cc.app.context as WeslParseContext;\n  const completedScope = weslContext.scope;\n  // srcLog(cc.src, cc.start, \"completeScope\", completedScope.id);\n  // console.log(scopeIdentTree(completedScope));\n  const { parent } = completedScope;\n  if (parent) {\n    weslContext.scope = parent;\n  } else if (tracing) {\n    const { idents, kind } = completedScope;\n    console.log(\"ERR: completeScope, no parent scope\", { kind, idents });\n  }\n  return completedScope;\n}\n\n// prettier-ignore\nexport type OpenElem<T extends AbstractElem = AbstractElem> = \n  Pick< T, \"kind\" > & { contents: AbstractElem[] };\n\n// prettier-ignore\nexport type PartElem<T extends AbstractElem = AbstractElem> = \n  Pick< T, \"kind\" | \"start\" | \"end\" > & { contents: AbstractElem[] };\n\ntype VarLikeElem =\n  | GlobalVarElem\n  | VarElem\n  | ConstElem\n  | OverrideElem\n  | AliasElem;\n\nexport function collectVarLike<E extends VarLikeElem>(\n  kind: E[\"kind\"],\n): CollectPair<E> {\n  return collectElem(kind, (cc: CollectContext, openElem: PartElem<E>) => {\n    // dlog({ tags: [...Object.keys(cc.tags)] });\n    const name = cc.tags.declIdent?.[0] as DeclIdentElem;\n    const typeRef = cc.tags.typeRef?.[0] as RefIdentElem;\n    const decl_scope = cc.tags.decl_scope?.[0] as Scope;\n    const partElem = { ...openElem, name, typeRef };\n    const varElem = withTextCover(partElem, cc) as E;\n    (name.ident as DeclIdent).declElem = varElem as DeclarationElem;\n    name.ident.scope = decl_scope;\n    return varElem;\n  });\n}\n\nexport function collectFn(): CollectPair<FnElem> {\n  return collectElem(\"fn\", (cc: CollectContext, openElem: PartElem<FnElem>) => {\n    const name = cc.tags.fnName?.[0] as DeclIdentElem;\n    const body_scope = cc.tags.body_scope?.[0] as Scope;\n    const params: ParamElem[] = cc.tags.fnParam?.flat(3) ?? [];\n    const returnType: RefIdentElem | undefined = cc.tags.returnType?.flat(3)[0];\n    const partElem: FnElem = { ...openElem, name, params, returnType };\n    const fnElem = withTextCover(partElem, cc);\n    (name.ident as DeclIdent).declElem = fnElem;\n    name.ident.scope = body_scope;\n\n    return fnElem;\n  });\n}\n\nexport function collectFnParam(): CollectPair<ParamElem> {\n  return collectElem(\n    \"param\",\n    (cc: CollectContext, openElem: PartElem<ParamElem>) => {\n      const name = cc.tags.paramName?.[0]! as DeclIdentElem;\n      const typeRef = cc.tags.typeRef?.[0]! as RefIdentElem;\n      const elem: ParamElem = { ...openElem, name, typeRef };\n      const paramElem = withTextCover(elem, cc);\n      name.ident.declElem = paramElem;\n\n      // name.ident.scope = pseudoScope(typeRef); // TODO set scope for param?\n      return paramElem;\n    },\n  );\n}\n\nexport function collectStruct(): CollectPair<StructElem> {\n  return collectElem(\n    \"struct\",\n    (cc: CollectContext, openElem: PartElem<StructElem>) => {\n      const name = cc.tags.typeName?.[0] as DeclIdentElem;\n      const members = cc.tags.members as StructMemberElem[];\n      const structElem = { ...openElem, name, members };\n      const elem = withTextCover(structElem, cc);\n      (name.ident as DeclIdent).declElem = elem as DeclarationElem;\n      name.ident.scope = cc.tags.struct_scope?.[0] as Scope;\n\n      return elem;\n    },\n  );\n}\n\nexport function collectStructMember(): CollectPair<StructMemberElem> {\n  return collectElem(\n    \"member\",\n    (cc: CollectContext, openElem: PartElem<StructMemberElem>) => {\n      const name = cc.tags.nameElem?.[0]!;\n      const typeRef = cc.tags.typeRef?.[0];\n      const partElem = { ...openElem, name, typeRef };\n      return withTextCover(partElem, cc);\n    },\n  );\n}\n\nexport function collectNameElem(cc: CollectContext): NameElem {\n  const { start, end, src, app } = cc;\n  const { srcModule } = app.stable as WeslAST;\n  const name = src.slice(start, end);\n  const elem: NameElem = { kind: \"name\", srcModule, start, end, name };\n  addToOpenElem(cc, elem);\n  return elem;\n}\n\n// prettier-ignore\nexport function collectModule(): \n    CollectPair<ModuleElem > {\n  return collectElem(\n    \"module\",\n    (cc: CollectContext, openElem: PartElem<ModuleElem>) => {\n      const ccComplete = { ...cc, start: 0, end: cc.src.length }; // force module to cover entire source despite ws skipping\n      const moduleElem: ModuleElem = withTextCover(openElem, ccComplete);\n      const weslState: StableState = cc.app.stable;\n      weslState.moduleElem = moduleElem;\n      return moduleElem;\n    },\n  );\n}\n\nexport function importList(cc: CollectContext): SegmentList {\n  const list = cc.tags.list as PathSegment[];\n  return new SegmentList(list);\n}\n\nexport function importSegment(cc: CollectContext): SimpleSegment {\n  const segOrig = cc.tags.segment?.[0] as string;\n  const seg = segOrig === \".\" ? \"package\" : segOrig; // TODO convert legacy syntax for now\n  return new SimpleSegment(seg, cc.tags.as?.[0]);\n}\n\nexport function importTree(cc: CollectContext): ImportTree {\n  const path = cc.tags.p?.flat() as PathSegment[]; // LATER fix typing\n  return new ImportTree(path);\n}\n\nexport function importElem(): CollectPair<ImportElem> {\n  return collectElem(\n    \"import\",\n    (cc: CollectContext, openElem: PartElem<ImportElem>) => {\n      const path = cc.tags.p as PathSegment[]; // LATER ts typing\n      const imports = new ImportTree(path);\n      const partialElem: ImportElem = { ...openElem, imports };\n      const importElem = withTextCover(partialElem, cc);\n      (cc.app.stable as StableState).imports.push(imports);\n      return importElem;\n    },\n  );\n}\n\n/** collect a scope start starts before and ends after a parser */\nexport function scopeCollect(): CollectPair<void> {\n  return {\n    before: startScope,\n    after: completeScope,\n  };\n}\n\nexport function collectSimpleElem<V extends AbstractElem & ElemWithContents>(\n  kind: V[\"kind\"],\n): CollectPair<V> {\n  return collectElem(kind, (cc, part) => withTextCover(part, cc) as V);\n}\n\nfunction collectElem<V extends AbstractElem>(\n  kind: V[\"kind\"],\n  fn: (cc: CollectContext, partialElem: PartElem<V>) => V,\n): CollectPair<V> {\n  return {\n    before: (cc: CollectContext) => {\n      const partialElem = { kind, contents: [] };\n      const weslContext: WeslParseContext = cc.app.context;\n      weslContext.openElems.push(partialElem);\n    },\n    after: (cc: CollectContext) => {\n      // TODO refine start?\n      const weslContext: WeslParseContext = cc.app.context;\n      const partialElem = weslContext.openElems.pop()!;\n      console.assert(partialElem && partialElem.kind === kind);\n      const elem = fn(cc, { ...partialElem, start: cc.start, end: cc.end });\n      addToOpenElem(cc, elem);\n      return elem;\n    },\n  };\n}\n\n/**\n * @return a copy of the element with contents extended\n * to include TextElems to cover the entire range.\n */\nfunction withTextCover<T extends ElemWithContents>(\n  elem: T,\n  cc: CollectContext,\n): T {\n  const contents = coverWithText(cc, elem.contents);\n  return { ...elem, contents };\n}\n\n/** cover the entire source range with Elems by creating TextElems to\n * cover any parts of the source that are not covered by other elems\n * @returns the existing elems combined with any new TextElems, in src order */\nfunction coverWithText(\n  cc: CollectContext,\n  existing: AbstractElem[],\n): AbstractElem[] {\n  let { start: pos } = cc;\n  const { end, app } = cc;\n  const ast: WeslAST = app.stable;\n  const sorted = existing.sort((a, b) => a.start - b.start);\n\n  const elems = sorted.flatMap(elem => {\n    const result = pos < elem.start ? [makeTextElem(elem.start), elem] : [elem];\n    pos = elem.end;\n    return result;\n  });\n\n  if (pos < end) {\n    elems.push(makeTextElem(end));\n  }\n\n  return elems;\n\n  function makeTextElem(end: number): TextElem {\n    return { kind: \"text\", start: pos, end, srcModule: ast.srcModule };\n  }\n}\n","import {\n  disablePreParse,\n  kind,\n  makeEolf,\n  matchOneOf,\n  NoTags,\n  opt,\n  or,\n  Parser,\n  repeat,\n  repeatPlus,\n  seq,\n  setTraceName,\n  TagRecord,\n  tagScope,\n  tokenMatcher,\n  tokens,\n  tokenSkipSet,\n  tracing,\n  withSepPlus\n} from \"mini-parse\";\nimport {\n  importElem,\n  importList,\n  importSegment,\n  importTree,\n} from \"./WESLCollect.js\";\nimport { digits, eol, ident, } from \"./WESLTokens.js\";\n\n\n// TODO now that ';' is required, special ws and eol handling is probably not needed.\nconst skipWsSet = new Set([\"ws\"]);\nfunction skipWs<V, T extends TagRecord>(p: Parser<V, T>): Parser<V, T> {\n  return tokenSkipSet(skipWsSet, p);\n}\nfunction noSkipWs<V, T extends TagRecord>(p: Parser<V, T>): Parser<V, T> {\n  return tokenSkipSet(null, p);\n}\n\nconst importSymbolSet = \"/ { } , ( ) .. . * ; @ #\"; // Had to add @ and # here to get the parsing tests to work. Weird.\nconst importSymbol = matchOneOf(importSymbolSet);\n\n// TODO reconsider whether we need a separate token set for import statements vs wgsl/wesl\nexport const importTokens = tokenMatcher({\n  ws: /\\s+/,\n  importSymbol,\n  ident, // TODO allow '-' in pkg names?\n  digits,\n});\n\nexport const eolTokens = tokenMatcher({\n  ws: /[ \\t]+/, // don't include \\n, for eolf\n  eol,\n});\n\nconst eolf = disablePreParse(makeEolf(eolTokens, importTokens.ws));\nconst wordToken = kind(importTokens.ident);\n\n// forward references for mutual recursion\nlet packagePath: Parser<any, NoTags> = null as any;\n\nconst simpleSegment = tagScope(\n  wordToken.ptag(\"segment\").collect(importSegment),\n);\n\n/** last simple segment is allowed to have an 'as' rename */\nconst lastSimpleSegment = tagScope(\n  seq(\n    wordToken.ptag(\"segment\"),\n    skipWs(opt(seq(\"as\", wordToken.ptag(\"as\")))),\n  ).collect(importSegment),\n);\n\n/** an item an a collection list {a, b} */\nconst collectionItem = or(\n  tagScope(or(() => packagePath).collect(importTree)),\n  lastSimpleSegment,\n);\n\nconst importCollection = tagScope(\n  seq(\n    \"{\",\n    skipWs(\n      seq(\n        withSepPlus(\",\", () => collectionItem.ctag(\"list\")),\n        \"}\",\n      ),\n    ),\n  ).collect(importList),\n);\n\n/** a relative path element like \"./\" or \"../\" */\nconst relativeSegment = tagScope(\n  seq(or(\".\", \"..\").ptag(\"segment\"), \"/\").collect(importSegment),\n).ctag(\"p\");\n\nconst lastSegment = or(lastSimpleSegment, importCollection);\n\nconst packageTail = seq(\n  repeat(seq(simpleSegment.ctag(\"p\"), \"/\")),\n  lastSegment.ctag(\"p\"),\n);\n\n/** a module path starting with ../ or ./ */\nconst relativePath = seq(repeatPlus(relativeSegment), packageTail);\n\nconst packagePrefix = tagScope(\n  seq(wordToken.ptag(\"segment\"), \"/\").collect(importSegment),\n).ctag(\"p\");\n\n/** a module path, starting with a simple element */\npackagePath = seq(packagePrefix, packageTail);\n\nconst fullPath = noSkipWs(\n  seq(kind(importTokens.ws), or(relativePath, packagePath)),\n);\n\n/** parse a WESL style wgsl import statement. */\nexport const weslImport = tagScope(\n  tokens(\n    importTokens,\n    seq(\"import\", fullPath, opt(\";\"), eolf).collect(importElem()),\n  ),\n);\n\nif (tracing) {\n  const names: Record<string, Parser<unknown, TagRecord>> = {\n    simpleSegment,\n    lastSimpleSegment,\n    importCollection,\n    relativeSegment,\n    relativePath,\n    packagePrefix,\n    packagePath,\n    fullPath,\n    weslImport,\n  };\n\n  Object.entries(names).forEach(([name, parser]) => {\n    setTraceName(parser, name);\n  });\n}\n","import {\n  any,\n  anyNot,\n  anyThrough,\n  disablePreParse,\n  makeEolf,\n  or,\n  Parser,\n  repeat,\n  req,\n  resultLog,\n  seq,\n  tokens,\n} from \"mini-parse\";\nimport { argsTokens, lineCommentTokens, mainTokens } from \"./WESLTokens.ts\";\n\n/* Basic parsing functions for comment handling . */\n\n/** currently unused */\nexport const unknown = any().map(r => {\n  const { kind, text } = r.value;\n  const deepName = r.ctx._debugNames.join(\" > \");\n\n  resultLog(r, `??? ${kind}: '${text}'  ${deepName}`);\n  // throw new Error(\"Fail fast\");\n});\n\nconst eolf: Parser<any> = disablePreParse(\n  makeEolf(argsTokens, argsTokens.ws),\n);\n\nconst skipToEol = tokens(lineCommentTokens, anyThrough(eolf));\n\nexport const blockComment: Parser<any> = seq(\n  \"/*\",\n  repeat(or(() => blockComment, anyNot(\"*/\"))),\n  req(\"*/\"),\n);\n\nexport const lineComment = seq(tokens(mainTokens, \"//\"), skipToEol);\n\nexport const comment = or(() => lineComment, blockComment).trace({\n  hide: true,\n});\n","import {\n  eof,\n  kind,\n  opt,\n  or,\n  Parser,\n  preParse,\n  repeat,\n  repeatPlus,\n  req,\n  seq,\n  setTraceName,\n  tagScope,\n  text,\n  tokens,\n  tokenSkipSet,\n  tracing,\n  withSep,\n  withSepPlus,\n} from \"mini-parse\";\nimport { weslImport } from \"./ImportGrammar.ts\";\nimport { bracketTokens, mainTokens } from \"./WESLTokens.ts\";\nimport { comment } from \"./CommentsGrammar.ts\";\nimport {\n  collectFn,\n  collectFnParam,\n  collectModule,\n  collectNameElem,\n  collectSimpleElem,\n  collectStruct,\n  collectStructMember,\n  collectVarLike,\n  declIdentElem,\n  refIdent,\n  scopeCollect,\n} from \"./WESLCollect.ts\";\n\n/** parser that recognizes key parts of WGSL and also directives like #import */\n\nexport const word = or(\n  kind(mainTokens.ident),\n  kind(mainTokens.textureStorage),\n);\n\nconst qualified_ident = withSepPlus(\"::\", word);\n\nconst diagnostic_rule_name = withSep(\".\", word, { requireOne: true });\nconst diagnostic_control = seq(\n  \"(\",\n  word,\n  \",\",\n  diagnostic_rule_name,\n  opt(\",\"),\n  \")\",\n);\n\n/** list of words that we don't need to collect (e.g. for @interpolate) */\nconst word_list = seq(\"(\", withSep(\",\", word, { requireOne: true }), \")\");\n\nconst attribute = seq(\n  \"@\",\n  req(\n    or(\n      // These attributes have no arguments\n      or(\"compute\", \"const\", \"fragment\", \"invariant\", \"must_use\", \"vertex\"),\n      // These attributes have arguments, but the argument doesn't have any identifiers\n      seq(\n        or(\"interpolate\", \"builtin\"),\n        req(() => word_list),\n      ),\n      seq(\"diagnostic\", diagnostic_control),\n      // These are normal attributes\n      seq(\n        or(\n          \"workgroup_size\",\n          \"align\",\n          \"binding\",\n          \"blend_src\",\n          \"group\",\n          \"id\",\n          \"location\",\n          \"size\",\n        ),\n        req(() => argument_expression_list),\n      ),\n      // Everything else is also a normal attribute, it might have an expression list\n      seq(\n        word,\n        opt(() => argument_expression_list),\n      ),\n    ),\n  ),\n);\n\nconst argument_expression_list = seq(\n  \"(\",\n  withSep(\",\", () => expression),\n  req(\")\"),\n);\n\nconst opt_attributes = repeat(attribute);\n\n/** parse an identifier into a TypeNameElem */\nexport const typeNameDecl = req(word.collect(declIdentElem, \"typeName\"));\n\n/** parse an identifier into a TypeNameElem */\nexport const fnNameDecl = req(\n  word.collect(declIdentElem, \"fnName\"),\n  \"missing fn name\",\n);\n\nconst std_type_specifier = seq(\n  word.collect(refIdent, \"typeRef\"),\n  () => opt_template_list,\n);\n\nconst texture_storage_type = seq(\n  kind(mainTokens.textureStorage),\n  () => opt_template_words,\n);\n\nconst ptr_type = seq(\n  \"ptr\",\n  req(\"<\"),\n  word,\n  req(\",\"),\n  () => template_arg_expression,\n  opt(seq(\",\", word)),\n  req(\">\"),\n);\n\nexport const type_specifier: Parser<any> = or(\n  texture_storage_type,\n  ptr_type,\n  std_type_specifier,\n) as any;\n\nconst optionally_typed_ident = seq(\n  word.collect(declIdentElem, \"declIdent\"),\n  opt(seq(\":\", type_specifier)),\n);\n\nconst req_optionally_typed_ident = req(optionally_typed_ident);\n\nexport const struct_member = seq(\n  opt_attributes,\n  word.collect(collectNameElem, \"nameElem\"),\n  \":\",\n  req(type_specifier),\n).collect(collectStructMember());\n\nexport const struct_decl = seq(\n  \"struct\",\n  req(typeNameDecl),\n  seq(\n    req(\"{\"),\n    withSepPlus(\",\", struct_member).ptag(\"members\"),\n    req(\"}\"),\n  ).collect(scopeCollect(), \"struct_scope\"),\n).collect(collectStruct());\n\n/** Also covers func_call_statement.post.ident */\nexport const fn_call = seq(\n  word.collect(refIdent, \"fn_call.refIdent\"), // we collect this in fnDecl, to attach to FnElem\n  () => opt_template_list,\n  argument_expression_list,\n);\n\nconst fnParam = tagScope(\n  seq(\n    opt_attributes,\n    word.collect(declIdentElem, \"paramName\"),\n    opt(seq(\":\", req(type_specifier))),\n  ).collect(collectFnParam()),\n).ctag(\"fnParam\");\n\nconst fnParamList = seq(\"(\", withSep(\",\", fnParam), \")\");\n\nconst local_variable_decl = seq(\n  \"var\",\n  () => opt_template_list,\n  req_optionally_typed_ident,\n  opt(seq(\"=\", () => expression)),\n).collect(collectVarLike(\"var\"), \"variable_decl\");\n\nconst global_variable_decl = seq(\n  \"var\",\n  () => opt_template_words,\n  req_optionally_typed_ident,\n  opt(seq(\"=\", () => expression.collect(scopeCollect(), \"decl_scope\"))),\n);\n\n/** Aka template_elaborated_ident.post.ident */\nconst opt_template_list = opt(\n  seq(\n    tokens(bracketTokens, \"<\"),\n    withSepPlus(\",\", () => template_arg_expression),\n    tokens(bracketTokens, \">\"),\n  ),\n);\n\n/** template list of non-identifier words. e.g. var <storage> */\nconst opt_template_words = opt(\n  seq(\n    tokens(bracketTokens, \"<\"),\n    withSepPlus(\",\", () => word),\n    tokens(bracketTokens, \">\"),\n  ),\n);\n\nconst template_elaborated_ident = seq(\n  word.collect(refIdent),\n  opt_template_list,\n);\n\nconst literal = or(\"true\", \"false\", kind(mainTokens.digits));\n\nconst paren_expression = seq(\"(\", () => expression, req(\")\"));\n\nconst call_expression = seq(\n  template_elaborated_ident,\n  argument_expression_list,\n);\n\nconst primary_expression = or(\n  literal,\n  paren_expression,\n  call_expression,\n  template_elaborated_ident,\n);\n\nconst component_or_swizzle = repeatPlus(\n  or(\n    seq(\".\", word),\n    seq(\"[\", () => expression, req(\"]\")),\n  ),\n);\n\n/**\n * bitwise_expression.post.unary_expression\n * & ^ |\n * expression\n * && ||\n * relational_expression.post.unary_expression\n * > >= < <= != ==\n * shift_expression.post.unary_expression\n * % * / + - << >>\n */\nconst makeExpressionOperator = (isTemplate: boolean) => {\n  const allowedOps = (\n    \"& | ^ << <= < != == % * / + -\" + (isTemplate ? \"\" : \" && || >> >= >\")\n  ).split(\" \");\n  return or(...allowedOps);\n};\n\nconst unary_expression: Parser<any> = or(\n  seq(or(...\"! & * - ~\".split(\" \")), () => unary_expression),\n  seq(primary_expression, opt(component_or_swizzle)),\n);\n\nconst makeExpression = (isTemplate: boolean) => {\n  return seq(\n    unary_expression,\n    repeat(seq(makeExpressionOperator(isTemplate), unary_expression)),\n  );\n};\n\nexport const expression = makeExpression(false);\nconst template_arg_expression = makeExpression(true);\n\nconst unscoped_compound_statement = seq(\n  opt_attributes,\n  text(\"{\"),\n  repeat(() => statement),\n  req(\"}\"),\n);\n\nconst compound_statement = seq(\n  opt_attributes,\n  seq(\n    text(\"{\"),\n    repeat(() => statement),\n    req(\"}\"),\n  ).collect(scopeCollect()),\n);\n\nconst for_init = or(\n  fn_call,\n  () => variable_or_value_statement,\n  () => variable_updating_statement,\n);\n\nconst for_update = or(fn_call, () => variable_updating_statement);\n\nconst for_statement = seq(\n  opt_attributes,\n  \"for\",\n  seq(\n    req(\"(\"),\n    opt(for_init),\n    req(\";\"),\n    opt(expression),\n    req(\";\"),\n    opt(for_update),\n    req(\")\"),\n    unscoped_compound_statement,\n  ).collect(scopeCollect()),\n);\n\nconst if_statement = seq(\n  opt_attributes,\n  \"if\",\n  req(seq(expression, compound_statement)),\n  repeat(seq(\"else\", \"if\", req(seq(expression, compound_statement)))),\n  opt(seq(\"else\", req(compound_statement))),\n);\nconst loop_statement = seq(\n  opt_attributes,\n  \"loop\",\n  opt_attributes,\n  req(\n    seq(\n      \"{\",\n      repeat(() => statement),\n      opt(\n        seq(\n          \"continuing\",\n          opt_attributes,\n          \"{\",\n          repeat(() => statement),\n          opt(seq(\"break\", \"if\", expression, \";\")),\n          \"}\",\n        ),\n      ),\n      \"}\",\n    ),\n  ),\n);\n\nconst case_selector = or(\"default\", expression);\nconst switch_clause = or(\n  seq(\n    \"case\",\n    withSep(\",\", case_selector, { requireOne: true }),\n    opt(\":\"),\n    compound_statement,\n  ),\n  seq(\"default\", opt(\":\"), compound_statement),\n);\n\nconst switch_body = seq(opt_attributes, \"{\", repeatPlus(switch_clause), \"}\");\nconst switch_statement = seq(opt_attributes, \"switch\", expression, switch_body);\n\nconst while_statement = seq(\n  opt_attributes,\n  \"while\",\n  expression,\n  compound_statement,\n);\n\nconst statement: Parser<any> = or(\n  for_statement,\n  if_statement,\n  loop_statement,\n  switch_statement,\n  while_statement,\n  compound_statement,\n  seq(\"break\", \";\"),\n  seq(\"continue\", \";\"),\n  seq(\";\"),\n  () => const_assert,\n  seq(\"discard\", \";\"),\n  seq(\"return\", opt(expression), \";\"),\n  seq(fn_call, \";\"),\n  seq(() => variable_or_value_statement, \";\"),\n  seq(() => variable_updating_statement, \";\"),\n);\n\nconst lhs_expression: Parser<any> = or(\n  seq(word.collect(refIdent), opt(component_or_swizzle)),\n  seq(\"(\", () => lhs_expression, \")\", opt(component_or_swizzle)),\n  seq(\"&\", () => lhs_expression),\n  seq(\"*\", () => lhs_expression),\n);\n\nconst variable_or_value_statement = or(\n  // Also covers the = expression case\n  local_variable_decl,\n  seq(\"const\", req_optionally_typed_ident, req(\"=\"), expression),\n  seq(\"let\", req_optionally_typed_ident, req(\"=\"), expression),\n);\n\nconst variable_updating_statement = or(\n  seq(\n    lhs_expression,\n    or(\"=\", \"<<=\", \">>=\", \"%=\", \"&=\", \"*=\", \"+=\", \"-=\", \"/=\", \"^=\", \"|=\"), // TODO: try making this a lexer rule instead of a parser rule\n    expression,\n  ),\n  seq(lhs_expression, or(\"++\", \"--\")),\n  seq(\"_\", \"=\", expression),\n);\n\nexport const fn_decl = seq(\n  opt_attributes,\n  text(\"fn\"),\n  req(fnNameDecl),\n  seq(\n    req(fnParamList),\n    opt(seq(\"->\", opt_attributes, type_specifier.ctag(\"returnType\"))),\n    req(unscoped_compound_statement),\n  ).collect(scopeCollect(), \"body_scope\"),\n).collect(collectFn());\n\nconst global_value_decl = or(\n  seq(\n    opt_attributes,\n    \"override\",\n    optionally_typed_ident,\n    seq(opt(seq(\"=\", expression.collect(scopeCollect(), \"decl_scope\")))),\n    \";\",\n  ).collect(collectVarLike(\"override\")),\n  seq(\n    \"const\",\n    optionally_typed_ident,\n    \"=\",\n    seq(expression).collect(scopeCollect(), \"decl_scope\"),\n    \";\",\n  ).collect(collectVarLike(\"const\")),\n);\n\nexport const global_alias = seq(\n  \"alias\",\n  req(word).collect(declIdentElem, \"declIdent\"),\n  req(\"=\"),\n  req(type_specifier).collect(scopeCollect(), \"decl_scope\"),\n  req(\";\"),\n).collect(collectVarLike(\"alias\"), \"global_alias\");\n\nconst const_assert = seq(\"const_assert\", req(expression), \";\").collect(\n  collectSimpleElem(\"assert\"),\n);\n\nconst import_statement = weslImport;\n\nconst global_directive = seq(\n  or(\n    seq(\"diagnostic\", diagnostic_control),\n    seq(\"enable\", withSep(\",\", word, { requireOne: true })),\n    seq(\"requires\", withSep(\",\", word, { requireOne: true })),\n  ),\n  \";\",\n);\n\nexport const global_decl = tagScope(\n  or(\n    fn_decl,\n    seq(opt_attributes, global_variable_decl, \";\").collect(\n      collectVarLike(\"gvar\"),\n      \"g_variable_decl\",\n    ),\n    global_value_decl,\n    \";\",\n    global_alias,\n    const_assert,\n    struct_decl,\n  ),\n);\n\nconst end = tokenSkipSet(null, seq(repeat(kind(mainTokens.ws)), eof()));\nexport const weslRoot = preParse(\n  comment,\n  seq(\n    repeat(weslImport),\n    repeat(or(global_directive, weslImport)),\n    repeat(or(global_decl, weslImport)),\n    req(end),\n  ).collect(collectModule(), \"collectModule\"),\n);\n\nif (tracing) {\n  const names: Record<string, Parser<unknown>> = {\n    qualified_ident,\n    diagnostic_rule_name,\n    diagnostic_control,\n    attribute,\n    argument_expression_list,\n    opt_attributes,\n    typeNameDecl,\n    fnNameDecl,\n    type_specifier,\n    optionally_typed_ident,\n    struct_member,\n    struct_decl,\n    fn_call,\n    fnParam,\n    fnParamList,\n    local_variable_decl,\n    global_variable_decl,\n    opt_template_list,\n    template_elaborated_ident,\n    literal,\n    paren_expression,\n    call_expression,\n    primary_expression,\n    component_or_swizzle,\n    unary_expression,\n    expression,\n    template_arg_expression,\n    compound_statement,\n    for_init,\n    for_update,\n    for_statement,\n    if_statement,\n    loop_statement,\n    case_selector,\n    switch_clause,\n    switch_body,\n    switch_statement,\n    while_statement,\n    statement,\n    lhs_expression,\n    variable_or_value_statement,\n    variable_updating_statement,\n    fn_decl,\n    global_value_decl,\n    global_alias,\n    const_assert,\n    import_statement,\n    global_directive,\n    global_decl,\n    end,\n    weslRoot,\n  };\n\n  Object.entries(names).forEach(([name, parser]) => {\n    setTraceName(parser, name);\n  });\n}\n","import { tracing } from \"mini-parse\";\nimport {\n  ImportTree,\n  PathSegment,\n  SegmentList,\n  SimpleSegment,\n} from \"./ImportTree.js\";\n\nexport interface FlatImport {\n  importPath: string[];\n  modulePath: string[];\n}\n\n/**\n * Simplify importTree into a flattened map from import paths to module paths.\n *\n * @return map from import path (with 'as' renaming) to module Path\n */\nexport function flattenTreeImport(imp: ImportTree): FlatImport[] {\n  return recursiveResolve([], [], imp.segments);\n\n  /** recurse through segments of path, producing  */\n  function recursiveResolve(\n    resolvedImportPath: string[],\n    resolvedExportPath: string[],\n    remainingPath: PathSegment[],\n  ): FlatImport[] {\n    const [segment, ...rest] = remainingPath;\n    if (segment === undefined) {\n      throw new Error(`undefined segment ${imp.segments}`);\n    }\n    if (segment instanceof SimpleSegment) {\n      const importPath = [...resolvedImportPath, segment.as || segment.name];\n      const modulePath = [...resolvedExportPath, segment.name];\n      if (rest.length) {\n        // we're in the middle of the path so keep recursing\n        return recursiveResolve(importPath, modulePath, rest);\n      } else {\n        return [{ importPath, modulePath }];\n      }\n    }\n    if (segment instanceof SegmentList) {\n      // resolve path with each element in the list\n      return segment.list.flatMap(elem => {\n        const rPath = [elem, ...rest];\n        return recursiveResolve(resolvedImportPath, resolvedExportPath, rPath);\n      });\n    } else if (segment instanceof ImportTree) {\n      return recursiveResolve(\n        resolvedImportPath,\n        resolvedExportPath,\n        segment.segments,\n      );\n    }\n\n    if (tracing) console.log(\"unknown segment type\", segment); // should be impossible\n    return [];\n  }\n}\n","import { AppState, matchingLexer, ParserInit, SrcMap } from \"mini-parse\";\nimport { ModuleElem } from \"./AbstractElems.ts\";\nimport { ImportTree } from \"./ImportTree.ts\";\nimport { mainTokens } from \"./WESLTokens.ts\";\nimport { emptyScope, resetScopeIds, Scope, SrcModule } from \"./Scope.ts\";\nimport { OpenElem } from \"./WESLCollect.ts\";\nimport { weslRoot } from \"./WESLGrammar.ts\";\nimport { FlatImport, flattenTreeImport } from \"./FlattenTreeImport.ts\";\n\n/** result of a parse */\nexport interface WeslAST {\n  /** source text for this module */\n  srcModule: SrcModule;\n\n  /** root module element */\n  moduleElem: ModuleElem;\n\n  /** root scope for this module */\n  rootScope: Scope;\n\n  /** imports found in this module */\n  imports: ImportTree[];\n\n  /* constructed on demand from import trees, and cached */\n  _flatImports?: FlatImport[];\n}\n\n/** stable and unstable state used during parsing */\nexport interface WeslParseState\n  extends AppState<WeslParseContext, StableState> {\n  context: WeslParseContext;\n  stable: StableState;\n}\n\n/** stable values used or accumulated during parsing */\nexport type StableState = WeslAST;\n\n/** unstable values used during parse collection */\nexport interface WeslParseContext {\n  scope: Scope; // current scope (points somewhere in rootScope)\n  openElems: OpenElem[]; // elems that are collecting their contents\n}\n\nexport function parseSrcModule(\n  srcModule: SrcModule,\n  srcMap?: SrcMap,\n  maxParseCount: number | undefined = undefined,\n): WeslAST {\n  // TODO allow returning undefined for failure, or throw?\n\n  resetScopeIds();\n  const lexer = matchingLexer(srcModule.src, mainTokens);\n\n  const appState = blankWeslParseState(srcModule);\n\n  const init: ParserInit = { lexer, appState, srcMap, maxParseCount };\n  const parseResult = weslRoot.parse(init);\n  if (parseResult === null) {\n    throw new Error(\"parseWESL failed\");\n  }\n\n  return appState.stable as WeslAST;\n}\n\n// for tests. TODO rename\nexport function parseWESL(\n  src: string,\n  srcMap?: SrcMap,\n  maxParseCount: number | undefined = undefined,\n): WeslAST {\n  const srcModule: SrcModule = {\n    modulePath: \"package::test\",\n    filePath: \"./test.wesl\",\n    src,\n  };\n\n  return parseSrcModule(srcModule, srcMap, maxParseCount);\n}\n\nexport function blankWeslParseState(srcModule: SrcModule): WeslParseState {\n  const rootScope = emptyScope(\"module-scope\");\n  const moduleElem = null as any; // we'll fill this in later\n  return {\n    context: { scope: rootScope, openElems: [] },\n    stable: { srcModule, imports: [], rootScope, moduleElem },\n  };\n}\n\nexport function syntheticWeslParseState(): WeslParseState {\n  const srcModule: SrcModule = {\n    modulePath: \"package::test\",\n    filePath: \"./test.wesl\",\n    src: \"\",\n  };\n\n  return blankWeslParseState(srcModule);\n}\n\n/** @return a flattened form of the import tree for convenience in binding idents. */\nexport function flatImports(ast: WeslAST): FlatImport[] {\n  if (ast._flatImports) return ast._flatImports;\n\n  const flat = ast.imports.flatMap(flattenTreeImport);\n  ast._flatImports = flat;\n  return flat;\n}\n","export const stdFns = `bitcast all any select arrayLength \n  abs acos acosh asin asinh atan atanh atan2 ceil clamp cos cosh \n  countLeadingZeros countOneBits countTrailingZeros cross \n  degrees determinant distance dot dot4UI8Packed dot4I8Packed \n  exp exp2 extractBits faceForward firstLeadingBit firstTrailingBit \n  floor fma fract frexp inserBits inverseSqrt ldexp length log log2\n  max min mix modf normalize pow quantizeToF16 radians reflect refract\n  reverseBits round saturate sign sin sinh smoothstep sqrt step tan tanh\n  transpose trunc\n  dpdx dpdxCoarse dpdxFine dpdy dpdyCoarse dpdyFine fwidth \n  fwdithCoarse fwidthFine\n  textureDimensions textureGather textureGatherCompare textureLoad\n  textureNumLayers textureNumLevels textureNumSamples\n  textureSample textureSampleBias textureSampleCompare textureSampleCompareLevel\n  textureSampleGrad textureSampleLevel textureSampleBaseClampToEdge\n  textureStore\n  atomicLoad atomicStore atomicAdd atomicSub atomicMax atomicMin\n  atomicOr atomicXor atomicExchange atomicCompareExchangeWeak\n  pack4x8snorm pack4x8unorm pack4xI8 pack4xU8 pack4xI8Clamp pack4xU8Clamp\n  pack2x16snorm pack2x16unorm pack2x16float\n  unpack4x8snorm unpack4x8unorm unpack4xI8 unpack4xU8 \n  unpack2x16snorm unpack2x16unorm unpack2x16float\n  storageBarrier textureBarrier workgroupBarrier workgroupUniformLoad\n  `.split(/\\s+/);\n\nexport const stdTypes = `array atomic bool f16 f32 i32 \n  mat2x2 mat2x3 mat2x4 mat3x2 mat3x3 mat3x4 mat4x2 mat4x3 mat4x4\n  mat2x2f mat2x3f mat2x4f mat3x2f mat3x3f mat3x4f\n  mat4x2f mat4x3f mat4x4f\n  mat2x2h mat2x3h mat2x4h mat3x2h mat3x3h mat3x4h\n  mat4x2h mat4x3h mat4x4h\n  u32 vec2 vec3 vec4 ptr\n  vec2i vec3i vec4i vec2u vec3u vec4u\n  vec2f vec3f vec4f vec2h vec3h vec4h\n  texture_1d texture_2d texture_2d_array texture_3d \n  texture_cube texture_cube_array\n  texture_multisampled_2d texture_depth_multisampled_2d\n  texture_external\n  texture_storage_1d texture_storage_2d texture_storage_2d_array\n  texture_storage_3d\n  texture_depth_2d texture_depth_2d_array texture_depth_cube\n  texture_depth_cube_array\n  sampler sampler_comparison\n  rgba8unorm rgba8snorm rgba8uint rgba8sint\n  rgba16uint rgba16sint rgba16float \n  r32uint r32sint r32float rg32uint rg32sint rg32float\n  rgba32uint rgba32sint rgba32float\n  bgra8unorm \n  function uniform\n  `.split(/\\s+/); // LATER handle 'function' in template parser?\n\n/* Note the texel formats like rgba8unorm are here because they appear in type position\n in <templates> for texture_storage_* types. \n (We could parse texture_storage types specially, but user code is unlikely to alias \n  the texture format names with e.g. a 'struct rbga8unorm .)\n*/\n\n/** return true if the name is for a built in type (not a user struct) */\nexport function stdType(name: string): boolean {\n  return stdTypes.includes(name);\n}\n\n/** return true if the name is for a built in fn (not a user function) */\nexport function stdFn(name: string): boolean {\n  return stdFns.includes(name) || stdType(name);\n}\n","export function multiKeySet<A, B, V>(\n  m: Map<A, Map<B, V>>,\n  a: A,\n  b: B,\n  v: V,\n): void {\n  const bMap = m.get(a) || new Map();\n  m.set(a, bMap);\n  bMap.set(b, v);\n}\n\nconst tokenRegex = /\\b(\\w+)\\b/gi;\n/** replace strings in a text according to a relacement map\n * replaced strings must be 'tokens', surrounded by spaces or punctuation\n */\nexport function replaceWords(\n  text: string,\n  replace: Record<string, string>,\n): string {\n  return text.replaceAll(tokenRegex, s => (s in replace ? replace[s] : s));\n}\n\n/** return an array partitioned into possibly overlapping groups */\nexport function grouped<T>(a: T[], size: number, stride = size): T[][] {\n  const groups = [];\n  for (let i = 0; i < a.length; i += stride) {\n    groups.push(a.slice(i, i + size));\n  }\n  return groups;\n}\n\n/** group an array into subarrays by a key function */\nexport function groupBy<T, K>(a: T[], key: (t: T) => K): Map<K, T[]> {\n  const groups = new Map<K, T[]>();\n  for (const t of a) {\n    const k = key(t);\n    const group = groups.get(k) || [];\n    group.push(t);\n    groups.set(k, group);\n  }\n  return groups;\n}\n\n/** partition an array into two parts by a discriminator function */\nexport function partition<T>(a: T[], partFn: (t: T) => boolean): [T[], T[]] {\n  const yesPart: T[] = [];\n  const noPart: T[] = [];\n  for (const t of a) {\n    if (partFn(t)) yesPart.push(t);\n    else noPart.push(t);\n  }\n  return [yesPart, noPart];\n}\n\n/** run an carrying function over every element in an array,\n * i.e. an inclusive prefix scan */\nexport function scan<T, U>(array: T[], fn: (a: T, b: U) => U, zero: U): U[] {\n  const result = [zero];\n\n  let current = zero;\n  for (let i = 0; i < array.length; i++) {\n    current = fn(array[i], current);\n    result.push(current);\n  }\n  return result;\n}\n\n/** return a new record by replacing values in 'a' with 'b' as a map.\n * values in 'a' that are not in 'b' are unchanged.\n * e.g. {a: \"b\", x: 9}, {b: 1} yields {a: 1, x: 9}\n */\nexport function mapForward(\n  a: Record<string, string>,\n  b: Record<string, any>,\n): Record<string, any> {\n  const combined = Object.entries(a).map(([key, value]) => {\n    const mappedValue = value in b ? b[value] : value;\n    return [key, mappedValue];\n  });\n  return Object.fromEntries(combined);\n}\n\n/** return the last element of an array or undefined */\nexport function last<T>(a: T[]): T | undefined {\n  return a[a.length - 1];\n}\n\n/**\n * Overlap two arrays, returning the tail of b if a is a prefix of b.\n * Otherwise, return undefined.\n */\nexport function overlapTail<T>(a: T[], b: T[]): T[] | undefined {\n  let overlapSize = Math.min(a.length, b.length);\n\n  while (overlapSize > 0) {\n    const suffix = a.slice(-overlapSize);\n    const prefix = b.slice(0, overlapSize);\n    if (arrayEquals(suffix, prefix)) {\n      break;\n    } else {\n      overlapSize--;\n    }\n  }\n\n  if (overlapSize) {\n    return b.slice(overlapSize);\n  }\n}\n\nfunction arrayEquals(a: any[], b: any[]): boolean {\n  return a.length === b.length && a.every((val, index) => val === b[index]);\n}\n","import { debugNames, srcLog } from \"mini-parse\";\nimport { DeclarationElem } from \"./AbstractElems.ts\";\nimport { FlatImport } from \"./FlattenTreeImport.ts\";\nimport { ParsedRegistry } from \"./ParsedRegistry.ts\";\nimport { flatImports, WeslAST } from \"./ParseWESL.ts\";\nimport { DeclIdent, exportDecl, RefIdent, Scope } from \"./Scope.ts\";\nimport { identToString } from \"./debug/ScopeToString.ts\";\nimport { stdFn, stdType } from \"./StandardTypes.ts\";\nimport { last, overlapTail } from \"./Util.ts\";\n\n/**\n * Bind active reference idents to declaration Idents by mutating the refersTo: field\n * Also in this pass, set the mangledName: field for all active global declaration idents.\n *\n * @param parsed\n * @param conditions  only bind to/from idents that are valid with the current condition set\n * @return any new declaration elements found (they will need to be emitted)\n */\nexport function bindIdents(\n  ast: WeslAST,\n  parsed: ParsedRegistry,\n  conditions: Record<string, any>,\n): DeclarationElem[] {\n  /* \n    For each module's scope, search through the scope tree to find all ref idents\n      - For each ref ident, search up the scope tree to find a matching decl ident\n      - If no local match is found, check for partial matches with import statements\n        - combine ident with import statement to match a decl in exporting module\n\n    As global decl idents are found, mutate their mangled name to be globally unique.\n*/\n  const { rootScope } = ast;\n\n  const globalNames = new Set<string>();\n  const knownDecls = new Set<DeclIdent>();\n  rootScope.idents.forEach(ident => {\n    if (ident.kind === \"decl\") {\n      ident.mangledName = ident.originalName;\n      globalNames.add(ident.originalName);\n      knownDecls.add(ident);\n    }\n  });\n\n  const bindContext = {\n    parsed,\n    conditions,\n    knownDecls,\n    foundScopes: new Set<Scope>(),\n    globalNames,\n  };\n  const decls = bindIdentsRecursive(rootScope, bindContext);\n  return decls.flatMap(d =>\n    d.declElem && isGlobal(d.declElem) ? [d.declElem] : [],\n  );\n}\n\ninterface BindContext {\n  parsed: ParsedRegistry;\n  conditions: Record<string, any>;\n  knownDecls: Set<DeclIdent>; // decl idents discovered so far\n  foundScopes: Set<Scope>; // save work by not processing scopes multiple times\n  globalNames: Set<string>; // root level names  used so far\n}\n\n/**\n * Recursively bind references to declarations in this scope and\n * any child scopes referenced by these declarations.\n * Uses a hash set of found declarations to avoid duplication\n * @ return any new declarations found\n */\nfunction bindIdentsRecursive(\n  scope: Scope,\n  bindContext: BindContext,\n): DeclIdent[] {\n  // early exist if we've processed this scope before\n  const { foundScopes } = bindContext;\n  if (foundScopes.has(scope)) return [];\n  foundScopes.add(scope);\n\n  // dlog(scopeIdentTree(scope));\n\n  const { parsed, conditions } = bindContext;\n  const { globalNames, knownDecls } = bindContext;\n  const newDecls: DeclIdent[] = []; // new decl idents to process (and return)\n\n  scope.idents.forEach(ident => {\n    // dlog(`--- considering ident ${identToString(ident)}`);\n    if (ident.kind === \"ref\") {\n      if (!ident.refersTo && !ident.std) {\n        if (stdWgsl(ident.originalName)) {\n          ident.std = true;\n        } else {\n          let foundDecl =\n            findDeclInModule(ident.scope, ident) ??\n            findDeclImport(ident, parsed);\n\n          if (foundDecl) {\n            ident.refersTo = foundDecl;\n            if (!knownDecls.has(foundDecl)) {\n              knownDecls.add(foundDecl);\n              setDisplayName(ident.originalName, foundDecl, globalNames);\n              if (foundDecl.declElem && isGlobal(foundDecl.declElem)) {\n                newDecls.push(foundDecl);\n              }\n              // dlog(`  > found new decl: ${identToString(foundDecl)}`);\n            }\n          } else {\n            const { refIdentElem } = ident;\n            if (refIdentElem) {\n              const { srcModule, start, end } = refIdentElem;\n              const { filePath } = srcModule;\n              const msg = `unresolved identifier in file: ${filePath}`;\n              srcLog(srcModule.src, [start, end], msg);\n            }\n          }\n        }\n      }\n    }\n  });\n\n  // follow references from child scopes\n  const newFromChildren = scope.children.flatMap(child => {\n    // dlog(\"to newFromChildren\", { childScope: scopeIdentTree(child) });\n    return bindIdentsRecursive(child, bindContext);\n  });\n  // console.log(\n  //   \"new from children\",\n  //   newFromChildren.map(d => identToString(d)),\n  // );\n\n  // follow references from referenced declarations\n  const newFromRefs = newDecls.flatMap(decl => {\n    // dlog(\"to newFromRefs\", {\n    //   decl: identToString(decl),\n    //   declScope: scopeIdentTree(decl.scope),\n    // });\n    if (debugNames && !decl.scope) {\n      console.log(`--- decl ${identToString(decl)} has no scope`);\n      return [];\n    }\n    return bindIdentsRecursive(decl.scope, bindContext);\n  });\n  // console.log(\n  //   \"new from refs\",\n  //   newFromRefs.map(d => identToString(d)),\n  // );\n\n  return [newDecls, newFromChildren, newFromRefs].flat();\n}\n\nfunction setDisplayName(\n  proposedName: string,\n  decl: DeclIdent,\n  globalNames: Set<string>,\n): void {\n  if (!decl.mangledName) {\n    // if (!decl.declElem) {\n    //   console.log(\n    //     `--- decl ident ${identToString(decl)} has no declElem attached`,)\n    // } else\n    if (decl.declElem && isGlobal(decl.declElem)) {\n      decl.mangledName = declUniqueName(proposedName, globalNames);\n      // dlog(`  > mangle global decl: ${identToString(decl)}`);\n    } else {\n      // dlog(`  > no-mangle local decl: ${identToString(decl)}`);\n      decl.mangledName = decl.originalName;\n    }\n  }\n}\n\nfunction stdWgsl(name: string): boolean {\n  return stdType(name) || stdFn(name);\n}\n\n/** search earlier in the scope and in parent scopes to find a matching decl ident */\nfunction findDeclInModule(\n  scope: Scope,\n  ident: RefIdent,\n): DeclIdent | undefined {\n  const { parent } = scope;\n  const { originalName } = ident;\n\n  const found = scope.idents.find(\n    i => i.kind === \"decl\" && i.originalName === originalName,\n  );\n  if (found) return found as DeclIdent;\n\n  // recurse to check all idents in parent scope\n  if (parent) {\n    // dlog(\"checking parent scope\", {\n    //   ident: identToString(ident),\n    // });\n    // console.log(scopeIdentTree(parent));\n    return findDeclInModule(parent, ident);\n  }\n}\n\n/** Match a reference identifier to a declaration in\n * another module via an import statement */\nfunction findDeclImport(\n  refIdent: RefIdent,\n  parsed: ParsedRegistry,\n): DeclIdent | undefined {\n  // dlog(identToString(refIdent), { ast: !!refIdent.ast });\n  const flatImps = flatImports(refIdent.ast);\n\n  // find module path by combining identifer reference with import statement\n  const modulePathParts = matchingImport(refIdent, flatImps); // module path in array form\n\n  if (modulePathParts) {\n    return findExport(modulePathParts, parsed);\n  }\n}\n\n/** using the flattened import array, find an import that matches a provided identifier */\nfunction matchingImport(\n  ident: RefIdent,\n  flatImports: FlatImport[],\n): string[] | undefined {\n  const identParts = ident.originalName.split(\"::\");\n  for (const flat of flatImports) {\n    const impTail = overlapTail(flat.importPath, identParts);\n    if (impTail) {\n      return [...flat.modulePath, ...impTail];\n    }\n  }\n}\n\n/** @return an exported root element for the provided path */\nfunction findExport(\n  modulePathParts: string[],\n  parsed: ParsedRegistry,\n): DeclIdent | undefined {\n  const legacyConvert = modulePathParts.map(p => (p === \".\" ? \"package\" : p)); // TODO rm after we update grammar\n  const modulePath = legacyConvert.slice(0, -1).join(\"::\");\n  const module = parsed.modules[modulePath];\n  if (!module) {\n    // TODO show error with source location\n    console.log(\n      `ident ${modulePathParts.join(\"::\")} in import statement, but module not found`,\n    );\n  }\n\n  return exportDecl(module.rootScope, last(modulePathParts)!);\n}\n\n/** return mangled name for decl ident,\n *  mutating the Ident to remember mangled name if it hasn't yet been determined */\nexport function declUniqueName(\n  proposedName: string,\n  rootNames: Set<string>,\n): string {\n  const displayName = uniquifyName(proposedName, rootNames);\n  rootNames.add(displayName);\n\n  return displayName;\n}\n\n/** construct global unique name for use in the output */\nfunction uniquifyName(proposedName: string, rootNames: Set<string>): string {\n  let renamed = proposedName;\n  let conflicts = 0;\n\n  // create a unique name\n  while (rootNames.has(renamed)) {\n    renamed = proposedName + conflicts++;\n  }\n\n  // dlog({ proposedName, renamed });\n  return renamed;\n}\n\nexport function isGlobal(elem: DeclarationElem): boolean {\n  return [\"alias\", \"const\", \"override\", \"fn\", \"struct\", \"gvar\"].includes(\n    elem.kind,\n  );\n}\n","import { SrcMapBuilder, tracing } from \"mini-parse\";\nimport {\n  AbstractElem,\n  DeclIdentElem,\n  RefIdentElem,\n  NameElem,\n  TextElem,\n} from \"./AbstractElems.ts\";\nimport { isGlobal } from \"./BindIdents.ts\";\nimport { Conditions, DeclIdent, Ident, RefIdent } from \"./Scope.ts\";\nimport { identToString } from \"./debug/ScopeToString.ts\";\n\n/** passed to the emitters */\ninterface EmitContext {\n  srcBuilder: SrcMapBuilder; // constructing the linked output\n  conditions: Conditions; // settings for conditional compilation\n  extracting: boolean; // are we extracting or copying the root module\n}\n\n/** traverse the AST, starting from root elements, emitting wgsl for each */\nexport function lowerAndEmit(\n  srcBuilder: SrcMapBuilder,\n  rootElems: AbstractElem[],\n  conditions: Conditions,\n  extracting = true,\n): void {\n  const emitContext: EmitContext = { conditions, srcBuilder, extracting };\n  lowerAndEmitRecursive(rootElems, emitContext);\n}\n\nfunction lowerAndEmitRecursive(\n  elems: AbstractElem[],\n  emitContext: EmitContext,\n): void {\n  const validElems = elems.filter(e =>\n    conditionsValid(e, emitContext.conditions),\n  );\n  validElems.forEach(e => lowerAndEmitElem(e, emitContext));\n}\n\nexport function lowerAndEmitElem(e: AbstractElem, ctx: EmitContext): void {\n  switch (e.kind) {\n    case \"import\":\n      return; // drop imports statements from emitted text\n    case \"fn\":\n    case \"struct\":\n    case \"override\":\n    case \"const\":\n    case \"assert\":\n    case \"alias\":\n    case \"gvar\":\n      if (ctx.extracting) {\n        ctx.srcBuilder.addNl();\n        ctx.srcBuilder.addNl();\n      }\n      return emitContents(e, ctx);\n    case \"text\":\n      return emitText(e, ctx);\n    case \"ref\":\n    case \"decl\":\n      return emitIdent(e, ctx);\n    case \"param\":\n    case \"var\":\n    case \"module\":\n    case \"member\":\n      return emitContents(e, ctx);\n    case \"name\":\n      return emitName(e, ctx);\n    default:\n      const kind = (e as any).kind;\n      console.log(\"NYI for emit, elem kind:\", kind);\n      throw new Error(`NYI emit elem kind: ${kind}`);\n  }\n}\n\nexport function emitText(e: TextElem, ctx: EmitContext): void {\n  ctx.srcBuilder.addCopy(e.srcModule.src, e.start, e.end);\n}\n\nexport function emitName(e: NameElem, ctx: EmitContext): void {\n  ctx.srcBuilder.add(e.name, e.srcModule.src, e.start, e.end);\n}\n\nexport function emitContents(\n  elem: AbstractElem & { contents: AbstractElem[] },\n  ctx: EmitContext,\n): void {\n  elem.contents.forEach(e => lowerAndEmitElem(e, ctx));\n}\n\nexport function emitIdent(\n  e: RefIdentElem | DeclIdentElem,\n  ctx: EmitContext,\n): void {\n  if ((e.ident as RefIdent).std) {\n    ctx.srcBuilder.add(e.ident.originalName, e.srcModule.src, e.start, e.end);\n  } else {\n    const declIdent = findDecl(e.ident);\n    const mangledName = displayName(declIdent);\n    ctx.srcBuilder.add(mangledName!, e.srcModule.src, e.start, e.end);\n  }\n}\n\nfunction displayName(declIdent: DeclIdent): string {\n  if (declIdent.declElem && isGlobal(declIdent.declElem)) {\n    // mangled name was set in binding step\n    const mangledName = declIdent.mangledName;\n    if (tracing && !mangledName) {\n      console.log(\n        \"ERR: mangled name not found for decl ident\",\n        identToString(declIdent),\n      );\n    }\n    return mangledName!;\n  }\n\n  return declIdent.mangledName || declIdent.originalName;\n}\n\n/** trace through refersTo links in reference Idents until we find the declaration\n * expects that bindIdents has filled in all refersTo: links\n */\nexport function findDecl(ident: Ident): DeclIdent {\n  let i: Ident | undefined = ident;\n  do {\n    if (i.kind === \"decl\") {\n      return i;\n    }\n    i = i.refersTo;\n  } while (i);\n\n  throw new Error(\n    `unresolved ident: ${ident.originalName} (bug in bindIdents?)`,\n  );\n}\n\n/** check if the element is visible with the current current conditional compilation settings */\nexport function conditionsValid(\n  elem: AbstractElem,\n  conditions: Conditions,\n): boolean {\n  return true;\n}\n","/** simplistic path manipulation utilities */\n\nexport function relativePath(\n  srcPath: string | undefined,\n  reqPath: string,\n): string {\n  if (!srcPath) return reqPath;\n  const srcDir = dirname(srcPath);\n  const relative = join(srcDir, reqPath);\n  return relative;\n}\n\nexport function dirname(path: string): string {\n  const lastSlash = path.lastIndexOf(\"/\");\n  if (lastSlash === -1) return \".\";\n  return path.slice(0, lastSlash);\n}\n\nexport function join(a: string, b: string): string {\n  const joined = b.startsWith(\"/\") ? a + b : a + \"/\" + b;\n  return normalize(joined);\n}\n\n/** return path with ./ and foo/.. elements removed */\nexport function normalize(path: string): string {\n  const segments = path.split(\"/\");\n  const noDots = segments.filter(s => s !== \".\");\n  const noDbl: string[] = [];\n\n  noDots.forEach(s => {\n    if (s !== \"\") {\n      if (s === \"..\" && noDbl.length && noDbl[noDbl.length - 1] !== \"..\") {\n        noDbl.pop();\n      } else {\n        noDbl.push(s);\n      }\n    }\n  });\n\n  return noDbl.join(\"/\");\n}\n\n/** return path w/o a suffix.\n * e.g. /foo/bar.wgsl => /foo/bar */\nexport function noSuffix(path: string): string {\n  const lastSlash = path.lastIndexOf(\"/\");\n  const lastStart = lastSlash === -1 ? 0 : lastSlash + 1;\n\n  const suffix = path.indexOf(\".\", lastStart);\n  const suffixStart = suffix === -1 ? path.length : suffix;\n  return path.slice(0, suffixStart);\n}\n","import { WgslBundle } from \"random_wgsl\";\nimport { parseSrcModule, parseWESL, WeslAST } from \"./ParseWESL.ts\";\nimport { normalize, noSuffix } from \"./PathUtil.ts\";\nimport { SrcModule } from \"./Scope.ts\";\n\nexport interface ParsedRegistry {\n  modules: Record<string, WeslAST>; // key is module path, e.g. \"rand_pkg::foo::bar\"\n}\n\nexport function parsedRegistry(): ParsedRegistry {\n  return { modules: {} };\n}\n\n/**\n * Parse WESL each src module (file) into AST elements and a Scope tree.\n * @param src keys are module paths, values are wesl src strings\n */\nexport function parseWeslSrc(src: Record<string, string>): ParsedRegistry {\n  const parsedEntries = Object.entries(src).map(([path, src]) => {\n    const weslAST = parseWESL(src);\n    return [path, weslAST];\n  });\n  return { modules: Object.fromEntries(parsedEntries) };\n}\n\n/** Look up a module with a flexible selector.\n *    :: separated module path,   package::util\n *    / separated file path       ./util.wesl (or ./util)\n *    simpleName                  util\n */\nexport function selectModule(\n  parsed: ParsedRegistry,\n  selectPath: string,\n  packageName = \"package\",\n): WeslAST | undefined {\n  let modulePath: string;\n  if (selectPath.includes(\"::\")) {\n    modulePath = selectPath;\n  } else if (selectPath.includes(\"/\")) {\n    modulePath = fileToModulePath(selectPath, packageName);\n  } else {\n    modulePath = packageName + \"::\" + selectPath;\n  }\n\n  return parsed.modules[modulePath];\n}\n\n/**\n * @param srcFiles    map of source strings by file path\n *                    key is '/' separated relative path (relative to srcRoot, not absolute file path )\n *                    value is wesl source string\n * @param registry    add parsed modules to this registry\n * @param packageName name of package\n */\nexport function parseIntoRegistry(\n  srcFiles: Record<string, string>,\n  registry: ParsedRegistry,\n  packageName: string = \"package\",\n  maxParseCount?: number,\n): void {\n  const srcModules: SrcModule[] = Object.entries(srcFiles).map(\n    ([filePath, src]) => {\n      const modulePath = fileToModulePath(filePath, packageName);\n      return { modulePath, filePath, src };\n    },\n  );\n  srcModules.forEach(mod => {\n    const parsed = parseSrcModule(mod, undefined, maxParseCount);\n    if (registry.modules[mod.modulePath]) {\n      throw new Error(`duplicate module path: '${mod.modulePath}'`);\n    }\n    registry.modules[mod.modulePath] = parsed;\n  });\n}\n\nexport function parseLibsIntoRegistry(\n  libs: WgslBundle[],\n  registry: ParsedRegistry,\n): void {\n  libs.forEach(({ modules, name }) =>\n    parseIntoRegistry(modules, registry, name),\n  );\n}\n\nconst libExp = /^lib\\.w[eg]sl$/i;\n\n/** convert a relative file path (./foo/bar.wesl) to a module path (package::foo::bar) */\nfunction fileToModulePath(filePath: string, packageName: string): string {\n  if (packageName !== \"package\" && libExp.test(filePath)) {\n    // special case for lib.wesl files in external packages\n    return packageName;\n  }\n  const strippedPath = noSuffix(normalize(filePath));\n  const moduleSuffix = strippedPath.replaceAll(\"/\", \"::\");\n  const modulePath = packageName + \"::\" + moduleSuffix;\n  return modulePath;\n}\n","import { SrcMap, SrcMapBuilder, tracing } from \"mini-parse\";\nimport { bindIdents } from \"./BindIdents.ts\";\nimport { lowerAndEmit } from \"./LowerAndEmit.ts\";\nimport {\n  parsedRegistry,\n  ParsedRegistry,\n  parseIntoRegistry,\n  parseLibsIntoRegistry,\n  parseWeslSrc,\n  selectModule,\n} from \"./ParsedRegistry.ts\";\nimport { Conditions } from \"./Scope.ts\";\nimport { WgslBundle } from \"./WgslBundle.ts\";\n\n/* --- Overview: Plan for Linking WESL --- */\n\n/* \nThis is a bit of a rework/reshuffling from the 'legacy' version described in Internals.md.\n\nIt expects the parser to identify three types of idents: \n  global declarations, local declarations, references\n  (the legacy version distingished between type and variable idents, and more)\n\nIt tracks scopes, and keeps them independently from the AST. It uses the scopes trees for\nbinding references to declarations. (The legacy linker used combination\nof naming tricks and AST traversal to bind references to declarations.)\n\nBinding idents is more generic, which should simplify the code \nand extend more easily to for importing elements beyond structs and functions.\n\nIt asks less of the grammar, a complete WGSL grammar is easier to maintain \nif it can match the WGSL spec.\n\nIt replaces an AST pass with scope table pass, which should be a little faster. \n\nIt's much more friendly to future parallel execution and incremental rebuilding, \nwhich should make things a lot faster when we go there.\n\nThe architecture allows conditional compilation from the AST rather than from the src text.\n\nThe AST is now immutable, mutation is confined to the Idents and Scopes. \n*/\n\n/**\n * Link a set of WESL source modules (typically the text from .wesl files) into a single WGSL string.\n * Linking starts with a specified 'root' source module, and recursively incorporates code\n * referenced from other modules (in local files or libraries).\n *\n * Unreferenced (dead) code outside the root module is not included in the output WGSL.\n * Additionally the caller can specify conditions for to control conditional compilation.\n * Only code that is valid with the current conditions is included in the output.\n *\n * @param weslSrc map of wesl source strings (aka modules) by scoped path\n *                key is module path or file path\n *                  `package::foo::bar`, or './foo/bar.wesl', or './foo/bar'\n *                value is wesl src\n *                (inludes both library and local WESL modules)\n * @param rootModuleName name or module path of the root module\n * @param conditions runtime conditions for conditional compilation\n */\nexport function linkWesl(\n  weslSrc: Record<string, string>,\n  rootModuleName: string = \"main\",\n  conditions: Conditions = {},\n): SrcMap {\n  /* --- Step #1   Parsing WESL --- */\n  // parse all source modules in both app and libraries,\n  // producing Scope tree and AST elements for each module\n  const parsed: ParsedRegistry = parseWeslSrc(weslSrc);\n\n  return linkRegistry(parsed, rootModuleName, conditions);\n}\n\n// TODO DRY entry points\nexport function linkWeslFiles(\n  weslSrc: Record<string, string>,\n  rootModuleName: string = \"main\",\n  conditions: Conditions = {},\n  /** record of file names and wgsl text for modules */\n  libs: WgslBundle[] = [],\n  maxParseCount?: number,\n): SrcMap {\n  const registry = parsedRegistry();\n  parseIntoRegistry(weslSrc, registry, \"package\", maxParseCount);\n  parseLibsIntoRegistry(libs, registry);\n  return linkRegistry(registry, rootModuleName, conditions);\n}\n\nexport function linkRegistry(\n  parsed: ParsedRegistry,\n  rootModuleName: string = \"main\",\n  conditions: Conditions = {},\n): SrcMap {\n  // get a reference to the root module\n  const found = selectModule(parsed, rootModuleName);\n  if (!found) {\n    if (tracing) {\n      console.log(`parsed modules: ${Object.keys(parsed.modules)}`); \n      console.log(`root module not found: ${rootModuleName}`); \n    }\n    throw new Error(`Root module not found: ${rootModuleName}`);\n  }\n  const { moduleElem: rootModule } = found;\n  \n  /* --- Step #2   Binding Idents --- */\n  // link active Ident references to declarations, and uniquify global declarations\n  const newDecls = bindIdents(found, parsed, conditions);\n\n  /* --- Step #3   Writing WGSL --- */\n  // traverse the AST and emit WGSL (doesn't need scopes)\n  const srcBuilder = new SrcMapBuilder();\n  lowerAndEmit(srcBuilder, [rootModule], conditions, false); // emit the entire root module\n  lowerAndEmit(srcBuilder, newDecls, conditions); // emit referenced declarations from other modules\n  return srcBuilder.build();\n}\n\n/* ---- Commentary on present and future features ---- */\n/*\n\nTODO \n- distinguish between global and local declaration idents (only global ones need be uniquified)\n\nConditions\n- conditions are attached to the AST elements where they are defined\n  - only conditionally valid elements are emitted\n- consolidated conditions are attached to Idents\n  - only conditionally valid ref Idents are bound, and only to conditionaly valid declarations\n  - a condition stack (akin to the scope stack) is maintained while parsing to attach consolidated conditions to Idents\n- re-linking with new conditions, conservatively \n  - clear all mutated Ident fields (refersTo and mangled links) \n  - re-bind Idents, re-emit \n\nGenerics & specialization\n- attach generic parameters to ref and decl Idents, effectively creating a new Ident for each specialization\n- generate specialized elements at emit time, by checking the generic parameters of the decl ident\n\nIncrementally rebuilding\n- unchanged files don't need to be reparsed, only reparse dirty files.\n- support reflection only mode? no need to bind idents or emit for e.g. vite/IDE plugin generating reflection types \n\nParallel Processing (coarse grained via webworkers)\n- Parsing each module can be done in parallel\n- binding could be done partially in parallel? (esbuild doesn't parallelize here though)\n  - finding the declaration for each local ident could be done in parallel by module\n  - matching \n- Emitting could be easily modified to be done in partially in parallel\n  - traversing the AST to list the top level elements to emit could be done serially\n  - the text for each top level element could be emitted in parallel (presumably the bulk of the work)\n  - the merged text can be assembled serially\n\n*/\n"],"names":["_fragments","kind","end","last","ident","parser","fn","collectFn","ctag","ctx","result","newParser","eof","position","tokenMatcher","ignore","text","map","importElem","eolf","relativePath","refIdent","flatImports","displayName","src"],"mappings":"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"}

package/dist/wesl-testsuite/src/test-cases/BulkTests.d.ts

@@ -0,0 +1,4 @@
+import { BulkTest } from '../TestSchema.js';
+/** tests run on projects in the https://github.com/wgsl-tooling-wg/community-wgsl repo */
+export declare const bulkTests: BulkTest[];
+export default bulkTests;

package/dist/wesl-testsuite/src/test-cases/ImportCases.d.ts

@@ -0,0 +1,3 @@
+import { WgslTestSrc } from '../TestSchema.js';
+export declare const importCases: WgslTestSrc[];
+export default importCases;

package/dist/wesl-testsuite/src/test-cases/ImportSyntaxCases.d.ts

@@ -0,0 +1,3 @@
+import { ParsingTest } from '../TestSchema.js';
+export declare const importSyntaxCases: ParsingTest[];
+export default importSyntaxCases;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "wesl",
+  "version": "0.6.0-pre2",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "repository": "github:wgsl-tooling-wg/wgsl-linker",
+  "exports": {
+    ".": {
+      "types": "./dist/linker/src/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./minified": {
+      "types": "./dist/linker/src/index.d.ts",
+      "import": "./dist/minified.js",
+      "require": "./dist/minified.cjs"
+    }
+  },
+  "dependencies": {
+    "mini-parse": "0.6.0-pre2"
+  },
+  "devDependencies": {
+    "ncp": "^2.0.0",
+    "rollup-plugin-visualizer": "^5.12.0",
+    "terser": "^5.36.0",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^2.1.4",
+    "random_wgsl": "0.6.0-pre2"
+  },
+  "scripts": {
+    "build": "run-s build:main build:minified",
+    "build:main": "vite build",
+    "build:minified": "vite build -c minified.vite.config.js",
+    "build:brotli": "brotli -f dist/minified.cjs && ls -l dist/minified.cjs.br",
+    "build:size": "run-s build:minified build:brotli",
+    "format": "prettier . --write",
+    "lint": "eslint src",
+    "organize": "organize-imports-cli tsconfig.json",
+    "test": "vitest",
+    "test:once": "vitest run"
+  }
+}