@molecule/api-ai-tools 1.9.18 → 1.10.0

package/dist/suite-overlap.d.ts

@@ -83,6 +83,10 @@ export declare function withSuiteConfig(command: string, config: string | null |
  * suite, `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries).
  *
+ * The re-run keeps the run's `> <file>` redirect only in the sense of keeping its OUTPUT there:
+ * the target is rewritten to a fresh sibling ({@link redirectToFreshFile}), so a re-run never
+ * overwrites the log the run itself is the evidence for (xr-molecule-flash-m173).
+ *
  * `config` is the config the run was measured under ({@link withSuiteConfig}): the narrowed re-run
  * carries it whenever the command itself does not, so a run that dropped `--config` cannot be
  * handed back a command with the same defect (xr-molecule-flash-m113: every failing test was
@@ -101,9 +105,34 @@ export declare function withSuiteConfig(command: string, config: string | null |
  *   does not name one.
  * @param cwd - The directory `exec_command` was given, when it was; the base a location is
  *   resolved against when the command does not `cd` anywhere.
+ * @param env - The settings the REQUEST requires of the suite and this run left out
+ *   ({@link withRunEnv}): the re-run carries them, so a re-run of a run measured in the wrong
+ *   mode is not measured in that mode again (xr-molecule-flash-m182 +12:06).
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
-export declare function scopedRerunCommand(command: string, locations: readonly string[], excluded?: readonly string[], config?: string | null, cwd?: string | null): string;
+export declare function scopedRerunCommand(command: string, locations: readonly string[], excluded?: readonly string[], config?: string | null, cwd?: string | null, env?: readonly RunEnvSetting[]): string;
+/** One `NAME=value` the request requires of a suite run. */
+export interface RunEnvSetting {
+    name: string;
+    value: string;
+}
+/**
+ * The command with the request's required settings put in front of its RUN statement — the ONE
+ * place every composed re-run gets them (xr-molecule-flash-m182).
+ *
+ * The settings are written at the statement's own assignment offset, never in front of the whole
+ * command: a shell binds an assignment there to the statement's program, while one in front of the
+ * whole command is the environment of its FIRST statement alone (`APP_BASE=… cd app && npx
+ * playwright test` sets the variable for `cd`; xr-molecule-flash-m103 +28:08). A name the command
+ * gives a different value is replaced, and one it already gives the required value is left as
+ * written. When the parse cannot place the statement (a run inside a nested `sh -c '…'`), the
+ * settings become `export`s, which no statement boundary can swallow.
+ *
+ * @param command - The command to carry them.
+ * @param settings - The `NAME`/`value` pairs the request requires.
+ * @returns The command, or the command unchanged when it already carries every setting.
+ */
+export declare function withRunEnv(command: string, settings?: readonly RunEnvSetting[]): string;
 /**
  * One suite run, as the rule that decides whether a second may start beside it reads it.
  *

package/dist/suite-overlap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAQH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAc1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAClB,MAAM,CA0CR;AAgHD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqDD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACvC;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAYtF"}
+{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAQH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAS1F;AAqCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,EACnB,GAAG,GAAE,SAAS,aAAa,EAAO,GACjC,MAAM,CA8CR;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,aAAa,EAAO,GAAG,MAAM,CAe3F;AAkHD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AA2FD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACvC;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAYtF"}

package/dist/suite-overlap.js

@@ -108,17 +108,48 @@ export function namesSuiteConfig(command) {
 export function withSuiteConfig(command, config) {
     if (!config)
         return command;
-    const at = command.search(/\bplaywright\s+test\b/);
-    if (at === -1)
+    const run = playwrightStatement(command);
+    if (run === null)
         return command;
-    const head = command.slice(0, at);
-    const rest = command.slice(at);
-    const end = rest.search(/&&|\|\||;|\|/);
-    const statement = end === -1 ? rest : rest.slice(0, end);
-    const tail = end === -1 ? '' : rest.slice(end);
-    if (namesSuiteConfig(statement))
+    if (namesSuiteConfig(command.slice(run.start, run.end)))
         return command;
-    return `${head}${statement.replace(/^(playwright\s+test)\b/, `$1 --config ${shellQuote(config)}`)}${tail}`;
+    // Right after the runner's own words (`playwright test <here>`), so a launcher in front of
+    // them — `npx --no-install`, `node <path>/playwright` — is untouched and the flag is the
+    // runner's own argument wherever it sits.
+    return `${command.slice(0, run.afterRunner)} --config ${shellQuote(config)}${command.slice(run.afterRunner)}`;
+}
+/**
+ * A redirect that names a FILE for a stream whose target a re-run would destroy: `> f`, `>> f`,
+ * `1> f`, `&> f`. `2>` is stderr and deliberately not matched; a descriptor duplication
+ * (`2>&1`, `>&2`) has no file target and does not match either, because `&` cannot start one.
+ */
+const FILE_REDIRECT = /(^|\s)(&>>?|1?>>?)(\s*)(?:'([^']+)'|"([^"]+)"|([^\s;&|]+))/g;
+/** A target that is not a log anyone could lose: rewriting it would CREATE a file. */
+const DEVICE_TARGET = /^\/dev\//;
+/**
+ * The command with every file redirect pointed at a fresh file beside its original target
+ * (`/tmp/pw-full.log` → `/tmp/pw-full.rerun.log`), and nothing else changed.
+ *
+ * A re-run composed from a run's own command keeps the run's redirect by construction, and the
+ * run wrote the walk's only report to that file: xr-molecule-flash-m173 handed over *"Send this
+ * once the run ends: … npx playwright test …/articles.spec.ts:32 --retries=0 … > /tmp/pw-full.log
+ * 2>&1"* — the ONE narrowed re-run that was about to check the fixes would have overwritten the
+ * full walk's log, destroying the other 11 failures' error reports. Following the platform's own
+ * advice must never destroy the evidence it was based on.
+ *
+ * @param command - A shell command.
+ * @returns The command whose file redirects write to a fresh target.
+ */
+function redirectToFreshFile(command) {
+    return command.replace(FILE_REDIRECT, (whole, before, op, space, single, double, bare) => {
+        const target = single ?? double ?? bare ?? '';
+        // `/dev/null` and friends are not a report to preserve; leaving them keeps the re-run silent
+        // the way the run was, where rewriting them would create a file nobody asked for.
+        if (!target || DEVICE_TARGET.test(target))
+            return whole;
+        const quote = single !== undefined ? "'" : double !== undefined ? '"' : '';
+        return `${before}${op}${space}${quote}${target}.rerun.log${quote}`;
+    });
 }
 /**
  * The whole-suite command made scoped to the tests it should re-run instead: the same
@@ -126,6 +157,10 @@ export function withSuiteConfig(command, config) {
  * suite, `--last-failed` dropped (it re-runs the tests that never ran too, X1 flash-m60) and
  * `--retries=0` set (a re-run of a known failure does not need to pay for retries).
  *
+ * The re-run keeps the run's `> <file>` redirect only in the sense of keeping its OUTPUT there:
+ * the target is rewritten to a fresh sibling ({@link redirectToFreshFile}), so a re-run never
+ * overwrites the log the run itself is the evidence for (xr-molecule-flash-m173).
+ *
  * `config` is the config the run was measured under ({@link withSuiteConfig}): the narrowed re-run
  * carries it whenever the command itself does not, so a run that dropped `--config` cannot be
  * handed back a command with the same defect (xr-molecule-flash-m113: every failing test was
@@ -144,19 +179,23 @@ export function withSuiteConfig(command, config) {
  *   does not name one.
  * @param cwd - The directory `exec_command` was given, when it was; the base a location is
  *   resolved against when the command does not `cd` anywhere.
+ * @param env - The settings the REQUEST requires of the suite and this run left out
+ *   ({@link withRunEnv}): the re-run carries them, so a re-run of a run measured in the wrong
+ *   mode is not measured in that mode again (xr-molecule-flash-m182 +12:06).
  * @returns The scoped command, or the command unchanged when it runs no Playwright suite.
  */
-export function scopedRerunCommand(command, locations, excluded = [], config, cwd) {
-    const at = command.search(/\bplaywright\s+test\b/);
-    if (at === -1)
+export function scopedRerunCommand(command, locations, excluded = [], config, cwd, env = []) {
+    const run = playwrightStatement(command);
+    if (run === null)
         return command;
-    const head = command.slice(0, at);
-    const rest = command.slice(at);
     // Only the first statement runs the suite; the rest (`| tail -50`, `&& echo done`)
     // is left exactly as it was.
-    const end = rest.search(/&&|\|\||;|\|/);
-    const statement = end === -1 ? rest : rest.slice(0, end);
-    const tail = end === -1 ? '' : rest.slice(end);
+    const statement = command.slice(run.start, run.end);
+    const tail = command.slice(run.end);
+    // The arguments after the runner's own words (`playwright test`), where the narrowed re-run
+    // writes its locations — the launcher in front of them (`npx --no-install`, `node
+    // <path>/playwright`) is not part of the arguments.
+    const args = command.slice(run.afterRunner, run.end);
     // One literal alternation, regex-escaped and shell-quoted: a title carries parentheses and
     // quotes (`should only allow comment author to delete`) that are regex and shell syntax alike.
     const invert = excluded.length > 0 && !/--grep-invert\b/.test(command)
@@ -176,16 +215,79 @@ export function scopedRerunCommand(command, locations, excluded = [], config, cw
     // nothing — "No tests found" — so every location is rendered in a form Playwright can match
     // ({@link playwrightLocations}).
     const narrowed = playwrightLocations(locations, command, cwd);
-    const scoped = dropSupersededSpecFiles(statement, narrowed)
+    const dropped = dropSupersededSpecFiles(args, narrowed)
         .replace(/\s*--last-failed\b/g, '')
-        .replace(/\s*--retries(?:[= ]\d+)?/g, '')
-        .replace(/^(playwright\s+test)\b/, `$1 ${narrowed.join(' ')} --retries=0${carry}${invert}`);
+        .replace(/\s*--retries(?:[= ]\d+)?/g, '');
+    const scoped = command.slice(0, run.afterRunner) +
+        ` ${narrowed.join(' ')} --retries=0${carry}${invert}` +
+        dropped;
     // A command that starts the suite AGAIN after this statement is a chain of walks, not a re-run:
     // everything from the next suite runner on is dropped, so the composed command carries ONE walk.
     // X1 xr-molecule-flash-m157 (+14:02) was handed a re-run that still carried the chain's second
     // whole walk — 4.5 minutes measuring code it had not changed.
     const rerunTail = suiteRunStatements(tail).length > 0 ? '' : tail;
-    return `${head}${scoped}${rerunTail}`;
+    return withRunEnv(`${redirectToFreshFile(scoped)}${redirectToFreshFile(rerunTail)}`, env);
+}
+/** A `NAME=value` word in command position, optionally behind `export`/`env`. */
+const ENV_WORD = /(^|[\s;&|(])(?:export[ \t]+|env[ \t]+)?([A-Za-z_][A-Za-z0-9_]*)=('[^']*'|"[^"]*"|[^\s;&|]+)/g;
+/** The value a command gives a name, unquoted, or null when it sets none. */
+function envValueOf(command, name) {
+    for (const m of command.matchAll(ENV_WORD)) {
+        if (m[2] !== name)
+            continue;
+        return (m[3] ?? '').replace(/^(['"])(.*)\1$/, '$2');
+    }
+    return null;
+}
+/** The command with one `NAME=value` word taken out, whitespace and all. */
+function withoutEnvWord(command, name) {
+    const pattern = new RegExp(`(^|[\\s;&|(])(?:export[ \\t]+|env[ \\t]+)?${name}=('[^']*'|"[^"]*"|[^\\s;&|]+)`);
+    const m = pattern.exec(command);
+    if (!m)
+        return command;
+    const start = m.index + m[1].length;
+    const end = m.index + m[0].length;
+    const left = /[ \t]*$/.exec(command.slice(0, start))?.[0] ?? '';
+    const chain = /^[ \t]*(?:&&|\|\||;)[ \t]*/.exec(command.slice(end));
+    // A word between two chained statements takes the following operator with it, so the result is
+    // `a && b` and not `a && && b`.
+    if (chain && left.length > 0)
+        return command.slice(0, start) + command.slice(end + chain[0].length);
+    if (left.length > 0)
+        return command.slice(0, start - left.length) + command.slice(end);
+    const right = /^[ \t]*/.exec(command.slice(end))?.[0] ?? '';
+    return command.slice(0, start) + command.slice(end + right.length);
+}
+/**
+ * The command with the request's required settings put in front of its RUN statement — the ONE
+ * place every composed re-run gets them (xr-molecule-flash-m182).
+ *
+ * The settings are written at the statement's own assignment offset, never in front of the whole
+ * command: a shell binds an assignment there to the statement's program, while one in front of the
+ * whole command is the environment of its FIRST statement alone (`APP_BASE=… cd app && npx
+ * playwright test` sets the variable for `cd`; xr-molecule-flash-m103 +28:08). A name the command
+ * gives a different value is replaced, and one it already gives the required value is left as
+ * written. When the parse cannot place the statement (a run inside a nested `sh -c '…'`), the
+ * settings become `export`s, which no statement boundary can swallow.
+ *
+ * @param command - The command to carry them.
+ * @param settings - The `NAME`/`value` pairs the request requires.
+ * @returns The command, or the command unchanged when it already carries every setting.
+ */
+export function withRunEnv(command, settings = []) {
+    const added = [];
+    let out = command;
+    for (const setting of settings) {
+        if (envValueOf(out, setting.name) === setting.value)
+            continue;
+        out = withoutEnvWord(out, setting.name);
+        added.push(`${setting.name}=${setting.value}`);
+    }
+    if (added.length === 0)
+        return command;
+    const at = locatedCommandSegments(out).find((entry) => entry.segment !== null && PLAYWRIGHT_RUN.test(entry.segment.text))?.assignmentOffset ?? null;
+    const words = added.join(' ');
+    return at === null ? `export ${words} && ${out}` : `${out.slice(0, at)}${words} ${out.slice(at)}`;
 }
 /** A directory a `cd` can name literally: no `~`, no variable, no glob. */
 const LITERAL_DIR = /^[A-Za-z0-9_./+-]+$/;
@@ -267,7 +369,8 @@ function playwrightLocations(locations, command, cwd) {
 /** A spec-file argument Playwright accepts as its positional filter — never a flag. */
 const SPEC_FILE_ARGUMENT = /^(?!-)[^\s]*\.(?:spec|test)\.[cm]?[jt]sx?(?::\d+(?::\d+)?)?$/;
 /**
- * The statement with every bare spec-file argument taken out once the re-run names failure locations.
+ * The runner's own arguments with every bare spec-file argument taken out once the re-run names
+ * failure locations.
  *
  * The re-run is "just these": Playwright matches each positional argument against every collected
  * file's path, so a bare file left beside the `file:line`s re-admits ALL of that file's tests.
@@ -276,23 +379,20 @@ const SPEC_FILE_ARGUMENT = /^(?!-)[^\s]*\.(?:spec|test)\.[cm]?[jt]sx?(?::\d+(?::
  * failures sat in two of them — 32 tests, ~3 min, instead of the 8 failures' ~30 s. A file with no
  * failure in it has nothing to re-run, so it goes too.
  *
- * @param statement - The Playwright statement, starting at its own `playwright test`.
+ * The launcher's words are not arguments and are not here: the caller passes what follows
+ * `playwright test` ({@link playwrightStatement}'s `afterRunner`), so `node <path>/playwright
+ * test` and `npx playwright test` lose the same spec files.
+ *
+ * @param args - The run's own arguments, after `playwright test`.
  * @param locations - The failing `file:line`s the re-run names.
- * @returns The statement without its bare spec-file arguments.
+ * @returns The arguments without their bare spec-file arguments.
  */
-function dropSupersededSpecFiles(statement, locations) {
+function dropSupersededSpecFiles(args, locations) {
     if (locations.length === 0)
-        return statement;
-    const runner = /^(playwright\s+test)\b/.exec(statement);
-    if (runner === null)
-        return statement;
-    const head = runner[1];
-    const kept = statement
-        .slice(head.length)
-        .replace(/(^|\s+)([^\s]+)(?=\s|$)/g, (whole, _space, token) => {
+        return args;
+    return args.replace(/(^|\s+)([^\s]+)(?=\s|$)/g, (whole, _space, token) => {
         return SPEC_FILE_ARGUMENT.test(token) ? '' : whole;
     });
-    return `${head}${kept}`;
 }
 /**
  * The run in flight that makes a second run a hazard, or null when nothing is in the way.
@@ -320,6 +420,43 @@ export function suiteRunInTheWay(candidate, inFlight) {
  * closing quote is that echo. A version-pinned `playwright@1.44.0 test` is the same run.
  */
 const PLAYWRIGHT_RUN = /^(?:@playwright\/test|playwright)(?:@\S+)?\s+test(?=\s|$)/;
+/**
+ * The statement of a command that runs `playwright test`, and where its own arguments begin.
+ *
+ * Both rewrites that compose a command ({@link withSuiteConfig}, {@link scopedRerunCommand}) read
+ * the run through the shared shell parse — the same answer every classifier gets — instead of
+ * searching the text for `playwright test`. The search missed the runner reached by file (`node
+ * <path>/@playwright/test/cli.js test`, xr-molecule-flash-m179), so a narrowed re-run of that run
+ * silently stayed the whole suite.
+ *
+ * `afterRunner` is the offset just past the runner's own words (`playwright test`): the
+ * sub-command is the word after the program word, wherever the program word is (the script path
+ * behind `node`, the name itself otherwise), so an option written there is the run's own.
+ *
+ * @param command - The shell command.
+ * @returns The statement's span and its argument offset, or null when no statement runs the suite.
+ */
+function playwrightStatement(command) {
+    for (const located of locatedCommandSegments(command)) {
+        const segment = located.segment;
+        if (!segment || !PLAYWRIGHT_RUN.test(segment.text))
+            continue;
+        // A statement inside a nested `sh -c '<command>'` has no offsets here: its positions are
+        // positions in that string, so nothing may be spliced at them.
+        if (located.start === null || located.end === null || located.programOffset === null)
+            return null;
+        const words = [...command.slice(located.programOffset).matchAll(/\S+/g)];
+        const subcommand = words[1];
+        if (subcommand === undefined)
+            return null;
+        return {
+            start: located.start,
+            end: located.end,
+            afterRunner: located.programOffset + (subcommand.index ?? 0) + subcommand[0].length,
+        };
+    }
+    return null;
+}
 /**
  * What narrows a Playwright run to a part of the suite: a named file or line, a title filter, or
  * the tests the run before it printed (`--last-failed`, `--only-changed`).

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAwJ9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAiSD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAoFnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AAmBlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CA8pFxF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA4K9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AA6ZD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAqFnE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AAmBlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAguFxF"}