@statewalker/webrun-files-composite 0.7.1 → 0.8.1

package/src/cow-files-api.ts

@@ -0,0 +1,244 @@
+import type {
+  FileInfo,
+  FileStats,
+  FilesApi,
+  ListOptions,
+  ReadOptions,
+} from "@statewalker/webrun-files";
+import { basename, dirname, joinPath, normalizePath } from "@statewalker/webrun-files";
+
+/** Options for {@link cow}. */
+export interface CowOptions {
+  /**
+   * Filename prefix for per-path whiteout markers, stored in the writable
+   * layer. A whiteout for `/dir/name` lives at `/dir/<prefix>name`.
+   * Defaults to `".wh."`.
+   */
+  whiteoutPrefix?: string;
+  /**
+   * Filename for the opaque-directory marker, stored as a child of a
+   * directory whose base subtree has been deleted. Defaults to `".wh..opq"`.
+   */
+  opaqueName?: string;
+}
+
+type Layer = "writable" | "base" | "absent";
+
+/**
+ * Copy-on-write view: a writable layer over a read-only `base`. The `base`
+ * is **never** mutated — every change (write, delete, move) is recorded in
+ * the `writable` layer, using marker files to record deletions.
+ *
+ * Resolution precedence for any path:
+ * 1. a covering whiteout / opaque marker ⇒ the path is absent;
+ * 2. otherwise the `writable` layer, if it has the path;
+ * 3. otherwise fall through to `base`.
+ *
+ * Deletions are persisted as marker files inside the writable layer, so they
+ * survive across process restarts and work over any `FilesApi` backend.
+ * Markers are hidden from `read` / `list` / `stats` / `exists`.
+ *
+ * Use {@link cow} to construct one.
+ */
+class CowFilesApi implements FilesApi {
+  private readonly base: FilesApi;
+  private readonly writable: FilesApi;
+  private readonly whiteoutPrefix: string;
+  private readonly opaqueName: string;
+
+  constructor(base: FilesApi, writable: FilesApi, opts?: CowOptions) {
+    this.base = base;
+    this.writable = writable;
+    this.whiteoutPrefix = opts?.whiteoutPrefix ?? ".wh.";
+    this.opaqueName = opts?.opaqueName ?? ".wh..opq";
+  }
+
+  // --- marker helpers ---
+
+  private whiteoutPath(path: string): string {
+    const p = normalizePath(path);
+    return joinPath(dirname(p), `${this.whiteoutPrefix}${basename(p)}`);
+  }
+
+  private opaquePath(dir: string): string {
+    return joinPath(normalizePath(dir), this.opaqueName);
+  }
+
+  private isMarker(name: string): boolean {
+    return name.startsWith(this.whiteoutPrefix) || name === this.opaqueName;
+  }
+
+  private *ancestorsInclusive(dir: string): Iterable<string> {
+    let cur = normalizePath(dir);
+    yield cur;
+    while (cur !== "/") {
+      cur = dirname(cur);
+      yield cur;
+    }
+  }
+
+  private async hasDirectWhiteout(path: string): Promise<boolean> {
+    return this.writable.exists(this.whiteoutPath(path));
+  }
+
+  /** True when an opaque marker on `dir` or any ancestor hides base content. */
+  private async isBaseContentHidden(dir: string): Promise<boolean> {
+    for (const ancestor of this.ancestorsInclusive(dir)) {
+      if (await this.writable.exists(this.opaquePath(ancestor))) return true;
+    }
+    return false;
+  }
+
+  /** True when the base version of `path` is hidden by a marker. */
+  private async isBaseHidden(path: string): Promise<boolean> {
+    if (await this.hasDirectWhiteout(path)) return true;
+    return this.isBaseContentHidden(dirname(normalizePath(path)));
+  }
+
+  private async resolveLayer(path: string): Promise<Layer> {
+    if (await this.writable.exists(path)) return "writable";
+    if (await this.isBaseHidden(path)) return "absent";
+    if (await this.base.exists(path)) return "base";
+    return "absent";
+  }
+
+  /** Removes a covering whiteout marker so a write/mkdir resurrects the path. */
+  private async clearWhiteout(path: string): Promise<void> {
+    const marker = this.whiteoutPath(path);
+    if (await this.writable.exists(marker)) {
+      await this.writable.remove(marker);
+    }
+  }
+
+  // --- FilesApi ---
+
+  async *read(path: string, options?: ReadOptions): AsyncIterable<Uint8Array> {
+    const layer = await this.resolveLayer(path);
+    if (layer === "writable") yield* this.writable.read(path, options);
+    else if (layer === "base") yield* this.base.read(path, options);
+  }
+
+  async write(
+    path: string,
+    content: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,
+  ): Promise<void> {
+    await this.clearWhiteout(path);
+    await this.writable.write(path, content);
+  }
+
+  async mkdir(path: string): Promise<void> {
+    await this.clearWhiteout(path);
+    await this.writable.mkdir(path);
+  }
+
+  async stats(path: string): Promise<FileStats | undefined> {
+    const layer = await this.resolveLayer(path);
+    if (layer === "writable") return this.writable.stats(path);
+    if (layer === "base") return this.base.stats(path);
+    return undefined;
+  }
+
+  async exists(path: string): Promise<boolean> {
+    return (await this.resolveLayer(path)) !== "absent";
+  }
+
+  async *list(path: string, options?: ListOptions): AsyncIterable<FileInfo> {
+    yield* this.listDir(normalizePath(path), options?.recursive ?? false);
+  }
+
+  private async *listDir(dir: string, recursive: boolean): AsyncIterable<FileInfo> {
+    const stats = await this.stats(dir);
+    if (stats?.kind !== "directory") return;
+    for (const entry of await this.mergeChildren(dir)) {
+      yield entry;
+      if (recursive && entry.kind === "directory") {
+        yield* this.listDir(entry.path, true);
+      }
+    }
+  }
+
+  /** Direct children of `dir`: writable entries win, base entries fill in. */
+  private async mergeChildren(dir: string): Promise<FileInfo[]> {
+    const merged = new Map<string, FileInfo>();
+    if ((await this.writable.stats(dir))?.kind === "directory") {
+      for await (const entry of this.writable.list(dir)) {
+        if (this.isMarker(entry.name)) continue;
+        merged.set(entry.name, entry);
+      }
+    }
+    const baseHidden = await this.isBaseContentHidden(dir);
+    if (!baseHidden && (await this.base.stats(dir))?.kind === "directory") {
+      for await (const entry of this.base.list(dir)) {
+        if (merged.has(entry.name)) continue;
+        if (await this.hasDirectWhiteout(entry.path)) continue;
+        merged.set(entry.name, entry);
+      }
+    }
+    return [...merged.values()];
+  }
+
+  async remove(path: string): Promise<boolean> {
+    if ((await this.resolveLayer(path)) === "absent") return false;
+    if (await this.writable.exists(path)) {
+      await this.writable.remove(path);
+    }
+    // Record a whiteout only when the base still carries the path.
+    const baseStats = await this.base.stats(path);
+    if (baseStats) {
+      const marker =
+        baseStats.kind === "directory" ? this.opaquePath(path) : this.whiteoutPath(path);
+      await this.writable.write(marker, []);
+    }
+    return true;
+  }
+
+  async move(source: string, target: string): Promise<boolean> {
+    const stats = await this.stats(source);
+    if (!stats) return false;
+    await this.copyInto(source, target, stats);
+    await this.remove(source);
+    return true;
+  }
+
+  async copy(source: string, target: string): Promise<boolean> {
+    const stats = await this.stats(source);
+    if (!stats) return false;
+    await this.copyInto(source, target, stats);
+    return true;
+  }
+
+  /** Copies the composite view of `src` into the writable layer at `tgt`. */
+  private async copyInto(src: string, tgt: string, stats: FileStats): Promise<void> {
+    if (stats.kind === "file") {
+      await this.write(tgt, this.read(src));
+      return;
+    }
+    await this.mkdir(tgt);
+    for await (const entry of this.list(src)) {
+      await this.copyInto(entry.path, joinPath(tgt, entry.name), entry);
+    }
+  }
+}
+
+/**
+ * Builds a copy-on-write `FilesApi`: a `writable` layer over a read-only
+ * `base`. Reads fall through to `base`; every write goes to `writable`;
+ * `base` is never mutated. Deletions are persisted as marker files in
+ * `writable` (a per-path whiteout for files, one opaque marker for a deleted
+ * base directory), so they survive over any backend and across restarts.
+ *
+ * @param base The read-only lower layer. Never mutated.
+ * @param writable The upper layer that captures all changes and markers.
+ * @param opts Marker naming overrides (see {@link CowOptions}).
+ * @returns A read/write `FilesApi` composing the two layers.
+ *
+ * @example
+ * ```ts
+ * const fs = cow(releaseFiles, new MemFilesApi());
+ * await fs.write("/a.txt", data); // captured in the writable layer
+ * await fs.remove("/base-only");  // whiteout marker; base untouched
+ * ```
+ */
+export function cow(base: FilesApi, writable: FilesApi, opts?: CowOptions): FilesApi {
+  return new CowFilesApi(base, writable, opts);
+}

package/src/filtered-files-api.ts

@@ -0,0 +1,257 @@
+import type {
+  FileInfo,
+  FileStats,
+  FilesApi,
+  ListOptions,
+  ReadOptions,
+} from "@statewalker/webrun-files";
+import { normalizePath } from "@statewalker/webrun-files";
+import { globToRegExp } from "./glob-to-regexp.js";
+
+/**
+ * Predicate evaluated against a **normalized** path (single leading slash,
+ * no trailing slash) by `FilteredFilesApi` to decide visibility.
+ *
+ * - `true` → the path is visible (the wrapped operation runs).
+ * - `false` → the path is hidden (the wrapper short-circuits as if the path
+ *   did not exist).
+ *
+ * The predicate may be synchronous or return a `Promise<boolean>`. When
+ * async, it is awaited on each call — so prefer pure / cheap checks.
+ */
+export type PathFilter = (path: string) => boolean | Promise<boolean>;
+
+/**
+ * Builds a {@link PathFilter} that hides any path whose normalized form
+ * equals one of the provided prefixes or lives under `${prefix}/`.
+ *
+ * Prefixes are normalized through `normalizePath` (so `"foo"`, `"/foo"`, and
+ * `"/foo/"` are equivalent). Empty / root entries are dropped — they would
+ * otherwise hide every path.
+ *
+ * Matching is **boundary-aware**: the prefix `"/priv"` does not match the
+ * path `"/private"` because there is no `/` boundary between them.
+ *
+ * @param pathPrefixes Path prefixes whose contents (and the prefix itself)
+ *   should be hidden. Pass none to hide nothing.
+ *
+ * @example
+ * ```ts
+ * const filter = newPathFilter("/.git", "/node_modules");
+ * filter("/src/index.ts"); // true
+ * filter("/.git");         // false
+ * filter("/.git/HEAD");    // false
+ * filter("/notgit");       // true (boundary-aware, no false match)
+ * ```
+ */
+export function newPathFilter(...pathPrefixes: string[]): PathFilter {
+  const normalized = pathPrefixes.map((p) => normalizePath(p)).filter((p) => p !== "/");
+  return (path: string) => {
+    const target = normalizePath(path);
+    for (const prefix of normalized) {
+      if (target === prefix) return false;
+      if (target.startsWith(`${prefix}/`)) return false;
+    }
+    return true;
+  };
+}
+
+/**
+ * Builds a {@link PathFilter} that hides any path whose normalized form
+ * matches at least one of the provided regular expressions.
+ *
+ * The path is normalized through `normalizePath` before matching, so a
+ * regexp anchored on `^/` always sees a leading slash and never a trailing
+ * one. The regexp's `lastIndex` is irrelevant — the filter calls `test`
+ * via a fresh evaluation each time, but stateful (`/g`, `/y`) regexps
+ * still mutate `lastIndex` across calls; pass non-stateful regexps unless
+ * you know what you are doing.
+ *
+ * @param pathRegexps Regular expressions whose match means "hide this
+ *   path". Pass none to hide nothing.
+ *
+ * @example
+ * ```ts
+ * // Hide every dotfile and every *.log file
+ * const filter = newRegexpPathFilter(/\/\.[^/]+$/, /\.log$/);
+ * filter("/src/index.ts"); // true
+ * filter("/.env");         // false (matches /\/\.[^/]+$/)
+ * filter("/build.log");    // false (matches /\.log$/)
+ * ```
+ */
+export function newRegexpPathFilter(...pathRegexps: RegExp[]): PathFilter {
+  return (path: string) => {
+    const target = normalizePath(path);
+    for (const regexp of pathRegexps) {
+      if (regexp.test(target)) return false;
+    }
+    return true;
+  };
+}
+
+/**
+ * Builds a {@link PathFilter} that hides any path whose normalized form
+ * matches at least one of the provided glob patterns.
+ *
+ * Each glob is compiled with `extended: true` and `globstar: true`, the
+ * standard "filesystem-style" mode:
+ *
+ * - `*` matches any number of characters within a single path segment
+ *   (does **not** cross `/`).
+ * - `**` between slashes matches zero or more whole path segments.
+ * - `?` matches exactly one character.
+ * - `[abc]` / `[a-z]` matches a single character in the set / range.
+ * - `{a,b,c}` matches one of the alternatives.
+ *
+ * Because matching is done on the **normalized** path (which always starts
+ * with `/`), patterns that should match anywhere in the tree need a
+ * leading `**​/`, e.g. `**​/*.log` to hide every `.log` file at any depth.
+ *
+ * Gotcha: `/foo/**` matches descendants of `/foo` but **not** `/foo`
+ * itself, because the glob requires a `/` after `foo` before `**` can
+ * match. To hide both the directory and its contents, list both prefixes:
+ * `newGlobPathFilter("/foo", "/foo/**")`. {@link newPathFilter} doesn't
+ * have this problem and may be a better fit for prefix-only hiding.
+ *
+ * @param pathGlobs Glob patterns whose match means "hide this path". Pass
+ *   none to hide nothing.
+ *
+ * @example
+ * ```ts
+ * const filter = newGlobPathFilter("**​/*.log", "/.git", "/.git/**");
+ * filter("/src/index.ts"); // true
+ * filter("/build.log");    // false (matches **​/*.log)
+ * filter("/.git");         // false (matches /.git)
+ * filter("/.git/HEAD");    // false (matches /.git/**)
+ * ```
+ */
+export function newGlobPathFilter(...pathGlobs: string[]): PathFilter {
+  const regexps = pathGlobs.map((glob) => globToRegExp(glob, { extended: true, globstar: true }));
+  return newRegexpPathFilter(...regexps);
+}
+
+/**
+ * `FilesApi` decorator that hides every path the supplied {@link PathFilter}
+ * rejects. Hidden paths are treated as if they do not exist:
+ *
+ * - `read` / `list` yield empty iterables.
+ * - `stats` returns `undefined`; `exists` returns `false`.
+ * - `remove` returns `false` (no error, nothing changed).
+ * - `move` / `copy` return `false` if either endpoint is hidden.
+ * - `write` / `mkdir` reject with an `Error` (since silently dropping a
+ *   write would lose data).
+ * - `list` recursively skips entries whose paths are hidden, so iterating a
+ *   visible parent never reveals a hidden child.
+ *
+ * Wrap any `FilesApi` to scope its visibility without changing the
+ * underlying storage; the wrapped instance still holds the data, it is just
+ * not reachable through this decorator.
+ *
+ * Pair with one of the built-in {@link PathFilter} factories
+ * ({@link newPathFilter}, {@link newRegexpPathFilter},
+ * {@link newGlobPathFilter}) or pass any predicate of shape
+ * `(path) => boolean | Promise<boolean>`.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   FilteredFilesApi,
+ *   newGlobPathFilter,
+ *   newPathFilter,
+ *   newRegexpPathFilter,
+ * } from "@statewalker/webrun-files-composite";
+ *
+ * // Hide by path prefix
+ * const noVcs = new FilteredFilesApi(sourceFiles, newPathFilter("/.git", "/.cache"));
+ * await noVcs.exists("/.git");        // false
+ * await noVcs.write("/.git/x", data); // throws "Path is hidden"
+ *
+ * // Hide by regexp
+ * const noLogs = new FilteredFilesApi(sourceFiles, newRegexpPathFilter(/\.log$/));
+ *
+ * // Hide by glob (extended + globstar mode)
+ * const noJunk = new FilteredFilesApi(
+ *   sourceFiles,
+ *   newGlobPathFilter("**​/*.log", "/.git", "/.git/**"),
+ * );
+ * ```
+ */
+export class FilteredFilesApi implements FilesApi {
+  private readonly source: FilesApi;
+  private readonly pathFilter: PathFilter;
+
+  /**
+   * @param source The underlying `FilesApi` whose paths will be selectively
+   *   hidden. Operations always delegate to this instance; the decorator
+   *   only adds the visibility check.
+   * @param pathFilter Predicate that decides per-call whether a normalized
+   *   path is visible. See {@link PathFilter}.
+   */
+  constructor(source: FilesApi, pathFilter: PathFilter) {
+    this.source = source;
+    this.pathFilter = pathFilter;
+  }
+
+  protected async isHidden(path: string): Promise<boolean> {
+    return (await this.pathFilter(normalizePath(path))) === false;
+  }
+
+  async *read(path: string, options?: ReadOptions): AsyncIterable<Uint8Array> {
+    if (await this.isHidden(path)) return;
+    yield* this.source.read(path, options);
+  }
+
+  async write(
+    path: string,
+    content: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,
+  ): Promise<void> {
+    if (await this.isHidden(path)) {
+      throw new Error(`Path is hidden: ${path}`);
+    }
+    await this.source.write(path, content);
+  }
+
+  async mkdir(path: string): Promise<void> {
+    if (await this.isHidden(path)) {
+      throw new Error(`Path is hidden: ${path}`);
+    }
+    await this.source.mkdir(path);
+  }
+
+  async *list(path: string, options?: ListOptions): AsyncIterable<FileInfo> {
+    if (await this.isHidden(path)) return;
+    for await (const entry of this.source.list(path, options)) {
+      if (await this.isHidden(entry.path)) continue;
+      yield entry;
+    }
+  }
+
+  async stats(path: string): Promise<FileStats | undefined> {
+    if (await this.isHidden(path)) return undefined;
+    return this.source.stats(path);
+  }
+
+  async exists(path: string): Promise<boolean> {
+    if (await this.isHidden(path)) return false;
+    return this.source.exists(path);
+  }
+
+  async remove(path: string): Promise<boolean> {
+    if (await this.isHidden(path)) return false;
+    return this.source.remove(path);
+  }
+
+  async move(source: string, target: string): Promise<boolean> {
+    if ((await this.isHidden(source)) || (await this.isHidden(target))) {
+      return false;
+    }
+    return this.source.move(source, target);
+  }
+
+  async copy(source: string, target: string): Promise<boolean> {
+    if ((await this.isHidden(source)) || (await this.isHidden(target))) {
+      return false;
+    }
+    return this.source.copy(source, target);
+  }
+}

package/src/glob-to-regexp.ts

@@ -0,0 +1,182 @@
+/**
+ * Glob → RegExp compiler.
+ *
+ * TypeScript port of `glob-to-regexp` by Nick Fitzgerald.
+ *
+ * Upstream:
+ *   - https://github.com/fitzgen/glob-to-regexp
+ *   - source: https://raw.githubusercontent.com/fitzgen/glob-to-regexp/master/index.js
+ *   - tests:  https://raw.githubusercontent.com/fitzgen/glob-to-regexp/master/test.js
+ *
+ * The original is published under the BSD 2-Clause license — see the
+ * upstream repository for the full text. This port preserves the original
+ * semantics; only the surface API has been re-typed for TypeScript.
+ */
+
+export interface GlobToRegExpOptions {
+  /**
+   * Enable bash-style extended globs. When `true`:
+   *
+   * - `?` matches exactly one character.
+   * - `[abc]` / `[a-z]` matches a single character in the set / range.
+   * - `{foo,bar}` matches one of the alternatives.
+   *
+   * When `false` (default), each of these characters is treated literally
+   * (they are escaped in the output regexp).
+   */
+  extended?: boolean;
+
+  /**
+   * Enable bash-style globstar semantics for `*` and `**`.
+   *
+   * - With `globstar: false` (default), every run of `*`s is translated to
+   *   `.*` — so `*` matches any number of characters, including `/`.
+   * - With `globstar: true`, a single `*` only matches within one path
+   *   segment (`[^/]*`), and a `**` segment (`**` between `/`s, or at the
+   *   start/end of the pattern) matches zero or more whole segments.
+   */
+  globstar?: boolean;
+
+  /**
+   * RegExp flags passed to the `RegExp` constructor. When `flags` includes
+   * `"g"`, the produced regexp is **not** anchored with `^…$`, so the glob
+   * matches anywhere in the string instead of the whole string.
+   */
+  flags?: string;
+}
+
+/**
+ * Compiles a glob pattern into a `RegExp`.
+ *
+ * @example
+ * ```ts
+ * globToRegExp("*.js");                       // /^.*\.js$/
+ * globToRegExp("*.js", { globstar: true });   // /^([^/]*)\.js$/
+ * globToRegExp("/foo/**", { globstar: true }) // /^\/foo\/((?:[^/]*(?:\/|$))*)$/
+ * globToRegExp("foo{bar,baz}", { extended: true }); // /^foo(bar|baz)$/
+ * ```
+ */
+export function globToRegExp(glob: string, opts: GlobToRegExpOptions = {}): RegExp {
+  if (typeof glob !== "string") {
+    throw new TypeError("Expected a string");
+  }
+
+  const str = String(glob);
+
+  // The regexp we are building, as a string.
+  let reStr = "";
+
+  // Whether we are matching so called "extended" globs (like bash) and
+  // should support single character matching, matching ranges of
+  // characters, group matching, etc.
+  const extended = !!opts.extended;
+
+  // Globstar semantics for `*` / `**`.
+  // - false: '/foo/*' becomes '^/foo/.*$' (matches '/foo/bar' AND '/foo/bar/baz')
+  // - true:  '/foo/*' becomes '^/foo/[^/]*$' (matches '/foo/bar' only)
+  //          '/foo/**' (with globstar=true) means "any depth under /foo".
+  const globstar = !!opts.globstar;
+
+  // True while inside an extended `{a,b}` group. Used to translate `,`.
+  let inGroup = false;
+
+  // RegExp flags passed straight through to the RegExp constructor.
+  const flags = typeof opts.flags === "string" ? opts.flags : "";
+
+  for (let i = 0; i < str.length; i++) {
+    const c = str[i];
+
+    switch (c) {
+      case "/":
+      case "$":
+      case "^":
+      case "+":
+      case ".":
+      case "(":
+      case ")":
+      case "=":
+      case "!":
+      case "|":
+        reStr += `\\${c}`;
+        break;
+
+      case "?":
+        reStr += extended ? "." : `\\${c}`;
+        break;
+
+      case "[":
+      case "]":
+        reStr += extended ? c : `\\${c}`;
+        break;
+
+      case "{":
+        if (extended) {
+          inGroup = true;
+          reStr += "(";
+        } else {
+          reStr += `\\${c}`;
+        }
+        break;
+
+      case "}":
+        if (extended) {
+          inGroup = false;
+          reStr += ")";
+        } else {
+          reStr += `\\${c}`;
+        }
+        break;
+
+      case ",":
+        if (inGroup) {
+          reStr += "|";
+        } else {
+          reStr += `\\${c}`;
+        }
+        break;
+
+      case "*": {
+        // Coalesce consecutive "*"s and remember the surrounding chars so
+        // we can decide whether this run is a "globstar" segment.
+        const prevChar = str[i - 1];
+        let starCount = 1;
+        while (str[i + 1] === "*") {
+          starCount++;
+          i++;
+        }
+        const nextChar = str[i + 1];
+
+        if (!globstar) {
+          // globstar disabled: any number of "*" maps to ".*".
+          reStr += ".*";
+        } else {
+          const isGlobstar =
+            starCount > 1 && // multiple "*"s
+            (prevChar === "/" || prevChar === undefined) && // segment start
+            (nextChar === "/" || nextChar === undefined); // segment end
+
+          if (isGlobstar) {
+            // Match zero or more whole path segments.
+            reStr += "((?:[^/]*(?:\\/|$))*)";
+            i++; // consume the trailing "/"
+          } else {
+            // Match within one path segment only.
+            reStr += "([^/]*)";
+          }
+        }
+        break;
+      }
+
+      default:
+        reStr += c;
+    }
+  }
+
+  // When the "g" flag is set, leave the regexp un-anchored so the caller
+  // can match the glob anywhere within a longer string.
+  if (!flags?.includes("g")) {
+    reStr = `^${reStr}$`;
+  }
+
+  return new RegExp(reStr, flags);
+}