wesl 0.7.26 → 0.7.28

package/src/parse/ContentsHelpers.ts

@@ -1,70 +0,0 @@
-import type {
-  ContainerElem,
-  ElemKindMap,
-  GrammarElem,
-  TextElem,
-} from "../AbstractElems.ts";
-import type { SrcModule } from "../Scope.ts";
-import type { ParsingContext } from "./ParsingContext.ts";
-
-/** Push partial element onto stack for content collection. */
-export function beginElem(
-  ctx: ParsingContext,
-  kind: ContainerElem["kind"],
-  contents: readonly GrammarElem[] = [],
-): void {
-  ctx.state.context.openElems.push({ kind, contents: [...contents] });
-}
-
-/** Pop element from stack, fill gaps with TextElems, return contents. */
-export function finishContents(
-  ctx: ParsingContext,
-  start: number,
-  end: number,
-): GrammarElem[] {
-  const open = ctx.state.context.openElems.pop();
-  if (!open) throw new Error("No open element to close");
-  return coverWithText(ctx, open.contents as GrammarElem[], start, end);
-}
-
-/** Finish element: get end position, close contents, return complete element. */
-export function finishElem<K extends keyof ElemKindMap>(
-  kind: K,
-  start: number,
-  ctx: ParsingContext,
-  params: Omit<ElemKindMap[K], "kind" | "start" | "end" | "contents">,
-): ElemKindMap[K] {
-  const end = ctx.stream.checkpoint();
-  const contents = finishContents(ctx, start, end);
-  return { kind, start, end, contents, ...params } as ElemKindMap[K];
-}
-
-/** Create a TextElem */
-export function makeText(
-  srcModule: SrcModule,
-  start: number,
-  end: number,
-): TextElem {
-  return { kind: "text", start, end, srcModule };
-}
-
-/** Fill gaps between child elements with TextElems. */
-function coverWithText(
-  ctx: ParsingContext,
-  contents: GrammarElem[],
-  start: number,
-  end: number,
-): GrammarElem[] {
-  const { srcModule } = ctx.state.stable;
-  const sorted = contents.slice().sort((a, b) => a.start - b.start);
-  const elems: GrammarElem[] = [];
-  let pos = start;
-
-  for (const elem of sorted) {
-    if (pos < elem.start) elems.push(makeText(srcModule, pos, elem.start));
-    elems.push(elem);
-    pos = elem.end;
-  }
-  if (pos < end) elems.push(makeText(srcModule, pos, end));
-  return elems;
-}

package/src/parse/stream/CachingStream.ts

@@ -1,48 +0,0 @@
-import type { Stream, Token } from "../../Stream.ts";
-
-export class CachingStream<T extends Token> implements Stream<T> {
-  private cache = new Cache<number, { token: T | null; checkpoint: number }>(5);
-  private inner: Stream<T>;
-  constructor(inner: Stream<T>) {
-    this.inner = inner;
-  }
-  checkpoint(): number {
-    return this.inner.checkpoint();
-  }
-  reset(position: number): void {
-    this.inner.reset(position);
-  }
-  nextToken(): T | null {
-    const startPos = this.checkpoint();
-    const cachedValue = this.cache.get(startPos);
-    if (cachedValue !== undefined) {
-      this.reset(cachedValue.checkpoint);
-      return cachedValue.token;
-    } else {
-      const token = this.inner.nextToken();
-      const checkpoint = this.checkpoint();
-      this.cache.set(startPos, { token, checkpoint });
-      return token;
-    }
-  }
-  get src(): string {
-    return this.inner.src;
-  }
-}
-
-/** size limited key value cache */
-class Cache<K, V> extends Map<K, V> {
-  private readonly max: number;
-  constructor(max: number) {
-    super();
-    this.max = max;
-  }
-
-  set(k: K, v: V): this {
-    if (this.size > this.max) {
-      const first = this.keys().next().value;
-      if (first) this.delete(first);
-    }
-    return super.set(k, v);
-  }
-}

package/src/parse/stream/MatchersStream.ts

@@ -1,85 +0,0 @@
-import type { Span } from "../../Span.ts";
-import type { Stream, TypedToken } from "../../Stream.ts";
-import { toRegexSource } from "./RegexHelpers.ts";
-
-/** Runs a `RegexMatchers` on an input string */
-export class MatchersStream<Kind extends string>
-  implements Stream<TypedToken<Kind>>
-{
-  private position = 0;
-  public text: string;
-  private matchers: RegexMatchers<Kind>;
-
-  constructor(text: string, matchers: RegexMatchers<Kind>) {
-    this.text = text;
-    this.matchers = matchers;
-  }
-
-  checkpoint(): number {
-    return this.position;
-  }
-  reset(position: number): void {
-    this.position = position;
-  }
-  nextToken(): TypedToken<Kind> | null {
-    const result = this.matchers.execAt(this.text, this.position);
-    if (result === null) return null;
-    this.position = result.span[1];
-    return result;
-  }
-  get src(): string {
-    return this.text;
-  }
-}
-
-/**
- * The matchers passed to this object must follow certain rules:
- * - They must use non-capturing groups: `(?:...)`
- * - They must NOT use `^` or `$`
- */
-export class RegexMatchers<Kind extends string> {
-  private groups: Kind[];
-  private exp: RegExp;
-  constructor(matchers: Record<Kind, string | RegExp>) {
-    this.groups = Object.keys(matchers) as Kind[];
-    const expParts = Object.entries(matchers as Record<string, string | RegExp>)
-      .map(toRegexSource)
-      .join("|");
-    // d = return substrings of each match
-    // y = sticky, only match at the start of the string
-    // u = unicode aware
-    this.exp = new RegExp(expParts, "dyu");
-  }
-
-  execAt(text: string, position: number): TypedToken<Kind> | null {
-    this.exp.lastIndex = position;
-    const matches = this.exp.exec(text);
-    const matchedIndex = findGroupDex(matches?.indices);
-
-    if (matchedIndex) {
-      const { span, groupDex } = matchedIndex;
-      const kind = this.groups[groupDex];
-      return { kind, span, text: text.slice(span[0], span[1]) };
-    } else {
-      return null;
-    }
-  }
-}
-
-interface MatchedIndex {
-  span: Span;
-  groupDex: number;
-}
-
-function findGroupDex(
-  indices: RegExpIndicesArray | undefined,
-): MatchedIndex | undefined {
-  if (indices !== undefined) {
-    for (let i = 1; i < indices.length; i++) {
-      const span = indices[i];
-      if (span !== undefined) {
-        return { span, groupDex: i - 1 };
-      }
-    }
-  }
-}