@prisma/param-graph 7.3.0-integration-parameterization.15 → 7.4.0-dev.22

package/dist/serialization.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Binary serialization for ParamGraph.
+ *
+ * This module handles compact binary encoding/decoding of the param graph structure.
+ * The format uses a hybrid approach: JSON string array for field names + binary blob
+ * for structural data (nodes, edges, roots).
+ *
+ * ## Serialized Representation
+ *
+ * ```
+ * SerializedParamGraph {
+ *   strings: string[]   // String table (field names, enum names, root keys)
+ *   graph: string       // Base64url-encoded binary blob
+ * }
+ * ```
+ *
+ * ## Why Hybrid?
+ *
+ * - **Strings stay as JSON**: V8's JSON.parse is highly optimized for string arrays
+ * - **Structure goes binary**: Indices, flags, masks benefit from compact encoding
+ * - **Best of both**: Fast parsing + compact size where it matters
+ *
+ * ## Variable-Length Encoding
+ *
+ * All integer values (except fixed-size fields like `scalarMask` and `flags`) use
+ * unsigned LEB128 (Little Endian Base 128) variable-length encoding:
+ *
+ * - Values 0-127: 1 byte
+ * - Values 128-16383: 2 bytes
+ * - Values 16384-2097151: 3 bytes
+ * - And so on...
+ *
+ * Optional values use value+1 encoding: 0 means "none/undefined", N+1 means actual value N.
+ *
+ * ## Binary Blob Layout
+ *
+ * ```
+ * ┌───────────────────────────────────────────────────────────────────┐
+ * │ HEADER                                                            │
+ * ├───────────────────────────────────────────────────────────────────┤
+ * │ inputNodeCount: varuint                                           │
+ * │ outputNodeCount: varuint                                          │
+ * │ rootCount: varuint                                                │
+ * └───────────────────────────────────────────────────────────────────┘
+ *
+ * ┌───────────────────────────────────────────────────────────────────┐
+ * │ INPUT NODES (repeated inputNodeCount times)                       │
+ * ├───────────────────────────────────────────────────────────────────┤
+ * │ edgeCount: varuint                                                │
+ * │ edges[]                                                           │
+ * └───────────────────────────────────────────────────────────────────┘
+ *
+ * ┌───────────────────────────────────────────────────────────────────┐
+ * │ INPUT EDGE                                                        │
+ * ├───────────────────────────────────────────────────────────────────┤
+ * │ fieldIndex: varuint                                               │
+ * │ scalarMask: u16                                                   │
+ * │ childNodeId: varuint (0=none, N+1=actual)                         │
+ * │ enumNameIndex: varuint (0=none, N+1=actual)                       │
+ * │ flags: u8                                                         │
+ * └───────────────────────────────────────────────────────────────────┘
+ *
+ * ┌───────────────────────────────────────────────────────────────────┐
+ * │ OUTPUT NODES (repeated outputNodeCount times)                     │
+ * ├───────────────────────────────────────────────────────────────────┤
+ * │ edgeCount: varuint                                                │
+ * │ edges[]                                                           │
+ * └───────────────────────────────────────────────────────────────────┘
+ *
+ * ┌───────────────────────────────────────────────────────────────────┐
+ * │ OUTPUT EDGE                                                       │
+ * ├───────────────────────────────────────────────────────────────────┤
+ * │ fieldIndex: varuint                                               │
+ * │ argsNodeId: varuint (0=none, N+1=actual)                          │
+ * │ outputNodeId: varuint (0=none, N+1=actual)                        │
+ * └───────────────────────────────────────────────────────────────────┘
+ *
+ * ┌───────────────────────────────────────────────────────────────────┐
+ * │ ROOTS (repeated rootCount times)                                  │
+ * ├───────────────────────────────────────────────────────────────────┤
+ * │ keyIndex: varuint                                                 │
+ * │ argsNodeId: varuint (0=none, N+1=actual)                          │
+ * │ outputNodeId: varuint (0=none, N+1=actual)                        │
+ * └───────────────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * ## Embedding in Generated Client
+ *
+ * ```js
+ * config.parameterizationSchema = {
+ *   strings: JSON.parse('["where","id","email",...]'),
+ *   graph: "base64url_encoded_binary_blob..."
+ * }
+ * ```
+ */
+import type { ParamGraphData } from './types';
+/**
+ * Serialized format stored in the generated client.
+ */
+export interface SerializedParamGraph {
+    /** String table (field names, enum names, root keys) */
+    strings: string[];
+    /** Base64url-encoded binary blob for structural data */
+    graph: string;
+}
+/**
+ * Serializes a ParamGraphData to the compact binary format.
+ */
+export declare function serializeParamGraph(data: ParamGraphData): SerializedParamGraph;
+/**
+ * Deserializes a binary-encoded ParamGraph.
+ */
+export declare function deserializeParamGraph(serialized: SerializedParamGraph): ParamGraphData;

package/dist/serialization.js

@@ -0,0 +1,276 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serialization_exports = {};
+__export(serialization_exports, {
+  deserializeParamGraph: () => deserializeParamGraph,
+  serializeParamGraph: () => serializeParamGraph
+});
+module.exports = __toCommonJS(serialization_exports);
+function serializeParamGraph(data) {
+  return new Serializer(data).serialize();
+}
+function deserializeParamGraph(serialized) {
+  return new Deserializer(serialized).deserialize();
+}
+function encodeBase64url(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64url");
+}
+function decodeBase64url(str) {
+  return Buffer.from(str, "base64url");
+}
+function varuintSize(value) {
+  let size = 1;
+  while (value >= 128) {
+    size++;
+    value >>>= 7;
+  }
+  return size;
+}
+class Serializer {
+  #data;
+  #buffer;
+  #view;
+  #offset = 0;
+  #rootKeys;
+  constructor(data) {
+    this.#data = data;
+    this.#rootKeys = Object.keys(data.roots);
+    const size = this.#calculateBufferSize();
+    this.#buffer = new ArrayBuffer(size);
+    this.#view = new DataView(this.#buffer);
+  }
+  serialize() {
+    this.#writeHeader();
+    this.#writeInputNodes();
+    this.#writeOutputNodes();
+    this.#writeRoots();
+    return {
+      strings: this.#data.strings,
+      graph: encodeBase64url(new Uint8Array(this.#buffer, 0, this.#offset))
+    };
+  }
+  #writeVaruint(value) {
+    while (value >= 128) {
+      this.#view.setUint8(this.#offset++, value & 127 | 128);
+      value >>>= 7;
+    }
+    this.#view.setUint8(this.#offset++, value);
+  }
+  #writeOptionalVaruint(value) {
+    this.#writeVaruint(value === void 0 ? 0 : value + 1);
+  }
+  #writeByte(value) {
+    this.#view.setUint8(this.#offset, value);
+    this.#offset += 1;
+  }
+  #writeU16(value) {
+    this.#view.setUint16(this.#offset, value, true);
+    this.#offset += 2;
+  }
+  #calculateBufferSize() {
+    let size = 0;
+    size += varuintSize(this.#data.inputNodes.length);
+    size += varuintSize(this.#data.outputNodes.length);
+    size += varuintSize(this.#rootKeys.length);
+    for (const node of this.#data.inputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      size += varuintSize(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        size += varuintSize(fieldIndex);
+        size += 2;
+        size += varuintSize(edge.childNodeId === void 0 ? 0 : edge.childNodeId + 1);
+        size += varuintSize(edge.enumNameIndex === void 0 ? 0 : edge.enumNameIndex + 1);
+        size += 1;
+      }
+    }
+    for (const node of this.#data.outputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      size += varuintSize(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        size += varuintSize(fieldIndex);
+        size += varuintSize(edge.argsNodeId === void 0 ? 0 : edge.argsNodeId + 1);
+        size += varuintSize(edge.outputNodeId === void 0 ? 0 : edge.outputNodeId + 1);
+      }
+    }
+    for (const key of this.#rootKeys) {
+      const root = this.#data.roots[key];
+      const keyIndex = this.#data.strings.indexOf(key);
+      size += varuintSize(keyIndex);
+      size += varuintSize(root.argsNodeId === void 0 ? 0 : root.argsNodeId + 1);
+      size += varuintSize(root.outputNodeId === void 0 ? 0 : root.outputNodeId + 1);
+    }
+    return size;
+  }
+  #writeHeader() {
+    this.#writeVaruint(this.#data.inputNodes.length);
+    this.#writeVaruint(this.#data.outputNodes.length);
+    this.#writeVaruint(this.#rootKeys.length);
+  }
+  #writeInputNodes() {
+    for (const node of this.#data.inputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      this.#writeVaruint(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        this.#writeVaruint(fieldIndex);
+        this.#writeU16(edge.scalarMask ?? 0);
+        this.#writeOptionalVaruint(edge.childNodeId);
+        this.#writeOptionalVaruint(edge.enumNameIndex);
+        this.#writeByte(edge.flags);
+      }
+    }
+  }
+  #writeOutputNodes() {
+    for (const node of this.#data.outputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      this.#writeVaruint(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        this.#writeVaruint(fieldIndex);
+        this.#writeOptionalVaruint(edge.argsNodeId);
+        this.#writeOptionalVaruint(edge.outputNodeId);
+      }
+    }
+  }
+  #writeRoots() {
+    for (const key of this.#rootKeys) {
+      const root = this.#data.roots[key];
+      const keyIndex = this.#data.strings.indexOf(key);
+      if (keyIndex === -1) {
+        throw new Error(`Root key "${key}" not found in strings table`);
+      }
+      this.#writeVaruint(keyIndex);
+      this.#writeOptionalVaruint(root.argsNodeId);
+      this.#writeOptionalVaruint(root.outputNodeId);
+    }
+  }
+}
+class Deserializer {
+  #serialized;
+  #view;
+  #offset = 0;
+  constructor(serialized) {
+    this.#serialized = serialized;
+    const bytes = decodeBase64url(serialized.graph);
+    this.#view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  deserialize() {
+    const { inputNodeCount, outputNodeCount, rootCount } = this.#readHeader();
+    const inputNodes = this.#readInputNodes(inputNodeCount);
+    const outputNodes = this.#readOutputNodes(outputNodeCount);
+    const roots = this.#readRoots(rootCount);
+    return {
+      strings: this.#serialized.strings,
+      inputNodes,
+      outputNodes,
+      roots
+    };
+  }
+  #readVaruint() {
+    let value = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = this.#view.getUint8(this.#offset++);
+      value |= (byte & 127) << shift;
+      shift += 7;
+    } while (byte >= 128);
+    return value;
+  }
+  #readOptionalVaruint() {
+    const value = this.#readVaruint();
+    return value === 0 ? void 0 : value - 1;
+  }
+  #readByte() {
+    const value = this.#view.getUint8(this.#offset);
+    this.#offset += 1;
+    return value;
+  }
+  #readU16() {
+    const value = this.#view.getUint16(this.#offset, true);
+    this.#offset += 2;
+    return value;
+  }
+  #readHeader() {
+    const inputNodeCount = this.#readVaruint();
+    const outputNodeCount = this.#readVaruint();
+    const rootCount = this.#readVaruint();
+    return { inputNodeCount, outputNodeCount, rootCount };
+  }
+  #readInputNodes(count) {
+    const inputNodes = [];
+    for (let i = 0; i < count; i++) {
+      const edgeCount = this.#readVaruint();
+      const edges = {};
+      for (let j = 0; j < edgeCount; j++) {
+        const fieldIndex = this.#readVaruint();
+        const scalarMask = this.#readU16();
+        const childNodeId = this.#readOptionalVaruint();
+        const enumNameIndex = this.#readOptionalVaruint();
+        const flags = this.#readByte();
+        const edge = { flags };
+        if (scalarMask !== 0) edge.scalarMask = scalarMask;
+        if (childNodeId !== void 0) edge.childNodeId = childNodeId;
+        if (enumNameIndex !== void 0) edge.enumNameIndex = enumNameIndex;
+        edges[fieldIndex] = edge;
+      }
+      inputNodes.push({ edges });
+    }
+    return inputNodes;
+  }
+  #readOutputNodes(count) {
+    const outputNodes = [];
+    for (let i = 0; i < count; i++) {
+      const edgeCount = this.#readVaruint();
+      const edges = {};
+      for (let j = 0; j < edgeCount; j++) {
+        const fieldIndex = this.#readVaruint();
+        const argsNodeId = this.#readOptionalVaruint();
+        const outputNodeId = this.#readOptionalVaruint();
+        const edge = {};
+        if (argsNodeId !== void 0) edge.argsNodeId = argsNodeId;
+        if (outputNodeId !== void 0) edge.outputNodeId = outputNodeId;
+        edges[fieldIndex] = edge;
+      }
+      outputNodes.push({ edges });
+    }
+    return outputNodes;
+  }
+  #readRoots(count) {
+    const roots = {};
+    for (let i = 0; i < count; i++) {
+      const keyIndex = this.#readVaruint();
+      const argsNodeId = this.#readOptionalVaruint();
+      const outputNodeId = this.#readOptionalVaruint();
+      const key = this.#serialized.strings[keyIndex];
+      const root = {};
+      if (argsNodeId !== void 0) root.argsNodeId = argsNodeId;
+      if (outputNodeId !== void 0) root.outputNodeId = outputNodeId;
+      roots[key] = root;
+    }
+    return roots;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deserializeParamGraph,
+  serializeParamGraph
+});

package/dist/serialization.mjs

@@ -0,0 +1,251 @@
+function serializeParamGraph(data) {
+  return new Serializer(data).serialize();
+}
+function deserializeParamGraph(serialized) {
+  return new Deserializer(serialized).deserialize();
+}
+function encodeBase64url(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64url");
+}
+function decodeBase64url(str) {
+  return Buffer.from(str, "base64url");
+}
+function varuintSize(value) {
+  let size = 1;
+  while (value >= 128) {
+    size++;
+    value >>>= 7;
+  }
+  return size;
+}
+class Serializer {
+  #data;
+  #buffer;
+  #view;
+  #offset = 0;
+  #rootKeys;
+  constructor(data) {
+    this.#data = data;
+    this.#rootKeys = Object.keys(data.roots);
+    const size = this.#calculateBufferSize();
+    this.#buffer = new ArrayBuffer(size);
+    this.#view = new DataView(this.#buffer);
+  }
+  serialize() {
+    this.#writeHeader();
+    this.#writeInputNodes();
+    this.#writeOutputNodes();
+    this.#writeRoots();
+    return {
+      strings: this.#data.strings,
+      graph: encodeBase64url(new Uint8Array(this.#buffer, 0, this.#offset))
+    };
+  }
+  #writeVaruint(value) {
+    while (value >= 128) {
+      this.#view.setUint8(this.#offset++, value & 127 | 128);
+      value >>>= 7;
+    }
+    this.#view.setUint8(this.#offset++, value);
+  }
+  #writeOptionalVaruint(value) {
+    this.#writeVaruint(value === void 0 ? 0 : value + 1);
+  }
+  #writeByte(value) {
+    this.#view.setUint8(this.#offset, value);
+    this.#offset += 1;
+  }
+  #writeU16(value) {
+    this.#view.setUint16(this.#offset, value, true);
+    this.#offset += 2;
+  }
+  #calculateBufferSize() {
+    let size = 0;
+    size += varuintSize(this.#data.inputNodes.length);
+    size += varuintSize(this.#data.outputNodes.length);
+    size += varuintSize(this.#rootKeys.length);
+    for (const node of this.#data.inputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      size += varuintSize(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        size += varuintSize(fieldIndex);
+        size += 2;
+        size += varuintSize(edge.childNodeId === void 0 ? 0 : edge.childNodeId + 1);
+        size += varuintSize(edge.enumNameIndex === void 0 ? 0 : edge.enumNameIndex + 1);
+        size += 1;
+      }
+    }
+    for (const node of this.#data.outputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      size += varuintSize(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        size += varuintSize(fieldIndex);
+        size += varuintSize(edge.argsNodeId === void 0 ? 0 : edge.argsNodeId + 1);
+        size += varuintSize(edge.outputNodeId === void 0 ? 0 : edge.outputNodeId + 1);
+      }
+    }
+    for (const key of this.#rootKeys) {
+      const root = this.#data.roots[key];
+      const keyIndex = this.#data.strings.indexOf(key);
+      size += varuintSize(keyIndex);
+      size += varuintSize(root.argsNodeId === void 0 ? 0 : root.argsNodeId + 1);
+      size += varuintSize(root.outputNodeId === void 0 ? 0 : root.outputNodeId + 1);
+    }
+    return size;
+  }
+  #writeHeader() {
+    this.#writeVaruint(this.#data.inputNodes.length);
+    this.#writeVaruint(this.#data.outputNodes.length);
+    this.#writeVaruint(this.#rootKeys.length);
+  }
+  #writeInputNodes() {
+    for (const node of this.#data.inputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      this.#writeVaruint(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        this.#writeVaruint(fieldIndex);
+        this.#writeU16(edge.scalarMask ?? 0);
+        this.#writeOptionalVaruint(edge.childNodeId);
+        this.#writeOptionalVaruint(edge.enumNameIndex);
+        this.#writeByte(edge.flags);
+      }
+    }
+  }
+  #writeOutputNodes() {
+    for (const node of this.#data.outputNodes) {
+      const fieldIndices = Object.keys(node.edges).map(Number);
+      this.#writeVaruint(fieldIndices.length);
+      for (const fieldIndex of fieldIndices) {
+        const edge = node.edges[fieldIndex];
+        this.#writeVaruint(fieldIndex);
+        this.#writeOptionalVaruint(edge.argsNodeId);
+        this.#writeOptionalVaruint(edge.outputNodeId);
+      }
+    }
+  }
+  #writeRoots() {
+    for (const key of this.#rootKeys) {
+      const root = this.#data.roots[key];
+      const keyIndex = this.#data.strings.indexOf(key);
+      if (keyIndex === -1) {
+        throw new Error(`Root key "${key}" not found in strings table`);
+      }
+      this.#writeVaruint(keyIndex);
+      this.#writeOptionalVaruint(root.argsNodeId);
+      this.#writeOptionalVaruint(root.outputNodeId);
+    }
+  }
+}
+class Deserializer {
+  #serialized;
+  #view;
+  #offset = 0;
+  constructor(serialized) {
+    this.#serialized = serialized;
+    const bytes = decodeBase64url(serialized.graph);
+    this.#view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  deserialize() {
+    const { inputNodeCount, outputNodeCount, rootCount } = this.#readHeader();
+    const inputNodes = this.#readInputNodes(inputNodeCount);
+    const outputNodes = this.#readOutputNodes(outputNodeCount);
+    const roots = this.#readRoots(rootCount);
+    return {
+      strings: this.#serialized.strings,
+      inputNodes,
+      outputNodes,
+      roots
+    };
+  }
+  #readVaruint() {
+    let value = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = this.#view.getUint8(this.#offset++);
+      value |= (byte & 127) << shift;
+      shift += 7;
+    } while (byte >= 128);
+    return value;
+  }
+  #readOptionalVaruint() {
+    const value = this.#readVaruint();
+    return value === 0 ? void 0 : value - 1;
+  }
+  #readByte() {
+    const value = this.#view.getUint8(this.#offset);
+    this.#offset += 1;
+    return value;
+  }
+  #readU16() {
+    const value = this.#view.getUint16(this.#offset, true);
+    this.#offset += 2;
+    return value;
+  }
+  #readHeader() {
+    const inputNodeCount = this.#readVaruint();
+    const outputNodeCount = this.#readVaruint();
+    const rootCount = this.#readVaruint();
+    return { inputNodeCount, outputNodeCount, rootCount };
+  }
+  #readInputNodes(count) {
+    const inputNodes = [];
+    for (let i = 0; i < count; i++) {
+      const edgeCount = this.#readVaruint();
+      const edges = {};
+      for (let j = 0; j < edgeCount; j++) {
+        const fieldIndex = this.#readVaruint();
+        const scalarMask = this.#readU16();
+        const childNodeId = this.#readOptionalVaruint();
+        const enumNameIndex = this.#readOptionalVaruint();
+        const flags = this.#readByte();
+        const edge = { flags };
+        if (scalarMask !== 0) edge.scalarMask = scalarMask;
+        if (childNodeId !== void 0) edge.childNodeId = childNodeId;
+        if (enumNameIndex !== void 0) edge.enumNameIndex = enumNameIndex;
+        edges[fieldIndex] = edge;
+      }
+      inputNodes.push({ edges });
+    }
+    return inputNodes;
+  }
+  #readOutputNodes(count) {
+    const outputNodes = [];
+    for (let i = 0; i < count; i++) {
+      const edgeCount = this.#readVaruint();
+      const edges = {};
+      for (let j = 0; j < edgeCount; j++) {
+        const fieldIndex = this.#readVaruint();
+        const argsNodeId = this.#readOptionalVaruint();
+        const outputNodeId = this.#readOptionalVaruint();
+        const edge = {};
+        if (argsNodeId !== void 0) edge.argsNodeId = argsNodeId;
+        if (outputNodeId !== void 0) edge.outputNodeId = outputNodeId;
+        edges[fieldIndex] = edge;
+      }
+      outputNodes.push({ edges });
+    }
+    return outputNodes;
+  }
+  #readRoots(count) {
+    const roots = {};
+    for (let i = 0; i < count; i++) {
+      const keyIndex = this.#readVaruint();
+      const argsNodeId = this.#readOptionalVaruint();
+      const outputNodeId = this.#readOptionalVaruint();
+      const key = this.#serialized.strings[keyIndex];
+      const root = {};
+      if (argsNodeId !== void 0) root.argsNodeId = argsNodeId;
+      if (outputNodeId !== void 0) root.outputNodeId = outputNodeId;
+      roots[key] = root;
+    }
+    return roots;
+  }
+}
+export {
+  deserializeParamGraph,
+  serializeParamGraph
+};

package/dist/serialization.test.d.ts

@@ -0,0 +1 @@
+export {};