ashlr-plugin 1.36.4

package/bench/refs/node-sdk/src/util/create-stitchable-stream.ts

@@ -0,0 +1,112 @@
+import { createResolvablePromise } from './create-resolvable-promise';
+
+/**
+ * Creates a stitchable stream that can pipe one stream at a time.
+ *
+ * @template T - The type of values emitted by the streams.
+ * @returns {Object} An object containing the stitchable stream and control methods.
+ */
+export function createStitchableStream<T>(): {
+  stream: ReadableStream<T>;
+  addStream: (innerStream: ReadableStream<T>) => void;
+  close: () => void;
+  terminate: () => void;
+} {
+  let innerStreamReaders: ReadableStreamDefaultReader<T>[] = [];
+  let controller: ReadableStreamDefaultController<T> | null = null;
+  let isClosed = false;
+  let waitForNewStream = createResolvablePromise<void>();
+
+  const terminate = () => {
+    isClosed = true;
+    waitForNewStream.resolve();
+
+    innerStreamReaders.forEach(reader => reader.cancel());
+    innerStreamReaders = [];
+    controller?.close();
+  };
+
+  const processPull = async () => {
+    // Case 1: Outer stream is closed and no more inner streams
+    if (isClosed && innerStreamReaders.length === 0) {
+      controller?.close();
+      return;
+    }
+
+    // Case 2: No inner streams available, but outer stream is open
+    // wait for a new inner stream to be added or the outer stream to close
+    if (innerStreamReaders.length === 0) {
+      waitForNewStream = createResolvablePromise<void>();
+      await waitForNewStream.promise;
+      return await processPull();
+    }
+
+    try {
+      const { value, done } = await innerStreamReaders[0].read();
+
+      if (done) {
+        // Case 3: Current inner stream is done
+        innerStreamReaders.shift(); // Remove the finished stream
+
+        if (innerStreamReaders.length === 0 && isClosed) {
+          // when closed and no more inner streams, stop pulling
+          controller?.close();
+        } else {
+          // continue pulling from the next stream
+          await processPull();
+        }
+      } else {
+        // Case 4: Current inner stream returns an item
+        controller?.enqueue(value);
+      }
+    } catch (error) {
+      // Case 5: Current inner stream throws an error
+      controller?.error(error);
+      innerStreamReaders.shift(); // Remove the errored stream
+      terminate(); // we have errored, terminate all streams
+    }
+  };
+
+  return {
+    stream: new ReadableStream<T>({
+      start(controllerParam) {
+        controller = controllerParam;
+      },
+      pull: processPull,
+      async cancel() {
+        for (const reader of innerStreamReaders) {
+          await reader.cancel();
+        }
+        innerStreamReaders = [];
+        isClosed = true;
+      },
+    }),
+    addStream: (innerStream: ReadableStream<T>) => {
+      if (isClosed) {
+        throw new Error('Cannot add inner stream: outer stream is closed');
+      }
+
+      innerStreamReaders.push(innerStream.getReader());
+      waitForNewStream.resolve();
+    },
+
+    /**
+     * Gracefully close the outer stream. This will let the inner streams
+     * finish processing and then close the outer stream.
+     */
+    close: () => {
+      isClosed = true;
+      waitForNewStream.resolve();
+
+      if (innerStreamReaders.length === 0) {
+        controller?.close();
+      }
+    },
+
+    /**
+     * Immediately close the outer stream. This will cancel all inner streams
+     * and close the outer stream.
+     */
+    terminate,
+  };
+}

package/bench/refs/node-sdk/src/util/download/download.ts

@@ -0,0 +1,74 @@
+import {
+  DownloadError,
+  readResponseWithSizeLimit,
+  DEFAULT_MAX_DOWNLOAD_SIZE,
+  validateDownloadUrl,
+} from '@ai-sdk/provider-utils';
+import {
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent,
+} from '@ai-sdk/provider-utils';
+import { VERSION } from '../../version';
+
+/**
+ * Download a file from a URL.
+ *
+ * @param url - The URL to download from.
+ * @param maxBytes - Maximum allowed download size in bytes. Defaults to 100 MiB.
+ * @param abortSignal - An optional abort signal to cancel the download.
+ * @returns The downloaded data and media type.
+ *
+ * @throws DownloadError if the download fails or exceeds maxBytes.
+ */
+export const download = async ({
+  url,
+  maxBytes,
+  abortSignal,
+}: {
+  url: URL;
+  maxBytes?: number;
+  abortSignal?: AbortSignal;
+}) => {
+  const urlText = url.toString();
+  validateDownloadUrl(urlText);
+  try {
+    const response = await fetch(urlText, {
+      headers: withUserAgentSuffix(
+        {},
+        `ai-sdk/${VERSION}`,
+        getRuntimeEnvironmentUserAgent(),
+      ),
+      signal: abortSignal,
+    });
+
+    // Validate final URL after redirects to prevent SSRF via open redirect
+    if (response.redirected) {
+      validateDownloadUrl(response.url);
+    }
+
+    if (!response.ok) {
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText,
+      });
+    }
+
+    const data = await readResponseWithSizeLimit({
+      response,
+      url: urlText,
+      maxBytes: maxBytes ?? DEFAULT_MAX_DOWNLOAD_SIZE,
+    });
+
+    return {
+      data,
+      mediaType: response.headers.get('content-type') ?? undefined,
+    };
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+
+    throw new DownloadError({ url: urlText, cause: error });
+  }
+};

package/bench/refs/node-sdk/src/util/error-handler.ts

@@ -0,0 +1 @@
+export type ErrorHandler = (error: unknown) => void;

package/bench/refs/node-sdk/src/util/fix-json.ts

@@ -0,0 +1,401 @@
+type State =
+  | 'ROOT'
+  | 'FINISH'
+  | 'INSIDE_STRING'
+  | 'INSIDE_STRING_ESCAPE'
+  | 'INSIDE_LITERAL'
+  | 'INSIDE_NUMBER'
+  | 'INSIDE_OBJECT_START'
+  | 'INSIDE_OBJECT_KEY'
+  | 'INSIDE_OBJECT_AFTER_KEY'
+  | 'INSIDE_OBJECT_BEFORE_VALUE'
+  | 'INSIDE_OBJECT_AFTER_VALUE'
+  | 'INSIDE_OBJECT_AFTER_COMMA'
+  | 'INSIDE_ARRAY_START'
+  | 'INSIDE_ARRAY_AFTER_VALUE'
+  | 'INSIDE_ARRAY_AFTER_COMMA';
+
+// Implemented as a scanner with additional fixing
+// that performs a single linear time scan pass over the partial JSON.
+//
+// The states should ideally match relevant states from the JSON spec:
+// https://www.json.org/json-en.html
+//
+// Please note that invalid JSON is not considered/covered, because it
+// is assumed that the resulting JSON will be processed by a standard
+// JSON parser that will detect any invalid JSON.
+export function fixJson(input: string): string {
+  const stack: State[] = ['ROOT'];
+  let lastValidIndex = -1;
+  let literalStart: number | null = null;
+
+  function processValueStart(char: string, i: number, swapState: State) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push('INSIDE_STRING');
+          break;
+        }
+
+        case 'f':
+        case 't':
+        case 'n': {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push('INSIDE_LITERAL');
+          break;
+        }
+
+        case '-': {
+          stack.pop();
+          stack.push(swapState);
+          stack.push('INSIDE_NUMBER');
+          break;
+        }
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push('INSIDE_NUMBER');
+          break;
+        }
+
+        case '{': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push('INSIDE_OBJECT_START');
+          break;
+        }
+
+        case '[': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push('INSIDE_ARRAY_START');
+          break;
+        }
+      }
+    }
+  }
+
+  function processAfterObjectValue(char: string, i: number) {
+    switch (char) {
+      case ',': {
+        stack.pop();
+        stack.push('INSIDE_OBJECT_AFTER_COMMA');
+        break;
+      }
+      case '}': {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+
+  function processAfterArrayValue(char: string, i: number) {
+    switch (char) {
+      case ',': {
+        stack.pop();
+        stack.push('INSIDE_ARRAY_AFTER_COMMA');
+        break;
+      }
+      case ']': {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+
+    switch (currentState) {
+      case 'ROOT':
+        processValueStart(char, i, 'FINISH');
+        break;
+
+      case 'INSIDE_OBJECT_START': {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push('INSIDE_OBJECT_KEY');
+            break;
+          }
+          case '}': {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+
+      case 'INSIDE_OBJECT_AFTER_COMMA': {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push('INSIDE_OBJECT_KEY');
+            break;
+          }
+        }
+        break;
+      }
+
+      case 'INSIDE_OBJECT_KEY': {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push('INSIDE_OBJECT_AFTER_KEY');
+            break;
+          }
+        }
+        break;
+      }
+
+      case 'INSIDE_OBJECT_AFTER_KEY': {
+        switch (char) {
+          case ':': {
+            stack.pop();
+            stack.push('INSIDE_OBJECT_BEFORE_VALUE');
+
+            break;
+          }
+        }
+        break;
+      }
+
+      case 'INSIDE_OBJECT_BEFORE_VALUE': {
+        processValueStart(char, i, 'INSIDE_OBJECT_AFTER_VALUE');
+        break;
+      }
+
+      case 'INSIDE_OBJECT_AFTER_VALUE': {
+        processAfterObjectValue(char, i);
+        break;
+      }
+
+      case 'INSIDE_STRING': {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+
+          case '\\': {
+            stack.push('INSIDE_STRING_ESCAPE');
+            break;
+          }
+
+          default: {
+            lastValidIndex = i;
+          }
+        }
+
+        break;
+      }
+
+      case 'INSIDE_ARRAY_START': {
+        switch (char) {
+          case ']': {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, 'INSIDE_ARRAY_AFTER_VALUE');
+            break;
+          }
+        }
+        break;
+      }
+
+      case 'INSIDE_ARRAY_AFTER_VALUE': {
+        switch (char) {
+          case ',': {
+            stack.pop();
+            stack.push('INSIDE_ARRAY_AFTER_COMMA');
+            break;
+          }
+
+          case ']': {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+
+        break;
+      }
+
+      case 'INSIDE_ARRAY_AFTER_COMMA': {
+        processValueStart(char, i, 'INSIDE_ARRAY_AFTER_VALUE');
+        break;
+      }
+
+      case 'INSIDE_STRING_ESCAPE': {
+        stack.pop();
+        lastValidIndex = i;
+
+        break;
+      }
+
+      case 'INSIDE_NUMBER': {
+        switch (char) {
+          case '0':
+          case '1':
+          case '2':
+          case '3':
+          case '4':
+          case '5':
+          case '6':
+          case '7':
+          case '8':
+          case '9': {
+            lastValidIndex = i;
+            break;
+          }
+
+          case 'e':
+          case 'E':
+          case '-':
+          case '.': {
+            break;
+          }
+
+          case ',': {
+            stack.pop();
+
+            if (stack[stack.length - 1] === 'INSIDE_ARRAY_AFTER_VALUE') {
+              processAfterArrayValue(char, i);
+            }
+
+            if (stack[stack.length - 1] === 'INSIDE_OBJECT_AFTER_VALUE') {
+              processAfterObjectValue(char, i);
+            }
+
+            break;
+          }
+
+          case '}': {
+            stack.pop();
+
+            if (stack[stack.length - 1] === 'INSIDE_OBJECT_AFTER_VALUE') {
+              processAfterObjectValue(char, i);
+            }
+
+            break;
+          }
+
+          case ']': {
+            stack.pop();
+
+            if (stack[stack.length - 1] === 'INSIDE_ARRAY_AFTER_VALUE') {
+              processAfterArrayValue(char, i);
+            }
+
+            break;
+          }
+
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+
+        break;
+      }
+
+      case 'INSIDE_LITERAL': {
+        const partialLiteral = input.substring(literalStart!, i + 1);
+
+        if (
+          !'false'.startsWith(partialLiteral) &&
+          !'true'.startsWith(partialLiteral) &&
+          !'null'.startsWith(partialLiteral)
+        ) {
+          stack.pop();
+
+          if (stack[stack.length - 1] === 'INSIDE_OBJECT_AFTER_VALUE') {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === 'INSIDE_ARRAY_AFTER_VALUE') {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+
+        break;
+      }
+    }
+  }
+
+  let result = input.slice(0, lastValidIndex + 1);
+
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+
+    switch (state) {
+      case 'INSIDE_STRING': {
+        result += '"';
+        break;
+      }
+
+      case 'INSIDE_OBJECT_KEY':
+      case 'INSIDE_OBJECT_AFTER_KEY':
+      case 'INSIDE_OBJECT_AFTER_COMMA':
+      case 'INSIDE_OBJECT_START':
+      case 'INSIDE_OBJECT_BEFORE_VALUE':
+      case 'INSIDE_OBJECT_AFTER_VALUE': {
+        result += '}';
+        break;
+      }
+
+      case 'INSIDE_ARRAY_START':
+      case 'INSIDE_ARRAY_AFTER_COMMA':
+      case 'INSIDE_ARRAY_AFTER_VALUE': {
+        result += ']';
+        break;
+      }
+
+      case 'INSIDE_LITERAL': {
+        const partialLiteral = input.substring(literalStart!, input.length);
+
+        if ('true'.startsWith(partialLiteral)) {
+          result += 'true'.slice(partialLiteral.length);
+        } else if ('false'.startsWith(partialLiteral)) {
+          result += 'false'.slice(partialLiteral.length);
+        } else if ('null'.startsWith(partialLiteral)) {
+          result += 'null'.slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+
+  return result;
+}

package/bench/refs/node-sdk/src/util/merge-objects.ts

@@ -0,0 +1,79 @@
+/**
+ * Deeply merges two objects together.
+ * - Properties from the `overrides` object override those in the `base` object with the same key.
+ * - For nested objects, the merge is performed recursively (deep merge).
+ * - Arrays are replaced, not merged.
+ * - Primitive values are replaced.
+ * - If both `base` and `overrides` are undefined, returns undefined.
+ * - If one of `base` or `overrides` is undefined, returns the other.
+ *
+ * @param base The target object to merge into
+ * @param overrides The source object to merge from
+ * @returns A new object with the merged properties, or undefined if both inputs are undefined
+ */
+export function mergeObjects<T extends object, U extends object>(
+  base: T | undefined,
+  overrides: U | undefined,
+): (T & U) | T | U | undefined {
+  // If both inputs are undefined, return undefined
+  if (base === undefined && overrides === undefined) {
+    return undefined;
+  }
+
+  // If target is undefined, return source
+  if (base === undefined) {
+    return overrides;
+  }
+
+  // If source is undefined, return target
+  if (overrides === undefined) {
+    return base;
+  }
+
+  // Create a new object to avoid mutating the inputs
+  const result = { ...base } as T & U;
+
+  // Iterate through all keys in the source object
+  for (const key in overrides) {
+    if (Object.prototype.hasOwnProperty.call(overrides, key)) {
+      const overridesValue = overrides[key];
+
+      // Skip if the overrides value is undefined
+      if (overridesValue === undefined) continue;
+
+      // Get the base value if it exists
+      const baseValue =
+        key in base ? base[key as unknown as keyof T] : undefined;
+
+      // Check if both values are objects that can be deeply merged
+      const isSourceObject =
+        overridesValue !== null &&
+        typeof overridesValue === 'object' &&
+        !Array.isArray(overridesValue) &&
+        !(overridesValue instanceof Date) &&
+        !(overridesValue instanceof RegExp);
+
+      const isTargetObject =
+        baseValue !== null &&
+        baseValue !== undefined &&
+        typeof baseValue === 'object' &&
+        !Array.isArray(baseValue) &&
+        !(baseValue instanceof Date) &&
+        !(baseValue instanceof RegExp);
+
+      // If both values are mergeable objects, merge them recursively
+      if (isSourceObject && isTargetObject) {
+        result[key as keyof (T & U)] = mergeObjects(
+          baseValue as object,
+          overridesValue as object,
+        ) as any;
+      } else {
+        // For primitives, arrays, or when one value is not a mergeable object,
+        // simply override with the source value
+        result[key as keyof (T & U)] = overridesValue as any;
+      }
+    }
+  }
+
+  return result;
+}

package/bench/refs/python-lib/.refrev

@@ -0,0 +1 @@
+be0642f7cb8900282a43b53cd50cf00a05161ed6

package/bench/refs/python-lib/README.md

@@ -0,0 +1,18 @@
+# python-lib reference subset
+
+Subset of [github.com/pandas-dev/pandas](https://github.com/pandas-dev/pandas) at commit
+`be0642f7cb8900282a43b53cd50cf00a05161ed6`, included for benchmark reproducibility.
+
+30 Python source files sampled from `pandas/core/` covering:
+accessor helpers, array algorithms, array types (boolean, floating, integer,
+numeric, period, masked, numpy, arrow), numba kernels, and sparse array support.
+
+No test files are included. Files under `tests/` were excluded.
+
+## License notice
+
+The files in `pandas/` are copyright the pandas development team and contributors,
+licensed under the BSD 3-Clause License. See
+https://github.com/pandas-dev/pandas/blob/main/LICENSE for the full text.
+These files are included here solely for benchmark reproducibility under the
+BSD 3-Clause License terms.