@solidjs/web 2.0.0-experimental.9 → 2.0.0-rc.1

package/server-functions/dist/client.js

@@ -0,0 +1,763 @@
+const REVALIDATE_HEADER = "X-Revalidate";
+
+const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
+function getServerFunctionMetadata(fn) {
+  if (typeof fn !== "function") return undefined;
+  return fn[SERVER_FUNCTION_METADATA] || undefined;
+}
+function isServerFunction(fn) {
+  return typeof fn === "function" && !!fn[SERVER_FUNCTION_METADATA];
+}
+function withMeta(fn, meta) {
+  const metadata = getServerFunctionMetadata(fn);
+  if (!metadata) {
+    throw new Error("withMeta expects a server function reference");
+  }
+  Object.assign(metadata, meta);
+  return fn;
+}
+const LIVE_SOURCE = Symbol.for("solid.LiveSource");
+const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
+function provideServerFunctionRPC(rpc) {
+  globalThis[SERVER_FUNCTION_RPC] || (globalThis[SERVER_FUNCTION_RPC] = rpc);
+}
+
+const FLASH_COOKIE = "flash";
+const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
+function hasFlashCookie(cookieHeader) {
+  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
+}
+function clearFlashCookie() {
+  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
+}
+
+const codecConfig = {
+  codec: undefined
+};
+function configureServerFunctionsCodec(codec) {
+  codecConfig.codec = codec;
+}
+function getServerFunctionsCodec() {
+  return codecConfig.codec;
+}
+const flightConfig = {
+  consumer: undefined
+};
+function subscribeFlightData(consumer) {
+  flightConfig.consumer = consumer;
+  return () => {
+    if (flightConfig.consumer === consumer) flightConfig.consumer = undefined;
+  };
+}
+function getFlightDataConsumer() {
+  return flightConfig.consumer;
+}
+function frameAddress(id, args) {
+  return args && args.length ? id + ":" + hashArguments(args) : id;
+}
+function hashArguments(args) {
+  let hash = 0;
+  const text = stableString(args);
+  for (let i = 0; i < text.length; i++) {
+    hash = (hash << 5) - hash + text.charCodeAt(i);
+    hash |= 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+function stableString(value, seen) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "bigint" ? value + "n" : String(value);
+  }
+  if (value instanceof Date) return "Date:" + value.getTime();
+  seen || (seen = new Set());
+  if (seen.has(value)) return "~";
+  seen.add(value);
+  if (value instanceof Map) {
+    const entries = [];
+    for (const [k, v] of value) {
+      entries.push(stableString(k, seen) + "=>" + stableString(v, seen));
+    }
+    return "Map{" + entries.sort().join(",") + "}";
+  }
+  if (value instanceof Set) {
+    const members = [];
+    for (const v of value) members.push(stableString(v, seen));
+    return "Set{" + members.sort().join(",") + "}";
+  }
+  if (Array.isArray(value)) {
+    let out = "[";
+    for (let i = 0; i < value.length; i++) out += (i ? "," : "") + stableString(value[i], seen);
+    return out + "]";
+  }
+  const keys = Object.keys(value).sort();
+  let out = "{";
+  for (let i = 0; i < keys.length; i++) {
+    out += (i ? "," : "") + keys[i] + ":" + stableString(value[keys[i]], seen);
+  }
+  return out + "}";
+}
+const FUNCTION_HEADER = "X-Server-Function-Id";
+const ERROR_HEADER = "X-Server-Function-Error";
+const ERROR_HEADER_MARKER = "=?1?";
+const NEEDS_ENCODING = /[^\x20-\x7e\xa0-\xff]/;
+function encodeErrorHeaderValue(value) {
+  let stripped = String(value).replace(/[\r\n]+/g, "");
+  if (!NEEDS_ENCODING.test(stripped) && !stripped.startsWith(ERROR_HEADER_MARKER) && stripped === stripped.trim()) {
+    return stripped;
+  }
+  if (typeof stripped.toWellFormed === "function") {
+    stripped = stripped.toWellFormed();
+  } else {
+    stripped = stripped.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
+  }
+  return ERROR_HEADER_MARKER + encodeURIComponent(stripped);
+}
+function decodeErrorHeaderValue(value) {
+  if (typeof value !== "string" || !value.startsWith(ERROR_HEADER_MARKER)) {
+    return value;
+  }
+  try {
+    return decodeURIComponent(value.slice(ERROR_HEADER_MARKER.length));
+  } catch {
+    return value;
+  }
+}
+const INSTANCE_HEADER = "X-Server-Function-Instance";
+const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
+const FILE_FORM_KEY = "__server_function_file__";
+const BodyFormat = {
+  Serialized: "0",
+  String: "1",
+  FormData: "2",
+  URLSearchParams: "3",
+  Blob: "4",
+  File: "5",
+  ArrayBuffer: "6",
+  Uint8Array: "7",
+  Json: "8"
+};
+const JSON_SAFE_DEPTH_LIMIT = 4096;
+const EXIT = {};
+function isJSONSafe(value) {
+  const stack = [value];
+  const ancestors = new Set();
+  while (stack.length) {
+    const v = stack.pop();
+    if (v === EXIT) {
+      ancestors.delete(stack.pop());
+      continue;
+    }
+    if (v === null) continue;
+    const t = typeof v;
+    if (t === "string" || t === "boolean") continue;
+    if (t === "number") {
+      if (!Number.isFinite(v)) return false;
+      continue;
+    }
+    if (t !== "object") return false;
+    if (ancestors.has(v) || ancestors.size >= JSON_SAFE_DEPTH_LIMIT) return false;
+    ancestors.add(v);
+    stack.push(v, EXIT);
+    if (Array.isArray(v)) {
+      for (let i = 0; i < v.length; i++) stack.push(v[i]);
+    } else {
+      const proto = Object.getPrototypeOf(v);
+      if (proto !== Object.prototype && proto !== null) return false;
+      if (Symbol.asyncIterator in v || Symbol.iterator in v) return false;
+      for (const k in v) stack.push(v[k]);
+    }
+  }
+  return true;
+}
+function getHeadersAndBody(body) {
+  switch (true) {
+    case typeof body === "string":
+      return {
+        headers: {
+          "Content-Type": "text/plain",
+          [BODY_FORMAT_HEADER]: BodyFormat.String
+        },
+        body
+      };
+    case body instanceof FormData:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.FormData
+        },
+        body
+      };
+    case body instanceof URLSearchParams:
+      return {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          [BODY_FORMAT_HEADER]: BodyFormat.URLSearchParams
+        },
+        body
+      };
+    case typeof File !== "undefined" && body instanceof File:
+      {
+        const formData = new FormData();
+        formData.append(FILE_FORM_KEY, body, body.name);
+        return {
+          headers: {
+            [BODY_FORMAT_HEADER]: BodyFormat.File
+          },
+          body: formData
+        };
+      }
+    case body instanceof Blob:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Blob
+        },
+        body
+      };
+    case body instanceof ArrayBuffer:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.ArrayBuffer
+        },
+        body
+      };
+    case body instanceof Uint8Array:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Uint8Array
+        },
+        body: new Uint8Array(body)
+      };
+    default:
+      return undefined;
+  }
+}
+async function extractBody(source, codecOptions) {
+  const contentType = source.headers.get("content-type");
+  const format = source.headers.get(BODY_FORMAT_HEADER);
+  const clone = source.clone();
+  switch (true) {
+    case format === BodyFormat.Serialized:
+      return await deserializeStream(clone, codecOptions);
+    case format === BodyFormat.Json:
+      return JSON.parse(await clone.text());
+    case format === BodyFormat.String:
+      return await clone.text();
+    case format === BodyFormat.File:
+      {
+        const formData = await clone.formData();
+        return formData.get(FILE_FORM_KEY);
+      }
+    case format === BodyFormat.FormData:
+    case contentType && contentType.startsWith("multipart/form-data"):
+      return await clone.formData();
+    case format === BodyFormat.URLSearchParams:
+    case contentType && contentType.startsWith("application/x-www-form-urlencoded"):
+      return new URLSearchParams(await clone.text());
+    case format === BodyFormat.Blob:
+      return await clone.blob();
+    case format === BodyFormat.ArrayBuffer:
+      return await clone.arrayBuffer();
+    case format === BodyFormat.Uint8Array:
+      return new Uint8Array(await clone.arrayBuffer());
+  }
+  return undefined;
+}
+function createChunk(data) {
+  const encoder = new TextEncoder();
+  const encodeData = encoder.encode(data);
+  const bytes = encodeData.length;
+  const chunk = new Uint8Array(12 + bytes);
+  chunk.set(encoder.encode(`;0x${bytes.toString(16).padStart(8, "0")};`));
+  chunk.set(encodeData, 12);
+  return chunk;
+}
+class ChunkReader {
+  constructor(stream) {
+    this.reader = stream.getReader();
+    this.buffer = new Uint8Array(0);
+    this.done = false;
+  }
+  async readChunk() {
+    const chunk = await this.reader.read();
+    if (!chunk.done) {
+      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
+      newBuffer.set(this.buffer);
+      newBuffer.set(chunk.value, this.buffer.length);
+      this.buffer = newBuffer;
+    } else {
+      this.done = true;
+    }
+  }
+  async next() {
+    while (this.buffer.length < 12) {
+      if (this.done) {
+        if (this.buffer.length === 0) return {
+          done: true,
+          value: undefined
+        };
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const decoder = new TextDecoder();
+    const bytes = Number.parseInt(decoder.decode(this.buffer.subarray(1, 11)), 16);
+    if (Number.isNaN(bytes)) {
+      throw new Error("Malformed server function stream.");
+    }
+    while (bytes > this.buffer.length - 12) {
+      if (this.done) {
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const partial = decoder.decode(this.buffer.subarray(12, 12 + bytes));
+    this.buffer = this.buffer.subarray(12 + bytes);
+    return {
+      done: false,
+      value: partial
+    };
+  }
+  async drain(interpret) {
+    while (true) {
+      const result = await this.next();
+      if (result.done) {
+        break;
+      }
+      interpret(result.value);
+    }
+  }
+}
+function serializeStream(value, codecOptions) {
+  return new ReadableStream({
+    async start(controller) {
+      const {
+        serializeJSON
+      } = await import('@solidjs/web/serialization');
+      serializeJSON(value, {
+        ...codecOptions,
+        onParse(node) {
+          controller.enqueue(createChunk(JSON.stringify(node)));
+        },
+        onDone() {
+          controller.close();
+        },
+        onError(error) {
+          controller.error(error);
+        }
+      });
+    }
+  });
+}
+async function serializeString(value, codecOptions) {
+  const response = new Response(serializeStream(value, codecOptions));
+  return await response.text();
+}
+async function deserializeStream(source, codecOptions) {
+  if (!source.body) {
+    throw new Error("missing body");
+  }
+  const reader = new ChunkReader(source.body);
+  const result = await reader.next();
+  if (!result.done) {
+    const {
+      createJSONDeserializer
+    } = await import('@solidjs/web/serialization/decode');
+    const deserializeChunk = createJSONDeserializer(codecOptions);
+    function interpretChunk(chunk) {
+      return deserializeChunk(JSON.parse(chunk));
+    }
+    reader.drain(interpretChunk).then(() => deserializeChunk.abort(new Error("Server function stream ended unexpectedly.")), error => deserializeChunk.abort(error));
+    return interpretChunk(result.value);
+  }
+  return undefined;
+}
+async function decodeResponse(response, codecOptions) {
+  if (!response.body) return undefined;
+  return await extractBody(response, codecOptions === undefined ? codecConfig.codec : codecOptions);
+}
+async function decodeResponsePayload(response, codecOptions) {
+  const decoded = await decodeResponse(response, codecOptions);
+  if (decoded !== undefined && response.headers.has(SINGLE_FLIGHT_HEADER)) {
+    return {
+      value: decoded.value,
+      flightData: decoded.data
+    };
+  }
+  return {
+    value: decoded
+  };
+}
+
+const config = {
+  endpoint: "/_server",
+  prepareRequest: undefined,
+  responseHandler: undefined,
+  serializeArgs: undefined
+};
+function serializeArguments(args) {
+  if (!config.serializeArgs) {
+    throw new Error("Server function arguments are sent as JSON by default and these " + "arguments are not JSON-serializable. Call enableRichArguments() " + '(from "@solidjs/web/server-functions/rich-args") once at startup ' + "to send Dates, Maps, Sets, typed arrays, etc. through the codec — " + "or pass a single Blob/FormData/File argument, which has a native " + "HTTP encoding.");
+  }
+  return config.serializeArgs(args);
+}
+function configureServerFunctionsClient({
+  endpoint,
+  codec,
+  prepareRequest,
+  responseHandler,
+  serializeArgs
+} = {}) {
+  if (endpoint !== undefined) config.endpoint = endpoint;
+  if (codec !== undefined) configureServerFunctionsCodec(codec);
+  if (prepareRequest !== undefined) config.prepareRequest = prepareRequest;
+  if (responseHandler !== undefined) config.responseHandler = responseHandler;
+  if (serializeArgs !== undefined) config.serializeArgs = serializeArgs;
+}
+let INSTANCE = 0;
+let rpcProvided = false;
+function provideRPC() {
+  if (rpcProvided) return;
+  rpcProvided = true;
+  provideServerFunctionRPC({
+    GET,
+    decodeResponse
+  });
+}
+async function createRequest(base, id, instance, options, meta) {
+  const headers = {
+    ...options.headers,
+    [FUNCTION_HEADER]: id,
+    [INSTANCE_HEADER]: instance
+  };
+  if (getFlightDataConsumer() && !options.read && (!options.method || options.method.toUpperCase() !== "GET")) {
+    headers[SINGLE_FLIGHT_HEADER] = "true";
+  }
+  let init = {
+    method: "POST",
+    ...options,
+    headers
+  };
+  if (config.prepareRequest) {
+    init = (await config.prepareRequest(init, {
+      id,
+      meta
+    })) || init;
+  }
+  return fetch(base, init);
+}
+async function initializeResponse(base, id, instance, options, args, meta) {
+  if (args.length === 0) {
+    return createRequest(base, id, instance, options, meta);
+  }
+  if (args.length === 1) {
+    const result = getHeadersAndBody(args[0]);
+    if (result) {
+      return createRequest(base, id, instance, {
+        ...options,
+        body: result.body,
+        headers: {
+          ...options.headers,
+          ...result.headers
+        }
+      }, meta);
+    }
+  }
+  try {
+    if (isJSONSafe(args)) {
+      return createRequest(base, id, instance, {
+        ...options,
+        body: JSON.stringify(args),
+        headers: {
+          ...options.headers,
+          "Content-Type": "application/json",
+          [BODY_FORMAT_HEADER]: BodyFormat.Json
+        }
+      }, meta);
+    }
+  } catch {
+  }
+  if (args.length > 1) {
+    try {
+      const trailing = getHeadersAndBody(args[args.length - 1]);
+      const leading = args.slice(0, -1).map(arg => arg === undefined ? null : arg);
+      if (trailing && isJSONSafe(leading)) {
+        const target = base + (base.includes("?") ? "&" : "?") + "args=" + encodeURIComponent(JSON.stringify(leading));
+        return createRequest(target, id, instance, {
+          ...options,
+          body: trailing.body,
+          headers: {
+            ...options.headers,
+            ...trailing.headers
+          }
+        }, meta);
+      }
+    } catch {
+    }
+  }
+  return createRequest(base, id, instance, {
+    ...options,
+    body: await serializeArguments(args),
+    headers: {
+      ...options.headers,
+      "Content-Type": "text/plain",
+      [BODY_FORMAT_HEADER]: BodyFormat.Serialized
+    }
+  }, meta);
+}
+async function fetchServerFunction(base, id, options, args, meta, callArgs = args) {
+  const instance = `server-function:${INSTANCE++}`;
+  const handler = config.responseHandler;
+  const context = handler && handler.capture ? handler.capture({
+    id,
+    meta
+  }) : undefined;
+  const controller = options.signal ? undefined : new AbortController();
+  if (controller) options = {
+    ...options,
+    signal: controller.signal
+  };
+  const response = await initializeResponse(base, id, instance, options, args, meta);
+  if (handler) {
+    const handled = handler.handle(response, {
+      id,
+      meta,
+      args: callArgs,
+      context
+    });
+    if (handled !== undefined) return handled;
+  }
+  if (response.headers.has(SINGLE_FLIGHT_HEADER)) {
+    const consumer = getFlightDataConsumer();
+    if (consumer) {
+      const payload = await decodeResponse(response);
+      await consumer(payload.data, {
+        response
+      });
+      if (response.headers.has(ERROR_HEADER) && !response.headers.has("Location") && !response.headers.has(REVALIDATE_HEADER)) {
+        throw payload.value;
+      }
+      return payload.value;
+    }
+  }
+  if (response.headers.has("Location") || response.headers.has(REVALIDATE_HEADER) || response.headers.has(SINGLE_FLIGHT_HEADER)) {
+    return response;
+  }
+  const result = await decodeResponse(response.clone());
+  if (response.headers.has(ERROR_HEADER)) {
+    throw result;
+  }
+  if (controller && result?.[Symbol.asyncIterator]) {
+    return {
+      [Symbol.asyncIterator]() {
+        const it = result[Symbol.asyncIterator]();
+        return {
+          next: () => it.next(),
+          return: value => (controller.abort(), Promise.resolve({
+            done: true,
+            value
+          }))
+        };
+      }
+    };
+  }
+  return result;
+}
+function createServerReference(id, name, base) {
+  provideRPC();
+  const metadata = name === undefined ? {} : {
+    name
+  };
+  const fn = (...args) => {
+    const handler = config.responseHandler;
+    if (handler && handler.intercept) {
+      const hit = handler.intercept({
+        id,
+        meta: metadata,
+        args
+      });
+      if (hit !== undefined) return hit;
+    }
+    return fetchServerFunction(base || config.endpoint, id, {}, args, metadata);
+  };
+  fn[SERVER_FUNCTION_METADATA] = metadata;
+  return new Proxy(fn, {
+    get(target, prop) {
+      if (prop === "id") return id;
+      if (prop === "url") {
+        return base || `${config.endpoint}?id=${encodeURIComponent(id)}`;
+      }
+      return target[prop];
+    }
+  });
+}
+function GET(fn) {
+  if (!isServerFunction(fn)) {
+    throw new Error("GET expects a server function reference");
+  }
+  provideRPC();
+  const id = fn.id;
+  const metadata = {
+    ...getServerFunctionMetadata(fn)
+  };
+  const wrapped = async (...args) => {
+    const handler = config.responseHandler;
+    if (handler && handler.intercept) {
+      const hit = handler.intercept({
+        id,
+        meta: metadata,
+        args
+      });
+      if (hit !== undefined) return hit;
+    }
+    let base = `${config.endpoint}?id=${encodeURIComponent(id)}`;
+    if (args.length) {
+      const encoded = isJSONSafe(args) ? JSON.stringify(args) : await serializeArguments(args);
+      base += `&args=${encodeURIComponent(encoded)}`;
+    }
+    return fetchServerFunction(base, id, {
+      method: "GET"
+    }, [], metadata, args);
+  };
+  wrapped[SERVER_FUNCTION_METADATA] = metadata;
+  wrapped.id = id;
+  Object.defineProperty(wrapped, "url", {
+    get: () => `${config.endpoint}?id=${encodeURIComponent(id)}`,
+    configurable: true
+  });
+  return withMeta(wrapped, {
+    method: "GET"
+  });
+}
+function live(fn) {
+  if (!isServerFunction(fn)) {
+    throw new Error("live expects a server function reference");
+  }
+  const id = fn.id;
+  const metadata = {
+    ...getServerFunctionMetadata(fn),
+    live: true
+  };
+  const wrapped = (...args) => {
+    const iterable = {
+      [LIVE_SOURCE]: true,
+      [Symbol.asyncIterator]() {
+        let it;
+        let connected = false;
+        let attempts = 0;
+        let stopped = false;
+        let ended = false;
+        let timer, wake;
+        const DONE = {
+          done: true,
+          value: undefined
+        };
+        const emit = (state, error) => {
+          try {
+            iterable.onstatus && iterable.onstatus(state, error);
+          } catch {}
+        };
+        const emitClosed = () => {
+          if (ended) return;
+          ended = true;
+          emit("closed");
+        };
+        const closeIt = value => {
+          const current = it;
+          it = undefined;
+          if (current) {
+            try {
+              const r = current.return && current.return(value);
+              if (r && typeof r.then === "function") r.then(undefined, () => {});
+            } catch {}
+          }
+        };
+        const callOnce = () => {
+          if (metadata.method === "GET") return fn(...args);
+          const handler = config.responseHandler;
+          if (handler && handler.intercept) {
+            const hit = handler.intercept({
+              id,
+              meta: metadata,
+              args
+            });
+            if (hit !== undefined) return hit;
+          }
+          return fetchServerFunction(fn.url, id, {
+            read: true
+          }, args, metadata, args);
+        };
+        const pull = async () => {
+          while (!stopped) {
+            try {
+              if (!it) {
+                const result = await callOnce();
+                connected = true;
+                it = result !== null && typeof result === "object" && result[Symbol.asyncIterator] ? result[Symbol.asyncIterator]() : async function* () {
+                  yield result;
+                }();
+                if (stopped) {
+                  closeIt();
+                  return DONE;
+                }
+                emit("connected");
+              }
+              const r = await it.next();
+              if (r.done) {
+                emitClosed();
+                return DONE;
+              }
+              if (stopped) return DONE;
+              attempts = 0;
+              return r;
+            } catch (error) {
+              if (!connected) throw error;
+              it = undefined;
+              emit("reconnecting", error);
+              await new Promise(resolve => {
+                wake = resolve;
+                timer = setTimeout(resolve, Math.min(500 * 2 ** attempts++, 10000));
+                if (typeof addEventListener === "function") addEventListener("online", resolve, {
+                  once: true
+                });
+              });
+              clearTimeout(timer);
+              if (typeof removeEventListener === "function") removeEventListener("online", wake);
+              timer = wake = undefined;
+            }
+          }
+          return DONE;
+        };
+        return {
+          next: () => pull(),
+          return(value) {
+            stopped = true;
+            if (timer !== undefined) clearTimeout(timer);
+            if (wake) wake();
+            closeIt(value);
+            emitClosed();
+            return Promise.resolve({
+              done: true,
+              value
+            });
+          }
+        };
+      }
+    };
+    return iterable;
+  };
+  wrapped[SERVER_FUNCTION_METADATA] = metadata;
+  wrapped.id = id;
+  Object.defineProperty(wrapped, "url", {
+    get: () => fn.url,
+    configurable: true
+  });
+  return wrapped;
+}
+function registerServerReference() {
+  throw new Error("registerServerReference must not be called in the client build");
+}
+function getServerFunctionInvocation() {
+  return undefined;
+}
+
+export { ChunkReader, ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, GET, INSTANCE_HEADER, REVALIDATE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, configureServerFunctionsClient, createChunk, createServerReference, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, deserializeStream, encodeErrorHeaderValue, frameAddress, getFlightDataConsumer, getServerFunctionInvocation, getServerFunctionMetadata, getServerFunctionsCodec, hasFlashCookie, isServerFunction, live, registerServerReference, serializeString, subscribeFlightData, withMeta };