@visulima/crud 1.0.0

package/dist/next/index.mjs

@@ -0,0 +1,729 @@
+import {
+  __commonJS,
+  __toESM,
+  get_accessible_routes_default
+} from "../chunk-UBXIGP5H.mjs";
+
+// ../../node_modules/.pnpm/next@12.3.1/node_modules/next/dist/compiled/cookie/index.js
+var require_cookie = __commonJS({
+  "../../node_modules/.pnpm/next@12.3.1/node_modules/next/dist/compiled/cookie/index.js"(exports, module) {
+    (() => {
+      "use strict";
+      if (typeof __nccwpck_require__ !== "undefined")
+        __nccwpck_require__.ab = __dirname + "/";
+      var e = {};
+      (() => {
+        var r = e;
+        r.parse = parse2;
+        r.serialize = serialize;
+        var i = decodeURIComponent;
+        var t = encodeURIComponent;
+        var a = /; */;
+        var n = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+        function parse2(e2, r2) {
+          if (typeof e2 !== "string") {
+            throw new TypeError("argument str must be a string");
+          }
+          var t2 = {};
+          var n2 = r2 || {};
+          var o = e2.split(a);
+          var s = n2.decode || i;
+          for (var p = 0; p < o.length; p++) {
+            var f = o[p];
+            var u = f.indexOf("=");
+            if (u < 0) {
+              continue;
+            }
+            var v = f.substr(0, u).trim();
+            var c = f.substr(++u, f.length).trim();
+            if ('"' == c[0]) {
+              c = c.slice(1, -1);
+            }
+            if (void 0 == t2[v]) {
+              t2[v] = tryDecode(c, s);
+            }
+          }
+          return t2;
+        }
+        function serialize(e2, r2, i2) {
+          var a2 = i2 || {};
+          var o = a2.encode || t;
+          if (typeof o !== "function") {
+            throw new TypeError("option encode is invalid");
+          }
+          if (!n.test(e2)) {
+            throw new TypeError("argument name is invalid");
+          }
+          var s = o(r2);
+          if (s && !n.test(s)) {
+            throw new TypeError("argument val is invalid");
+          }
+          var p = e2 + "=" + s;
+          if (null != a2.maxAge) {
+            var f = a2.maxAge - 0;
+            if (isNaN(f) || !isFinite(f)) {
+              throw new TypeError("option maxAge is invalid");
+            }
+            p += "; Max-Age=" + Math.floor(f);
+          }
+          if (a2.domain) {
+            if (!n.test(a2.domain)) {
+              throw new TypeError("option domain is invalid");
+            }
+            p += "; Domain=" + a2.domain;
+          }
+          if (a2.path) {
+            if (!n.test(a2.path)) {
+              throw new TypeError("option path is invalid");
+            }
+            p += "; Path=" + a2.path;
+          }
+          if (a2.expires) {
+            if (typeof a2.expires.toUTCString !== "function") {
+              throw new TypeError("option expires is invalid");
+            }
+            p += "; Expires=" + a2.expires.toUTCString();
+          }
+          if (a2.httpOnly) {
+            p += "; HttpOnly";
+          }
+          if (a2.secure) {
+            p += "; Secure";
+          }
+          if (a2.sameSite) {
+            var u = typeof a2.sameSite === "string" ? a2.sameSite.toLowerCase() : a2.sameSite;
+            switch (u) {
+              case true:
+                p += "; SameSite=Strict";
+                break;
+              case "lax":
+                p += "; SameSite=Lax";
+                break;
+              case "strict":
+                p += "; SameSite=Strict";
+                break;
+              case "none":
+                p += "; SameSite=None";
+                break;
+              default:
+                throw new TypeError("option sameSite is invalid");
+            }
+          }
+          return p;
+        }
+        function tryDecode(e2, r2) {
+          try {
+            return r2(e2);
+          } catch (r3) {
+            return e2;
+          }
+        }
+      })();
+      module.exports = e;
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/next@12.3.1/node_modules/next/dist/server/api-utils/index.js
+var require_api_utils = __commonJS({
+  "../../node_modules/.pnpm/next@12.3.1/node_modules/next/dist/server/api-utils/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.getCookieParser = getCookieParser;
+    exports.sendStatusCode = sendStatusCode;
+    exports.redirect = redirect;
+    exports.checkIsManualRevalidate = checkIsManualRevalidate;
+    exports.clearPreviewData = clearPreviewData;
+    exports.sendError = sendError;
+    exports.setLazyProp = setLazyProp;
+    exports.SYMBOL_CLEARED_COOKIES = exports.SYMBOL_PREVIEW_DATA = exports.RESPONSE_LIMIT_DEFAULT = exports.COOKIE_NAME_PRERENDER_DATA = exports.COOKIE_NAME_PRERENDER_BYPASS = exports.PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = exports.PRERENDER_REVALIDATE_HEADER = void 0;
+    function getCookieParser(headers) {
+      return function parseCookie() {
+        const header = headers.cookie;
+        if (!header) {
+          return {};
+        }
+        const { parse: parseCookieFn } = require_cookie();
+        return parseCookieFn(Array.isArray(header) ? header.join(";") : header);
+      };
+    }
+    function sendStatusCode(res, statusCode) {
+      res.statusCode = statusCode;
+      return res;
+    }
+    function redirect(res, statusOrUrl, url) {
+      if (typeof statusOrUrl === "string") {
+        url = statusOrUrl;
+        statusOrUrl = 307;
+      }
+      if (typeof statusOrUrl !== "number" || typeof url !== "string") {
+        throw new Error(`Invalid redirect arguments. Please use a single argument URL, e.g. res.redirect('/destination') or use a status code and URL, e.g. res.redirect(307, '/destination').`);
+      }
+      res.writeHead(statusOrUrl, {
+        Location: url
+      });
+      res.write(url);
+      res.end();
+      return res;
+    }
+    var PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+    exports.PRERENDER_REVALIDATE_HEADER = PRERENDER_REVALIDATE_HEADER;
+    var PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = "x-prerender-revalidate-if-generated";
+    exports.PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER;
+    function checkIsManualRevalidate(req, previewProps) {
+      return {
+        isManualRevalidate: req.headers[PRERENDER_REVALIDATE_HEADER] === previewProps.previewModeId,
+        revalidateOnlyGenerated: !!req.headers[PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER]
+      };
+    }
+    var COOKIE_NAME_PRERENDER_BYPASS = `__prerender_bypass`;
+    exports.COOKIE_NAME_PRERENDER_BYPASS = COOKIE_NAME_PRERENDER_BYPASS;
+    var COOKIE_NAME_PRERENDER_DATA = `__next_preview_data`;
+    exports.COOKIE_NAME_PRERENDER_DATA = COOKIE_NAME_PRERENDER_DATA;
+    var RESPONSE_LIMIT_DEFAULT = 4 * 1024 * 1024;
+    exports.RESPONSE_LIMIT_DEFAULT = RESPONSE_LIMIT_DEFAULT;
+    var SYMBOL_PREVIEW_DATA = Symbol(COOKIE_NAME_PRERENDER_DATA);
+    exports.SYMBOL_PREVIEW_DATA = SYMBOL_PREVIEW_DATA;
+    var SYMBOL_CLEARED_COOKIES = Symbol(COOKIE_NAME_PRERENDER_BYPASS);
+    exports.SYMBOL_CLEARED_COOKIES = SYMBOL_CLEARED_COOKIES;
+    function clearPreviewData(res, options = {}) {
+      if (SYMBOL_CLEARED_COOKIES in res) {
+        return res;
+      }
+      const { serialize } = require_cookie();
+      const previous = res.getHeader("Set-Cookie");
+      res.setHeader(`Set-Cookie`, [
+        ...typeof previous === "string" ? [
+          previous
+        ] : Array.isArray(previous) ? previous : [],
+        serialize(COOKIE_NAME_PRERENDER_BYPASS, "", {
+          expires: new Date(0),
+          httpOnly: true,
+          sameSite: false ? "none" : "lax",
+          secure: false,
+          path: "/",
+          ...options.path !== void 0 ? {
+            path: options.path
+          } : void 0
+        }),
+        serialize(COOKIE_NAME_PRERENDER_DATA, "", {
+          expires: new Date(0),
+          httpOnly: true,
+          sameSite: false ? "none" : "lax",
+          secure: false,
+          path: "/",
+          ...options.path !== void 0 ? {
+            path: options.path
+          } : void 0
+        })
+      ]);
+      Object.defineProperty(res, SYMBOL_CLEARED_COOKIES, {
+        value: true,
+        enumerable: false
+      });
+      return res;
+    }
+    var ApiError2 = class extends Error {
+      constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+      }
+    };
+    exports.ApiError = ApiError2;
+    function sendError(res, statusCode, message) {
+      res.statusCode = statusCode;
+      res.statusMessage = message;
+      res.end(message);
+    }
+    function setLazyProp({ req }, prop, getter) {
+      const opts = {
+        configurable: true,
+        enumerable: true
+      };
+      const optsReset = {
+        ...opts,
+        writable: true
+      };
+      Object.defineProperty(req, prop, {
+        ...opts,
+        get: () => {
+          const value = getter();
+          Object.defineProperty(req, prop, {
+            ...optsReset,
+            value
+          });
+          return value;
+        },
+        set: (value) => {
+          Object.defineProperty(req, prop, {
+            ...optsReset,
+            value
+          });
+        }
+      });
+    }
+  }
+});
+
+// src/base-crud-handler.ts
+var import_api_utils = __toESM(require_api_utils());
+import createHttpError5 from "http-errors";
+
+// src/handler/create.ts
+var createHandler = async ({
+  adapter,
+  query,
+  resourceName,
+  request
+}) => {
+  const resources = await adapter.create(resourceName, request.body, query);
+  return {
+    data: resources,
+    status: 201
+  };
+};
+var create_default = createHandler;
+
+// src/handler/delete.ts
+import createHttpError from "http-errors";
+var deleteHandler = async ({
+  adapter,
+  query,
+  resourceName,
+  resourceId
+}) => {
+  const resource = await adapter.getOne(resourceName, resourceId, query);
+  if (resource) {
+    const deletedResource = await adapter.delete(resourceName, resourceId, query);
+    return {
+      data: deletedResource,
+      status: 200
+    };
+  }
+  throw createHttpError(404, `${resourceName} ${resourceId} not found`);
+};
+var delete_default = deleteHandler;
+
+// src/handler/list.ts
+import { paginate } from "@visulima/pagination";
+var listHandler = async ({
+  adapter,
+  query,
+  resourceName,
+  pagination
+}) => {
+  let isPaginated = false;
+  let paginationOptions;
+  if (typeof (query == null ? void 0 : query.page) !== "undefined") {
+    if ((query == null ? void 0 : query.page) <= 0) {
+      throw new Error("page query must be a strictly positive number");
+    }
+    paginationOptions = {
+      page: query == null ? void 0 : query.page,
+      perPage: (query == null ? void 0 : query.limit) || pagination.perPage
+    };
+  }
+  if (paginationOptions) {
+    isPaginated = true;
+    query.skip = (paginationOptions.page - 1) * paginationOptions.perPage;
+    query.limit = paginationOptions.perPage;
+  }
+  const resources = await adapter.getAll(resourceName, query);
+  if (isPaginated) {
+    const { page, total } = await adapter.getPaginationData(resourceName, query);
+    const paginator = paginate(page, paginationOptions.perPage, total, resources);
+    return {
+      data: paginator.toJSON(),
+      status: 200
+    };
+  }
+  return {
+    data: resources,
+    status: 200
+  };
+};
+var list_default = listHandler;
+
+// src/handler/read.ts
+import createHttpError2 from "http-errors";
+var readHandler = async ({
+  adapter,
+  query,
+  resourceName,
+  resourceId
+}) => {
+  const resource = await adapter.getOne(resourceName, resourceId, query);
+  if (!resource) {
+    throw createHttpError2(404, `${resourceName} ${resourceId} not found`);
+  }
+  return {
+    data: resource,
+    status: 200
+  };
+};
+var read_default = readHandler;
+
+// src/handler/update.ts
+import createHttpError3 from "http-errors";
+var updateHandler = async ({
+  adapter,
+  query,
+  resourceName,
+  resourceId,
+  request
+}) => {
+  const resource = await adapter.getOne(resourceName, resourceId, query);
+  if (resource) {
+    const updatedResource = await adapter.update(resourceName, resourceId, request.body, query);
+    return {
+      status: 201,
+      data: updatedResource
+    };
+  }
+  throw createHttpError3(404, `${resourceName} ${resourceId} not found`);
+};
+var update_default = updateHandler;
+
+// src/query-parser.ts
+import set from "lodash.set";
+import { parse } from "qs";
+var parseRecursive = (select) => {
+  if (typeof select === "string") {
+    const selectFields = {};
+    const fields = select.split(",");
+    fields.forEach((field) => {
+      set(selectFields, field, true);
+    });
+    return selectFields;
+  }
+  throw new Error("select query param must be a string");
+};
+var parseWhere = (where) => {
+  const whereObject = JSON.parse(where);
+  const parsed = {};
+  Object.keys(whereObject).forEach((key) => {
+    set(parsed, key, whereObject[key]);
+  });
+  return parsed;
+};
+var parseOrderBy = (orderBy) => {
+  const parsed = {};
+  const orderByObject = JSON.parse(orderBy);
+  if (Object.keys(orderByObject).length > 0) {
+    const key = Object.keys(orderByObject)[0];
+    if (orderByObject[key] === "$asc" || orderByObject[key] === "$desc") {
+      parsed[key] = orderByObject[key];
+    }
+  }
+  if (Object.keys(parsed).length !== 1) {
+    throw new Error("orderBy needs to be an object with exactly 1 property with either $asc or $desc value");
+  }
+  return parsed;
+};
+var parseQuery = (queryString) => {
+  if (queryString) {
+    const query = parse(queryString);
+    const parsedQuery = {};
+    if (query.select) {
+      parsedQuery.select = parseRecursive(query.select);
+    }
+    if (query.include) {
+      parsedQuery.include = parseRecursive(query.include);
+    }
+    if (query.where) {
+      parsedQuery.where = parseWhere(query.where);
+    }
+    if (query.orderBy) {
+      parsedQuery.orderBy = parseOrderBy(query.orderBy);
+    }
+    if (typeof query.limit !== "undefined") {
+      parsedQuery.limit = Number.isFinite(+query.limit) ? +query.limit : void 0;
+    }
+    if (typeof query.skip !== "undefined") {
+      parsedQuery.skip = Number.isFinite(+query.skip) ? +query.skip : void 0;
+    }
+    if (query.distinct) {
+      parsedQuery.distinct = query.distinct;
+    }
+    if (query.page) {
+      parsedQuery.page = Number.isFinite(+query.page) ? +query.page : void 0;
+    }
+    return {
+      originalQuery: query,
+      ...parsedQuery
+    };
+  }
+  return {};
+};
+var query_parser_default = parseQuery;
+
+// src/utils/format-resource-id.ts
+var formatResourceId = (resourceId) => Number.isSafeInteger(+resourceId) ? +resourceId : resourceId;
+var format_resource_id_default = formatResourceId;
+
+// src/utils/get-resource-name-from-url.ts
+var ensureCamelCase = (string_) => `${string_.charAt(0).toLowerCase()}${string_.slice(1)}`;
+var getResourceNameFromUrl = (url, models) => {
+  const realPath = url.split("?")[0];
+  if (typeof realPath === "undefined") {
+    throw new TypeError("Path is undefined");
+  }
+  const modelName = Object.keys(models).find((name) => {
+    const routeName = models[name];
+    const camelCaseModel = ensureCamelCase(routeName);
+    return new RegExp(`(${routeName}|${camelCaseModel}$)|(${routeName}|${camelCaseModel}/)`, "g").test(realPath);
+  });
+  return {
+    modelName,
+    resourceName: models[modelName]
+  };
+};
+
+// src/utils/get-route-type.ts
+import { match } from "path-to-regexp";
+var getRouteType = (method, url, resourceName) => {
+  const realPath = url.split("?")[0];
+  if (typeof realPath === "undefined") {
+    throw new TypeError("Path is undefined");
+  }
+  if (!realPath.includes(`/${resourceName}`)) {
+    throw new Error(`invalid resource name '${resourceName}' for route '${realPath}'`);
+  }
+  const entityMatcher = match([`/(.*)/${resourceName}`, `/(.*)/${resourceName}/:id`], { decode: decodeURIComponent });
+  const simpleMatcher = match(`/(.*)/${resourceName}`, {
+    decode: decodeURIComponent
+  });
+  switch (method) {
+    case "GET": {
+      const pathMatch = entityMatcher(realPath);
+      if (pathMatch && pathMatch.params.id) {
+        return {
+          routeType: "READ_ONE" /* READ_ONE */,
+          resourceId: pathMatch.params.id
+        };
+      }
+      return {
+        routeType: "READ_ALL" /* READ_ALL */
+      };
+    }
+    case "POST": {
+      const pathMatch = simpleMatcher(realPath);
+      if (pathMatch) {
+        return {
+          routeType: "CREATE" /* CREATE */
+        };
+      }
+      return {
+        routeType: null
+      };
+    }
+    case "PUT":
+    case "PATCH": {
+      const pathMatch = entityMatcher(realPath);
+      if (pathMatch && pathMatch.params.id) {
+        return {
+          routeType: "UPDATE" /* UPDATE */,
+          resourceId: pathMatch.params.id
+        };
+      }
+      return {
+        routeType: null
+      };
+    }
+    case "DELETE": {
+      const pathMatch = entityMatcher(realPath);
+      if (pathMatch && pathMatch.params.id) {
+        return {
+          routeType: "DELETE" /* DELETE */,
+          resourceId: pathMatch.params.id
+        };
+      }
+      return {
+        routeType: null
+      };
+    }
+    default: {
+      return {
+        routeType: null
+      };
+    }
+  }
+};
+var get_route_type_default = getRouteType;
+
+// src/utils/validate-adapter-methods.ts
+import createHttpError4 from "http-errors";
+var adapterMethods = ["create"];
+var validateAdapterMethods = (adapter) => {
+  adapterMethods.forEach((method) => {
+    if (!adapter[method]) {
+      throw createHttpError4(500, `Adapter must implement the "${method}" method.`);
+    }
+  });
+};
+var validate_adapter_methods_default = validateAdapterMethods;
+
+// src/base-crud-handler.ts
+async function baseHandler(responseExecutor, finalExecutor, adapter, options) {
+  var _a, _b;
+  try {
+    validate_adapter_methods_default(adapter);
+  } catch (error_) {
+    const error = error_;
+    throw new import_api_utils.ApiError(error.statusCode, error.message);
+  }
+  await ((_a = adapter.init) == null ? void 0 : _a.call(adapter));
+  const config = {
+    formatResourceId: format_resource_id_default,
+    pagination: {
+      perPage: 20
+    },
+    ...options
+  };
+  const routeNames = await ((_b = adapter.mapModelsToRouteNames) == null ? void 0 : _b.call(adapter));
+  const modelRoutes = {};
+  adapter.getModels().forEach((modelName) => {
+    var _a2, _b2;
+    modelRoutes[modelName] = ((_b2 = (_a2 = config == null ? void 0 : config.models) == null ? void 0 : _a2[modelName]) == null ? void 0 : _b2.name) || (routeNames == null ? void 0 : routeNames[modelName]) || modelName;
+  });
+  return async (request, responseOrContext) => {
+    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j;
+    const { resourceName, modelName } = getResourceNameFromUrl(request.url, modelRoutes);
+    if (!resourceName) {
+      if (true) {
+        const mappedModels = await ((_a2 = adapter.mapModelsToRouteNames) == null ? void 0 : _a2.call(adapter));
+        if (typeof mappedModels === "object") {
+          throw createHttpError5(404, `Resource not found, possible models: ${Object.values(mappedModels).join(", ")}`);
+        }
+      }
+      throw createHttpError5(404, `Resource not found: ${request.url}`);
+    }
+    const { routeType, resourceId } = get_route_type_default(request.method, request.url, resourceName);
+    if (routeType === null) {
+      throw createHttpError5(404, `Route not found: ${request.url}`);
+    }
+    const modelConfig = (_b2 = options == null ? void 0 : options.models) == null ? void 0 : _b2[modelName];
+    const accessibleRoutes = get_accessible_routes_default(modelConfig == null ? void 0 : modelConfig.only, modelConfig == null ? void 0 : modelConfig.exclude, (options == null ? void 0 : options.exposeStrategy) || "all");
+    if (!accessibleRoutes.includes(routeType)) {
+      throw createHttpError5(404, `Route not found: ${request.url}`);
+    }
+    try {
+      const resourceIdFormatted = ((_c = modelConfig == null ? void 0 : modelConfig.formatResourceId) == null ? void 0 : _c.call(modelConfig, resourceId)) ?? config.formatResourceId(resourceId);
+      await ((_d = adapter.connect) == null ? void 0 : _d.call(adapter));
+      const parsedQuery = query_parser_default(request.url.split("?")[1]);
+      const parameters = {
+        adapter,
+        query: adapter.parseQuery(modelName, parsedQuery),
+        resourceName: modelName
+      };
+      try {
+        let responseConfig;
+        switch (routeType) {
+          case "READ_ONE" /* READ_ONE */: {
+            responseConfig = await (((_e = config == null ? void 0 : config.handlers) == null ? void 0 : _e.get) || read_default)({
+              ...parameters,
+              resourceId: resourceIdFormatted
+            });
+            break;
+          }
+          case "READ_ALL" /* READ_ALL */: {
+            responseConfig = await (((_f = config == null ? void 0 : config.handlers) == null ? void 0 : _f.list) || list_default)({
+              ...parameters,
+              query: {
+                ...parameters.query,
+                page: parsedQuery.page ? Number(parsedQuery.page) : void 0,
+                limit: parsedQuery.limit ? Number(parsedQuery.limit) : void 0
+              },
+              pagination: config.pagination
+            });
+            break;
+          }
+          case "CREATE" /* CREATE */: {
+            responseConfig = await (((_g = config == null ? void 0 : config.handlers) == null ? void 0 : _g.create) || create_default)({
+              ...parameters,
+              request
+            });
+            break;
+          }
+          case "UPDATE" /* UPDATE */: {
+            responseConfig = await (((_h = config == null ? void 0 : config.handlers) == null ? void 0 : _h.update) || update_default)({
+              ...parameters,
+              resourceId: resourceIdFormatted,
+              request
+            });
+            break;
+          }
+          case "DELETE" /* DELETE */: {
+            responseConfig = await (((_i = config == null ? void 0 : config.handlers) == null ? void 0 : _i.delete) || delete_default)({
+              ...parameters,
+              resourceId: resourceIdFormatted
+            });
+            break;
+          }
+          default: {
+            responseConfig = {
+              status: 404,
+              data: "Method not found"
+            };
+          }
+        }
+        await responseExecutor(responseOrContext, responseConfig);
+      } catch (error) {
+        if (adapter.handleError && !(error instanceof import_api_utils.ApiError)) {
+          adapter.handleError(error);
+        } else {
+          throw error;
+        }
+      }
+    } finally {
+      await ((_j = adapter.disconnect) == null ? void 0 : _j.call(adapter));
+      await finalExecutor(responseOrContext);
+    }
+  };
+}
+var base_crud_handler_default = baseHandler;
+
+// src/next/api/edge/index.ts
+async function handler(adapter, options) {
+  return base_crud_handler_default(
+    async (_, responseConfig) => new Response(JSON.stringify(responseConfig.data), {
+      status: responseConfig.status,
+      headers: {
+        "content-type": "application/json; charset=utf-8"
+      }
+    }),
+    async () => {
+    },
+    adapter,
+    options
+  );
+}
+var edge_default = handler;
+
+// src/next/api/node/index.ts
+async function handler2(adapter, options) {
+  return base_crud_handler_default(
+    async (response, responseConfig) => {
+      response.status(responseConfig.status).send(responseConfig.data);
+    },
+    async (response) => {
+      response.end();
+    },
+    adapter,
+    options
+  );
+}
+var node_default = handler2;
+export {
+  edge_default as edgeHandler,
+  node_default as nodeHandler
+};
+/*!
+ * cookie
+ * Copyright(c) 2012-2014 Roman Shtylman
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+//# sourceMappingURL=index.mjs.map