@amabeth/repeating-wheel-picker 1.1.0 → 1.2.0

package/example/node_modules/expo/src/winter/FormData.ts

@@ -0,0 +1,222 @@
+// React Native's FormData implementation is missing several methods that are used in React for server actions.
+// https://github.com/facebook/react-native/blob/42dcfdd2cdb59fe545523cb57db6ee32a96b9298/packages/react-native/Libraries/Network/FormData.js#L1
+// https://github.com/facebook/react/blob/985747f81033833dca22f30b0c04704dd4bd3714/packages/react-client/src/ReactFlightReplyClient.js#L212
+
+type ReactNativeFormDataInternal = FormData & {
+  _parts: [string, string | Blob][];
+};
+
+export type ExpoFormDataValue = string | Blob;
+export type ExpoFormDataPart =
+  | {
+      // WinterCG FormData string
+      string: string;
+      headers: { [name: string]: string };
+    }
+  | {
+      // WinterCG FormData blob in our wrapped form
+      blob: Blob;
+      headers: { [name: string]: string };
+      name?: string | undefined;
+      type?: string | undefined;
+    }
+  | {
+      // React Native proprietary local file
+      uri: string;
+      headers: { [name: string]: string };
+      name?: string | undefined;
+      type?: string | undefined;
+    };
+
+export declare class ExpoFormData {
+  constructor();
+
+  // React Native proprietary local file
+  append(name: string, value: { uri: string; name?: string; type?: string }): void;
+  append(name: string, value: string): void;
+  append(name: string, value: Blob, filename?: string): void;
+
+  delete(name: string): void;
+  get(name: string): FormDataEntryValue | null;
+  getAll(name: string): FormDataEntryValue[];
+  has(name: string): boolean;
+
+  // React Native proprietary local file
+  set(name: string, value: { uri: string; name?: string; type?: string }): void;
+  set(name: string, value: string): void;
+  set(name: string, value: Blob, filename?: string): void;
+
+  // iterable
+  forEach(
+    callback: (value: FormDataEntryValue, key: string, iterable: FormData) => void,
+    thisArg?: unknown
+  ): void;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<FormDataEntryValue>;
+  entries(): IterableIterator<[string, FormDataEntryValue]>;
+  [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
+}
+
+function ensureMinArgCount(name: string, args: any[], expected: number) {
+  if (args.length < expected) {
+    const argName = expected === 2 ? 'arguments' : 'argument';
+    // Matches the errors in Chrome.
+    throw new TypeError(
+      `Failed to execute '${name}' on 'FormData': ${expected} ${argName} required, but only ${args.length} present.`
+    );
+  }
+}
+
+function normalizeArgs(
+  name: string,
+  value: any,
+  blobFilename: string | undefined
+): [string, File | string] {
+  if (value instanceof Blob) {
+    // @ts-expect-error: `Blob.data.blobId` is react-native's proprietary property.
+    if (value.data?.blobId != null) {
+      // For react-native created Blob objects,
+      // we need to keep its original form as-is without breaking functionality.
+      // However, we need to pass `name` for our file name handling.
+      // @ts-expect-error: Mutating the Blob object to add the `name` property.
+      value.name = blobFilename ?? 'blob';
+    } else {
+      value = { type: value.type, name: blobFilename ?? 'blob', blob: value };
+    }
+  } else if (typeof value !== 'object') {
+    value = String(value);
+  }
+  return [String(name), value];
+}
+
+export function installFormDataPatch(formData: typeof FormData): typeof ExpoFormData {
+  formData.prototype.append = function append(this: ReactNativeFormDataInternal, ...props: any[]) {
+    ensureMinArgCount('append', props, 2);
+    // @ts-ignore: When inferred FormData.append from React Native types, it does not support the 3rd blobFilename argument.
+    const [name, value, blobFilename] = props;
+    this._parts.push(normalizeArgs(name, value, blobFilename));
+  };
+
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype.set = function set(this: ReactNativeFormDataInternal, ...props: any[]) {
+    ensureMinArgCount('set', props, 2);
+    const [name, value, blobFilename] = props;
+    const args = normalizeArgs(name, value, blobFilename);
+    let replaced = false;
+
+    for (let i = 0; i < this._parts.length; i++) {
+      if (this._parts[i][0] === args[0]) {
+        if (!replaced) {
+          this._parts[i] = args;
+          replaced = true;
+        } else {
+          this._parts.splice(i, 1);
+          i--;
+        }
+      }
+    }
+
+    if (!replaced) {
+      this._parts.push(args);
+    }
+  };
+
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype.delete ??= function (this: ReactNativeFormDataInternal, ...props: any[]) {
+    ensureMinArgCount('delete', props, 1);
+    let [name] = props;
+    name = String(name);
+    for (let i = 0; i < this._parts.length; i++) {
+      if (this._parts[i][0] === name) {
+        this._parts.splice(i, 1);
+        i--;
+      }
+    }
+  };
+
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype.get ??= function (
+    this: ReactNativeFormDataInternal,
+    ...props: any[]
+  ): FormDataEntryValue | null {
+    ensureMinArgCount('get', props, 1);
+    let [name] = props;
+    name = String(name);
+    for (const part of this._parts) {
+      if (part[0] === name) {
+        // @ts-expect-error: We don't perform correct normalization when setting the args so the return value will
+        // not be a normalized File object.
+        return part[1];
+      }
+    }
+    return null;
+  };
+
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype.has ??= function (this: ReactNativeFormDataInternal, ...props: any[]) {
+    ensureMinArgCount('has', props, 1);
+    let [name] = props;
+    name = String(name);
+    for (const part of this._parts) {
+      if (part[0] === name) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  // Required for RSC: https://github.com/facebook/react/blob/985747f81033833dca22f30b0c04704dd4bd3714/packages/react-dom-bindings/src/server/ReactFizzConfigDOM.js#L1056
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype.forEach ??= function forEach(
+    this: ReactNativeFormDataInternal,
+    ...props: any[]
+  ) {
+    ensureMinArgCount('forEach', props, 1);
+
+    const [callback, thisArg] = props;
+    if (typeof callback !== 'function') {
+      throw new TypeError(
+        `Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'.`
+      );
+    }
+    for (const part of this._parts) {
+      // @ts-ignore: part[1] could throw an error in Node.js runtime because of `File` type mismatch.
+      callback.call(thisArg, part[1], part[0], this);
+    }
+  };
+
+  // Required for RSC: https://github.com/facebook/react/blob/985747f81033833dca22f30b0c04704dd4bd3714/packages/react-server/src/ReactFlightServer.js#L2117
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype.entries ??= function* entries(
+    this: ReactNativeFormDataInternal
+  ): IterableIterator<[string, FormDataEntryValue]> {
+    for (const part of this._parts) {
+      // @ts-expect-error: We don't perform correct normalization when setting the args so the return value will
+      // not be a normalized File object.
+      yield part;
+    }
+  };
+
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype.keys ??= function* keys(this: ReactNativeFormDataInternal) {
+    for (const part of this._parts) {
+      yield part[0];
+    }
+  };
+
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype.values ??= function* values(
+    this: ReactNativeFormDataInternal
+  ): IterableIterator<FormDataEntryValue> {
+    for (const part of this._parts) {
+      // @ts-expect-error: We don't perform correct normalization when setting the args so the return value will
+      // not be a normalized File object.
+      yield part[1];
+    }
+  };
+
+  // @ts-ignore: DOM.iterable is disabled for jest compat
+  formData.prototype[Symbol.iterator] = formData.prototype.entries;
+
+  return formData as unknown as typeof ExpoFormData;
+}

package/example/node_modules/expo/src/winter/ImportMetaRegistry.ts

@@ -0,0 +1,14 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import { getBundleUrl } from '../utils/getBundleUrl';
+
+/**
+ * Registry to handle import.meta functionality for React Native environment
+ * Similar to how it works in the web, but adapted for the RN context
+ * https://github.com/wintercg/import-meta-registry
+ */
+export const ImportMetaRegistry = {
+  get url() {
+    return getBundleUrl();
+  },
+};

package/example/node_modules/expo/src/winter/TextDecoder.ts

@@ -0,0 +1,429 @@
+// A fork of text-encoding but with only UTF-8 decoder.
+// `TextEncoder` is in Hermes and we only need utf-8 decoder for React Server Components.
+//
+// https://github.com/inexorabletash/text-encoding/blob/3f330964c0e97e1ed344c2a3e963f4598610a7ad/lib/encoding.js#L1
+
+/**
+ * Checks if a number is within a specified range.
+ * @param a The number to test.
+ * @param min The minimum value in the range, inclusive.
+ * @param max The maximum value in the range, inclusive.
+ * @returns `true` if a passed number is within the specified range.
+ */
+function inRange(a: number, min: number, max: number): boolean {
+  return min <= a && a <= max;
+}
+
+/**
+ * Converts an array of code points to a string.
+ * @param codePoints Array of code points.
+ * @returns The string representation of given array.
+ */
+function codePointsToString(codePoints: number[]): string {
+  let s = '';
+  for (let i = 0; i < codePoints.length; ++i) {
+    let cp = codePoints[i];
+    if (cp <= 0xffff) {
+      s += String.fromCharCode(cp);
+    } else {
+      cp -= 0x10000;
+      s += String.fromCharCode((cp >> 10) + 0xd800, (cp & 0x3ff) + 0xdc00);
+    }
+  }
+  return s;
+}
+
+function normalizeBytes(input?: ArrayBuffer | DataView): Uint8Array {
+  if (typeof input === 'object' && input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  } else if (
+    typeof input === 'object' &&
+    'buffer' in input &&
+    input.buffer instanceof ArrayBuffer
+  ) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  return new Uint8Array(0);
+}
+
+/**
+ * End-of-stream is a special token that signifies no more tokens
+ * are in the stream.
+ */
+const END_OF_STREAM = -1;
+
+const FINISHED = -1;
+
+/**
+ * A stream represents an ordered sequence of tokens.
+ *
+ * @constructor
+ * @param {!(number[]|Uint8Array)} tokens Array of tokens that provide the stream.
+ */
+class Stream {
+  private tokens: number[];
+
+  constructor(tokens: number[] | Uint8Array) {
+    this.tokens = Array.prototype.slice.call(tokens);
+    // Reversed as push/pop is more efficient than shift/unshift.
+    this.tokens.reverse();
+  }
+
+  /**
+   * @return {boolean} True if end-of-stream has been hit.
+   */
+  endOfStream(): boolean {
+    return !this.tokens.length;
+  }
+
+  /**
+   * When a token is read from a stream, the first token in the
+   * stream must be returned and subsequently removed, and
+   * end-of-stream must be returned otherwise.
+   *
+   * @return {number} Get the next token from the stream, or
+   * end_of_stream.
+   */
+  read(): number {
+    if (!this.tokens.length) return END_OF_STREAM;
+    return this.tokens.pop()!;
+  }
+
+  /**
+   * When one or more tokens are prepended to a stream, those tokens
+   * must be inserted, in given order, before the first token in the
+   * stream.
+   *
+   * @param token The token(s) to prepend to the stream.
+   */
+  prepend(token: number | number[]): void {
+    if (Array.isArray(token)) {
+      while (token.length) this.tokens.push(token.pop()!);
+    } else {
+      this.tokens.push(token);
+    }
+  }
+
+  /**
+   * When one or more tokens are pushed to a stream, those tokens
+   * must be inserted, in given order, after the last token in the
+   * stream.
+   *
+   * @param token The tokens(s) to push to the stream.
+   */
+  push(token: number | number[]): void {
+    if (Array.isArray(token)) {
+      while (token.length) this.tokens.unshift(token.shift()!);
+    } else {
+      this.tokens.unshift(token);
+    }
+  }
+}
+
+function decoderError(fatal: boolean, opt_code_point?: number) {
+  if (fatal) throw TypeError('Decoder error');
+  return opt_code_point || 0xfffd;
+}
+
+interface Encoding {
+  name: string;
+  labels: string[];
+}
+
+const LABEL_ENCODING_MAP: { [key: string]: Encoding } = {};
+
+function getEncoding(label: string): Encoding | null {
+  label = label.trim().toLowerCase();
+  if (label in LABEL_ENCODING_MAP) {
+    return LABEL_ENCODING_MAP[label];
+  }
+  return null;
+}
+
+/** [Encodings table](https://encoding.spec.whatwg.org/encodings.json) (Incomplete as we only need TextDecoder utf8 in Expo RSC. A more complete implementation should be added to Hermes as native code.) */
+const ENCODING_MAP: { heading: string; encodings: Encoding[] }[] = [
+  {
+    encodings: [
+      {
+        labels: [
+          'unicode-1-1-utf-8',
+          'unicode11utf8',
+          'unicode20utf8',
+          'utf-8',
+          'utf8',
+          'x-unicode20utf8',
+        ],
+        name: 'UTF-8',
+      },
+    ],
+    heading: 'The Encoding',
+  },
+];
+
+ENCODING_MAP.forEach((category) => {
+  category.encodings.forEach((encoding) => {
+    encoding.labels.forEach((label) => {
+      LABEL_ENCODING_MAP[label] = encoding;
+    });
+  });
+});
+
+// Registry of of encoder/decoder factories, by encoding name.
+const DECODERS: { [key: string]: (options: { fatal: boolean }) => UTF8Decoder } = {
+  'UTF-8': (options) => new UTF8Decoder(options),
+};
+
+// 9.1.1 utf-8 decoder
+
+interface Decoder {
+  handler: (stream: Stream, bite: number) => number | number[] | null | -1;
+}
+
+class UTF8Decoder implements Decoder {
+  // utf-8's decoder's has an associated utf-8 code point, utf-8
+  // bytes seen, and utf-8 bytes needed (all initially 0), a utf-8
+  // lower boundary (initially 0x80), and a utf-8 upper boundary
+  // (initially 0xBF).
+  private utf8CodePoint = 0;
+  private utf8BytesSeen = 0;
+  private utf8BytesNeeded = 0;
+  private utf8LowerBoundary = 0x80;
+  private utf8UpperBoundary = 0xbf;
+  constructor(private options: { fatal: boolean }) {}
+  /**
+   * @param {Stream} stream The stream of bytes being decoded.
+   * @param {number} bite The next byte read from the stream.
+   * @return {?(number|!Array.<number>)} The next code point(s)
+   *     decoded, or null if not enough data exists in the input
+   *     stream to decode a complete code point.
+   */
+  handler(stream: Stream, bite: number): number | null | -1 {
+    // 1. If byte is end-of-stream and utf-8 bytes needed is not 0,
+    // set utf-8 bytes needed to 0 and return error.
+    if (bite === END_OF_STREAM && this.utf8BytesNeeded !== 0) {
+      this.utf8BytesNeeded = 0;
+      return decoderError(this.options.fatal);
+    }
+
+    // 2. If byte is end-of-stream, return finished.
+    if (bite === END_OF_STREAM) return FINISHED;
+
+    // 3. If utf-8 bytes needed is 0, based on byte:
+    if (this.utf8BytesNeeded === 0) {
+      // 0x00 to 0x7F
+      if (inRange(bite, 0x00, 0x7f)) {
+        // Return a code point whose value is byte.
+        return bite;
+      }
+
+      // 0xC2 to 0xDF
+      else if (inRange(bite, 0xc2, 0xdf)) {
+        // 1. Set utf-8 bytes needed to 1.
+        this.utf8BytesNeeded = 1;
+
+        // 2. Set UTF-8 code point to byte & 0x1F.
+        this.utf8CodePoint = bite & 0x1f;
+      }
+
+      // 0xE0 to 0xEF
+      else if (inRange(bite, 0xe0, 0xef)) {
+        // 1. If byte is 0xE0, set utf-8 lower boundary to 0xA0.
+        if (bite === 0xe0) this.utf8LowerBoundary = 0xa0;
+        // 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.
+        if (bite === 0xed) this.utf8UpperBoundary = 0x9f;
+        // 3. Set utf-8 bytes needed to 2.
+        this.utf8BytesNeeded = 2;
+        // 4. Set UTF-8 code point to byte & 0xF.
+        this.utf8CodePoint = bite & 0xf;
+      }
+
+      // 0xF0 to 0xF4
+      else if (inRange(bite, 0xf0, 0xf4)) {
+        // 1. If byte is 0xF0, set utf-8 lower boundary to 0x90.
+        if (bite === 0xf0) this.utf8LowerBoundary = 0x90;
+        // 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.
+        if (bite === 0xf4) this.utf8UpperBoundary = 0x8f;
+        // 3. Set utf-8 bytes needed to 3.
+        this.utf8BytesNeeded = 3;
+        // 4. Set UTF-8 code point to byte & 0x7.
+        this.utf8CodePoint = bite & 0x7;
+      }
+
+      // Otherwise
+      else {
+        // Return error.
+        return decoderError(this.options.fatal);
+      }
+
+      // Return continue.
+      return null;
+    }
+
+    // 4. If byte is not in the range utf-8 lower boundary to utf-8
+    // upper boundary, inclusive, run these substeps:
+    if (!inRange(bite, this.utf8LowerBoundary, this.utf8UpperBoundary)) {
+      // 1. Set utf-8 code point, utf-8 bytes needed, and utf-8
+      // bytes seen to 0, set utf-8 lower boundary to 0x80, and set
+      // utf-8 upper boundary to 0xBF.
+      this.utf8CodePoint = 0;
+      this.utf8BytesNeeded = 0;
+      this.utf8BytesSeen = 0;
+      this.utf8LowerBoundary = 0x80;
+      this.utf8UpperBoundary = 0xbf;
+
+      // 2. Prepend byte to stream.
+      stream.prepend(bite);
+
+      // 3. Return error.
+      return decoderError(this.options.fatal);
+    }
+
+    // 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary
+    // to 0xBF.
+    this.utf8LowerBoundary = 0x80;
+    this.utf8UpperBoundary = 0xbf;
+
+    // 6. Set UTF-8 code point to (UTF-8 code point << 6) | (byte &
+    // 0x3F)
+    this.utf8CodePoint = (this.utf8CodePoint << 6) | (bite & 0x3f);
+
+    // 7. Increase utf-8 bytes seen by one.
+    this.utf8BytesSeen += 1;
+
+    // 8. If utf-8 bytes seen is not equal to utf-8 bytes needed,
+    // continue.
+    if (this.utf8BytesSeen !== this.utf8BytesNeeded) return null;
+
+    // 9. Let code point be utf-8 code point.
+    const code_point = this.utf8CodePoint;
+
+    // 10. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes
+    // seen to 0.
+    this.utf8CodePoint = 0;
+    this.utf8BytesNeeded = 0;
+    this.utf8BytesSeen = 0;
+
+    // 11. Return a code point whose value is code point.
+    return code_point;
+  }
+}
+
+// 8.1 Interface TextDecoder
+// @docsMissing
+export class TextDecoder {
+  private _encoding: Encoding | null;
+  private _ignoreBOM: boolean;
+  private _errorMode: string;
+  private _BOMseen: boolean = false;
+  private _doNotFlush: boolean = false;
+  private _decoder: UTF8Decoder | null = null;
+
+  constructor(
+    label: string = 'utf-8',
+    options: {
+      fatal?: boolean;
+      ignoreBOM?: boolean;
+    } = {}
+  ) {
+    if (options != null && typeof options !== 'object') {
+      throw new TypeError(
+        'Second argument of TextDecoder must be undefined or an object, e.g. { fatal: true }'
+      );
+    }
+
+    const normalizedLabel = String(label).trim().toLowerCase();
+    const encoding = getEncoding(normalizedLabel);
+    if (encoding === null || encoding.name === 'replacement') {
+      throw new RangeError(`Unknown encoding: ${label} (normalized: ${normalizedLabel})`);
+    }
+
+    if (!DECODERS[encoding.name]) {
+      throw new Error(`Decoder not present: ${encoding.name}`);
+    }
+
+    this._encoding = encoding;
+    this._ignoreBOM = !!options.ignoreBOM;
+    this._errorMode = options.fatal ? 'fatal' : 'replacement';
+  }
+
+  // Getter methods for encoding, fatal, and ignoreBOM
+  get encoding(): string {
+    return this._encoding?.name.toLowerCase() ?? '';
+  }
+
+  get fatal(): boolean {
+    return this._errorMode === 'fatal';
+  }
+
+  get ignoreBOM(): boolean {
+    return this._ignoreBOM;
+  }
+
+  decode(input?: ArrayBuffer | DataView, options: { stream?: boolean } = {}): string {
+    const bytes = normalizeBytes(input);
+
+    // 1. If the do not flush flag is unset, set decoder to a new
+    // encoding's decoder, set stream to a new stream, and unset the
+    // BOM seen flag.
+    if (!this._doNotFlush) {
+      this._decoder = DECODERS[this._encoding!.name]({
+        fatal: this.fatal,
+      });
+      this._BOMseen = false;
+    }
+
+    // 2. If options's stream is true, set the do not flush flag, and
+    // unset the do not flush flag otherwise.
+    this._doNotFlush = Boolean(options['stream']);
+
+    // 3. If input is given, push a copy of input to stream.
+    // TODO: Align with spec algorithm - maintain stream on instance.
+    const input_stream = new Stream(bytes);
+
+    // 4. Let output be a new stream.
+    const output: number[] = [];
+
+    while (true) {
+      const token = input_stream.read();
+
+      if (token === END_OF_STREAM) break;
+
+      const result = this._decoder!.handler(input_stream, token);
+
+      if (result === FINISHED) break;
+
+      if (result !== null) {
+        output.push(result);
+      }
+    }
+
+    if (!this._doNotFlush) {
+      do {
+        const result = this._decoder!.handler(input_stream, input_stream.read());
+        if (result === FINISHED) break;
+        if (result === null) continue;
+        if (Array.isArray(result)) output.push(...result);
+        else output.push(result);
+      } while (!input_stream.endOfStream());
+      this._decoder = null;
+    }
+
+    return this.serializeStream(output);
+  }
+
+  // serializeStream method for converting code points to a string
+  private serializeStream(stream: number[]): string {
+    if (this._encoding!.name === 'UTF-8') {
+      if (!this._ignoreBOM && !this._BOMseen && stream[0] === 0xfeff) {
+        // If BOM is detected at the start of the stream and we're not ignoring it
+        this._BOMseen = true;
+        stream.shift(); // Remove the BOM
+      } else if (stream.length > 0) {
+        this._BOMseen = true;
+      }
+    }
+
+    // Convert the stream of code points to a string
+    return codePointsToString(stream);
+  }
+}

package/example/node_modules/expo/src/winter/fetch/ExpoFetchModule.ts

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+export const ExpoFetchModule = requireNativeModule('ExpoFetchModule');

package/example/node_modules/expo/src/winter/fetch/ExpoFetchModule.web.ts

@@ -0,0 +1,7 @@
+class StubNativeRequest {}
+class StubNativeResponse {}
+
+export const ExpoFetchModule = {
+  NativeRequest: StubNativeRequest,
+  NativeResponse: StubNativeResponse,
+};

package/example/node_modules/expo/src/winter/fetch/FetchErrors.ts

@@ -0,0 +1,11 @@
+export class FetchError extends Error {
+  constructor(message: string, { cause, stack }: { cause?: unknown; stack?: string } = {}) {
+    super(`fetch failed: ${message}`);
+    this.cause = cause;
+    this.stack = stack;
+  }
+
+  static createFromError(error: Error): FetchError {
+    return new FetchError(error.message, { cause: error.cause, stack: error.stack });
+  }
+}