@steerprotocol/app-loader 2.1.1 → 3.0.1

package/lib/browser.mjs

@@ -0,0 +1,757 @@
+// src/internal/instantiate.ts
+import { ethers } from "ethers";
+
+// src/timestring.ts
+var DEFAULT_OPTS = {
+  hoursPerDay: 24,
+  daysPerWeek: 7,
+  weeksPerMonth: 4,
+  monthsPerYear: 12,
+  daysPerYear: 365.25
+};
+var UNIT_MAP = {
+  ms: ["ms", "milli", "millisecond", "milliseconds"],
+  s: ["s", "sec", "secs", "second", "seconds"],
+  m: ["m", "min", "mins", "minute", "minutes"],
+  h: ["h", "hr", "hrs", "hour", "hours"],
+  d: ["d", "day", "days"],
+  w: ["w", "week", "weeks"],
+  mth: ["mon", "mth", "mths", "month", "months"],
+  y: ["y", "yr", "yrs", "year", "years"]
+};
+function parseTimestring(value, returnUnit, opts) {
+  const options = Object.assign({}, DEFAULT_OPTS, opts || {});
+  let strValue;
+  if (typeof value === "number") {
+    strValue = parseInt(value.toString()) + "ms";
+  } else if (value.match(/^[-+]?[0-9.]+$/g)) {
+    strValue = parseInt(value) + "ms";
+  } else {
+    strValue = value;
+  }
+  let totalSeconds = 0;
+  const unitValues = getUnitValues(options);
+  const groups = strValue.toLowerCase().replace(/[^.\w+-]+/g, "").match(/[-+]?[0-9.]+[a-z]+/g);
+  if (groups === null) {
+    throw new Error(`The value [${strValue}] could not be parsed by timestring`);
+  }
+  groups.forEach((group) => {
+    const valMatch = group.match(/[0-9.]+/g);
+    const unitMatch = group.match(/[a-z]+/g);
+    if (valMatch && unitMatch) {
+      const val = parseFloat(valMatch[0]);
+      const unit = unitMatch[0];
+      totalSeconds += getSeconds(val, unit, unitValues);
+    }
+  });
+  if (returnUnit) {
+    return convert(totalSeconds, returnUnit, unitValues);
+  }
+  return totalSeconds;
+}
+function getUnitValues(opts) {
+  const unitValues = {
+    ms: 1e-3,
+    s: 1,
+    m: 60,
+    h: 3600,
+    d: 0,
+    w: 0,
+    mth: 0,
+    y: 0
+  };
+  unitValues.d = opts.hoursPerDay * unitValues.h;
+  unitValues.w = opts.daysPerWeek * unitValues.d;
+  unitValues.mth = opts.daysPerYear / opts.monthsPerYear * unitValues.d;
+  unitValues.y = opts.daysPerYear * unitValues.d;
+  return unitValues;
+}
+function getUnitKey(unit) {
+  for (const key of Object.keys(UNIT_MAP)) {
+    if (UNIT_MAP[key].indexOf(unit) > -1) {
+      return key;
+    }
+  }
+  throw new Error(`The unit [${unit}] is not supported by timestring`);
+}
+function getSeconds(value, unit, unitValues) {
+  return value * unitValues[getUnitKey(unit)];
+}
+function convert(value, unit, unitValues) {
+  return value / unitValues[getUnitKey(unit)];
+}
+
+// src/Candle.ts
+var Candle = class {
+  /**
+   * Creates a candle instance.
+   * @param timestamp - Candle open timestamp in milliseconds.
+   * @param high - Highest traded price.
+   * @param low - Lowest traded price.
+   * @param open - Opening price.
+   * @param close - Closing price.
+   * @param volume - Total traded volume.
+   */
+  constructor(timestamp, high, low, open, close, volume) {
+    this.timestamp = timestamp;
+    this.high = high;
+    this.low = low;
+    this.open = open;
+    this.close = close;
+    this.volume = volume;
+  }
+  /**
+   * Serializes the candle as JSON.
+   * @returns The candle as a JSON string.
+   */
+  toString() {
+    return JSON.stringify(this);
+  }
+};
+function generateCandles(data, candleSize) {
+  const candleWidth = parseTimestring(candleSize, "ms", {});
+  if (data.length === 0) {
+    throw new Error("Input data is empty");
+  }
+  const _data = data.map((point) => {
+    return Object.assign(Object.assign({}, point), {
+      // Older inputs may still provide 10-digit second timestamps instead of milliseconds.
+      timestamp: point.timestamp && String(point.timestamp).length == 10 ? point.timestamp * 1e3 : point.timestamp
+    });
+  });
+  if (_data[0] === void 0 || Object.keys(_data[0]).length === 0) {
+    return [];
+  }
+  const ohlcvData = [];
+  let i = 0;
+  let currentTimestamp = Math.floor(_data[0].timestamp / candleWidth) * candleWidth;
+  let open = _data[0].price;
+  let high = _data[0].price;
+  let low = _data[0].price;
+  let close = _data[0].price;
+  let volume = 0;
+  while (i < _data.length) {
+    open = close;
+    high = close;
+    low = close;
+    volume = 0;
+    let innerI = i;
+    while (innerI < _data.length && _data[innerI].timestamp < currentTimestamp + candleWidth) {
+      open = innerI === 0 ? _data[innerI].price : open;
+      high = Math.max(high, _data[innerI].price);
+      low = Math.min(low, _data[innerI].price);
+      close = _data[innerI].price;
+      volume += _data[innerI].volume;
+      innerI++;
+    }
+    ohlcvData.push({
+      timestamp: currentTimestamp,
+      high,
+      low,
+      open,
+      close,
+      volume
+    });
+    currentTimestamp += candleWidth;
+    i = innerI;
+  }
+  return ohlcvData;
+}
+
+// src/RawTradeData.ts
+var RawTradeData = class {
+  /**
+   * Creates a raw trade data point.
+   * @param timestamp - Trade timestamp.
+   * @param price - Trade price.
+   * @param volume - Trade volume.
+   */
+  constructor(timestamp, price, volume) {
+    this.timestamp = timestamp;
+    this.price = price;
+    this.volume = volume;
+  }
+};
+
+// src/internal/instantiate.ts
+function instantiate(module, imports = {}, runtime = {}) {
+  let WASM_MEMORY;
+  let WASM_EXPORTS;
+  let WASM_DV;
+  let ASYNCIFY_PTR = 0;
+  let ASYNCIFY_MEM;
+  let ASYNCIFY_INITIALIZED = false;
+  let fetchFn = null;
+  let ccxtFn = null;
+  let detachedValue = null;
+  let executeInFlight = false;
+  const pinScopes = [];
+  const adaptedImports = Object.assign(
+    {
+      console: {
+        /**
+         * Logs a lifted AssemblyScript string.
+         * @param text - Pointer to the message string.
+         */
+        log(text) {
+          console.log(__liftString(text));
+        }
+      },
+      ethers: {
+        /**
+         * Hashes a lifted string with `keccak256`.
+         * @param str_ptr - Pointer to the input string.
+         * @returns Pointer to the hashed string result.
+         */
+        keccak256_str(str_ptr) {
+          const str = __liftString(str_ptr);
+          const hash = ethers.keccak256(str);
+          return withAutoPinScope(() => __lowerString(hash));
+        },
+        /**
+         * Hashes a lifted buffer with `keccak256`.
+         * @param buf_ptr - Pointer to the input buffer.
+         * @returns Pointer to the hashed string result.
+         */
+        keccak256_buf(buf_ptr) {
+          const buf = __liftBuffer(buf_ptr);
+          const hash = ethers.keccak256(new Uint8Array(buf));
+          return withAutoPinScope(() => __lowerString(hash));
+        }
+      },
+      // @ts-ignore
+      env: {
+        /**
+         * Raises a JavaScript error for an AssemblyScript abort.
+         * @param message - Pointer to the abort message.
+         * @param fileName - Pointer to the source filename.
+         * @param lineNumber - Source line number.
+         * @param columnNumber - Source column number.
+         */
+        abort(message, fileName, lineNumber, columnNumber) {
+          (() => {
+            throw Error(`${__liftString(message)} in ${__liftString(fileName)}:${lineNumber}:${columnNumber}`);
+          })();
+        },
+        /**
+         * Initializes Asyncify bookkeeping for host callbacks.
+         * @param frame_ptr - Asyncify frame pointer.
+         * @param stack_ptr - Asyncify stack pointer.
+         */
+        _initAsyncify(frame_ptr, stack_ptr) {
+          if (!WASM_EXPORTS["asyncify_get_state"])
+            throw new Error(
+              "Asyncify initialized, but not enabled when run! Compile with the --runPasses asyncify flag or asyncify-shim transform!"
+            );
+          if (ASYNCIFY_INITIALIZED) return;
+          ASYNCIFY_PTR = frame_ptr;
+          ASYNCIFY_MEM[ASYNCIFY_PTR >> 2] = ASYNCIFY_PTR + 8;
+          ASYNCIFY_MEM[ASYNCIFY_PTR + 4 >> 2] = stack_ptr;
+          ASYNCIFY_INITIALIZED = true;
+        },
+        /**
+         * Aggregates lifted trade data into candles.
+         * @param data - Pointer to the serialized trade array.
+         * @param candleSize - Pointer to the candle size string.
+         * @returns Pointer to the serialized candle array.
+         */
+        generateCandles(data, candleSize) {
+          const _data = __liftString(data) || "[]";
+          const _candleSize = __liftString(candleSize) || "69m";
+          const candles = generateCandles(JSON.parse(_data), _candleSize);
+          return withAutoPinScope(() => __lowerString(JSON.stringify(candles)));
+        },
+        /**
+         * Logs a lifted AssemblyScript string.
+         * @param text - Pointer to the message string.
+         */
+        "console.log": (text) => {
+          console.log(__liftString(text));
+        },
+        /**
+         * Schedules an async OHLCV request for asyncified execution.
+         * @param exchangeId - Pointer to the exchange id string.
+         * @param symbol - Pointer to the market symbol string.
+         * @param timeframe - Pointer to the timeframe string.
+         * @param limit - Maximum number of rows.
+         * @param since - Optional start timestamp.
+         * @returns Pointer to the rewound OHLCV matrix when replaying.
+         */
+        ccxt_fetchOHLCV: (exchangeId, symbol, timeframe, limit, since) => {
+          const currentState = WASM_EXPORTS.asyncify_get_state();
+          if (currentState === 2 /* Rewinding */) {
+            WASM_EXPORTS.asyncify_stop_rewind();
+            const ptr = __lowerStaticArray(
+              (pointer, value) => {
+                __setU32(pointer, __lowerStaticArray(__setF64, 7, 3, value, Float64Array));
+              },
+              8,
+              2,
+              detachedValue
+            );
+            return ptr;
+          }
+          const _exchange = __liftString(exchangeId);
+          const _symbol = __liftString(symbol);
+          const _timeframe = __liftString(timeframe);
+          ccxtFn = async () => {
+            if (!_exchange || !_symbol || !_timeframe)
+              throw new Error("Exchange, Symbol, or Timeframe not provided when fetching OHCLV data.");
+            const ccxt = await getCcxtOrThrow(runtime);
+            const data = await new ccxt[_exchange]({
+              apiKey: "",
+              secret: ""
+            }).fetchOHLCV(_symbol, _timeframe, since, limit);
+            return data;
+          };
+          WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+        }
+      },
+      "as-fetch": {
+        /**
+         * Initializes Asyncify bookkeeping for as-fetch host calls.
+         * @param frame_ptr - Asyncify frame pointer.
+         * @param stack_ptr - Asyncify stack pointer.
+         */
+        _initAsyncify(frame_ptr, stack_ptr) {
+          if (!WASM_EXPORTS["asyncify_get_state"])
+            throw new Error(
+              "Asyncify initialized, but not enabled when run! Compile with the --runPasses asyncify flag or asyncify-shim transform!"
+            );
+          if (ASYNCIFY_INITIALIZED) return;
+          ASYNCIFY_PTR = frame_ptr;
+          ASYNCIFY_MEM[ASYNCIFY_PTR >> 2] = ASYNCIFY_PTR + 8;
+          ASYNCIFY_MEM[ASYNCIFY_PTR + 4 >> 2] = stack_ptr;
+          ASYNCIFY_INITIALIZED = true;
+        },
+        /**
+         * Executes a synchronous asyncified POST request.
+         * @param url - Pointer to the request URL.
+         * @param mode - Numeric fetch mode.
+         * @param headers - Pointer to the header array.
+         * @param body - Pointer to the request body.
+         * @returns Pointer to the response body when replaying.
+         */
+        _fetchPOSTSync(url, mode, headers, body) {
+          const currentState = WASM_EXPORTS.asyncify_get_state();
+          if (currentState === 2 /* Rewinding */) {
+            WASM_EXPORTS.asyncify_stop_rewind();
+            const ptr = __lowerBuffer(detachedValue);
+            detachedValue = null;
+            return ptr;
+          }
+          fetchFn = async () => {
+            const fetchImpl = await getFetchOrThrow(runtime);
+            const res = await fetchImpl(__liftString(url) || "", {
+              method: "POST",
+              mode: modeToString(mode) || "cors",
+              headers: __liftArray(
+                (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                2,
+                headers
+              ) || [],
+              body: __liftBuffer(body)
+            });
+            const value = await res.arrayBuffer();
+            return value;
+          };
+          WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+        },
+        /**
+         * Executes a synchronous asyncified GET request.
+         * @param url - Pointer to the request URL.
+         * @param mode - Numeric fetch mode.
+         * @param headers - Pointer to the header array.
+         * @returns Pointer to the response body when replaying.
+         */
+        _fetchGETSync(url, mode, headers) {
+          const currentState = WASM_EXPORTS.asyncify_get_state();
+          if (currentState === 2 /* Rewinding */) {
+            WASM_EXPORTS.asyncify_stop_rewind();
+            const ptr = __lowerBuffer(detachedValue);
+            detachedValue = null;
+            return ptr;
+          }
+          fetchFn = async () => {
+            const fetchImpl = await getFetchOrThrow(runtime);
+            const res = await fetchImpl(__liftString(url) || "", {
+              method: "GET",
+              mode: modeToString(mode) || "cors",
+              headers: __liftArray(
+                (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                2,
+                headers
+              ) || []
+            });
+            const value = await res.arrayBuffer();
+            return value;
+          };
+          WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
+        },
+        /**
+         * Executes an asynchronous GET request and forwards the response to wasm.
+         * @param url - Pointer to the request URL.
+         * @param mode - Numeric fetch mode.
+         * @param headers - Pointer to the header array.
+         * @param callbackID - Wasm callback identifier.
+         */
+        _fetchGET(url, mode, headers, callbackID) {
+          void (async () => {
+            try {
+              const fetchImpl = await getFetchOrThrow(runtime);
+              const res = await fetchImpl(__liftString(url) || "", {
+                method: "GET",
+                mode: modeToString(mode) || "cors",
+                headers: __liftArray(
+                  (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                  2,
+                  headers
+                ) || []
+              });
+              const body = await res.arrayBuffer();
+              WASM_EXPORTS.responseHandler(body, res.status, res.redirected ? 1 : 0, callbackID);
+            } catch (error) {
+              console.error(error);
+            }
+          })();
+        },
+        /**
+         * Executes an asynchronous POST request and forwards the response to wasm.
+         * @param url - Pointer to the request URL.
+         * @param mode - Numeric fetch mode.
+         * @param headers - Pointer to the header array.
+         * @param body - Request body.
+         * @param callbackID - Wasm callback identifier.
+         */
+        _fetchPOST(url, mode, headers, body, callbackID) {
+          void (async () => {
+            try {
+              const fetchImpl = await getFetchOrThrow(runtime);
+              const res = await fetchImpl(__liftString(url) || "", {
+                method: "POST",
+                mode: modeToString(mode) || "cors",
+                body,
+                headers: __liftArray(
+                  (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                  2,
+                  headers
+                ) || []
+              });
+              const responseBody = await res.arrayBuffer();
+              WASM_EXPORTS.responseHandler(responseBody, res.status, res.redirected ? 1 : 0, callbackID);
+            } catch (error) {
+              console.error(error);
+            }
+          })();
+        }
+      }
+    },
+    imports
+  );
+  const mod = new WebAssembly.Instance(module, adaptedImports);
+  WASM_EXPORTS = mod.exports;
+  WASM_MEMORY = WASM_EXPORTS.memory || adaptedImports.env.memory;
+  ASYNCIFY_MEM = new Uint32Array(WASM_MEMORY.buffer);
+  const handledExports = Object.setPrototypeOf(
+    {
+      /**
+       * Forwards an HTTP response body into the wasm export.
+       * @param body - Response body.
+       * @param statusCode - HTTP status code.
+       * @param redirected - Whether the request redirected.
+       * @param callbackID - Wasm callback identifier.
+       */
+      responseHandler(body, statusCode, redirected, callbackID) {
+        if (!WASM_EXPORTS["responseHandler"])
+          throw new Error(
+            'Unable to call .responseHandler on wasm module. Add the line export { responseHandler } from "as-fetch/assembly" to your entry file.'
+          );
+        withPinScope(() => {
+          WASM_EXPORTS.responseHandler(__lowerBuffer(body), statusCode, redirected ? 1 : 0, callbackID);
+        });
+      },
+      /**
+       * Initializes the wasm module with a JSON configuration payload.
+       * @param config - Serialized connector configuration.
+       * @returns `true` when initialization succeeds.
+       */
+      initialize(config) {
+        if (!WASM_EXPORTS["initialize"])
+          throw new Error("Unable to call .initialize on wasm module. Are you sure this is a data connector?");
+        try {
+          withPinScope(() => {
+            WASM_EXPORTS.initialize(__lowerString(config));
+          });
+          return true;
+        } catch (e) {
+          console.error(e);
+          return false;
+        }
+      },
+      /**
+       * Executes the wasm module, replaying arguments across asyncify rewinds.
+       * @param params - Logical execute arguments.
+       * @returns The lifted execute result.
+       */
+      async execute(...params) {
+        if (!WASM_EXPORTS["execute"])
+          throw new Error("Unable to call .execute on wasm module. Are you sure this is a data connector?");
+        if (executeInFlight) {
+          throw new Error("Concurrent execute calls are not supported on the same wasm instance.");
+        }
+        executeInFlight = true;
+        const replayArgs = snapshotLogicalArgs(params);
+        try {
+          let result;
+          try {
+            result = executeWithReplayArgs(replayArgs);
+          } catch (error) {
+            if (params.length !== 0) {
+              throw error;
+            }
+            replayArgs.splice(0, replayArgs.length, "");
+            result = executeWithReplayArgs(replayArgs);
+          }
+          if (ASYNCIFY_INITIALIZED) {
+            while (WASM_EXPORTS.asyncify_get_state() === 1 /* Unwinding */) {
+              WASM_EXPORTS.asyncify_stop_unwind();
+              if (fetchFn) {
+                const pendingFetch = fetchFn;
+                fetchFn = null;
+                detachedValue = await pendingFetch();
+              }
+              if (ccxtFn) {
+                const pendingCcxt = ccxtFn;
+                ccxtFn = null;
+                detachedValue = await pendingCcxt();
+              }
+              WASM_EXPORTS.asyncify_start_rewind(ASYNCIFY_PTR);
+              result = executeWithReplayArgs(replayArgs);
+            }
+          }
+          return __liftString(result);
+        } finally {
+          fetchFn = null;
+          ccxtFn = null;
+          detachedValue = null;
+          executeInFlight = false;
+        }
+      },
+      /**
+       * Reads the connector configuration schema from wasm.
+       * @returns The lifted configuration payload.
+       */
+      config() {
+        if (!WASM_EXPORTS["config"])
+          throw new Error("Unable to call .config on wasm module. Are you sure this is a data connector?");
+        return withPinScope(() => __liftString(WASM_EXPORTS.config()));
+      },
+      /**
+       * Reads the connector transform from wasm.
+       * @returns The lifted transform payload.
+       */
+      transform() {
+        if (!WASM_EXPORTS["transform"])
+          throw new Error("Unable to call .transform on wasm module. Are you sure this is a data connector?");
+        return withPinScope(() => __liftString(WASM_EXPORTS.transform()));
+      },
+      /**
+       * Resets wasm module state when supported.
+       */
+      reset() {
+        if (WASM_EXPORTS["reset"]) WASM_EXPORTS.reset();
+      }
+    },
+    WASM_EXPORTS
+  );
+  WASM_DV = new DataView(WASM_MEMORY.buffer);
+  function __lower(val) {
+    if (typeof val === "number") {
+      return val;
+    } else if (typeof val === "string") {
+      return __lowerString(val);
+    } else if (val instanceof ArrayBuffer) {
+      return __lowerBuffer(val);
+    } else {
+      return 0;
+    }
+  }
+  function lowerArgs(values) {
+    const loweredArgs = new Array(values.length);
+    for (let i = 0; i < values.length; i++) {
+      loweredArgs[i] = __lower(values[i]);
+    }
+    return loweredArgs;
+  }
+  function snapshotLogicalArgs(values) {
+    return values.map((value) => {
+      if (value instanceof ArrayBuffer) {
+        return value.slice(0);
+      }
+      return value;
+    });
+  }
+  function executeWithReplayArgs(values) {
+    return withPinScope(() => WASM_EXPORTS.execute(...lowerArgs(values)));
+  }
+  function withPinScope(fn) {
+    pinScopes.push([]);
+    try {
+      return fn();
+    } finally {
+      const scope = pinScopes.pop() || [];
+      for (let i = scope.length - 1; i >= 0; i--) {
+        WASM_EXPORTS.__unpin(scope[i]);
+      }
+    }
+  }
+  function withAutoPinScope(fn) {
+    if (pinScopes.length > 0) {
+      return fn();
+    }
+    return withPinScope(fn);
+  }
+  function trackPinnedPointer(ptr) {
+    const scope = pinScopes[pinScopes.length - 1];
+    if (scope) {
+      scope.push(ptr);
+    }
+    return ptr;
+  }
+  function __liftString(ptr) {
+    if (!ptr) return null;
+    const end = ptr + new Uint32Array(WASM_MEMORY.buffer)[ptr - 4 >>> 2] >>> 1;
+    const memoryU16 = new Uint16Array(WASM_MEMORY.buffer);
+    let start = ptr >>> 1;
+    let string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  function __lowerString(value) {
+    if (value == null) return 0;
+    const length = value.length;
+    const ptr = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(length << 1, 2) >>> 0));
+    const memoryU16 = new Uint16Array(WASM_MEMORY.buffer);
+    for (let i = 0; i < length; ++i) memoryU16[(ptr >>> 1) + i] = value.charCodeAt(i);
+    return ptr;
+  }
+  function __liftBuffer(ptr) {
+    if (!ptr) return null;
+    return WASM_MEMORY.buffer.slice(ptr, ptr + new Uint32Array(WASM_MEMORY.buffer)[ptr - 4 >>> 2]);
+  }
+  function __lowerBuffer(value) {
+    if (value == null) return 0;
+    const ptr = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(value.byteLength, 1) >>> 0));
+    new Uint8Array(WASM_MEMORY.buffer).set(new Uint8Array(value), ptr);
+    return ptr;
+  }
+  function __liftArray(liftElement, align, ptr) {
+    if (!ptr) return null;
+    const dataStart = __getU32(ptr + 4);
+    const length = WASM_DV.getUint32(ptr + 12, true);
+    const values = new Array(length);
+    for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0));
+    return values;
+  }
+  function __lowerStaticArray(lowerElement, id, align, values, typedConstructor = null) {
+    if (values == null) return 0;
+    const length = values.length;
+    const buffer = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(length << align, id)) >>> 0) >>> 0;
+    if (typedConstructor) {
+      new typedConstructor(WASM_MEMORY.buffer, buffer, length).set(values);
+    } else {
+      for (let i = 0; i < length; i++) lowerElement(buffer + (i << align >>> 0), values[i]);
+    }
+    return buffer;
+  }
+  function __setU32(ptr, value) {
+    try {
+      WASM_DV.setUint32(ptr, value, true);
+    } catch {
+      WASM_DV = new DataView(WASM_MEMORY.buffer);
+      WASM_DV.setUint32(ptr, value, true);
+    }
+  }
+  function __setF64(ptr, value) {
+    try {
+      WASM_DV.setFloat64(ptr, value, true);
+    } catch {
+      WASM_DV = new DataView(WASM_MEMORY.buffer);
+      WASM_DV.setFloat64(ptr, value, true);
+    }
+  }
+  function __getU32(ptr) {
+    try {
+      return WASM_DV.getUint32(ptr, true);
+    } catch {
+      WASM_DV = new DataView(WASM_MEMORY.buffer);
+      return WASM_DV.getUint32(ptr, true);
+    }
+  }
+  return handledExports;
+}
+async function getFetchOrThrow(runtime) {
+  if (!runtime.getFetch) {
+    throw new Error("Fetch is not available in this runtime.");
+  }
+  return runtime.getFetch();
+}
+async function getCcxtOrThrow(runtime) {
+  if (!runtime.getCcxt) {
+    throw new Error("ccxt is not available in this runtime.");
+  }
+  return runtime.getCcxt();
+}
+function modeToString(mode) {
+  if (mode == 1) return "cors";
+  if (mode == 2) return "no-cors";
+  if (mode == 3) return "same-origin";
+  if (mode == 4) return "navigate";
+  return null;
+}
+
+// src/browser.ts
+function loadWasmSync(input, imports = {}) {
+  return instantiate(new WebAssembly.Module(input), imports, {
+    getFetch: getBrowserFetch,
+    getCcxt: getBrowserCcxt
+  });
+}
+async function loadWasm(input, imports = {}) {
+  const module = typeof input === "string" ? await compileFromUrl(input) : await WebAssembly.compile(input);
+  return instantiate(module, imports, {
+    getFetch: getBrowserFetch,
+    getCcxt: getBrowserCcxt
+  });
+}
+async function compileFromUrl(url) {
+  const fetchImpl = await getBrowserFetch();
+  const response = await fetchImpl(url);
+  if (typeof WebAssembly.compileStreaming === "function") {
+    try {
+      return await WebAssembly.compileStreaming(Promise.resolve(response.clone()));
+    } catch {
+    }
+  }
+  return WebAssembly.compile(await response.arrayBuffer());
+}
+async function getBrowserFetch() {
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("Fetch is not available in this browser runtime.");
+  }
+  return globalThis.fetch.bind(globalThis);
+}
+async function getBrowserCcxt() {
+  const ccxt = globalThis.ccxt;
+  if (!ccxt) {
+    throw new Error("ccxt is not available in this browser runtime.");
+  }
+  return ccxt;
+}
+export {
+  Candle,
+  RawTradeData,
+  loadWasm,
+  loadWasmSync
+};
+//# sourceMappingURL=browser.mjs.map