{"version":3,"file":"minified.cjs","sources":["../../mini-parse/src/ParserUtil.ts","../../mini-parse/src/ParserCombinator.ts","../../mini-parse/src/ParserLogging.ts","../../mini-parse/src/Parser.ts","../../mini-parse/src/ParserTracing.ts","../../mini-parse/src/MatchingLexer.ts","../../mini-parse/src/SrcMap.ts","../../mini-parse/src/TokenMatcher.ts","../src/LinkerLogging.ts","../src/Util.ts","../src/Slicer.ts","../src/ResolveImport.ts","../src/TraverseRefs.ts","../../../node_modules/.pnpm/berry-pretty@0.0.5/node_modules/berry-pretty/dist/index.js","../src/Linker.ts","../src/ImportTree.ts","../src/PathUtil.ts","../src/ImportResolutionMap.ts","../src/MatchWgslD.ts","../src/Conditionals.ts","../src/ParseSupport.ts","../src/GleamImport.ts","../src/ParseDirective.ts","../src/ParseWgslD.ts","../src/ParseModule.ts","../src/ParsedRegistry.ts","../src/ModuleRegistry.ts"],"sourcesContent":["/** 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}","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  ParserContext,\n  ParserResult,\n  TagRecord,\n  parser,\n  runExtended,\n  simpleParser,\n  tokenSkipSet,\n} from \"./Parser.js\";\nimport { ctxLog } from \"./ParserLogging.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    `text ${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\n  const result = parser(\"seq\", (ctx: ParserContext) => {\n    const values = [];\n    let tagged = {};\n    for (const p of parsers) {\n      const result = p._run(ctx);\n      if (result === null) return null;\n\n      tagged = mergeTags(tagged, result.tags);\n      values.push(result.value);\n    }\n    return { value: values, tags: tagged };\n  });\n\n  return result 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 result = 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  return result 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 result: 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  return result;\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  return 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}\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 result = seq(repeat(anyNot(p)), p).traceName(\n    `anyThrough ${p.debugName}`\n  );\n  type V = typeof result extends Parser<infer V, any> ? V : never;\n  return result 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  return parser(\"repeat\", repeatWhileFilter(arg));\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  return seq(p, repeat(p))\n    .map((r) => [r.value[0], ...r.value[1]])\n    .traceName(\"repeatPlus\");\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  return parser(\"repeatWhile\", repeatWhileFilter(arg, filterFn));\n}\n\ntype RepeatWhileResult<A extends CombinatorArg> = OptParserResult<\n  SeqValues<A[]>,\n  TagsFromArg<A>\n>;\n\nfunction repeatWhileFilter<A extends CombinatorArg>(\n  arg: A,\n  filterFn: ResultFilterFn<ResultFromArg<A>> = () => true\n): (ctx: ParserContext) => RepeatWhileResult<A> {\n  const p = parserArg(arg);\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  return parser(\"req\", (ctx: ParserContext) => {\n    const result = p._run(ctx);\n    if (result === null) {\n      ctxLog(ctx, msg ?? `expected ${p.debugName}`);\n      throw new ParseError();\n    }\n    return result;\n  });\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 pTagged = or(parser).tag(\"_sepTag\");\n  const first = requireOne ? pTagged : opt(pTagged);\n  const last = trailing ? opt(sep) : yes();\n\n  return seq(first, repeat(seq(sep, 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\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  return parser(`tokens ${matcher._traceName}`, (state: ParserContext) => {\n    return state.lexer.withMatcher(matcher, () => {\n      return p._run(state);\n    });\n  });\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  return 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}\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  return parser(\"withTags\", (ctx: ParserContext) => {\n    const result = p._run(ctx);\n    return result ? { value: result.value, tags: {} } : null;\n  });\n}\n","import { ExtendedResult, ParserContext } from \"./Parser.js\";\nimport { logger, parserLog } 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(result: ExtendedResult<any, any>, ...msgs: any[]): 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  log(line, `  Ln ${lineNum}`);\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 { CombinatorArg, ParserFromArg } from \"./CombinatorTypes.js\";\nimport { Lexer } from \"./MatchingLexer.js\";\nimport { ParseError, parserArg } from \"./ParserCombinator.js\";\nimport { srcLog } from \"./ParserLogging.js\";\nimport {\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<A> {\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: A;\n\n  /** typical place for user written parsers to accumulate results, e.g. syntax tree */\n  state: any;\n}\n\nexport interface ParserInit<A = any> {\n  /** supply tokens to the parser*/\n  lexer: Lexer;\n\n  /** application specific context and result storage, shared with every parser */\n  app?: AppState<A>;\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<A = any> {\n  lexer: Lexer;\n\n  app: AppState<A>;\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;\n\n  _debugNames: string[];\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<T, N extends TagRecord = NoTags, A = any>\n  extends ParserResult<T, N> {\n  src: string;\n  srcMap?: SrcMap;\n  start: number;\n  end: number;\n  app: AppState<A>;\n  ctx: ParserContext<A>;\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  preDisabled?: true;\n}\n\ninterface ConstructArgs<T, N extends TagRecord> extends ParserArgs {\n  fn: ParseFn<T, N>;\n}\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  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.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      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  /** 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  /** 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        app = { context: {}, state: [] },\n      } = init;\n      return this._run({\n        lexer,\n        app,\n        srcMap,\n        _preParse: [],\n        _parseCount: 0,\n        _preCacheFails: new Map(),\n        maxParseCount,\n        _debugNames: [this.debugName],\n      });\n    } catch (e) {\n      if (!(e instanceof ParseError)) {\n        console.error(e);\n      }\n      return null;\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  parser._traceName = traceName;\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  const origPosition = lexer.position();\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  function runInContext(tContext: ParserContext): OptParserResult<T, N> {\n    tContext._debugNames.push(p.debugName);\n    const traceSuccessOnly = tContext._trace?.successOnly;\n    if (!p.terminal && tracing && !traceSuccessOnly)\n      parserLog(`..${p.debugName}`);\n\n    if (!p.preDisabled) {\n      execPreParsers(tContext);\n    } else {\n      tContext._preParse = [];\n    }\n\n    // run the parser function for this stage\n    const result = p.fn(tContext);\n\n    tContext._debugNames.pop();\n\n    if (result === null || result === undefined) {\n      // parser failed\n      tracing && !traceSuccessOnly && parserLog(`x ${p.debugName}`);\n      // parserLog(\"reset position to:\", origPosition)\n      lexer.position(origPosition);\n      context.app.context = origAppContext;\n      return null;\n    } else {\n      // parser succeeded\n      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      return { value, tags };\n    }\n  }\n\n  return result;\n}\n\nfunction execPreParsers(ctx: ParserContext): void {\n  const { _preParse, _preCacheFails, lexer } = ctx;\n\n  const ctxNoPre = { ...ctx, _preParse: [] };\n  _preParse.forEach((pre) => {\n    // get the cache of failed positions for this pre-parser\n    const failCache = _preCacheFails.get(pre) || new Set();\n    _preCacheFails.set(pre, failCache);\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 (failCache.has(position)) break;\n\n      preResult = pre._run(ctxNoPre);\n    } while (preResult !== null && preResult !== undefined);\n\n    failCache.add(position);\n    lexer.position(position); // reset position to end of last successful parse\n  });\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  return parser(`map`, (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\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  return parser(\"toParser\", (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\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  mainParser: Parser<T, N>\n): Parser<T, N> {\n  const ignoreSet = ignore ?? emptySet;\n  return parser(\n    `tokenIgnore ${[...ignoreSet.values()]}`,\n    (ctx: ParserContext): OptParserResult<T, N> =>\n      ctx.lexer.withIgnore(ignoreSet, () => mainParser._run(ctx))\n  );\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  mainParser: Parser<T, N>\n): Parser<T, N> {\n  return parser(\"preParse\", (ctx: ParserContext): OptParserResult<T, N> => {\n    const newCtx = { ...ctx, _preParse: [pre, ...ctx._preParse] };\n    return mainParser._run(newCtx);\n  });\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","import { Parser, ParserContext, setTraceName } from \"./Parser.js\";\n\nexport let tracing = false;\n\n/** enable tracing of parser activity via .trace() */\nexport function enableTracing(): void {\n  tracing = true;\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\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/** 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}); // TODO FIXME later, shouldn't need to copy 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}","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\"), rootMatcher;\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","import { dlog } from \"berry-pretty\";\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   */\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      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 { srcLog } from \"./ParserLogging.js\";\n\nexport interface Token {\n  kind: string;\n  text: string;\n}\n\ntype 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  _traceName?: 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      this.delete(this.keys().next().value);\n    }\n    return super.set(k, v);\n  }\n}\n\nexport function tokenMatcher<T extends Record<string, string | RegExp>>(\n  matchers: T,\n  traceName = \"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, \"midg\");\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        // grammar didn't recognize something, and regex skipped ahead to match\n        srcLog(\n          src,\n          startPos,\n          `skipped: '${src.slice(startPos, startEnd[0])}' to get to: '${text}'`\n        );\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    _traceName: traceName,\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 { logger, srcLog } from \"mini-parse\";\nimport { AbstractElem } from \"./AbstractElems.js\";\nimport { TextModule } from \"./ParseModule.js\";\nimport { FoundRef } from \"./TraverseRefs.js\";\n\nexport function refLog(ref: FoundRef, ...msgs: any[]): void {\n  if (ref.kind !== \"gen\") {\n    moduleLog(ref.expMod, [ref.elem.start, ref.elem.end], ...msgs);\n  } else {\n    logger(ref.name, ...msgs);\n  }\n}\n\nexport function moduleLog(\n  mod: TextModule,\n  pos: number | [number, number],\n  ...msgs: any[]\n): void {\n  const { src, srcMap } = mod;\n  srcLog(\n    srcMap ?? src,\n    pos,\n    ...msgs,\n    ` module: ${mod.modulePath}`\n  );\n}\n\nexport function elemLog(\n  mod: TextModule,\n  elem: AbstractElem,\n  ...msgs: any[]\n): void {\n  const { src, srcMap } = mod;\n  const { start, end } = elem;\n  srcLog(srcMap ?? src, [start, end], ...msgs);\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    partFn(t) ? yesPart.push(t) : 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 { SrcMap, SrcMapEntry } from \"mini-parse\";\nimport { last, scan } from \"./Util.js\";\n\n/** specify a start,end portion of a string to be replaced */\nexport interface SliceReplace {\n  start: number;\n  end: number;\n  replacement: string;\n}\n\ninterface SlicingProgress {\n  srcPos: number;\n  destPos: number;\n  results: string[];\n  entries: SrcMapEntry[];\n}\n\n/**\n * Rewrite a string by replacing segments them with provided texts.\n *\n * example:\n * src:\n *  aaabbbbbc\n *     ^    ^\n *     St   End Repl='XXX'\n *\n * returns a srcMap with the new text and mappings from the original text to the new text\n *  aaaXXXc\n */\nexport function sliceReplace(\n  src: string,\n  slices: SliceReplace[],\n  start = 0,\n  end = src.length\n): SrcMap {\n  const sorted = [...slices].sort((a, b) => a.start - b.start);\n  const initProgress = { srcPos: start, destPos: 0, results: [], entries: [] };\n  const slicePogress = scan(sorted, oneSlice, initProgress);\n  const lastProgress = finalProgress2(slicePogress);\n\n  const { results, entries } = lastProgress;\n  const text = results.join(\"\");\n  const srcMap = new SrcMap(text, entries);\n  return srcMap;\n\n  /** visit one slice, return progress */\n  function oneSlice(\n    slice: SliceReplace,\n    progress: SlicingProgress\n  ): SlicingProgress {\n    // dlog({ slice });\n    // update text with copy and replacement\n    const copyText = src.slice(progress.srcPos, slice.start);\n    const copied = replaceOne(copyText, slice.start, progress);\n    const replaced = replaceOne(slice.replacement, slice.end, copied);\n\n    return replaced;\n  }\n\n  /** add provided text to the result, advance src position, and add a srcMap entry\n   * @return the accumulated progress */\n  function replaceOne(\n    replacement: string,\n    newSrcPos: number,\n    progress: SlicingProgress\n  ): SlicingProgress {\n    const { destPos, entries } = progress;\n    const newDestPos = destPos + replacement.length;\n\n    // new srcMap entry if there is a replacement text (otherwise there's nothing to map dest to src)\n    let newEntries = entries;\n    if (replacement) {\n      const { srcPos } = progress;\n      newEntries = entries.concat({\n        src,\n        srcStart: srcPos,\n        srcEnd: newSrcPos,\n        destStart: destPos,\n        destEnd: newDestPos,\n      });\n    }\n\n    // update results text and progress\n    const { results } = progress;\n    const newResults = replacement ? results.concat(replacement) : results;\n    return {\n      srcPos: newSrcPos,\n      destPos: newDestPos,\n      results: newResults,\n      entries: newEntries,\n    };\n  }\n\n  /**\n   * If there's any trailing text uncovered by the slices before the end,\n   * add a result and srcMap entry\n   *\n   * @return the accumulated progress\n   */\n  function finalProgress2(progress: SlicingProgress[]): SlicingProgress {\n    const lastProgress = last(progress) ?? initProgress;\n    const { srcPos } = lastProgress;\n    return replaceOne(src.slice(srcPos, end), end, lastProgress);\n  }\n}\n\nconst tokenRegex = /\\b(\\w+)\\b/gi;\n/** find strings in a text -\n * found strings must be 'tokens', surrounded by spaces or punctuation\n *\n * @return SliceReplace elements\n */\nexport function sliceWords(\n  text: string,\n  replace: Record<string, string>\n): SliceReplace[] {\n  const tokens = [...text.matchAll(tokenRegex)];\n  const find = Object.keys(replace);\n  const matches = tokens.filter((m) => find.includes(m[0]));\n  const slices = matches.map((m) => {\n    const start = m.index;\n    const end = start + m[0].length;\n    const replacement = replace[m[0]];\n    return { start, end, replacement };\n  });\n  return slices;\n}\n","import { dlog } from \"berry-pretty\";\nimport { ResolveMap } from \"./ImportResolutionMap.js\";\nimport { ModuleExport } from \"./ModuleRegistry.js\";\nimport { StringPairs } from \"./TraverseRefs.js\";\nimport { overlapTail } from \"./Util.js\";\nimport { logResolveMap } from \"./LogResolveMap.js\";\n\nexport interface ResolvedImport {\n  modExp: ModuleExport;\n  callSegments: string[];\n  expImpArgs: StringPairs;\n}\n\n/** resolve an import to an export using the resolveMap\n * @param callPath the reference to the import, e.g. \"foo::bar\" from\n *    import pkg::foo\n *    fn () { foo::bar(); }\n *\n * Cases: all of these find export path pkg/foo\n *   foo() -> import pkg::foo,\n *   bar() -> import pkg::foo as bar\n *   pkg::foo()  -> import pkg\n *   pkg::foo()  -> import pkg::foo\n *   npkg::foo() -> import pkg as npkg\n *   npkg.foo()  -> import pkg as npkg\n */\nexport function resolveImport(\n  callPath: string,\n  resolveMap: ResolveMap\n): ResolvedImport | undefined {\n  const callSegments = callPath.includes(\"::\")\n    ? callPath.split(\"::\")\n    : callPath.split(\".\");\n\n  // logResolveMap(resolveMap);\n\n  const expPath = impToExportPath(callSegments, resolveMap);\n  if (expPath) {\n    const impToExp = resolveMap.exportMap.get(expPath);\n    // dlog({ callSegments, expPath, impToExp: !!impToExp });\n\n    if (impToExp) {\n      const { modExp, expImpArgs } = impToExp;\n      return { modExp, callSegments, expImpArgs };\n    }\n  } else {\n    // dlog({ callSegments, expPath });\n  }\n\n  return undefined;\n}\n\n/** Convert a caller path to an export path,\n * caller paths are allowed to overlap with export paths\n * (at least with rust style call syntax, where e.g. foo overlaps:\n *    import pkg::foo;\n *    foo::bar()\n *  )\n */\nfunction impToExportPath(\n  impSegments: string[],\n  resolveMap: ResolveMap\n): string | undefined {\n  const { pathsMap } = resolveMap;\n  for (const [imp, exp] of pathsMap) {\n    const impTail = overlapTail(imp, impSegments);\n    if (impTail) {\n      const combined = [exp, ...impTail];\n      return combined.join(\"/\");\n    }\n  }\n\n  return undefined;\n}\n","import { dlog } from \"berry-pretty\";\nimport {\n  AliasElem,\n  CallElem,\n  ExportElem,\n  ExtendsElem,\n  FnElem,\n  StructElem,\n  StructMemberElem,\n  TreeImportElem,\n  TypeRefElem,\n  VarElem,\n} from \"./AbstractElems.js\";\nimport { refFullName } from \"./Linker.js\";\nimport { moduleLog } from \"./LinkerLogging.js\";\nimport {\n  GeneratorExport,\n  GeneratorModule,\n  ModuleExport,\n} from \"./ModuleRegistry.js\";\nimport { ParsedRegistry } from \"./ParsedRegistry.js\";\nimport { TextExport, TextModule } from \"./ParseModule.js\";\nimport { resolveImport } from \"./ResolveImport.js\";\nimport { groupBy, last } from \"./Util.js\";\n\n/**\n * A wrapper around a wgsl element targeted for inclusion in the link\n * There is one FoundRef per unique target element.\n * . Multiple references to a single target element share the same FoundRef.\n * . But multiple versions of a target element from generic expansion\n *   result in multiple FoundRefs.\n */\nexport type FoundRef = TextRef | GeneratorRef;\n\nexport type StringPairs = [string, string][];\n\ninterface FoundRefBase {\n  /** proposed name to use for this referent, either fn/struct name or 'as' name from the import.\n   * name might still be rewritten by global uniqueness remapping */\n  proposedName: string;\n\n  /** rename needed for the referent element due to the global uniqueness mapping */\n  rename?: string;\n}\n\nexport interface ExportInfo {\n  /** reference that led us to find this ref */\n  fromRef: FoundRef;\n\n  /** import or extends elem that resolved to this export (so we can later separate out extends) */\n  fromImport: ExtendsElem | TreeImportElem;\n\n  /** mapping from export arguments to import arguments\n   * (could be mapping to import args prior to this import, via chain of importing) */\n  expImpArgs: [string, string][];\n}\n\nexport interface GeneratorRef extends FoundRefBase {\n  kind: \"gen\";\n\n  expInfo: ExportInfo;\n\n  /** module containing the exported function */\n  expMod: GeneratorModule;\n\n  /** name of the generated function (may be renamed by import as) */\n  name: string;\n\n  mergeRefs?: undefined;\n}\n\n/** A reference to a target wgsl element (e.g. a function). */\nexport interface TextRef extends FoundRefBase {\n  kind: \"txt\";\n\n  /** module containing the referenced element */\n  expMod: TextModule;\n\n  /** referenced element */\n  elem: FnElem | StructElem | VarElem | AliasElem | StructMemberElem;\n\n  /** extra data if the referenced element is from another module */\n  expInfo?: ExportInfo;\n\n  /** refs to extends elements on this struct element\n   * (added in a post processing step after traverse) */\n  mergeRefs?: TextRef[];\n}\n\n/**\n * Recursively walk through all imported references starting from a src module, calling\n * a function for each reference to an addressable wgsl element (fn, struct, etc.).\n *\n * Note that the reference graph may have multiple references to the same src element.\n * (Currently the linker will recurse through the the same node multiple times\n * to handle varied import parameters.)\n */\nexport function traverseRefs(\n  srcModule: TextModule,\n  registry: ParsedRegistry,\n  fn: (ref: FoundRef) => void\n): void {\n  const { aliases, fns, structs, vars } = srcModule;\n  const expMod = srcModule;\n  const srcRefs: TextRef[] = [...structs, ...vars, ...fns, ...aliases].map(\n    (elem) => ({\n      kind: \"txt\",\n      proposedName: elem.name,\n      expMod,\n      elem,\n    })\n  );\n  srcRefs.forEach((ref) => fn(ref));\n  if (!srcRefs.length) return;\n\n  // recurse on the external refs from the src root elements\n  const nonGenRefs = textRefs(srcRefs);\n  const childRefs = nonGenRefs.flatMap((srcRef) =>\n    elemRefs(srcRef, srcModule, registry)\n  );\n  const seen = new Set<string>();\n  recursiveRefs(childRefs, registry, eachRef);\n\n  function eachRef(ref: FoundRef): true | undefined {\n    // printRef(ref);\n    fn(ref);\n    if (unseen(ref)) {\n      return true;\n    }\n  }\n\n  function unseen(ref: FoundRef): true | undefined {\n    const fullName = refFullName(ref);\n    if (!seen.has(fullName)) {\n      seen.add(fullName);\n      return true;\n    }\n  }\n}\n\n/*\n * traversal of the wgsl src reference graph as follows:\n *  fn -> calls -> (local fn or import+export+fn)\n *  fn -> typeRefs -> (local struct or import+export+struct)\n *  struct -> typeRefs -> (local struct or import+export+struct)\n *  struct -> extends -> (local struct or import+export+struct)\n *  var -> typeRefs -> (local struct or import+export+struct)\n */\nfunction recursiveRefs(\n  refs: FoundRef[],\n  registry: ParsedRegistry,\n  fn: (ref: FoundRef) => boolean | undefined\n): void {\n  // run the fn on each ref, and prep to recurse on each ref for which the fn returns true\n  const filtered = refs.filter((r) => fn(r));\n\n  const nonGenRefs = textRefs(filtered); // we don't need to trace generated text (and thus we don't parse it anyway)\n\n  const modGroups = groupBy(nonGenRefs, (r) => r.expMod);\n  [...modGroups.entries()].forEach(([mod, refs]) => {\n    if (refs.length) {\n      const childRefs = refs.flatMap((r) => elemRefs(r, mod, registry));\n      recursiveRefs(childRefs, registry, fn);\n    }\n  });\n}\n\nexport function textRefs(refs: FoundRef[]): TextRef[] {\n  return refs.filter(textRef);\n}\n\nfunction textRef(ref: FoundRef): ref is TextRef {\n  return ref.kind !== \"gen\";\n}\n\n/** return all struct/fn refs from a src element */\nfunction elemRefs(\n  srcRef: TextRef,\n  mod: TextModule,\n  registry: ParsedRegistry\n): FoundRef[] {\n  const { elem } = srcRef;\n  let fnRefs: FoundRef[] = [];\n  let mergeRefs: FoundRef[] = [];\n  if (elem.kind === \"fn\") {\n    const userCalls = elem.calls.filter(\n      (call) => !stdFn(call.name) && call.name !== elem.name\n    );\n    fnRefs = elemChildrenRefs(srcRef, userCalls, mod, registry);\n  } else if (elem.kind === \"struct\") {\n    mergeRefs = extendsRefs(srcRef, elem, mod, registry);\n  }\n  const userTypeRefs = elemTypeRefs(elem);\n  const tRefs = elemChildrenRefs(srcRef, userTypeRefs, mod, registry);\n  return [...fnRefs, ...tRefs, ...mergeRefs];\n}\n\n/** return type references from an element */\nfunction elemTypeRefs(\n  elem: FnElem | StructElem | VarElem | AliasElem | StructMemberElem\n): TypeRefElem[] {\n  let typeRefs: TypeRefElem[];\n  const { kind } = elem;\n  if (\n    kind === \"fn\" ||\n    kind === \"var\" ||\n    kind === \"alias\" ||\n    kind === \"member\"\n  ) {\n    typeRefs = elem.typeRefs;\n  } else if (kind === \"struct\") {\n    typeRefs = elem.members?.flatMap((m) => m.typeRefs) || [];\n  } else {\n    console.error(\"unexpected kind\", elem);\n    typeRefs = [];\n  }\n  const userTypeRefs = typeRefs.filter((ref) => !stdType(ref.name));\n  return userTypeRefs;\n}\n\n/** find fn/struct references from children of a fn or struct elem\n * (children being call references and type references from the fn or struct) */\nfunction elemChildrenRefs(\n  srcRef: TextRef,\n  children: (CallElem | TypeRefElem)[],\n  mod: TextModule,\n  registry: ParsedRegistry\n): FoundRef[] {\n  return children.flatMap((elem) => linkedRef(elem, srcRef, mod, registry));\n}\n\n/** given a source elem that refers to another element (like a fn call or type reference),\n * return a TextRef linking the src elem to its referent, possibly through an import/export */\nfunction linkedRef(\n  elem: CallElem | TypeRefElem,\n  srcRef: TextRef,\n  mod: TextModule,\n  registry: ParsedRegistry\n): FoundRef[] {\n  const { name } = elem;\n  if (importArgRef(srcRef, name)) return [];\n\n  const foundRef =\n    importRef(srcRef, name, mod, mod.imports, registry) ??\n    // importingRef(srcRef, name, mod, registry) ??\n    localRef(name, mod);\n\n  if (foundRef) {\n    if ([\"typeRef\", \"call\"].includes(elem.kind)) {\n      // bind src elem to referent elem (resolve reference)\n      elem.ref = foundRef;\n    } else {\n      console.error(\"unexpected kind\", elem);\n    }\n  }\n\n  if (foundRef) return [foundRef];\n\n  moduleLog(srcRef.expMod, elem.start, `reference not found: ${name}`);\n  return [];\n}\n\n/** create references to any extends elements attached to this struct */\nfunction extendsRefs(\n  srcRef: TextRef,\n  elem: StructElem,\n  mod: TextModule,\n  registry: ParsedRegistry\n): FoundRef[] {\n  const merges = elem.extendsElems;\n  if (!merges) return [];\n  return merges.flatMap((merge) => {\n    const foundRef = importRef(srcRef, merge.name, mod, mod.imports, registry);\n    if (foundRef) return [foundRef];\n\n    moduleLog(srcRef.expMod, merge.start, `import merge reference not found`);\n    return [];\n  });\n}\n\n/** @return true if the ref is to an import parameter */\nfunction importArgRef(srcRef: FoundRef, name: string): boolean | undefined {\n  if (srcRef.expInfo) {\n    return !!srcRef.expInfo.expImpArgs.find(([expArg]) => expArg === name);\n  }\n}\n\n/** If this src element references an #import function\n * @return an TextRef describing the export to link */\nfunction importRef(\n  fromRef: TextRef,\n  name: string,\n  impMod: TextModule,\n  imports: (TreeImportElem | ExtendsElem)[],\n  registry: ParsedRegistry\n): TextRef | GeneratorRef | undefined {\n  const resolveMap = registry.importResolveMap(impMod);\n  const resolved = resolveImport(name, resolveMap);\n  const fromImport = imports[0]; // TODO implement\n  if (resolved) {\n    const { modExp, callSegments, expImpArgs } = resolved;\n    const proposedName = last(callSegments)!;\n    const expMod = modExp.module;\n    const expInfo: ExportInfo = {\n      fromImport,\n      fromRef,\n      expImpArgs,\n    };\n    if (expMod.kind === \"text\") {\n      const exp = modExp.exp as TextExport;\n      return {\n        kind: \"txt\",\n        expInfo,\n        expMod,\n        elem: exp.ref,\n        proposedName,\n      };\n    } else if (expMod.kind === \"generator\") {\n      const exp = modExp.exp as GeneratorExport;\n      return {\n        kind: \"gen\",\n        expInfo,\n        expMod,\n        proposedName,\n        name: exp.name,\n      };\n    }\n  }\n}\n\n// function matchImportExportArgs(\n//   impMod: TextModule | GeneratorModule,\n//   imp: ExtendsElem,\n//   expMod: TextModule | GeneratorModule,\n//   exp: ExportElem | GeneratorExport\n// ): StringPairs {\n//   const impArgs = imp.args ?? [];\n//   const expArgs = exp.args ?? [];\n//   if (expArgs.length !== impArgs.length) {\n//     impMod.kind === \"text\" &&\n//       moduleLog(impMod, imp.start, \"mismatched import and export params\");\n//     expMod.kind === \"text\" && moduleLog(expMod, (exp as ExportElem).start);\n//   }\n//   return expArgs.map((p, i) => [p, impArgs[i]]);\n// }\n\n/** If this element references an #export.. importing function\n * @return a ref describing the export to link */\n// function importingRef(\n//   srcRef: FoundRef,\n//   name: string,\n//   impMod: TextModule,\n//   registry: ParsedRegistry\n// ): TextRef | GeneratorRef | undefined {\n// let fromImport: TreeImportElem | undefined;\n\n// // find a matching 'importing' phrase in an #export\n// const textExport = impMod.exports.find((exp) => {\n//   fromImport = exp.importing?.find((i) => i.name === name);\n//   return !!fromImport;\n// });\n\n// // find the export for the importing\n// const modExp = matchingExport(fromImport, impMod, registry);\n// if (!modExp) return;\n// isDefined(fromImport);\n// isDefined(textExport);\n\n// if (srcRef.kind !== \"txt\") {\n//   refLog(srcRef, \"unexpected srcRef\", srcRef.kind);\n//   return;\n// }\n\n// const expImpArgs = importingArgs(fromImport, modExp.exp, srcRef);\n// const expInfo: ExportInfo = {\n//   fromRef: srcRef,\n//   fromImport,\n//   expImpArgs,\n// };\n// if (modExp.kind === \"text\") {\n//   const exp = modExp.exp;\n\n//   return {\n//     kind: \"txt\",\n//     expInfo,\n//     expMod: modExp.module as TextModule,\n//     elem: exp.ref,\n//     proposedName: fromImport.as ?? exp.ref.name,\n//   };\n// } else if (modExp.kind === \"function\") {\n//   const exp = modExp.exp;\n//   return {\n//     kind: \"gen\",\n//     expInfo,\n//     expMod: modExp.module,\n//     proposedName: fromImport.as ?? exp.name,\n//     name: exp.name,\n//   };\n// }\n\n//   return undefined;\n// }\n\n/**\n * @return the arguments for an importing reference, mapping through the\n * export and the original import directives.\n *\n * e.g. we're tracking a fn call that references through an 'importing':\n *   import1 -> export2 -> importing3 -> export4\n * and we want to find the mapping from export4 args to import1 args\n *\n * for example:\n *   #import foo(A, B)\n *   #export foo(C, D) importing bar(D)\n *   #export bar(X)\n * we want to return mapping of X -> B for the importing clasue\n *\n * @param imp - the importing clause\n * @param exp - export matching the importing clause\n * @param srcRef - reference that led us to this import\n */\nfunction importingArgs(\n  imp: TreeImportElem,\n  exp: ExportElem | GeneratorExport,\n  srcRef: TextRef\n): StringPairs {\n  return [];\n  // if (srcRef.expInfo === undefined) return [];\n  // const expImp = matchImportExportArgs(\n  //   srcRef.expInfo.fromRef.expMod,\n  //   imp,\n  //   srcRef.expMod,\n  //   exp\n  // ); // X -> D\n  // const srcExpImp = srcRef.expInfo.expImpArgs;\n  // return expImp.flatMap(([iExp, iImp]) => {\n  //   const pair = srcExpImp.find(([srcExpArg]) => srcExpArg === iImp); // D -> B\n  //   if (!pair) {\n  //     moduleLog(srcRef.expMod, imp.start, \"importing arg doesn't match export\");\n  //     return [];\n  //   }\n  //   const [, impArg] = pair;\n  //   return [[iExp, impArg]] as [string, string][]; // X -> B\n  // });\n}\n\nfunction isDefined<T>(a: T | undefined): asserts a is T {\n  /* */\n}\n\nfunction matchingExport(\n  imp: TreeImportElem | ExtendsElem | undefined,\n  mod: TextModule,\n  registry: ParsedRegistry\n): ModuleExport | undefined {\n  if (!imp) return;\n\n  dlog(\"NYI\");\n  // TODO\n\n  // const modExp = registry.getModuleExportOld(mod, imp.name, imp.from);\n  // if (!modExp) {\n  //   moduleLog(mod, imp.start, \"export not found for import\");\n  // }\n  // return modExp;\n}\n\nfunction localRef(name: string, mod: TextModule): TextRef | undefined {\n  const elem =\n    mod.fns.find((fn) => fn.name === name) ??\n    mod.structs.find((s) => s.name === name);\n  if (elem) {\n    return {\n      kind: \"txt\",\n      expMod: mod,\n      elem: elem,\n      proposedName: elem.name,\n      expInfo: undefined,\n    };\n  }\n}\n\ninterface AsNamed {\n  as?: string;\n  name: string;\n}\n\nfunction importName(asNamed: AsNamed): string {\n  return asNamed.as || asNamed.name;\n}\n\nconst 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 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\nconst 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 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  `.split(/\\s+/);\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) */\nfunction stdType(name: string): boolean {\n  return stdTypes.includes(name);\n}\n\nexport function refName(ref: FoundRef): string {\n  return ref.kind === \"gen\" ? ref.name : ref.elem.name;\n}\n\n/** return true if the name is for a built in fn (not a user function) */\nfunction stdFn(name: string): boolean {\n  return stdFns.includes(name) || stdType(name);\n}\n","// src/BerryStringUtil.ts\nvar spaces = memoize((nesting) => {\n  return \" \".repeat(nesting);\n});\nvar defaultCallerSize = 20;\nvar multiLinePad = \"\\n\" + spaces(defaultCallerSize + 3);\nfunction indentMultiLine(messages) {\n  return messages.map(indentString);\n}\nfunction padTrimCaller(caller, callerSize = defaultCallerSize) {\n  return (caller + spaces(callerSize)).slice(0, callerSize);\n}\nfunction indentString(m) {\n  if (typeof m === \"string\") {\n    return m.replace(/\\n/g, multiLinePad);\n  } else {\n    return m;\n  }\n}\nfunction memoize(fn) {\n  const cache = /* @__PURE__ */ new Map();\n  return function(...args) {\n    const key = JSON.stringify(args);\n    if (cache.has(key)) {\n      return cache.get(key);\n    } else {\n      const value = fn(...args);\n      cache.set(key, value);\n      return value;\n    }\n  };\n}\n\n// src/ReplaceUndefined.ts\nfunction replaceUndefined(obj, defaults) {\n  const result = { ...defaults, ...removeUndefined(obj) };\n  return result;\n}\nfunction removeUndefined(obj) {\n  const result = { ...obj };\n  for (const key in result) {\n    if (result[key] === void 0) {\n      delete result[key];\n    }\n  }\n  return result;\n}\n\n// src/BerryPretty.ts\nvar defaultOptions = {\n  compact: true,\n  wrapLength: 40,\n  maxDepth: 6,\n  maxArray: 24,\n  prototypes: false,\n  precision: 4\n};\nvar circularRef = {\n  iAmCircular: true\n};\nif (typeof DOMRect === \"undefined\") {\n  globalThis.DOMRect = function() {\n  };\n}\nfunction pretty(value, options = {}) {\n  const opts = replaceUndefined(options, defaultOptions);\n  const { wrapLength, compact } = opts;\n  const iterated = /* @__PURE__ */ new Map();\n  let result = prettyToString(value, opts, iterated);\n  if (compact && result.length > wrapLength) {\n    result = prettyToString(value, { ...opts, compact: false }, iterated);\n  }\n  return result;\n}\nfunction prettyToString(value, opts, iterated = /* @__PURE__ */ new Map()) {\n  const state = { nesting: 0, depth: 0, seen: /* @__PURE__ */ new Set(), iterated };\n  if (isObject(value)) {\n    state.seen.add(value);\n  }\n  return prettyRecursive(value, opts, state);\n}\nfunction prettyRecursive(value, options, state) {\n  let result;\n  if (state.depth++ >= options.maxDepth) {\n    result = \"...\";\n  } else if (isInteger(value)) {\n    result = value.toFixed();\n  } else if (typeof value === \"number\") {\n    result = prettyFloat(value, options.precision);\n  } else if (typeof value === \"string\") {\n    result = `\"${replaceSpecials(value)}\"`;\n  } else if (arrayIsh(value)) {\n    result = arrayToString(value, options, state);\n  } else if (value instanceof Date) {\n    result = value.toLocaleString();\n  } else if (value instanceof Function) {\n    result = \"function \" + value.name + \"()\";\n  } else if (isDomElement(value)) {\n    result = value;\n  } else if (value === circularRef) {\n    result = \"<circular reference>\";\n  } else if (value instanceof DOMRect) {\n    const { top, left, height, width } = value;\n    result = prettyRecursive({ top, left, height, width }, options, state);\n  } else if (typeof value === \"symbol\") {\n    result = value.toString();\n  } else if (value instanceof Error) {\n    result = errorToString(value, options, state);\n  } else if (value instanceof Map || value && value.constructor === Map) {\n    result = mapToString(value, options, state);\n  } else if (value instanceof Set || value && value.constructor === Set) {\n    result = setToString(value, options, state);\n  } else if (value && value[Symbol.iterator]) {\n    result = iterableToString(value, options, state);\n  } else if (isInstance(value)) {\n    result = instanceToString(value, options, state);\n  } else if (isObject(value)) {\n    result = objectToString(value, options, state);\n  } else if (value === true) {\n    result = \"true\";\n  } else if (value === false) {\n    result = \"false\";\n  } else if (value === null) {\n    result = \"null\";\n  } else if (value === void 0) {\n    result = \"undefined\";\n  } else {\n    result = value;\n  }\n  state.depth--;\n  return result;\n}\nvar specials = /* @__PURE__ */ new Map([\n  [\"\t\", \"\\\\t\"],\n  [\"\\r\", \"\\\\r\"],\n  [\"\\n\", \"\\\\n\"],\n  ['\"', '\\\\\"']\n]);\nfunction replaceSpecials(s) {\n  return [...s].map((c) => specials.get(c) || c).join(\"\");\n}\nfunction replaceCircular(keyValues, seen) {\n  return keyValues.map(([key, value]) => {\n    if (testCircular(value, seen)) {\n      return [key, circularRef];\n    } else {\n      return [key, value];\n    }\n  });\n}\nfunction testCircular(value, seen) {\n  if (isObject(value)) {\n    if (seen.has(value)) {\n      return true;\n    } else {\n      seen.add(value);\n    }\n  }\n  return false;\n}\nfunction isObject(value) {\n  const valueType = typeof value;\n  return value != null && (valueType === \"object\" || valueType === \"function\");\n}\nfunction arrayIsh(value) {\n  return Array.isArray(value) || ArrayBuffer.isView(value);\n}\nfunction arrayToString(values, options, state) {\n  if (options.compact || values.length <= 1) {\n    return oneLineArray(values, options, state);\n  } else {\n    return multiLineArray(values, options, state);\n  }\n}\nfunction oneLineArray(value, options, state) {\n  const expanded = [...value];\n  const values = expanded.slice(0, options.maxArray).map((v) => prettyRecursive(v, options, state));\n  if (expanded.length > options.maxArray) {\n    values.push(\"...\");\n  }\n  return \"[\" + values.join(\", \") + \"]\";\n}\nfunction multiLineArray(value, options, state) {\n  const bracketIndent = spaces(state.nesting);\n  state.nesting++;\n  const values = [...value].slice(0, options.maxArray).map((v) => prettyRecursive(v, options, state));\n  if (value.length > options.maxArray) {\n    values.push(\"...\");\n  }\n  const indent = spaces(state.nesting * 2);\n  state.nesting--;\n  const lastDex = values.length - 1;\n  const indentedLines = values.map((v, i) => {\n    const comma = i === lastDex ? \"\" : \",\";\n    return indent + v + comma + \"\\n\";\n  });\n  const linesTogether = indentedLines.join(\"\");\n  const open = bracketIndent + \"[\\n\";\n  const close = bracketIndent + \"]\";\n  return open + linesTogether + close;\n}\nfunction isClass(v) {\n  return typeof v === \"function\" && /^class\\s/.test(Function.prototype.toString.call(v));\n}\nfunction isInstance(value) {\n  return value && isClass(value.constructor);\n}\nfunction instanceToString(value, options, state) {\n  const record = objectToString(value, options, state);\n  return `${value.constructor.name} ${record}`;\n}\nfunction objectToString(value, options, state) {\n  const { compact, prototypes } = options;\n  const rawKeyValues = prototypes ? allEntries(value) : Object.entries(value);\n  const keyValues = replaceCircular(rawKeyValues, state.seen);\n  if (compact) {\n    return oneLineObj(keyValues, options, state);\n  } else {\n    return multiLineKV(keyValues, options, state);\n  }\n}\nfunction oneLineObj(keyValues, options, state) {\n  const kvStrings = keyValues.map(\n    ([k, v]) => k + \": \" + prettyRecursive(v, options, state)\n  );\n  return \"{\" + kvStrings.join(\", \") + \"}\";\n}\nfunction multiLineKV(keyValues, opts, state, separator = \": \") {\n  if (keyValues.length === 0) {\n    return \"{ }\";\n  }\n  const braceNesting = state.nesting, braceIndent = spaces(braceNesting * 2), indent = braceIndent + \"  \";\n  state.nesting++;\n  const kvStrings = keyValues.map(\n    ([k, v]) => k + separator + prettyRecursive(v, opts, state)\n  );\n  state.nesting--;\n  return formatKVs(kvStrings, braceIndent, indent);\n}\nfunction formatKVs(kvStrings, braceIndent, indent) {\n  let indentedStrings;\n  let firstLine;\n  if (braceIndent === \"\") {\n    firstLine = \"{ \";\n    const first = kvStrings[0];\n    indentedStrings = kvStrings.slice(1).map((kv) => indent + kv) || [];\n    indentedStrings.unshift(first);\n  } else {\n    firstLine = \"{\\n\";\n    indentedStrings = kvStrings.map((kv) => indent + kv);\n  }\n  return firstLine + indentedStrings.join(\",\\n\") + \"\\n\" + braceIndent + \"}\";\n}\nfunction allEntries(obj) {\n  const keyValues = [];\n  for (const key in obj) {\n    const value = obj[key];\n    keyValues.push([key, value]);\n  }\n  return keyValues;\n}\nfunction prettyFloat(value, precision = 4) {\n  const str = value.toPrecision(precision);\n  if (str.indexOf(\".\") === -1) {\n    return str;\n  }\n  let last = str.length - 1;\n  while (str[last] === \"0\") {\n    last -= 1;\n  }\n  if (str[last] === \".\") {\n    last -= 1;\n  }\n  return str.slice(0, last + 1);\n}\nfunction isInteger(value) {\n  if (typeof value !== \"number\") {\n    return false;\n  }\n  if (Number.isInteger(value)) {\n    return true;\n  }\n  return isFinite(value) && Math.floor(value) === value;\n}\nfunction errorToString(err, options, state) {\n  const stack = err.stack?.split(\"\\n\").slice(1, 2)[0];\n  return prettyRecursive(\n    { err: err.name, message: err.message, stack },\n    options,\n    state\n  );\n}\nfunction mapToString(map, options, state) {\n  const rawKeyValues = [...map.entries()].map(([key, value]) => {\n    const keyString = prettyRecursive(key, options, state);\n    return [keyString, value];\n  });\n  const keyValues = replaceCircular(rawKeyValues, state.seen);\n  return multiLineKV(keyValues, options, state, \" -> \");\n}\nfunction setToString(set, options, state) {\n  const values = [...set.values()].map((value) => {\n    return prettyRecursive(value, options, state);\n  });\n  return \"{\" + values.join(\", \") + \"}\";\n}\nfunction iterableToString(iterable, options, state) {\n  let expanded = state.iterated.get(iterable);\n  if (!expanded) {\n    expanded = [...iterable];\n    state.iterated.set(iterable, expanded);\n  }\n  return arrayToString(expanded, options, state);\n}\nfunction isDomElement(value) {\n  if (typeof Element === \"undefined\") {\n    return false;\n  } else {\n    return value instanceof Element || value instanceof Text;\n  }\n}\n\n// src/BerryStack.ts\nfunction callerName(stack, level = 1, showFile = false) {\n  const lines = stack.split(\"\\n\");\n  if (lines.length && lines[0].startsWith(\"Error\")) {\n    return callerFromChromeStack(lines, level, showFile);\n  } else {\n    return callerFromFirefoxStack(lines, level, showFile);\n  }\n}\nfunction callerFromFirefoxStack(stackLines, level = 1, showFile = false) {\n  showFile;\n  if (stackLines.length < level) {\n    return \"\";\n  }\n  const line = stackLines[level];\n  const atDex = line.indexOf(\"@\");\n  if (atDex === -1) {\n    return \"\";\n  }\n  return line.slice(0, atDex);\n}\nfunction callerFromChromeStack(stackLines, level = 1, showFile = false) {\n  if (stackLines.length < level + 1) {\n    return \"\";\n  }\n  const line = stackLines[level + 1];\n  const afterAt = startAfterAt(line);\n  if (!afterAt) {\n    return \"\";\n  }\n  const paren = afterAt.indexOf(\" (\");\n  if (paren > 0) {\n    const fullFunctionName = afterAt.slice(0, paren);\n    const functionName = afterDot(fullFunctionName);\n    if (showFile) {\n      const fileName = fileFromUrlLine(afterAt);\n      return `${fileName}.${functionName}`;\n    } else {\n      return functionName;\n    }\n  } else {\n    return fileFromUrlLine(afterAt);\n  }\n}\nfunction fileFromUrlLine(text) {\n  let start = 0;\n  let end = text.length;\n  const slash = text.lastIndexOf(\"/\");\n  if (slash > 0) {\n    start = slash + 1;\n    const lastColon = text.lastIndexOf(\":\");\n    if (lastColon > 0) {\n      const secondColon = text.lastIndexOf(\":\", lastColon - 1);\n      if (secondColon > 0) {\n        end = secondColon;\n      } else {\n        end = lastColon;\n      }\n    }\n  }\n  const fileWithSuffix = text.slice(start, end);\n  return beforeDot(fileWithSuffix);\n}\nvar at = \"at \";\nfunction startAfterAt(line) {\n  const atDex = line.indexOf(at);\n  if (atDex === -1) {\n    return void 0;\n  }\n  const start = atDex + at.length;\n  return line.slice(start);\n}\nfunction beforeDot(text) {\n  const dot = text.lastIndexOf(\".\");\n  if (dot > 0) {\n    return text.slice(0, dot);\n  } else {\n    return text;\n  }\n}\nfunction afterDot(text) {\n  const dot = text.indexOf(\".\");\n  if (dot > 0) {\n    return text.slice(dot + 1);\n  } else {\n    return text;\n  }\n}\n\n// src/DebugLog.ts\nvar dLog = dlog;\nvar dErr = derr;\nvar dWarn = dwarn;\nvar defaultOptions2 = {\n  stackLevel: 0,\n  showFile: false,\n  nameSize: 20,\n  compact: true,\n  wrapLength: 40,\n  maxDepth: 6,\n  maxArray: 24,\n  prototypes: false,\n  precision: 4\n};\nfunction dlog(...items) {\n  console.log(...dLogMessages({}, ...items));\n}\nfunction dlogOpt(options, ...items) {\n  console.log(...dLogMessages(options, ...items));\n}\nfunction dsert(test, ...items) {\n  if (!test) {\n    const messages = dLogMessages({}, ...items);\n    console.assert(test, messages);\n  }\n}\nfunction derr(...items) {\n  console.error(...dLogMessages({}, ...items));\n}\nfunction dwarn(...items) {\n  console.warn(...dLogMessages({}, ...items));\n}\nfunction dLogDefaultOptions(options) {\n  Object.assign(defaultOptions2, options);\n}\nfunction dlogMessagesTest(options, ...items) {\n  return dLogMessages(options, ...items);\n}\nfunction dLogMessages(options, ...items) {\n  const opts = replaceUndefined(options, defaultOptions2);\n  const level = opts.stackLevel + 2;\n  const messages = items.map((item) => {\n    if (item != null && typeof item == \"object\") {\n      return debugVars(item, opts);\n    } else {\n      return item;\n    }\n  });\n  const caller = callerName(new Error().stack || \"\", level, opts.showFile);\n  const fixedWidthCaller = padTrimCaller(caller, opts.nameSize);\n  messages.unshift(`${fixedWidthCaller} |`);\n  return indentMultiLine(messages);\n}\nfunction debugVars(vars, options) {\n  const strings = Object.entries(vars).map(\n    ([key, value]) => `${key}: ${pretty(value, options)}`\n  );\n  const multiline = strings.find((s) => s.includes(\"\\n\"));\n  if (multiline) {\n    return strings.join(\"\\n\");\n  } else {\n    return strings.join(\"  \");\n  }\n}\nexport {\n  callerName,\n  dErr,\n  dLog,\n  dLogDefaultOptions,\n  dWarn,\n  derr,\n  dlog,\n  dlogMessagesTest,\n  dlogOpt,\n  dsert,\n  dwarn,\n  pretty,\n  prettyFloat\n};\n//# sourceMappingURL=index.js.map\n","import { dlog } from \"berry-pretty\";\nimport {\n  AliasElem,\n  FnElem,\n  GlobalDirectiveElem,\n  StructElem,\n  StructMemberElem,\n  TypeRefElem,\n  VarElem,\n} from \"./AbstractElems.js\";\nimport { refLog } from \"./LinkerLogging.js\";\nimport { ParsedRegistry } from \"./ParsedRegistry.js\";\nimport { TextModule } from \"./ParseModule.js\";\nimport { SliceReplace, sliceReplace } from \"./Slicer.js\";\nimport {\n  FoundRef,\n  GeneratorRef,\n  TextRef,\n  refName,\n  traverseRefs,\n} from \"./TraverseRefs.js\";\nimport { partition, replaceWords } from \"./Util.js\";\nimport { printRef } from \"./RefDebug.js\";\n\ntype DirectiveRef = {\n  kind: \"dir\";\n  expMod: TextModule;\n  elem: GlobalDirectiveElem;\n};\n\ntype LoadableRef = TextRef | GeneratorRef | DirectiveRef;\n\n/**\n * Produce a linked wgsl string with all directives processed\n * (e.g. #import'd functions from other modules are inserted into the resulting string).\n *\n * @param runtimeParams runtime parameters for #import/#export values,\n *  template values, and code generation parameters\n */\nexport function linkWgslModule(\n  srcModule: TextModule,\n  registry: ParsedRegistry,\n  extParams: Record<string, any> = {}\n): string {\n  const refs = findReferences(srcModule, registry); // all recursively referenced structs and fns\n\n  // mix the merge refs into the import/export refs\n  const loadRefs = prepRefsMergeAndLoad(refs);\n\n  // convert global directives into LoadableRefs\n  const directiveRefs = globalDirectiveRefs(srcModule);\n\n  // extract export texts, rewriting via rename map and exp/imp args\n  const extractRefs = [...loadRefs, ...directiveRefs];\n  return extractTexts(extractRefs, extParams);\n}\n\n/** Find references to elements like structs and fns to import into the linked result.\n * (note that local functions are not listed unless they are referenced)\n */\nexport function findReferences(\n  srcModule: TextModule,\n  registry: ParsedRegistry\n): FoundRef[] {\n  // map full export name (with generic params from import) to name for linked result\n  const visited = new Map<string, string>();\n\n  // set of linked result names (values of visited map)\n  const rootNames = new Set<string>();\n\n  // accumulates all elements to add to the linked result\n  const found: FoundRef[] = [];\n\n  traverseRefs(srcModule, registry, refVisit);\n  return found;\n\n  /**\n   * process one reference found by the reference traversal\n   *\n   * choose a unique name for the reference so that it can be imported into the\n   */\n  function refVisit(ref: FoundRef): void {\n    const fullName = refFullName(ref);\n    let linkName = visited.get(fullName);\n    if (!linkName) {\n      linkName = uniquifyName(ref.proposedName, rootNames);\n      visited.set(fullName, linkName);\n      rootNames.add(linkName);\n      found.push(ref);\n    }\n\n    // always set the rename field to make sure we rewrite calls with module path prefixes\n    ref.rename = linkName; // TODO only set if necessary\n  }\n}\n\n/**\n * Calculate a unique name for a top level element like a struct or fn.\n * @param proposedName\n * @param rootNames\n * @returns the unique name (which may be the proposed name if it's so far unique)\n */\nfunction uniquifyName(\n  /** proposed name for this fn in the linked results (e.g. import as name) */\n  proposedName: string,\n  rootNames: Set<string>\n): 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  return renamed;\n}\n\n/**\n * unique id for a future root level element in the form:\n *    moduleName.elemName(impParam1, impParam2, ...)\n * We'll eventually give each unique element a unique fn, struct or variable name\n * in the linked source.\n */\nexport function refFullName(ref: FoundRef): string {\n  const expImpArgs = ref.expInfo?.expImpArgs ?? [];\n  const impArgs = expImpArgs.map(([, arg]) => arg);\n  const argsStr = \"(\" + impArgs.join(\",\") + \")\";\n  return ref.expMod.modulePath + \".\" + refName(ref) + argsStr;\n}\n\n/**\n * Perpare the refs found in the traverse for loading:\n * . sort through found refs, and attach merge refs to normal export refs\n *   so that the export can be rewritten with the merged struct members\n *\n * @return the set of refs that will be loaded\n */\nfunction prepRefsMergeAndLoad(refs: FoundRef[]): FoundRef[] {\n  const { generatorRefs, mergeRefs, nonMergeRefs } = partitionRefTypes(refs);\n  const expRefs = combineMergeRefs(mergeRefs, nonMergeRefs);\n\n  return [...generatorRefs, ...expRefs];\n}\n\n/** combine export refs with any merge refs for the same element */\nfunction combineMergeRefs(\n  mergeRefs: TextRef[],\n  nonMergeRefs: TextRef[]\n): TextRef[] {\n  // map from the element name of a struct annotated with #extends to the merge refs\n  const mergeMap = new Map<string, TextRef[]>();\n  mergeRefs.forEach((r) => {\n    if (r.expInfo) {\n      // LATER support merges from local refs too\n      const fullName = refFullName(r.expInfo.fromRef);\n      const merges = mergeMap.get(fullName) || [];\n      merges.push(r);\n      mergeMap.set(fullName, merges);\n    }\n  });\n\n  // combine the merge refs into the export refs on the same element\n  const expRefs: TextRef[] = nonMergeRefs.map((ref) => ({\n    ...ref,\n    mergeRefs: recursiveMerges(ref),\n  }));\n\n  return expRefs;\n\n  /** find any extends on this element,\n   * and recurse to find any extends on the merging source element */\n  function recursiveMerges(ref: TextRef): TextRef[] {\n    const fullName = refFullName(ref);\n    const merges = mergeMap.get(fullName) ?? [];\n    const transitiveMerges = merges.flatMap(recursiveMerges);\n    return [...merges, ...transitiveMerges];\n  }\n}\n\ninterface RefTypes {\n  mergeRefs: TextRef[];\n  nonMergeRefs: TextRef[];\n  generatorRefs: GeneratorRef[];\n}\n\n/** separate refs into local, gen, merge, and non-merge refs */\nfunction partitionRefTypes(refs: FoundRef[]): RefTypes {\n  const txt = refs.filter((r) => r.kind === \"txt\") as TextRef[];\n  const gen = refs.filter((r) => r.kind === \"gen\") as GeneratorRef[];\n  const [merge, nonMerge] = partition(\n    txt,\n    (r) => r.expInfo?.fromImport.kind === \"extends\"\n  );\n\n  return {\n    generatorRefs: gen,\n    mergeRefs: merge,\n    nonMergeRefs: nonMerge,\n  };\n}\n\n/** construct DirectiveRefs for from globalDirective elements\n * (so that we can use the standard extract path to copy them to the linked output) */\nfunction globalDirectiveRefs(srcModule: TextModule): DirectiveRef[] {\n  const directiveRefs = srcModule.globalDirectives.map((e) =>\n    toDirectiveRef(e, srcModule)\n  );\n  return directiveRefs;\n}\n\n/** convert a global directive element into a DirectiveRef */\nfunction toDirectiveRef(\n  elem: GlobalDirectiveElem,\n  expMod: TextModule\n): DirectiveRef {\n  return {\n    kind: \"dir\",\n    elem,\n    expMod,\n  };\n}\n\n// LATER rename imported vars or aliases\nfunction loadOtherElem(\n  ref: TextRef | DirectiveRef,\n  extParams: Record<string, string>\n): string {\n  const { expMod, elem } = ref;\n  const typeRefs = (elem as VarElem | AliasElem).typeRefs ?? [];\n  const slicing = typeRefSlices(typeRefs);\n  const srcMap = sliceReplace(expMod.preppedSrc, slicing, elem.start, elem.end);\n  // LATER propogate srcMap\n\n  return applyExpImp(srcMap.dest, ref, extParams);\n}\n\nfunction loadGeneratedElem(\n  ref: GeneratorRef,\n  extParams: Record<string, string>\n): string {\n  const genExp = ref.expMod.exports.find((e) => e.name === ref.name);\n  if (!genExp) {\n    refLog(ref, \"missing generator\", ref.name);\n    return \"//?\";\n  }\n  const fnName = ref.rename ?? ref.proposedName ?? ref.name;\n  const params = refExpImp(ref, extParams);\n\n  const text = genExp?.generate(fnName, params);\n  return text;\n}\n\n/** load exported text for an import */\nfunction extractTexts(\n  refs: LoadableRef[],\n  extParams: Record<string, string>\n): string {\n  return refs\n    .map((r) => {\n      if (r.kind === \"gen\") {\n        return loadGeneratedElem(r, extParams);\n      }\n      if (r.kind === \"txt\") {\n        const elemKind = r.elem.kind;\n        if (elemKind === \"fn\") {\n          return loadFnText(r.elem, r, extParams);\n        }\n        if (elemKind === \"struct\") {\n          return loadStruct(r, extParams);\n        }\n        if (elemKind === \"var\" || elemKind === \"alias\") {\n          return loadOtherElem(r, extParams);\n        }\n        console.warn(\"can't extract. unexpected elem kind:\", elemKind, r.elem);\n      }\n      if (r.kind === \"dir\") {\n        return loadOtherElem(r, extParams);\n      }\n    })\n    .join(\"\\n\\n\");\n}\n\n/** load a struct text, mixing in any elements from #extends */\nfunction loadStruct(ref: TextRef, extParams: Record<string, string>): string {\n  const structElem = ref.elem as StructElem;\n\n  const rootMembers =\n    structElem.members?.map((m) => loadMemberText(m, ref, extParams)) ?? [];\n\n  const newMembers =\n    ref.mergeRefs?.flatMap((mergeRef) => {\n      const mergeStruct = mergeRef.elem as StructElem;\n      return mergeStruct.members?.map((member) =>\n        loadMemberText(member, mergeRef, extParams)\n      );\n    }) ?? [];\n\n  const allMembers = [rootMembers, newMembers].flat().map((m) => \"  \" + m);\n  const membersText = allMembers.join(\",\\n\");\n  const name = ref.rename || structElem.name;\n  return `struct ${name} {\\n${membersText}\\n}`;\n}\n\nfunction loadMemberText(\n  member: StructMemberElem,\n  ref: TextRef,\n  extParams: Record<string, string>\n): string {\n  const newRef = { ...ref, elem: member };\n  return loadOtherElem(newRef, extParams);\n}\n\n/** get the export/import param map if appropriate for this ref */\nfunction refExpImp(\n  ref: FoundRef,\n  extParams: Record<string, string>\n): Record<string, string> {\n  const expImp = ref.expInfo?.expImpArgs ?? [];\n  const entries = expImp.map(([exp, imp]) => {\n    if (imp.startsWith(\"ext.\")) {\n      const value = extParams[imp.slice(4)];\n      if (value) return [exp, value];\n\n      refLog(ref, \"missing ext param\", imp, extParams);\n    }\n    return [exp, imp];\n  });\n  return Object.fromEntries(entries);\n}\n\nfunction loadFnText(\n  elem: FnElem,\n  ref: TextRef,\n  extParams: Record<string, string>\n): string {\n  const { rename } = ref;\n  const slicing: SliceReplace[] = [];\n\n  if (rename) {\n    const { start, end } = elem.nameElem;\n    slicing.push({ start, end, replacement: rename });\n  }\n\n  elem.calls.forEach((call) => {\n    const rename = call?.ref?.rename;\n    if (rename) {\n      const { start, end } = call;\n      slicing.push({ start, end, replacement: rename });\n    }\n  });\n\n  slicing.push(...typeRefSlices(elem.typeRefs));\n\n  const srcMap = sliceReplace(\n    ref.expMod.preppedSrc,\n    slicing,\n    elem.start,\n    elem.end\n  );\n\n  return applyExpImp(srcMap.dest, ref, extParams);\n}\n\n/** rewrite the src text according to module templating and exp/imp params */\nfunction applyExpImp(\n  src: string,\n  ref: TextRef | DirectiveRef,\n  extParams: Record<string, string>\n): string {\n  const params = ref.kind === \"txt\" ? refExpImp(ref, extParams) : {};\n  return replaceWords(src, params);\n}\n\nfunction typeRefSlices(typeRefs: TypeRefElem[]): SliceReplace[] {\n  const slicing: SliceReplace[] = [];\n  typeRefs.forEach((typeRef) => {\n    const rename = typeRef?.ref?.rename;\n    if (rename) {\n      const { start, end } = typeRef;\n      slicing.push({ start, end, replacement: rename });\n    }\n  });\n  return slicing;\n}\n","export class ImportTree {\n  constructor(public segments: PathSegment[]) {}\n}\n\nexport type PathSegment = SimpleSegment | Wildcard | 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)\n  ) {}\n}\n\nexport class SegmentList {\n  constructor(public list: PathSegment[]) {}\n}\n\nexport class Wildcard {\n  constructor(public as?: string) {}\n}\n\nexport function treeToString(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 Wildcard) {\n    return \"*\";\n  }\n  if (segment instanceof SegmentList) {\n    return `{${segment.list.map((s) => segmentToString(s)).join(\", \")}}`;\n  }\n  if (segment instanceof ImportTree) {\n    return `(${treeToString(segment)})`;\n  }\n  throw new Error(`unknown segment type ${segment}`);\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 { ExportElem, TreeImportElem } from \"./AbstractElems.js\";\nimport {\n  ImportTree,\n  PathSegment,\n  SegmentList,\n  SimpleSegment,\n  Wildcard,\n} from \"./ImportTree.js\";\nimport { moduleLog } from \"./LinkerLogging.js\";\nimport {\n  GeneratorExport,\n  GeneratorModule,\n  ModuleExport,\n} from \"./ModuleRegistry.js\";\nimport { exportName, ParsedRegistry } from \"./ParsedRegistry.js\";\nimport { TextModule } from \"./ParseModule.js\";\nimport { dirname, normalize } from \"./PathUtil.js\";\nimport { StringPairs } from \"./TraverseRefs.js\";\n\n/**\n * Maps to resolve imports to exports.\n *\n * We could be bringing two different things into scope when we import mymod::foo\n * 1) an exported function, used as foo()\n * 2) a module path, used as foo::bar()  (or foo.bar())\n *\n * Two maps are provided:\n *  . from (caller) import path to export path (taking into account 'import as' renaming)\n *  . from export path to exported wgsl element\n *\n * For module paths that don't resolve immediately to a wgsl element,\n * we expect to resolve them to wgsl elements later when combined with\n * a reference site suffix, e.g.:\n *    import pkg::a as b      // pkg::b -> pkg::a     map import path to export path\n *    fn foo() { b::bar(); }  // can now resolve to exported element pkg::a::bar\n */\nexport interface ResolveMap {\n  // map from caller path to exporter path [\"pkg\", \"subpath\", \"asName\"] -> \"mypkg/subpath/expName\"\n  // import params are appended to the export path \"mypkg/foo/exp(X)\" so that paths are unique for generics\n  pathsMap: Array<[string[], string]>;\n\n  // map from export path string \"mypkg/foo/exp\" to resolved export\n  // import params are appended to the export path: \"mypkg/foo/exp(X)\" so that paths are unique for generics\n  exportMap: Map<string, ExportPathToExport>;\n}\n\n/*\n * Flattening wildcards and segment lists,\n * and resolve paths that refer to exported elements\n *\n * These entries will be converted into a ResolveMap\n */\ntype ResolvedEntry = ExportPathToExport | ImportToExportPath;\nclass ExportPathToExport {\n  constructor(\n    public exportPath: string,\n    public modExp: ModuleExport,\n    public expImpArgs: StringPairs\n  ) {}\n}\n\nclass ImportToExportPath {\n  constructor(\n    public importPath: string[],\n    public exportPath: string\n  ) {}\n}\n\n/** Expand all imports paths to their corresponding export paths\n * and from the export path to the exported element (fn, struct var) if possible.\n *\n * Wildcards and path lists are fully expanded.\n *\n * @returns a ResolveMap\n */\nexport function importResolutionMap(\n  importingModule: TextModule,\n  imports: TreeImportElem[],\n  registry: ParsedRegistry\n): ResolveMap {\n  const resolveEntries = imports.flatMap((imp) =>\n    resolveTreeImport(importingModule, imp, registry)\n  );\n\n  const exportEntries: [string, ExportPathToExport][] = [];\n  const pathEntries: [string[], string][] = [];\n\n  resolveEntries.forEach((e) => {\n    if (e instanceof ExportPathToExport) {\n      exportEntries.push([e.exportPath, e]);\n    } else {\n      pathEntries.push([e.importPath, e.exportPath]);\n    }\n  });\n\n  return {\n    exportMap: new Map(exportEntries),\n    pathsMap: pathEntries,\n  };\n}\n\n/** @return flattened list of resolved import paths including\n * resolved exports (for fully specified export paths)\n */\nfunction resolveTreeImport(\n  importingModule: TextModule,\n  imp: TreeImportElem,\n  registry: ParsedRegistry\n): ResolvedEntry[] {\n  return recursiveResolve([], [], imp.imports.segments);\n\n  /** recurse through segments of path, producing  */\n  function recursiveResolve(\n    resolvedImportPath: string[],\n    resolvedExportPath: string[],\n    remainingPath: PathSegment[]\n  ): ResolvedEntry[] {\n    const [segment, ...rest] = remainingPath;\n    if (segment === undefined) {\n      throw new Error(`undefined segment ${imp.imports.segments}`);\n    }\n    if (segment instanceof SimpleSegment) {\n      const impPath = [...resolvedImportPath, segment.as || segment.name];\n      const expPath = [...resolvedExportPath, segment.name];\n      if (rest.length) {\n        // we're in the middle of the path so keep recursing\n        return recursiveResolve(impPath, expPath, rest);\n      } else {\n        return resolveFlatPath(impPath, expPath, segment.args);\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    }\n    if (segment instanceof Wildcard) {\n      const modulePath = resolvedExportPath.join(\"/\");\n      const m = registry.findModule(modulePath);\n      if (m) {\n        return wildCardExports(m, resolvedImportPath, resolvedExportPath);\n      } else {\n        console.error(\"no module found\", modulePath); // LATER point to source location in error\n      }\n      return [];\n    } else if (segment instanceof ImportTree) {\n      return recursiveResolve(\n        resolvedImportPath,\n        resolvedExportPath,\n        segment.segments\n      );\n    }\n\n    console.error(\"unknown segment type\", segment); // should be impossible\n    return [];\n  }\n\n  function wildCardExports(\n    m: GeneratorModule | TextModule,\n    resolvedImportPath: string[],\n    resolvedExportPath: string[]\n  ): ResolvedEntry[] {\n    const exportKind = m.kind === \"generator\" ? \"function\" : \"text\";\n    return m.exports.flatMap((exp) => {\n      const expPath = [...resolvedExportPath, exportName(exp)];\n      const impPath = [...resolvedImportPath, exportName(exp)];\n      const modExp = { kind: exportKind, module: m, exp } as ModuleExport;\n      return [\n        new ImportToExportPath(impPath, expPath.join(\"/\")),\n        new ExportPathToExport(impPath.join(\"/\"), modExp, []),\n      ];\n    });\n  }\n\n  /** resolve a flattened path as best we can, returning a path mapping entry\n   * and a\n   */\n  function resolveFlatPath(\n    impPath: string[],\n    expPath: string[],\n    impArgs: string[] | undefined\n  ): ResolvedEntry[] {\n    const resolvedImp = absolutePath(impPath, importingModule);\n    const resolvedExp = absolutePath(expPath, importingModule);\n\n    const impArgsStr = impArgs ? `(${impArgs.join(\", \")})` : \"\";\n    const expPathStr = resolvedExp.join(\"/\") + impArgsStr;\n\n    const entries: ResolvedEntry[] = [\n      new ImportToExportPath(resolvedImp, expPathStr),\n    ];\n\n    // try and resolve as an exported element as well\n    const modExp = registry.getModuleExport(importingModule, resolvedExp);\n    // dlog({ modExp: !!modExp, resolvedExp });\n    if (modExp) {\n      const expImpArgs = matchExportImportArgs(\n        importingModule,\n        imp,\n        impArgs ?? [],\n        modExp.module,\n        modExp.exp\n      );\n      entries.push(new ExportPathToExport(expPathStr, modExp, expImpArgs));\n    }\n    return entries;\n  }\n}\n\nfunction absolutePath(pathSegments: string[], mod: TextModule): string[] {\n  if (pathSegments[0] === \".\") {\n    const moduleDir = dirname(mod.modulePath);\n    const joined = [moduleDir, ...pathSegments.slice(1)].join(\"/\");\n    const modulePath = normalize(joined);\n    return modulePath.split(\"/\");\n  } else {\n    return pathSegments;\n  }\n}\n\nfunction matchExportImportArgs(\n  impMod: TextModule | GeneratorModule,\n  imp: TreeImportElem,\n  impArgs: string[],\n  expMod: TextModule | GeneratorModule,\n  exp: ExportElem | GeneratorExport\n): StringPairs {\n  const expArgs = exp.args ?? [];\n  if (expArgs.length !== impArgs.length) {\n    impMod.kind === \"text\" &&\n      moduleLog(impMod, imp.start, \"mismatched import and export params\");\n    expMod.kind === \"text\" && moduleLog(expMod, (exp as ExportElem).start);\n  }\n  return expArgs.map((p, i) => [p, impArgs[i]]);\n}\n","import { matchOneOf, tokenMatcher } from \"mini-parse\";\n\n/** token matchers for wgsl with #directives */\n\nexport const eol = /\\n/;\nexport const directive = /#[a-zA-Z_]\\w*/;\nexport const notDirective = /[^#\\n]+/;\n\nconst symbolSet =\n  \"& && -> @ / ! [ ] { } : , = == != > >= < << <= % - -- \" + // '>>' elided for template parsing, e.g. vec2<vec2<u8>>\n  \". + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= >>= <<= <<\";\nconst symbol = matchOneOf(symbolSet);\nconst quote = /[\"']/;\n\nconst longIdent = /[a-zA-Z_][\\w.:]*/; // identifier that can include module path\nexport const word = /[a-zA-Z_]\\w*/; // LATER consider making this 'ident' per wgsl spec (incl. non-ascii)\nexport const digits = /(?:0x)?[\\d.]+[iuf]?/; // LATER parse more wgsl number variants\n\n/** matching tokens at wgsl root level */\nexport const mainTokens = tokenMatcher(\n  {\n    directive,\n    attr: /@[a-zA-Z_]\\w*/,\n    word,\n    digits,\n    symbol,\n    quote,\n    ws: /\\s+/,\n  },\n  \"main\"\n);\n\nexport const identTokens = tokenMatcher(\n  {\n    longIdent,\n    ws: /\\s+/,\n    symbol,\n    digits,\n    quote,\n  },\n  \"longIdent\"\n);\n\nexport const moduleTokens = tokenMatcher(\n  {\n    ws: /\\s+/,\n    moduleName: /[a-zA-Z_][\\w./:-]*/,\n  },\n  \"moduleName\"\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\nconst treeImportSymbolSet = \":: { } , ( ) _ . ; *\";\nconst importSymbol = matchOneOf(treeImportSymbolSet);\n\nexport const treeImportTokens = tokenMatcher({\n  directive,\n  quote,\n  ws: /\\s+/,\n  importSymbol,\n  word,\n  digits,\n}, \"treeTokens\");\n\nexport const rootWs = tokenMatcher({\n  blanks: /\\s+/,\n  other: /[^\\s]+/\n}, \"rootWs\");\n","/* handle #if #else #endif */\nimport {\n  any,\n  anyThrough,\n  eof,\n  ExtendedResult,\n  kind,\n  makeEolf,\n  matchingLexer,\n  matchOneOf,\n  TagRecord,\n  opt,\n  or,\n  Parser,\n  repeat,\n  req,\n  resultLog,\n  seq,\n  setTraceName,\n  srcLog,\n  SrcMap,\n  SrcMapEntry,\n  tokenMatcher,\n  tokenSkipSet,\n  tracing,\n} from \"mini-parse\";\nimport { directive, eol } from \"./MatchWgslD.js\";\nimport { ParseState } from \"./ParseWgslD.js\";\n\nexport const conditionalsTokens = tokenMatcher(\n  {\n    directive,\n    eol,\n    ws: /[ \\t]+/,\n    symbol: matchOneOf(\"// !\"),\n    word: /[^\\s\\n]+/,\n  },\n  \"conditionals\"\n);\n\nconst eolf = makeEolf(conditionalsTokens, conditionalsTokens.ws);\n\nconst ifDirective: Parser<any> = seq(\n  \"#if\",\n  seq(\n    opt(\"!\").tag(\"invert\"),\n    req(kind(conditionalsTokens.word).tag(\"name\")),\n    eolf\n  )\n).map((r) => {\n  // extract args\n  const ifArg = r.tags[\"name\"]?.[0] as string;\n  const invert = r.tags[\"invert\"]?.[0] === \"!\";\n\n  // lookup whether #if arg is truthy or not in paramsa, and invert for ! prefix\n  const { params } = r.app.state;\n  const arg = !!params[ifArg];\n  const truthy = invert ? !arg : arg;\n\n  pushIfState(r, truthy);\n});\n\nconst elseDirective = seq(\"#else\", eolf).map((r) => {\n  const oldTruth = popIfState(r);\n  if (oldTruth === undefined) resultLog(r, \"unmatched #else\");\n  pushIfState(r, !oldTruth);\n});\n\nconst endifDirective = seq(\"#endif\", eolf).map((r) => {\n  const oldTruth = popIfState(r);\n  if (oldTruth === undefined) resultLog(r, \"unmatched #endif\");\n});\n\nconst directiveLine = seq(\n  opt(\"//\"),\n  or(ifDirective, elseDirective, endifDirective)\n);\n\n// special case for last line which might not have a newline\nconst simpleLine = anyThrough(\"\\n\");\nconst lastLine = seq(any(), repeat(any()), eolf);\n\nconst regularLine = or(simpleLine, lastLine).map((r) => {\n  if (!skippingIfBody(r)) {\n    // resultLog(r, \"regularLine\", r.start, r.end);\n    pushLine(r);\n  }\n});\n\n// don't skip whitespace for regular lines - we want to copy them exactly.\nconst line = tokenSkipSet(null, regularLine);\n\nconst srcLines = seq(repeat(or(directiveLine, line)), eof());\n\nfunction skippingIfBody(\n  r: ExtendedResult<unknown, TagRecord, ParseState>\n): boolean {\n  const ifStack = r.app.state.ifStack as IfStackElem[];\n  return !ifStack.every(({ truthy }) => truthy);\n}\n\nfunction pushIfState<T>(\n  r: ExtendedResult<T, TagRecord, ParseState>,\n  truthy: boolean\n): void {\n  r.app.state.ifStack.push({ truthy, pos: r });\n}\n\nfunction popIfState<T>(\n  r: ExtendedResult<T, TagRecord, ParseState>\n): boolean | undefined {\n  const ifStack = r.app.state.ifStack as IfStackElem[];\n  const result = ifStack.pop();\n  return result?.truthy;\n}\n\nfunction pushLine(r: ExtendedResult<any>): void {\n  const line = r.src.slice(r.start, r.end);\n  const { state } = r.app;\n  const entry: SrcMapEntry = {\n    src: r.src,\n    srcStart: r.start,\n    srcEnd: r.end,\n    destStart: state.destLength,\n    destEnd: state.destLength + line.length,\n  };\n  state.srcMapEntries.push(entry);\n  state.destLength += line.length;\n  state.lines.push(line);\n}\n\ninterface IfStackElem {\n  truthy: boolean;\n  pos: { start: number; end: number };\n}\n\n/** preprocess a src string to handle #if #else #endif, etc. */\nexport function processConditionals(\n  src: string,\n  params: Record<string, any>\n): SrcMap {\n  const lines: string[] = [];\n  const srcMapEntries: SrcMapEntry[] = [];\n  const ifStack: IfStackElem[] = [];\n  srcLines.parse({\n    lexer: matchingLexer(src, conditionalsTokens),\n    app: {\n      context: {},\n      state: { ifStack, lines, srcMapEntries, destLength: 0, params },\n    },\n    maxParseCount: 1e6,\n  });\n  if (ifStack.length > 0) {\n    const { pos } = ifStack.slice(-1)[0];\n    srcLog(src, [pos.start, pos.end], \"unmatched #if/#else\");\n  }\n\n  const text = lines.join(\"\");\n  const srcMap = new SrcMap(text);\n  srcMap.addEntries(srcMapEntries);\n  srcMap.compact();\n  return srcMap;\n}\n\n/** debug for recognizer */\nif (tracing) {\n  const names: Record<string, Parser<unknown>> = {\n    ifDirective,\n    elseDirective,\n    endifDirective,\n    directiveLine,\n    simpleLine,\n    lastLine,\n    line,\n    srcLines,\n  };\n\n  Object.entries(names).forEach(([name, parser]) => {\n    setTraceName(parser, name);\n  });\n}\n","import {\n  ExtendedResult,\n  Parser,\n  any,\n  anyNot,\n  disablePreParse,\n  kind,\n  makeEolf,\n  or,\n  repeat,\n  req,\n  resultLog,\n  seq,\n  setTraceName,\n  tracing,\n  withSep,\n} from \"mini-parse\";\nimport { AbstractElem, AbstractElemBase } from \"./AbstractElems.js\";\nimport { argsTokens, mainTokens } from \"./MatchWgslD.js\";\nimport { lineComment } from \"./ParseDirective.js\";\n\n/* Basic parsing functions for comment handling, eol, etc. */\n\nexport const word = kind(mainTokens.word);\nexport const wordNum = or(word, kind(mainTokens.digits));\n\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\nexport const blockComment: Parser<any> = seq(\n  \"/*\",\n  repeat(or(() => blockComment, anyNot(\"*/\"))),\n  req(\"*/\")\n);\n\nexport const comment = or(() => lineComment, blockComment);\n\nexport const eolf: Parser<any> = disablePreParse(\n  makeEolf(argsTokens, argsTokens.ws)\n);\n\n/** ( a1, b1* ) with optinoal comments, spans lines */\nexport const wordNumArgs: Parser<string[]> = seq(\n  \"(\",\n  withSep(\",\", wordNum),\n  req(\")\")\n).map((r) => r.value[1]);\n\ntype ByKind<U, T> = U extends { kind: T } ? U : never;\n\ntype TagsType<U extends AbstractElem> = Record<\n  Exclude<keyof U, keyof AbstractElemBase>,\n  any[]\n>;\n\n/** create an AbstractElem from parse results\n * @param named keys in the tags result to copy to\n *  like named fields in the abstract elem (as a single value)\n * @param namedArray keys in the tags result to copy to\n *  like named fields in the abstract elem (as an array)\n */\nexport function makeElem<\n  U extends AbstractElem,\n  K extends U[\"kind\"], // 'kind' of AbtractElem \"fn\"\n  E extends ByKind<U, K>, // FnElem\n  T extends TagsType<E>, // {name: string[]}\n>(\n  kind: K,\n  er: ExtendedResult<any, Partial<T>>,\n  tags: (keyof T)[] = [],\n  tagArrays: (keyof T)[] = []\n): Partial<E> {\n  const { start, end } = er;\n\n  const nv = mapIfDefined(tags, er.tags, true);\n  const av = mapIfDefined(tagArrays, er.tags);\n  return { kind, start, end, ...nv, ...av } as Partial<E>;\n}\n\nfunction mapIfDefined<A>(\n  keys: (keyof A)[],\n  array: Partial<Record<keyof A, string[]>>,\n  firstElemOnly?: boolean\n): Partial<Record<keyof A, string | string[]>> {\n  const entries = keys.flatMap((k) => {\n    const ak = array[k];\n    const v = firstElemOnly ? ak?.[0] : ak;\n\n    if (v === undefined) return [];\n    else return [[k, v]];\n  });\n  return Object.fromEntries(entries);\n}\n\nif (tracing) {\n  const names: Record<string, Parser<unknown>> = {\n    skipBlockComment: blockComment,\n    comment,\n    wordNumArgs,\n  };\n\n  Object.entries(names).forEach(([name, parser]) => {\n    setTraceName(parser, name);\n  });\n}\n","import {\n  disablePreParse,\n  kind,\n  makeEolf,\n  matchOneOf,\n  NoTags,\n  opt,\n  or,\n  Parser,\n  repeatPlus,\n  seq,\n  setTraceName,\n  TagRecord,\n  tokenMatcher,\n  tokens,\n  tokenSkipSet,\n  tracing,\n  withSepPlus,\n  withTags,\n} from \"mini-parse\";\nimport { TreeImportElem } from \"./AbstractElems.js\";\nimport {\n  ImportTree,\n  PathSegment,\n  SegmentList,\n  SimpleSegment,\n  Wildcard,\n} from \"./ImportTree.js\";\nimport { digits, eol, word } from \"./MatchWgslD.js\";\nimport { makeElem } from \"./ParseSupport.js\";\n\nconst gleamImportSymbolSet = \"/ { } , ( ) .. . * ;\";\nconst gleamImportSymbol = matchOneOf(gleamImportSymbolSet);\n\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}\nconst ws = /\\s+/;\n\nexport const gleamImportTokens = tokenMatcher({\n  ws,\n  gleamImportSymbol,\n  word,\n  digits,\n});\n\nexport const packageTokens = tokenMatcher({\n  ws,\n  pkg: /[a-zA-Z_][\\w-]*/, // LATER follow spec\n});\n\nexport const eolTokens = tokenMatcher({\n  ws: /[ \\t]+/, // don't include \\n, for eolf\n  eol,\n});\n\nconst eolf = disablePreParse(\n  makeEolf(eolTokens, gleamImportTokens.ws).traceName(\"gleam_eolf\")\n);\nconst wordToken = kind(gleamImportTokens.word);\nconst pkgToken = kind(packageTokens.pkg);\n\n// forward references (for mutual recursion)\nlet pathTail: Parser<PathSegment[], NoTags> = null as any;\nlet packagePath: Parser<PathSegment[], NoTags> = null as any;\n\nconst simpleSegment = wordToken.map((r) => {\n  return new SimpleSegment(r.value);\n});\n\nconst itemImport = withTags(\n  seq(\n    wordToken.tag(\"segment\"),\n    skipWs(opt(seq(\"as\", wordToken.tag(\"as\"))))\n  ).map((r) => {\n    const segment = r.tags.segment[0];\n    return new SimpleSegment(segment, r.tags.as?.[0]);\n  })\n);\n\nconst starImport = seq(\n  skipWs(seq(\"*\", opt(seq(\"as\", wordToken.tag(\"as\")))))\n).map((r) => new Wildcard(r.tags.as?.[0]));\n\nconst collectionItem = or(\n  () => packagePath,\n  itemImport.map((r) => [r.value])\n);\n\nconst importCollection = withTags(\n  seq(\n    \"{\",\n    skipWs(\n      seq(\n        withSepPlus(\",\", () => collectionItem).tag(\"list\"),\n        \"}\" //\n      )\n    )\n  ).map((r) => {\n    const elems = r.tags.list.flat().map((l) => new ImportTree(l));\n    return new SegmentList(elems);\n  })\n);\n\nconst pathSegment = or(simpleSegment, importCollection);\n\nconst pathExtends = withTags(\n  seq(simpleSegment.tag(\"s\"), \"/\", () => pathTail.tag(\"s\")).map((r) =>\n    r.tags.s.flat()\n  )\n);\n\n/** The tail covers the part of the import path after the prefix */\npathTail = withTags(\n  or(\n    pathExtends,\n    or(importCollection, itemImport, starImport).map((r) => [r.value])\n  ).map((r) => {\n    return r.value.flat();\n  })\n);\n\n// The prefix covers the import path until the point we could import an item\n// so ../foo or foo/\n\nconst relativeSegment = withTags(\n  seq(or(\".\", \"..\").tag(\"dir\"), \"/\").map(\n    (r) => new SimpleSegment(r.tags.dir[0])\n  )\n);\n\nconst relativePrefix = withTags(\n  seq(\n    repeatPlus(relativeSegment.tag(\"seg\")),\n    simpleSegment.tag(\"seg\"),\n    \"/\"\n  ).map((r) => {\n    return r.tags.seg;\n  })\n);\n\nconst relativePath = withTags(\n  seq(relativePrefix.tag(\"p\"), pathTail.tag(\"p\")).map((r) => r.tags.p.flat())\n);\n\nconst packagePrefix = withTags(\n  seq(tokens(packageTokens, pkgToken.tag(\"pkg\")), \"/\").map((r) => [\n    new SimpleSegment(r.tags.pkg[0]),\n  ])\n);\n\npackagePath = seq(packagePrefix, pathTail).map((r) => r.value.flat());\n\nconst fullPath = noSkipWs(\n  seq(kind(gleamImportTokens.ws), or(relativePath, packagePath).tag(\"path\"))\n).map((r) => {\n  return new ImportTree(r.tags.path.flat());\n});\n\n/** parse a Gleam style wgsl import statement. */\nexport const gleamImport = withTags(\n  tokens(\n    gleamImportTokens,\n    seq(\"import\", fullPath.tag(\"imports\"), opt(\";\"), eolf).map((r) => {\n      const e = makeElem(\"treeImport\", r, [\"imports\"]) as TreeImportElem;\n      r.app.state.push(e);\n    })\n  )\n);\n\nif (tracing) {\n  const names: Record<string, Parser<unknown, TagRecord>> = {\n    simpleSegment,\n    itemImport,\n    starImport,\n    importCollection,\n    pathSegment,\n    pathExtends,\n    pathTail,\n    relativeSegment,\n    relativePrefix,\n    relativePath,\n    packagePrefix,\n    packagePath,\n    fullPath,\n    gleamImport,\n  };\n\n  Object.entries(names).forEach(([name, parser]) => {\n    setTraceName(parser, name);\n  });\n}\n","import {\n  Parser,\n  anyThrough,\n  kind,\n  opt,\n  or,\n  repeat,\n  req,\n  seq,\n  setTraceNames,\n  tokens,\n  tracing,\n  withSep\n} from \"mini-parse\";\nimport { ExtendsElem } from \"./AbstractElems.js\";\nimport { gleamImport } from \"./GleamImport.js\";\nimport { ImportTree, SimpleSegment } from \"./ImportTree.js\";\nimport {\n  argsTokens,\n  lineCommentTokens,\n  mainTokens,\n  moduleTokens,\n} from \"./MatchWgslD.js\";\nimport { eolf, makeElem } from \"./ParseSupport.js\";\n\n/* parse #directive enhancements to wgsl: #import, #export, etc. */\n\nconst argsWord = kind(argsTokens.arg);\nconst fromWord = or(argsWord, kind(argsTokens.relPath));\n\n// prettier-ignore\n/** ( <a> <,b>* ) */\nexport const directiveArgs: Parser<string[]> = \n  seq(\n    \"(\", \n    withSep(\",\", argsWord), \n    req(\")\")\n  ).map((r) => r.value[1]);\n\nconst fromClause = seq(\n  \"from\",\n  or(fromWord.tag(\"from\"), seq('\"', fromWord.tag(\"from\"), '\"'))\n);\n\nexport interface ImportClause {\n  name: string;\n  as?: string;\n  args?: string[];\n}\n\n// prettier-ignore\n/** foo <(A,B)> <as bar> */\nconst importClause = seq(\n  argsWord.tag(\"name\"),\n  opt(directiveArgs.tag(\"args\")),\n  opt(seq(\"as\", argsWord.tag(\"as\")))\n).map(r =>\n  ({ name: r.tags.name[0],\n    as: r.tags.as?.[0],\n    args: r.tags.args?.[0],\n  }) as ImportClause\n).tag(\"importClause\");\n\nconst importList = withSep(\",\", importClause, { requireOne: true });\n\n// prettier-ignore\nconst bracketedImportClause = or(\n  importList, \n  seq(\"{\", importList, \"}\")\n);\n\n/** <{> foo <,zip> <(A,B)> <as boo> <}> <from bar>\n * @returns array of ExtendsElem elements */\nfunction importPhrase<T extends ExtendsElem>(kind: T[\"kind\"]): Parser<T[]> {\n  const p = seq(bracketedImportClause, fromClause).map((r) => {\n    const from = r.tags.from?.[0];\n    return r.tags.importClause.map((impClause) => {\n      const elem = makeElem(kind, r as any, [], []) as unknown as T;\n      copyDefinedProps(impClause, [\"name\", \"as\", \"args\"], elem);\n      if (from) elem.from = from;\n      return elem;\n    });\n  });\n\n  return p;\n}\n\nconst importElemPhrase = seq(bracketedImportClause, fromClause).map((r) => {\n  const from = r.tags.from?.[0];\n  return r.tags.importClause.map((impClause) => {\n    const elem = makeElem(\"treeImport\", r as any, [], []);\n    const fromSegments = from.split(\"/\").map((s) => new SimpleSegment(s));\n    const lastSegment = new SimpleSegment(\n      impClause.name,\n      impClause.as,\n      impClause.args\n    );\n    const segments = [...fromSegments, lastSegment];\n    const importTree: ImportTree = new ImportTree(segments);\n    elem.imports = importTree;\n    // TODO wildcards\n    return elem;\n  });\n});\n\nconst extendsElemPhrase = importPhrase<ExtendsElem>(\"extends\");\nif (tracing) setTraceNames({ importElemPhrase, extendsElemPhrase });\n\n/** #import foo <(a,b)> <as boo> <from bar>  EOL */\nconst importDirective = seq(\n  or(\"#import\", \"import\"),\n  seq(importElemPhrase.tag(\"imp\"), opt(\";\"), () => eolf)\n).map((r) => {\n  r.tags.imp[0].forEach((imp) => {\n    imp.start = r.start; // use start of #import, not import phrase\n    r.app.state.push(imp);\n  });\n});\n\nexport const extendsDirective = seq(\n  or(\"#extends\", \"extends\"),\n  seq(extendsElemPhrase.tag(\"extends\"), eolf)\n).map((r) => {\n  r.tags.extends[0].map((ext) => {\n    ext.start = r.start; // use start of #extends, not import phrase\n    r.app.state.push(ext);\n  });\n});\n\nexport const importing = seq(\n  \"importing\",\n  seq(importElemPhrase.tag(\"importing\")),\n  repeat(seq(\",\", importElemPhrase.tag(\"importing\")))\n);\n\n/** #export <foo> <(a,b)> <importing bar(a) <zap(b)>* > EOL */\nexport const exportDirective = seq(\n  or(\"#export\", \"export\"),\n  seq(opt(directiveArgs.tag(\"args\")), opt(importing), opt(eolf))\n).map((r) => {\n  const e = makeElem(\"export\", r, [\"args\", \"importing\"]);\n  r.app.state.push(e);\n});\n\nconst moduleDirective = seq(\n  or(\"module\", \"#module\"),\n  tokens(moduleTokens, req(kind(moduleTokens.moduleName).tag(\"name\"))),\n  eolf\n).map((r) => {\n  const e = makeElem(\"module\", r);\n  e.name = normalizeModulePath(r.tags.name[0]);\n  r.app.state.push(e);\n});\n\nfunction normalizeModulePath(name: string): string {\n  if (name.includes(\"::\")) {\n    const result = name.split(\"::\").join(\"/\");\n    return result;\n  }\n  return name;\n}\n\nexport const directive = tokens(\n  argsTokens,\n  seq(\n    repeat(\"\\n\"),\n    or(\n      exportDirective,\n      importDirective,\n      gleamImport,\n      extendsDirective,\n      moduleDirective\n    )\n  )\n);\n\nconst skipToEol = tokens(lineCommentTokens, anyThrough(eolf));\n\n/** parse a line comment */\nexport const lineComment = seq(tokens(mainTokens, \"//\"), skipToEol);\n\nif (tracing) {\n  setTraceNames({\n    directiveArgs,\n    fromClause,\n    importClause,\n    importList,\n    bracketedImportClause,\n    importElemPhrase,\n    extendsElemPhrase,\n    importing,\n    importDirective,\n    extendsDirective,\n    exportDirective,\n    skipToEol,\n    lineComment,\n    moduleDirective,\n    directive,\n  });\n}\n\nfunction copyDefinedProps<S extends Record<string, any>>(\n  src: S,\n  keys: (keyof S)[],\n  dest: any\n): void {\n  keys.forEach((k) => {\n    if (src[k] !== undefined) dest[k] = src[k];\n  });\n}\n","import {\n  anyNot,\n  anyThrough,\n  eof,\n  ExtendedResult,\n  kind,\n  matchingLexer,\n  opt,\n  or,\n  Parser,\n  ParserContext,\n  ParserInit,\n  preParse,\n  repeat,\n  req,\n  seq,\n  setTraceName,\n  simpleParser,\n  SrcMap,\n  tokens,\n  tracing,\n  withSep,\n} from \"mini-parse\";\nimport { AbstractElem, TypeNameElem, TypeRefElem } from \"./AbstractElems.js\";\nimport { identTokens, mainTokens } from \"./MatchWgslD.js\";\nimport { directive } from \"./ParseDirective.js\";\nimport {\n  comment,\n  makeElem,\n  unknown,\n  word,\n  wordNumArgs,\n} from \"./ParseSupport.js\";\n\n/** parser that recognizes key parts of WGSL and also directives like #import */\n\nconst longIdent = kind(identTokens.longIdent);\n\n// prettier gets confused if we leave the quoted parens inline so make consts for them here\nconst lParen = \"(\";\nconst rParen = \")\";\n\nexport interface ParseState {\n  ifStack: boolean[]; // stack used while processiing nested #if #else #endif directives\n  params: Record<string, any>; // user provided params to templates, code gen and #if directives\n}\n\nconst optAttributes = repeat(seq(kind(mainTokens.attr), opt(wordNumArgs)));\nconst possibleTypeRef = Symbol(\"typeRef\");\n\nconst globalDirectiveOrAssert = seq(\n  or(\"diagnostic\", \"enable\", \"requires\", \"const_assert\"),\n  req(anyThrough(\";\"))\n).map((r) => {\n  const e = makeElem(\"globalDirective\", r);\n  r.app.state.push(e);\n});\n\n/** parse an identifier into a TypeNameElem */\nexport const typeNameDecl = req(word.tag(\"name\")).map((r) => {\n  return makeElem(\"typeName\", r, [\"name\"]) as TypeNameElem; // fix?\n});\n\n/** parse an identifier into a TypeNameElem */\nexport const fnNameDecl = req(word.tag(\"name\"), \"missing fn name\").map((r) => {\n  return makeElem(\"fnName\", r, [\"name\"]);\n});\n\n/** find possible references to user types (structs) in this possibly nested template */\nexport const template: Parser<any> = seq(\n  \"<\",\n  or(\n    word.tag(possibleTypeRef), // only the first element of the template can be a type\n    () => template\n  ),\n  repeat(\n    or(\n      () => template,\n      anyNot(\">\") // we don't care about the rest of the template\n    )\n  ),\n  req(\">\")\n);\n\n/** find possible references to user structs in this type specifier and any templates */\nexport const typeSpecifier: Parser<TypeRefElem[]> = seq(\n  tokens(identTokens, longIdent.tag(possibleTypeRef)),\n  opt(template)\n).map((r) =>\n  r.tags[possibleTypeRef].map((name) => {\n    const e = makeElem(\"typeRef\", r as ExtendedResult<any>);\n    e.name = name;\n    return e as Required<typeof e>;\n  })\n);\n\nexport const structMember = seq(\n  optAttributes,\n  word.tag(\"name\"),\n  \":\",\n  req(typeSpecifier.tag(\"typeRefs\"))\n).map((r) => {\n  return makeElem(\"member\", r, [\"name\", \"typeRefs\"]);\n});\n\nexport const structDecl = seq(\n  \"struct\",\n  req(typeNameDecl).tag(\"nameElem\"),\n  req(\"{\"),\n  withSep(\",\", structMember).tag(\"members\"),\n  req(\"}\")\n).map((r) => {\n  const e = makeElem(\"struct\", r, [\"members\"]);\n  const nameElem = r.tags.nameElem[0];\n  e.nameElem = nameElem;\n  e.name = nameElem.name;\n  r.app.state.push(e);\n});\n\n// keywords that can be followed by (), not to be confused with fn calls\nconst callishKeyword = simpleParser(\"keyword\", (ctx: ParserContext) => {\n  const keywords = [\"if\", \"for\", \"while\", \"const_assert\", \"return\"];\n  const token = ctx.lexer.next();\n  const text = token?.text;\n  if (text && keywords.includes(text)) {\n    return text;\n  }\n});\n\nexport const fnCall = tokens(\n  identTokens,\n  seq(\n    longIdent\n      .tag(\"name\")\n      .map((r) => makeElem(\"call\", r, [\"name\"]))\n      .tag(\"calls\"), // we collect this in fnDecl, to attach to FnElem\n    \"(\"\n  )\n);\n\n// prettier-ignore\nconst fnParam = seq(\n  optAttributes,\n  word,\n  opt(seq(\":\", req(typeSpecifier.tag(\"typeRefs\"))))\n);\n\nconst fnParamList = seq(lParen, withSep(\",\", fnParam), rParen);\n\n// prettier-ignore\nconst variableDecl = seq(\n  or(\"const\", \"var\", \"let\", \"override\"), \n  word, \n  \":\", \n  req(typeSpecifier).tag(\"typeRefs\")\n);\n\n// prettier-ignore\nconst block: Parser<any> = seq(\n  \"{\",\n  repeat(\n    or(\n      callishKeyword,\n      fnCall,\n      () => block,\n      variableDecl,\n      anyNot(\"}\")\n    )\n  ),\n  req(\"}\")\n);\n\nexport const fnDecl = seq(\n  optAttributes,\n  \"fn\",\n  req(fnNameDecl).tag(\"nameElem\"),\n  req(fnParamList),\n  opt(seq(\"->\", optAttributes, typeSpecifier.tag(\"typeRefs\"))),\n  req(block)\n).map((r) => {\n  const e = makeElem(\"fn\", r);\n  const nameElem = r.tags.nameElem[0];\n  e.nameElem = nameElem as Required<typeof nameElem>;\n  e.name = nameElem.name;\n  e.calls = r.tags.calls || [];\n  e.typeRefs = r.tags.typeRefs?.flat() || [];\n  r.app.state.push(e);\n});\n\nexport const globalVar = seq(\n  optAttributes,\n  or(\"const\", \"override\", \"var\"),\n  opt(template),\n  word.tag(\"name\"),\n  opt(seq(\":\", req(typeSpecifier.tag(\"typeRefs\")))),\n  req(anyThrough(\";\"))\n).map((r) => {\n  const e = makeElem(\"var\", r, [\"name\"]);\n  e.typeRefs = r.tags.typeRefs?.flat() || [];\n  r.app.state.push(e);\n});\n\nexport const globalAlias = seq(\n  \"alias\",\n  req(word.tag(\"name\")),\n  req(\"=\"),\n  req(typeSpecifier).tag(\"typeRefs\"),\n  req(\";\")\n).map((r) => {\n  const e = makeElem(\"alias\", r, [\"name\", \"typeRefs\"]);\n  r.app.state.push(e);\n});\n\nconst globalDecl = or(fnDecl, globalVar, globalAlias, structDecl, \";\");\n\nconst rootDecl = or(globalDirectiveOrAssert, globalDecl, directive, unknown);\n\nconst root = preParse(comment, seq(repeat(rootDecl), eof()));\n\nexport function parseWgslD(\n  src: string,\n  srcMap?: SrcMap,\n  params: Record<string, any> = {},\n  maxParseCount: number | undefined = undefined,\n  grammar = root\n): AbstractElem[] {\n  const lexer = matchingLexer(src, mainTokens);\n  const state: AbstractElem[] = [];\n  const context: ParseState = { ifStack: [], params };\n  const app = {\n    context,\n    state,\n  };\n  const init: ParserInit = {\n    lexer,\n    app,\n    srcMap,\n    maxParseCount,\n  };\n\n  grammar.parse(init);\n\n  return app.state;\n}\n\nif (tracing) {\n  const names: Record<string, Parser<unknown>> = {\n    globalDirectiveOrAssert,\n    template,\n    typeSpecifier,\n    structMember,\n    structDecl,\n    fnCall,\n    fnParam,\n    fnParamList,\n    block,\n    fnDecl,\n    globalVar,\n    globalAlias,\n    globalDecl,\n    rootDecl,\n    root,\n  };\n\n  Object.entries(names).forEach(([name, parser]) => {\n    setTraceName(parser, name);\n  });\n}\n","import { srcLog, SrcMap } from \"mini-parse\";\nimport {\n  AbstractElem,\n  AliasElem,\n  ExportElem,\n  ExtendsElem,\n  FnElem,\n  GlobalDirectiveElem,\n  ModuleElem,\n  StructElem,\n  TemplateElem,\n  TreeImportElem,\n  VarElem,\n} from \"./AbstractElems.js\";\nimport { processConditionals } from \"./Conditionals.js\";\nimport { ApplyTemplateFn } from \"./ModuleRegistry.js\";\nimport { parseWgslD } from \"./ParseWgslD.js\";\nimport { SliceReplace, sliceReplace } from \"./Slicer.js\";\n\n/** module with exportable text fragments that are optionally transformed by a templating engine */\nexport interface TextModule {\n  kind: \"text\";\n  template?: TemplateElem;\n  exports: TextExport[];\n  fns: FnElem[];\n  vars: VarElem[];\n  structs: StructElem[];\n  imports: (ExtendsElem | TreeImportElem)[];\n  aliases: AliasElem[];\n  globalDirectives: GlobalDirectiveElem[];\n\n  modulePath: string; // full path to the module e.g \"package/sub/foo\", or \"_root/sub/foo\"\n\n  /** original src for module */\n  src: string;\n\n  /** src code after processing #if conditionals  */\n  preppedSrc: string;\n\n  /** tracks changes through conditional processing for error reporting */\n  srcMap: SrcMap;\n}\n\n/** an export elem annotated with the fn/struct to which it refers */\nexport interface TextExport extends ExportElem {\n  ref: FnElem | StructElem;\n}\n\nexport function preProcess(\n  src: string,\n  params: Record<string, any> = {},\n  templates: Map<string, ApplyTemplateFn> = new Map()\n): SrcMap {\n  const condSrcMap = processConditionals(src, params);\n  return applyTemplate(condSrcMap, templates, params);\n}\n\nexport function parseModule(\n  src: string,\n  naturalModulePath: string,\n  params: Record<string, any> = {},\n  templates: Map<string, ApplyTemplateFn> = new Map()\n): TextModule {\n  const srcMap = preProcess(src, params, templates);\n\n  const preppedSrc = srcMap.dest;\n  const parsed = parseWgslD(preppedSrc, srcMap);\n  const exports = findExports(parsed, srcMap);\n  const fns = filterElems<FnElem>(parsed, \"fn\");\n  const aliases = filterElems<AliasElem>(parsed, \"alias\");\n  const globalDirectives = filterElems<GlobalDirectiveElem>(\n    parsed,\n    \"globalDirective\"\n  );\n  const imports = parsed.filter(\n    (e) => e.kind === \"extends\" || e.kind === \"treeImport\"\n  ) as (ExtendsElem | TreeImportElem)[];\n  const structs = filterElems<StructElem>(parsed, \"struct\");\n  const vars = filterElems<VarElem>(parsed, \"var\");\n  const template = filterElems<TemplateElem>(parsed, \"template\")?.[0];\n  const overridePath = filterElems<ModuleElem>(parsed, \"module\")[0]?.name;\n  matchMergeImports(parsed, srcMap);\n\n  const modulePath = overridePath ?? naturalModulePath;\n  // dlog({ modulePath, overridePath });\n  const kind = \"text\";\n  return {\n    ...{ kind, src, srcMap, preppedSrc, modulePath },\n    ...{ exports, fns, structs, vars, imports, template },\n    ...{ aliases, globalDirectives },\n  };\n}\n\nexport function filterElems<T extends AbstractElem>(\n  parsed: AbstractElem[],\n  kind: T[\"kind\"]\n): T[] {\n  return parsed.filter((e) => e.kind === kind) as T[];\n}\n\nfunction findExports(parsed: AbstractElem[], srcMap: SrcMap): TextExport[] {\n  const results: TextExport[] = [];\n  const exports = findKind<ExportElem>(parsed, \"export\");\n\n  exports.forEach(([elem, i]) => {\n    let next: AbstractElem | undefined;\n    do {\n      next = parsed[++i];\n    } while (next?.kind === \"extends\");\n    if (elem.kind === \"export\") {\n      if (next?.kind === \"fn\" || next?.kind === \"struct\") {\n        results.push({ ...elem, ref: next });\n      } else {\n        srcLog(srcMap, elem.start, `#export what? (#export a fn or struct)`);\n      }\n    }\n  });\n  return results;\n}\n\n/** fill in extendsElem field of structs */\nfunction matchMergeImports(parsed: AbstractElem[], srcMap: SrcMap): void {\n  const extendsElems = findKind<ExtendsElem>(parsed, \"extends\");\n  extendsElems.forEach(([extendsElem, i]) => {\n    let next: AbstractElem | undefined;\n    do {\n      next = parsed[++i];\n    } while (next?.kind === \"extends\" || next?.kind === \"export\");\n    if (next?.kind === \"struct\") {\n      next.extendsElems = next.extendsElems ?? [];\n      next.extendsElems.push(extendsElem);\n    } else {\n      srcLog(srcMap, extendsElem.start, `#extends not followed by a struct`);\n    }\n  });\n}\n\nfunction findKind<T extends AbstractElem>(\n  parsed: AbstractElem[],\n  kind: T[\"kind\"]\n): [T, number][] {\n  return parsed.flatMap((elem, i) =>\n    elem.kind === kind ? ([[elem, i]] as [T, number][]) : []\n  );\n}\n\nconst templateRegex = /#template\\s+([/[a-zA-Z_][\\w./-]*)/;\n\nfunction applyTemplate(\n  priorSrcMap: SrcMap,\n  templates: Map<string, ApplyTemplateFn>,\n  params: Record<string, any>\n): SrcMap {\n  const src = priorSrcMap.dest;\n  const foundTemplate = src.match(templateRegex);\n  if (!foundTemplate) {\n    return priorSrcMap;\n  }\n  const templateName = foundTemplate[1];\n  const templateFn = templates.get(templateName);\n  if (!templateFn) {\n    srcLog(\n      priorSrcMap,\n      foundTemplate.index!,\n      `template '${templateName}' not found in ModuleRegistry`\n    );\n    return priorSrcMap;\n  }\n\n  // dlog({priorSrcMap})\n\n  const start = foundTemplate.index!;\n  const end = start + foundTemplate[0].length;\n  const rmDirective: SliceReplace = { start, end, replacement: \"\" };\n  const removedMap = sliceReplace(src, [rmDirective]);\n  // dlog({ removedMap });\n  const removeMerged = priorSrcMap.merge(removedMap);\n  // dlog({ removeMerged });\n\n  const templatedMap = templateFn(removeMerged.dest, params);\n  // dlog({ templatedMap});\n\n  const srcMap = removeMerged.merge(templatedMap);\n  // dlog({ srcMap });\n\n  return srcMap;\n}\n","import { dlog } from \"berry-pretty\";\nimport { TreeImportElem } from \"./AbstractElems.js\";\nimport { importResolutionMap, ResolveMap } from \"./ImportResolutionMap.js\";\nimport { linkWgslModule } from \"./Linker.js\";\nimport {\n  GeneratorExport,\n  GeneratorModule,\n  GeneratorModuleExport,\n  ModuleExport,\n  ModuleRegistry,\n  relativeToAbsolute,\n  TextModuleExport,\n} from \"./ModuleRegistry.js\";\nimport { parseModule, TextExport, TextModule } from \"./ParseModule.js\";\nimport { dirname, normalize, noSuffix } from \"./PathUtil.js\";\n\n/** parse wgsl files and provided indexed access to modules and exports */\nexport class ParsedRegistry {\n  private textModules: TextModule[] = [];\n\n  constructor(\n    public registry: ModuleRegistry,\n    public conditions: Record<string, any> = {}\n  ) {\n    this.textModules = [];\n    this.registry.wgslSrc.forEach((src, fileName) => {\n      this.parseOneModule(src, conditions, fileName);\n    });\n  }\n\n  link(moduleSpecifier: string): string {\n    const module = this.findTextModule(moduleSpecifier);\n    if (!module) {\n      throw new Error(`Module not found: ${moduleSpecifier}`);\n    }\n    return linkWgslModule(module, this, this.conditions);\n  }\n\n  /** parse one module, register exports for later searching */\n  private parseOneModule(\n    src: string,\n    params: Record<string, any> = {},\n    modulePath: string\n  ): void {\n    const m = parseModule(src, modulePath, params, this.registry.templates);\n    this.textModules.push(m);\n  }\n\n  /** @return a ResolveMap to make it easier to resolve imports from the provided module */\n  importResolveMap(importingModule: TextModule): ResolveMap {\n    const treeImports: TreeImportElem[] = importingModule.imports.filter(\n      (i) => i.kind === \"treeImport\"\n    ); // TODO drop filter when we drop other import kinds\n\n    // TODO cache\n    return importResolutionMap(importingModule, treeImports, this);\n  }\n\n  /** @return a ModuleExport if the provided pathSegments\n   * reference an export in a registered module */\n  getModuleExport(\n    importingModule: TextModule, // TODO drop this and require pathSegments to be absolute\n    pathSegments: string[]\n  ): ModuleExport | undefined {\n    const exportName = pathSegments[pathSegments.length - 1];\n    if (pathSegments[0] === \".\") {\n      // relative module path in current package\n      const moduleDir = dirname(importingModule.modulePath);\n      const joined = [moduleDir, ...pathSegments.slice(1, -1)].join(\"/\");\n      const modulePath = normalize(joined);\n      const result = this.findExport(modulePath, exportName);\n      // dlog({ modulePath, exportName, result: !!result });\n      return result;\n    } else {\n      // package rooted path\n      const modulePath = pathSegments.slice(0, -1).join(\"/\");\n      const result = this.findExport(modulePath, exportName);\n      // dlog({ modulePath, exportName, result: !!result });\n      return result;\n    }\n  }\n\n  private findExport(\n    modulePath: string,\n    exportName: string\n  ): TextModuleExport | GeneratorModuleExport | undefined {\n    const module = this.findTextModule(modulePath);\n    // dlog({ modulePath, module: !!module });\n    const exp = module?.exports.find((e) => e.ref.name === exportName);\n    if (exp && module) {\n      return { module, exp: exp, kind: \"text\" };\n    }\n\n    return this.registry.generators.get(modulePath);\n  }\n\n  findModule(\n    moduleSpecifier: string\n  ): TextModule | GeneratorModule | undefined {\n    return (\n      this.findTextModule(moduleSpecifier) ??\n      this.registry.generators.get(moduleSpecifier)?.module\n    );\n  }\n\n  /**\n   * Find a text module by module specifier\n   * @param packageName requesting package name (for resolving relative paths)\n   */\n  findTextModule(\n    moduleSpecifier: string,\n    packageName = \"_root\"\n  ): TextModule | undefined {\n    // const modulePaths = this.textModules.map((m) => m.modulePath);\n    // dlog({ modulePaths });\n    const resolvedPath = moduleSpecifier.startsWith(\".\")\n      ? relativeToAbsolute(moduleSpecifier, packageName)\n      : moduleSpecifier;\n    const result =\n      this.textModules.find((m) => m.modulePath === resolvedPath) ??\n      this.textModules.find((m) => noSuffix(m.modulePath) === resolvedPath);\n    // dlog({ moduleSpecifier, packageName, result: !!result });\n    return result;\n  }\n\n}\n\nexport function exportName(exp: TextExport | GeneratorExport): string {\n  // TODO make TextExport into a class or give kinds to avoid unsound casts\n  const asTextExport = exp as TextExport;\n  const asGenExport = exp as GeneratorExport;\n  return asTextExport.ref?.name ?? asGenExport.name;\n}\n","import { SrcMap } from \"mini-parse\";\nimport { ParsedRegistry } from \"./ParsedRegistry.js\";\nimport { TextExport, TextModule } from \"./ParseModule.js\";\nimport { normalize } from \"./PathUtil.js\";\nimport { WgslBundle } from \"./WgslBundle.js\";\n\n/** A named function to transform code fragments (e.g. by inserting parameters) */\nexport interface Template {\n  name: string;\n  apply: ApplyTemplateFn;\n}\nexport type CodeGenFn = (\n  name: string,\n  params: Record<string, string>\n) => string;\n\nexport interface GeneratorExport {\n  name: string;\n  args: string[];\n  generate: CodeGenFn;\n}\n\n/** a named code generation function */\nexport interface RegisterGenerator {\n  /** export name for this generator */\n  name: string;\n\n  /** module namespace for this generator */\n  moduleName: string;\n\n  /** function to generate code at runtime */\n  generate: CodeGenFn;\n\n  /** arguments to pass when importing from this generator */\n  args?: string[];\n}\n\nexport type ApplyTemplateFn = (\n  src: string,\n  params: Record<string, any> // combination of external params and imp/exp params\n) => SrcMap;\n\n/** a single export from a module */\nexport type ModuleExport = TextModuleExport | GeneratorModuleExport;\n\nexport interface TextModuleExport {\n  module: TextModule;\n  exp: TextExport;\n  kind: \"text\";\n}\n\nexport interface GeneratorModule {\n  kind: \"generator\";\n  modulePath: string;\n  exports: GeneratorExport[];\n}\n\nexport interface GeneratorModuleExport {\n  module: GeneratorModule;\n  exp: GeneratorExport;\n  kind: \"function\";\n}\n\nexport interface RegistryParams {\n  /** record of file names and wgsl text for modules */\n  wgsl?: Record<string, string>;\n\n  /** record of file names and wgsl text for modules */\n  libs?: WgslBundle[];\n\n  /** string template handlers for processing exported functions and structs */\n  templates?: Template[];\n\n  /** code generation functions */\n  generators?: RegisterGenerator[];\n}\n\nconst libExp = /\\/lib\\.w[eg]sl/i;\n\n/**\n * A ModuleRegistry collects exportable code fragments, code generator functions,\n * and template processors.\n *\n * The ModuleRegistry provides everything required for linkWgsl to process\n * #import statements and generate a complete wgsl shader.\n */\nexport class ModuleRegistry {\n  templates = new Map<string, ApplyTemplateFn>();\n  // map from absolute module path to wgsl/wesl src text\n  wgslSrc = new Map<string, string>();\n  generators = new Map<string, GeneratorModuleExport>();\n\n  constructor(args?: RegistryParams) {\n    if (!args) return;\n    const { wgsl = {}, templates = [], libs = [], generators } = args;\n\n    Object.entries(wgsl).forEach(([fileName, src]) =>\n      this.wgslSrc.set(relativeToAbsolute(fileName, \"_root\"), src)\n    );\n\n    libs.forEach(({ name, modules}) => {\n      Object.entries(modules).forEach(([fileName, src]) => {\n        const absPath = relativeToAbsolute(fileName, name);\n        const canonPath = libExp.test(absPath)\n          ? absPath.slice(0, -\"/lib.wgsl\".length)\n          : absPath;\n        this.wgslSrc.set(canonPath, src);\n      });\n    });\n\n    templates && this.registerTemplate(...templates);\n    generators?.map((g) => this.registerGenerator(g));\n  }\n\n  /**\n   * Produce a linked wgsl string with all directives processed\n   * (e.g. #import'd functions from other modules are inserted into the resulting string).\n   * @param moduleName select the module to use as the root source\n   * @param runtimeParams runtime parameters for #import/#export values,\n   *  template values, and code generation parameters\n   */\n  link(moduleName: string, runtimeParams: Record<string, any> = {}): string {\n    return this.parsed(runtimeParams).link(moduleName);\n  }\n\n  /** Parse the text modules in the registry */\n  parsed(runtimeParams: Record<string, any> = {}): ParsedRegistry {\n    return new ParsedRegistry(this, runtimeParams);\n  }\n\n  /** register a function that generates code on demand */\n  registerGenerator(reg: RegisterGenerator): void {\n    const exp: GeneratorExport = {\n      name: reg.name,\n      args: reg.args ?? [],\n      generate: reg.generate,\n    };\n    const module: GeneratorModule = {\n      kind: \"generator\",\n      modulePath: reg.moduleName,\n      exports: [exp],\n    };\n\n    this.generators.set(module.modulePath, { kind: \"function\", module, exp });\n  }\n\n  /** register a template processor  */\n  registerTemplate(...templates: Template[]): void {\n    templates.forEach((t) => this.templates.set(t.name, t.apply));\n  }\n}\n\nexport function relativeToAbsolute(\n  relativePath: string,\n  packageName: string\n): string {\n  const normalPath = normalize(relativePath);\n  const fullPath = `${packageName}/${normalPath}`;\n  return fullPath;\n}\n"],"names":["mergeTags","a","b","sharedEntries","Reflect","ownKeys","filter","k","map","shared","Object","fromEntries","ParseError","Error","constructor","msg","super","kind","kindStr","simpleParser","state","next","lexer","text","seq","args","parsers","parserArg","parser","ctx","values","tagged","p","result","_run","tags","push","value","or","undefinedResult","opt","arg","any","anyNot","pos","position","not","r","traceName","anyThrough","repeat","debugName","filterFn","runExtended","repeatWhileFilter","eof","req","msgs","src","srcMap","srcLog","ctxLog","withSep","sep","opts","trailing","requireOne","pTagged","tag","first","last","_sepTag","tokens","matcher","_traceName","withMatcher","makeEolf","ws","tokenSkipSet","quotedText","Parser","fn","deepName","_debugNames","join","withTags","this","tagName","traceOptions","trace","terminal","traceSrc","preDisabled","_cloneWith","context","_parseCount","maxParseCount","origAppContext","app","origPosition","withTraceLogging","runInContext","tContext","traceSuccessOnly","_a","_trace","successOnly","tracing","parserLog","_preParse","_preCacheFails","ctxNoPre","forEach","pre","failCache","get","Set","preResult","set","has","add","execPreParsers","pop","runParser","name","extended","mappedValue","toParser","toParserFn","newParser","parse","init","Map","e","console","error","_b","toString","emptySet","ignore","mainParser","ignoreSet","withIgnore","disablePreParse","origStart","origResults","end","start","skipIgnored","logger","log","noLog","withTraceLoggingInternal","stubTraceLogging","logging","hide","shallow","indent","tlog","pad","currentIndent","slice","logFn","orig","withLogger","logInternal","resultLog","srcOrSrcMap","destPos","logInternalSrc","positions","srcPos","mapPositions","flat","mapSrcPositions","line","lineNum","linePos","linePos2","pos2","starts","found","startCache","matchAll","m","index","unshift","getStarts","length","mid","lineNl","srcLine","caret","firstCaret","secondCaret","carets","matchingLexer","rootMatcher","matcherStack","toNextToken","token","withMatcherIgnore","tokenMatcher","newMatcher","newIgnore","pushMatcher","elem","srcTrace","replace","SrcMap","dest","entries","addEntries","newEntries","destToSrc","compact","prev","i","destEnd","destStart","srcEnd","srcStart","sort","merge","other","mappedEntries","endSrc","otherSources","newMap","entry","find","Cache","max","v","size","delete","keys","matchers","groups","cache","expParts","toRegexSource","exp","RegExp","keyEntries","clear","lastIndex","startPos","matches","exec","matchedIndex","indices","startEnd","groupDex","findGroupDex","nameExp","expSrc","escapeRegex","verifyNonCapturing","source","regexSpecials","s","matchOneOf","syms","escaped","split","refLog","ref","moduleLog","expMod","mod","modulePath","tokenRegex","replaceWords","replaceAll","groupBy","key","t","group","partition","partFn","yesPart","noPart","scan","array","zero","current","overlapTail","overlapSize","Math","min","arrayEquals","every","val","sliceReplace","slices","sorted","initProgress","results","lastProgress","progress","replaceOne","finalProgress2","copied","replacement","newSrcPos","newDestPos","concat","resolveImport","callPath","resolveMap","callSegments","includes","expPath","impSegments","pathsMap","imp","impTail","impToExportPath","impToExp","exportMap","modExp","expImpArgs","traverseRefs","srcModule","registry","aliases","fns","structs","vars","srcRefs","proposedName","childRefs","textRefs","flatMap","srcRef","elemRefs","seen","recursiveRefs","fullName","refFullName","unseen","refs","textRef","fnRefs","mergeRefs","elemChildrenRefs","calls","call","stdFns","stdType","merges","extendsElems","foundRef","importRef","imports","extendsRefs","userTypeRefs","typeRefs","members","elemTypeRefs","tRefs","children","expInfo","expArg","importArgRef","localRef","linkedRef","fromRef","impMod","resolved","importResolveMap","fromImport","module","JSON","stringify","memoize","nesting","spaces","defaultCallerSize","DOMRect","globalThis","stdTypes","linkWgslModule","extParams","loadRefs","generatorRefs","nonMergeRefs","txt","gen","nonMerge","partitionRefTypes","expRefs","mergeMap","recursiveMerges","transitiveMerges","combineMergeRefs","prepRefsMergeAndLoad","findReferences","directiveRefs","globalDirectives","globalDirectiveRefs","genExp","exports","fnName","rename","params","refExpImp","generate","loadGeneratedElem","elemKind","slicing","nameElem","typeRefSlices","applyExpImp","preppedSrc","loadFnText","structElem","rootMembers","loadMemberText","newMembers","mergeRef","member","membersText","loadStruct","loadOtherElem","warn","extractTexts","visited","rootNames","linkName","renamed","conflicts","uniquifyName","argsStr","refName","startsWith","typeRef","ImportTree","segments","SimpleSegment","as","SegmentList","list","Wildcard","dirname","path","lastSlash","lastIndexOf","normalize","noDots","noDbl","noSuffix","lastStart","suffix","indexOf","suffixStart","ExportPathToExport","exportPath","ImportToExportPath","importPath","importResolutionMap","importingModule","resolveEntries","recursiveResolve","resolvedImportPath","resolvedExportPath","remainingPath","segment","rest","impPath","resolveFlatPath","rPath","findModule","wildCardExports","exportKind","exportName","impArgs","resolvedImp","absolutePath","resolvedExp","impArgsStr","expPathStr","getModuleExport","expArgs","matchExportImportArgs","resolveTreeImport","exportEntries","pathEntries","pathSegments","eol","directive","symbol","quote","word","digits","mainTokens","attr","identTokens","longIdent","moduleTokens","moduleName","lineCommentTokens","notEol","argsTokens","relPath","importSymbol","blanks","conditionalsTokens","eolf","ifDirective","ifArg","invert","pushIfState","elseDirective","oldTruth","popIfState","endifDirective","directiveLine","regularLine","ifStack","truthy","skippingIfBody","destLength","srcMapEntries","lines","pushLine","srcLines","wordNum","unknown","blockComment","comment","lineComment","wordNumArgs","makeElem","er","tagArrays","mapIfDefined","firstElemOnly","ak","gleamImportSymbol","skipWsSet","skipWs","gleamImportTokens","packageTokens","pkg","wordToken","pkgToken","pathTail","packagePath","simpleSegment","itemImport","starImport","collectionItem","importCollection","elems","l","pathExtends","relativeSegment","dir","relativePrefix","repeatPlus","seg","relativePath","packagePrefix","fullPath","noSkipWs","gleamImport","argsWord","fromWord","directiveArgs","fromClause","importList","bracketedImportClause","importElemPhrase","from","importClause","impClause","importTree","extendsElemPhrase","importDirective","extendsDirective","extends","ext","importing","exportDirective","moduleDirective","normalizeModulePath","skipToEol","optAttributes","possibleTypeRef","Symbol","globalDirectiveOrAssert","typeNameDecl","fnNameDecl","template","typeSpecifier","structMember","structDecl","callishKeyword","fnCall","fnParam","fnParamList","variableDecl","block","fnDecl","globalVar","globalAlias","globalDecl","rootDecl","root","newCtx","parseWgslD","grammar","preProcess","templates","condSrcMap","processConditionals","priorSrcMap","foundTemplate","match","templateRegex","templateName","templateFn","removedMap","removeMerged","templatedMap","applyTemplate","parseModule","naturalModulePath","parsed","findKind","findExports","filterElems","overridePath","extendsElem","matchMergeImports","ParsedRegistry","conditions","textModules","wgslSrc","fileName","parseOneModule","link","moduleSpecifier","findTextModule","treeImports","findExport","generators","packageName","resolvedPath","relativeToAbsolute","asGenExport","libExp","wgsl","libs","modules","absPath","canonPath","test","registerTemplate","g","registerGenerator","runtimeParams","reg","apply","stride","combined","bMap","srcPath","reqPath"],"mappings":"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","x_google_ignoreList":[13]}