@datawheel/bespoke 0.1.0

package/dist/server.js

@@ -0,0 +1,2944 @@
+import * as pg from "pg";
+import { DataTypes, Model, Sequelize, Error as Error$1, fn, col, Op, literal } from "sequelize";
+import yn from "yn";
+import * as d3Array from "d3-array";
+import * as d3Collection from "d3-collection";
+import * as d3Format from "d3-format";
+import * as d3TimeFormat from "d3-time-format";
+import { formatAbbreviate } from "d3plus-format";
+import { date as date$1 } from "d3plus-axis";
+import { assign, closest, merge } from "d3plus-common";
+import { strip, titleCase } from "d3plus-text";
+import axios from "axios";
+import slugifyFn from "slugify";
+import lunr from "lunr";
+import Base58 from "base58";
+import FlickrSDK from "flickr-sdk";
+import sharp from "sharp";
+import { createApi } from "unsplash-js";
+import fs from "fs";
+import NextCors from "nextjs-cors";
+import formidable from "formidable";
+var getLogging = (env = process.env) => yn(env.REPORTS_LOGGING), __defProp$k = Object.defineProperty, __defProps$c = Object.defineProperties, __getOwnPropDescs$c = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$q = Object.getOwnPropertySymbols, __hasOwnProp$q = Object.prototype.hasOwnProperty, __propIsEnum$q = Object.prototype.propertyIsEnumerable, __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$k = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$q.call(b, prop) && __defNormalProp$k(a, prop, b[prop]);
+  if (__getOwnPropSymbols$q)
+    for (var prop of __getOwnPropSymbols$q(b))
+      __propIsEnum$q.call(b, prop) && __defNormalProp$k(a, prop, b[prop]);
+  return a;
+}, __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
+class BlockModel extends Model {
+  getContent(locale) {
+    const content = this.contentByLocale.find((item) => item.locale === locale);
+    if (!content)
+      throw new Error(`Missing SearchContent for locale '${locale}' on Search ID '${this.id}'`);
+    return content;
+  }
+  toJSON() {
+    const attributes = this.get({ plain: !0 });
+    delete attributes.block_input;
+    const { inputs = [], consumers = [], contentByLocale = [] } = this;
+    return __spreadProps$c(__spreadValues$k({}, attributes), {
+      inputs: inputs.map((item) => item.toJSON()),
+      consumers: consumers.map((item) => item.toJSON()),
+      contentByLocale: Object.fromEntries(
+        contentByLocale.map((content) => [content.locale, content.toJSON()])
+      )
+    });
+  }
+}
+function initModel$b(sequelize) {
+  return BlockModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      autoIncrement: !0
+    },
+    settings: {
+      type: DataTypes.JSON,
+      defaultValue: {}
+    },
+    type: {
+      type: DataTypes.STRING,
+      defaultValue: "paragraph"
+    },
+    shared: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: !1
+    },
+    blockrow: DataTypes.STRING,
+    blockcol: DataTypes.STRING,
+    section_id: {
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_section",
+        key: "id"
+      }
+    }
+  }, {
+    sequelize,
+    modelName: "block",
+    tableName: "bespoke_reports_block",
+    freezeTableName: !0,
+    timestamps: !1
+  }), (models) => (BlockModel.hasMany(models.block_content, { foreignKey: "id", sourceKey: "id", as: "contentByLocale" }), BlockModel.belongsToMany(models.block, {
+    through: "block_input",
+    foreignKey: "block_id",
+    otherKey: "input_id",
+    as: "inputs"
+  }), BlockModel.belongsToMany(models.block, {
+    through: "block_input",
+    foreignKey: "input_id",
+    otherKey: "block_id",
+    as: "consumers"
+  }), BlockModel);
+}
+class BlockContentModel extends Model {
+}
+function initModel$a(sequelize) {
+  return BlockContentModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_block",
+        key: "id"
+      }
+    },
+    locale: {
+      type: DataTypes.STRING,
+      primaryKey: !0
+    },
+    content: {
+      type: DataTypes.JSON,
+      defaultValue: {}
+    }
+  }, {
+    sequelize,
+    modelName: "block_content",
+    tableName: "bespoke_reports_block_content",
+    freezeTableName: !0,
+    timestamps: !1
+  }), () => BlockContentModel;
+}
+class BlockInputModel extends Model {
+}
+function initModel$9(sequelize) {
+  return BlockInputModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      autoIncrement: !0
+    },
+    block_id: {
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_block",
+        key: "id"
+      }
+    },
+    input_id: {
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_block",
+        key: "id"
+      }
+    }
+  }, {
+    sequelize,
+    modelName: "block_input",
+    tableName: "bespoke_reports_block_input",
+    freezeTableName: !0,
+    timestamps: !1
+  }), () => BlockInputModel;
+}
+function logGamma(Z) {
+  const S = 1 + 76.18009173 / Z - 86.50532033 / (Z + 1) + 24.01409822 / (Z + 2) - 1.231739516 / (Z + 3) + 0.00120858003 / (Z + 4) - 536382e-11 / (Z + 5);
+  return (Z - 0.5) * Math.log(Z + 4.5) - (Z + 4.5) + Math.log(S * 2.50662827465);
+}
+function betinc(X, A, B) {
+  let A0 = 0, B0 = 1, A1 = 1, B1 = 1, M9 = 0, A2 = 0, C9;
+  for (; Math.abs((A1 - A2) / A1) > 1e-5; )
+    A2 = A1, C9 = -(A + M9) * (A + B + M9) * X / (A + 2 * M9) / (A + 2 * M9 + 1), A0 = A1 + C9 * A0, B0 = B1 + C9 * B0, M9 += 1, C9 = M9 * (B - M9) * X / (A + 2 * M9 - 1) / (A + 2 * M9), A1 = A0 + C9 * A1, B1 = B0 + C9 * B1, A0 /= B1, B0 /= B1, A1 /= B1, B1 = 1;
+  return A1 / A;
+}
+function binomialCdf(X, N, P) {
+  let betacdf, bincdf;
+  if (X < 0)
+    bincdf = 0;
+  else if (X >= N)
+    bincdf = 1;
+  else {
+    X = Math.floor(X);
+    const Z = P, A = X + 1, B = N - X, S = A + B, BT = Math.exp(logGamma(S) - logGamma(B) - logGamma(A) + A * Math.log(Z) + B * Math.log(1 - Z));
+    Z < (A + 1) / (S + 2) ? betacdf = BT * betinc(Z, A, B) : betacdf = 1 - BT * betinc(1 - Z, B, A), bincdf = 1 - betacdf;
+  }
+  return Math.round(bincdf * 1e5) / 1e5;
+}
+function criticalValue(confLevel) {
+  return {
+    0.99999: 15.137,
+    0.99: 6.635,
+    0.95: 3.841,
+    0.9: 2.706
+  }[confLevel];
+}
+function binP(N, p, x1, x2) {
+  const q = p / (1 - p);
+  let k = 0, v = 1, s = 0, tot = 0;
+  for (; k <= N; )
+    tot += v, k >= x1 & k <= x2 && (s += v), tot > 1e30 && (s /= 1e30, tot /= 1e30, v /= 1e30), k += 1, v = v * q * (N + 1 - k) / k;
+  return s / tot;
+}
+function computeMidP(vx, vN, confLevel) {
+  const vP = vx / vN, vTL = (100 - confLevel * 100) / 2;
+  let T1, T2;
+  if (vx === 0)
+    T1 = 0;
+  else {
+    let v = vP / 2, vsL = 0, vsH = vP;
+    const p = vTL / 100;
+    for (; vsH - vsL > 1e-5; )
+      binP(vN, v, vx, vx) * 0.5 + binP(vN, v, vx + 1, vN) > p ? (vsH = v, v = (vsL + v) / 2) : (vsL = v, v = (vsH + v) / 2);
+    T1 = v;
+  }
+  if (vx === vN)
+    T2 = 0;
+  else {
+    let v = (1 + vP) / 2, vsL = vP, vsH = 1;
+    const p = vTL / 100;
+    for (; vsH - vsL > 1e-5; )
+      binP(vN, v, vx, vx) * 0.5 + binP(vN, v, 0, vx - 1) < p ? (vsH = v, v = (vsL + v) / 2) : (vsL = v, v = (vsH + v) / 2);
+    T2 = v;
+  }
+  return { lci: T1, uci: T2 };
+}
+function smr(observedVal, expectedVal) {
+  const vx = observedVal, vN = expectedVal, Obs = vx, Exp = vN, ci = 95;
+  let v = 0.5, dv = 0.5, p = (100 - ci) / 2 / 100;
+  const vZ = Obs;
+  for (; dv > 1e-5; )
+    dv /= 2, poisP((1 + vZ) * v / (1 - v), vZ + 1, 1e10) + 0.5 * poisP((1 + vZ) * v / (1 - v), vZ, vZ) > p ? v -= dv : v += dv;
+  const QL = (1 + vZ) * v / (1 - v) / Exp;
+  for (v = 0.5, dv = 0.5, p = (100 - ci) / 2 / 100; dv > 1e-5; )
+    dv /= 2, poisP((1 + vZ) * v / (1 - v), 0, vZ - 1) + 0.5 * poisP((1 + vZ) * v / (1 - v), vZ, vZ) < p ? v -= dv : v += dv;
+  const QU = (1 + vZ) * v / (1 - v) / Exp;
+  return { lci: QL, uci: QU };
+}
+function poisP(Z, x1, x2) {
+  let q = 1, tot = 0, s = 0, k = 0;
+  for (; k < Z || q > tot * 1e-10; )
+    tot += q, k >= x1 & k <= x2 && (s += q), tot > 1e30 && (s /= 1e30, tot /= 1e30, q /= 1e30), k += 1, q = q * Z / k;
+  return s / tot;
+}
+var stats = {
+  binomialCdf,
+  binP,
+  computeMidP,
+  criticalValue,
+  smr
+}, __defProp$j = Object.defineProperty, __getOwnPropSymbols$p = Object.getOwnPropertySymbols, __hasOwnProp$p = Object.prototype.hasOwnProperty, __propIsEnum$p = Object.prototype.propertyIsEnumerable, __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$j = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$p.call(b, prop) && __defNormalProp$j(a, prop, b[prop]);
+  if (__getOwnPropSymbols$p)
+    for (var prop of __getOwnPropSymbols$p(b))
+      __propIsEnum$p.call(b, prop) && __defNormalProp$j(a, prop, b[prop]);
+  return a;
+};
+const libs = {
+  d3: __spreadValues$j(__spreadValues$j(__spreadValues$j(__spreadValues$j({}, d3Array), d3Collection), d3Format), d3TimeFormat),
+  d3plus: {
+    assign,
+    closest,
+    date: date$1,
+    formatAbbreviate,
+    merge,
+    strip,
+    titleCase
+  },
+  stats
+}, declaredFormatters = {};
+function declareFormatter(manifest) {
+  const func = manifest.logicFactory(libs);
+  return declaredFormatters[manifest.name] = {
+    description: manifest.description,
+    inputType: manifest.inputType,
+    logic: stringifyFn(func),
+    testValue: manifest.testValue,
+    type: manifest.type || "formatter"
+  }, func;
+}
+function stringifyFn(func) {
+  const strFunc = func.toString().trim();
+  if (strFunc.startsWith("function"))
+    return strFunc.replace(/^function(?:\s\w+)?\([^\)]\)/, "").trim().replace(/^{([\s\S]+)\}$/, "$1");
+  const noArgs = strFunc.replace(/^.+?=>/, "").trim();
+  return noArgs.startsWith("{") ? noArgs.replace(/^{([\s\S]+)\}$/, "$1") : `return ${noArgs}`;
+}
+var __defProp$i = Object.defineProperty, __getOwnPropSymbols$o = Object.getOwnPropertySymbols, __hasOwnProp$o = Object.prototype.hasOwnProperty, __propIsEnum$o = Object.prototype.propertyIsEnumerable, __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$i = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$o.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
+  if (__getOwnPropSymbols$o)
+    for (var prop of __getOwnPropSymbols$o(b))
+      __propIsEnum$o.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
+  return a;
+};
+const REPORT_TYPES = {
+  REPORT: "report",
+  STORY: "story"
+}, REPORT_MODES = {
+  UNILATERAL: "uni",
+  MULTILATERAL: "multi"
+}, REPORT_FIELDS = {
+  TITLE: "title",
+  SUBTITLE: "subtitle",
+  LABEL: "label"
+};
+REPORT_TYPES.REPORT + "", Object.values(REPORT_FIELDS), REPORT_TYPES.STORY + "", Object.values(REPORT_FIELDS);
+const ALLOWED = {
+  ALLOWED: "allowed",
+  ALLOWED_LOGIC: "allowedLogic"
+};
+__spreadValues$i({}, ALLOWED), __spreadValues$i({
+  POSITION: "position",
+  ICON: "icon"
+}, ALLOWED);
+const BLOCK_CONTENT_TYPES = {
+  IMAGE: "image",
+  PARAGRAPH: "paragraph",
+  SELECTOR: "selector",
+  STAT: "stat",
+  SUBTITLE: "subtitle",
+  TITLE: "title"
+}, BLOCK_LOGIC_TYPES = {
+  GENERATOR: "generator",
+  VIZ: "visualization"
+}, BLOCK_TYPES = __spreadValues$i(__spreadValues$i({}, BLOCK_CONTENT_TYPES), BLOCK_LOGIC_TYPES);
+BLOCK_TYPES.GENERATOR, BLOCK_TYPES.SELECTOR, BLOCK_TYPES.VIZ, BLOCK_TYPES.IMAGE;
+const BLOCK_FIELDS = {
+  ALT: "alt",
+  AUTHOR: "author",
+  FOOTNOTE: "footnote",
+  BIO: "bio",
+  IMAGE: "image",
+  LOGIC: "logic",
+  SIMPLE: "simple",
+  SIMPLE_ENABLED: "simpleEnabled",
+  PARAGRAPH: "paragraph",
+  SELECTOR_DEFAULT: "selectorDefault",
+  SELECTOR_DYNAMIC: "selectorDynamic",
+  SELECTOR_NAME: "selectorName",
+  SELECTOR_TYPE: "selectorType",
+  SRC: "src",
+  SLUG: "slug",
+  SUBTITLE: "subtitle",
+  TITLE: "title",
+  TOOLTIP: "tooltip",
+  TWITTER: "twitter",
+  VALUE: "value"
+};
+BLOCK_TYPES.IMAGE + "", BLOCK_FIELDS.SRC, BLOCK_FIELDS.ALT, BLOCK_TYPES.PARAGRAPH + "", BLOCK_TYPES.PARAGRAPH, BLOCK_FIELDS.TOOLTIP, BLOCK_TYPES.SELECTOR + "", BLOCK_FIELDS.SELECTOR_DEFAULT, BLOCK_FIELDS.SELECTOR_DYNAMIC, BLOCK_FIELDS.SELECTOR_NAME, BLOCK_FIELDS.SELECTOR_TYPE, BLOCK_TYPES.STAT + "", BLOCK_FIELDS.TITLE, BLOCK_FIELDS.SUBTITLE, BLOCK_FIELDS.VALUE, BLOCK_FIELDS.TOOLTIP, BLOCK_TYPES.SUBTITLE + "", BLOCK_FIELDS.SUBTITLE, BLOCK_FIELDS.TOOLTIP, BLOCK_TYPES.TITLE + "", BLOCK_FIELDS.TITLE, BLOCK_FIELDS.SLUG, BLOCK_FIELDS.TOOLTIP, BLOCK_TYPES.GENERATOR + "", BLOCK_TYPES.VIZ + "", __spreadValues$i({
+  NAME: "name",
+  DESCRIPTION: "description"
+}, ALLOWED);
+const FORMATTER_TYPES = {
+  FORMATTER: "formatter",
+  FUNCTION: "function"
+}, FORMATTER_INPUT_TYPES = {
+  STRING: "string",
+  NUMBER: "number",
+  OBJECT: "object",
+  DATE: "date"
+};
+var abbreviate = declareFormatter({
+  name: "abbreviate",
+  description: "Abbreviates a number into a smaller more human-readable number.",
+  logicFactory(libs2) {
+    return (n) => libs2.d3plus.formatAbbreviate(n);
+  },
+  inputType: "number",
+  testValue: "123456",
+  type: "formatter"
+}), abs = declareFormatter({
+  name: "abs",
+  description: "Simple Absolute Value.",
+  logicFactory(libs2) {
+    return (n) => Math.abs(n);
+  },
+  inputType: "number",
+  testValue: "-123",
+  type: "formatter"
+});
+const logicFactory$1 = () => function(n) {
+  let nums = new RegExp(/([\$0-9\,]+)[A-z\-\s\&]*([\$0-9\,]*)/g).exec(n);
+  return nums ? (nums = nums.slice(1).filter((d) => d.length).map((d) => (d.includes(",") && (d.indexOf(",") === d.length - 4 ? d = d.replace(/,000$/g, "k").replace(/([0-9]+)(,999$)/g, (n2) => `${parseInt(n2) + 1}k`) : d.indexOf(",") === d.length - 8 && (d = d.replace(/,000,000$/g, "M").replace(/([0-9]+)(,999,999$)/g, (n2) => `${parseInt(n2) + 1}M`))), d)), nums.length === 2 ? nums.join(" - ") : n.toLowerCase().match(/under|less|\</g) ? `< ${nums[0]}` : n.toLowerCase().match(/over|more|\+|\>/g) ? `${nums[0]}+` : `${nums[0]}`) : "None";
+};
+var bucket = declareFormatter({
+  name: "bucket",
+  description: "Sanitizes bucket strings to '< n', 'n1 - n2', and 'n+'",
+  logicFactory: logicFactory$1,
+  inputType: "number",
+  testValue: "1234",
+  type: "formatter"
+}), commas = declareFormatter({
+  name: "commas",
+  description: "* Rounds to nearest whole number and adds commas.",
+  logicFactory(libs2) {
+    return (n) => libs2.d3.format(",")(Math.round(n));
+  },
+  inputType: "number",
+  testValue: "1234.6",
+  type: "formatter"
+}), date = declareFormatter({
+  name: "date",
+  description: "Formats a date into '%B %d, %Y' format.",
+  logicFactory(libs2) {
+    return (n) => (typeof n == "string" && (n = libs2.d3plus.date(n)), libs2.d3.timeFormat("%B %d, %Y")(n));
+  },
+  inputType: "date",
+  testValue: "2022-01-01",
+  type: "formatter"
+}), dollar = declareFormatter({
+  name: "date",
+  description: "Adds a US dollar sign to the beginning of a String or Number.",
+  logicFactory(libs2) {
+    return (n) => (typeof n == "number" && (n = libs2.d3plus.formatAbbreviate(n)), n.charAt(0) === "-" ? n.replace("-", "-$") : `$${n}`);
+  },
+  inputType: "number",
+  testValue: "123",
+  type: "formatter"
+}), formatFieldName = declareFormatter({
+  name: "formatFieldName",
+  description: "Based on field name returns a string",
+  logicFactory(libs2) {
+    return (n) => {
+      if (n.contentType.toLowerCase() === "stat") {
+        if (n.field === "title")
+          return "Stat label";
+        if (n.field === "value")
+          return "Stat value";
+        if (n.field === "subtitle")
+          return "Stat subtitle";
+        if (n.field === "tooltip")
+          return "Tooltip text";
+      }
+      return n.contentType.toLowerCase() === "section" && n.field === "short" ? "Short title" : n.contentType.toLowerCase() === "description" && n.field === "description" ? "Paragraph" : n.field;
+    };
+  },
+  inputType: "object",
+  testValue: '{"field":"title","contentType":"stat"}',
+  type: "formatter"
+}), grewTo = declareFormatter({
+  name: "grewTo",
+  description: "Returns the text with grow direction: 'declined from', 'grew to' o 'stayed at'",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "declined from" : n > 0 ? "grew to" : "stayed at";
+  },
+  inputType: "number",
+  testValue: "-1234",
+  type: "formatter"
+}), grewWord = declareFormatter({
+  name: "grewWord",
+  description: "Returns either 'grew', 'declined', or 'stayed' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "declined" : n > 0 ? "grew" : "stayed";
+  },
+  inputType: "number",
+  testValue: "-1234",
+  type: "formatter"
+}), growing = declareFormatter({
+  name: "growing",
+  description: "Returns either 'declining', 'growing' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "declining" : "growing";
+  },
+  inputType: "number",
+  testValue: "-1234",
+  type: "formatter"
+});
+const logicFactory = () => function(n) {
+  const {
+    curr,
+    currMoe = 0,
+    prev,
+    prevMoe = 0
+  } = n;
+  let value;
+  if (currMoe || prevMoe) {
+    const f1 = (-prev / curr ** 2) ** 2 * currMoe ** 2, f2 = (1 / curr) ** 2 * prevMoe ** 2;
+    value = Math.sqrt(f1 + f2);
+  } else
+    value = (curr - prev) / prev;
+  return value * 100;
+};
+var growth = declareFormatter({
+  name: "growth",
+  description: "Calculates the growth percentage between two numbers provided the following object format: {curr, prev}. Also supports calculating the growth between two margin of errors using this format: {curr, currMoe, prev, prevMoe}",
+  logicFactory,
+  inputType: "object",
+  testValue: '{"curr":10,"currMoe":0,"prev":13,"prevMoe":0}',
+  type: "formatter"
+}), growthPct = declareFormatter({
+  name: "growthPct",
+  description: "Abbreviates a growth value, turns it absolute, and adds a percent sign.",
+  logicFactory(libs2) {
+    return (n) => `${libs2.d3plus.formatAbbreviate(Math.abs(n))}%`;
+  },
+  inputType: "number",
+  testValue: "12345",
+  type: "formatter"
+}), growthWord = declareFormatter({
+  name: "growthWord",
+  description: "Returns either 'growth' or 'decline' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "decline" : "growth";
+  },
+  inputType: "number",
+  testValue: "-1234",
+  type: "formatter"
+}), highWord = declareFormatter({
+  name: "highWord",
+  description: "Returns either 'higher than', 'lower than', or 'approximately the same as' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "lower than" : n > 0 ? "higher than" : "approximately the same as";
+  },
+  inputType: "number",
+  testValue: "0",
+  type: "formatter"
+}), increaseWord = declareFormatter({
+  name: "increaseWord",
+  description: "Returns either 'increase', 'decrease', or 'change' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "decrease" : n > 0 ? "increase" : "change";
+  },
+  inputType: "number",
+  testValue: "1234",
+  type: "formatter"
+}), increasedWord = declareFormatter({
+  name: "increasedWord",
+  description: "Returns either 'increased', 'decreased', or 'remained the same' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "decreased" : n > 0 ? "increased" : "remained the same";
+  },
+  inputType: "number",
+  testValue: "0",
+  type: "formatter"
+}), increasing = declareFormatter({
+  name: "increasing",
+  description: "Returns either 'decreasing', 'increasing' or 'maintaining' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "decreasing" : n > 0 ? "increasing" : "maintaining";
+  },
+  inputType: "number",
+  testValue: "-1234",
+  type: "formatter"
+}), largerThan = declareFormatter({
+  name: "largerThan",
+  description: "Returns either 'higher than', 'lower than', or 'approximately the same as' depending on the provided number's sign",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "smaller than" : n > 0 ? "larger than" : "the same as";
+  },
+  inputType: "number",
+  testValue: "-1234",
+  type: "formatter"
+}), list = declareFormatter({
+  name: "list",
+  description: "Joins an array of strings together, adding commas and 'and' when necessary.",
+  logicFactory(libs2) {
+    return (n) => n.reduce((str, item, i) => (i ? i === n.length - 1 && i === 1 ? str += ` and ${item}` : i === n.length - 1 ? str += `, and ${item}` : str += `, ${item}` : str += item, str), "");
+  },
+  inputType: "object",
+  testValue: '["foo","bar","bee"]',
+  type: "formatter"
+}), longWord = declareFormatter({
+  name: "longWord",
+  description: "",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "shorter" : n > 0 ? "longer" : "similar";
+  },
+  inputType: "number",
+  testValue: "5",
+  type: "formatter"
+}), lowerCaseFirst = declareFormatter({
+  name: "lowerCaseFirst",
+  description: "Converts the first letter of a string to lowercase",
+  logicFactory(libs2) {
+    return (n) => typeof n == "string" ? n.charAt(0).toLowerCase() + n.slice(1) : n;
+  },
+  inputType: "string",
+  testValue: "foo",
+  type: "formatter"
+}), moreFewerWord = declareFormatter({
+  name: "moreFewerWord",
+  description: "",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "fewer" : "more";
+  },
+  inputType: "number",
+  testValue: "-5",
+  type: "formatter"
+}), moreLess = declareFormatter({
+  name: "moreLess",
+  description: "Returns either 'more' or 'less' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "less" : "more";
+  },
+  inputType: "number",
+  testValue: "-5",
+  type: "formatter"
+}), moreWord = declareFormatter({
+  name: "moreLess",
+  description: "Returns either 'more than', 'less than', or 'approximately the same' depending on the provided number's sign.",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "less than" : n > 0 ? "more than" : "approximately the same";
+  },
+  inputType: "number",
+  testValue: "-5",
+  type: "formatter"
+}), olderWord = declareFormatter({
+  name: "olderWord",
+  description: "",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "getting younger" : n > 0 ? "getting older" : "staying the same age";
+  },
+  inputType: "number",
+  testValue: "-5",
+  type: "formatter"
+}), olderYounger = declareFormatter({
+  name: "olderYounger",
+  description: "",
+  logicFactory(libs2) {
+    return (n) => n < 0 ? "younger than" : n > 0 ? "older than" : "the same age as";
+  },
+  inputType: "number",
+  testValue: "-5",
+  type: "formatter"
+}), plural = declareFormatter({
+  name: "plural",
+  description: "Pluralizes a word.",
+  logicFactory(libs2) {
+    return (n) => n.replace(/\w$/g, (chr) => chr === "y" ? "ies" : `${chr}s`);
+  },
+  inputType: "string",
+  testValue: "Foo",
+  type: "formatter"
+}), pxToInt = declareFormatter({
+  name: "pxToInt",
+  description: "Takes a pixel value and converts it to an integer",
+  logicFactory(libs2) {
+    return (n) => parseInt(n.replace(/\D+/g, ""), 10);
+  },
+  inputType: "string",
+  testValue: "12px",
+  type: "formatter"
+}), salary = declareFormatter({
+  name: "salary",
+  description: "Displays salary values with proper precision (ie. '$74,200' instead of '$74.2k')",
+  logicFactory(libs2) {
+    return (n) => {
+      let str;
+      return n < 1e6 ? str = libs2.d3.format(",")(n.toFixed(0)) : str = libs2.d3plus.formatAbbreviate(n), `$${str}`;
+    };
+  },
+  inputType: "number",
+  testValue: "1000000",
+  type: "formatter"
+}), stripEntities$1 = declareFormatter({
+  name: "stripEntities",
+  description: "Removes non breaking spaces & other html entities from a string",
+  logicFactory(libs2) {
+    return (n) => typeof n == "string" ? String(n).replace(/&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-f]{1,6});/ig, " ") : n;
+  },
+  inputType: "string",
+  testValue: "<b>MyText</b>",
+  type: "formatter"
+}), stripHTML$1 = declareFormatter({
+  name: "stripHTML",
+  description: "Converts html tags to spaces, then removes redundant spaces",
+  logicFactory(libs2) {
+    return (n) => {
+      const entities = {
+        "&amp;": "&",
+        "&lt;": "<",
+        "&gt;": ">",
+        "&quot;": '"',
+        "&#x27;": "'",
+        "&#x60;": "`",
+        "&nbsp;": ""
+      }, source = `(?:${Object.keys(entities).join("|")})`, testRegexp = RegExp(source), replaceRegexp = RegExp(source, "g"), s = String(n).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+      return testRegexp.test(s) ? s.replace(replaceRegexp, (match) => entities[match]) : s;
+    };
+  },
+  inputType: "string",
+  testValue: "<b>My text</b>",
+  type: "formatter"
+}), stripOL = declareFormatter({
+  name: "stripOL",
+  description: "Removes ordered list wrapper tags from a string.",
+  logicFactory(libs2) {
+    return (n) => n.replace(/<ol>/g, "").replace(/<\/ol>/g, "");
+  },
+  inputType: "string",
+  testValue: "<ol><li>My list</li></ol>",
+  type: "formatter"
+}), stripP = declareFormatter({
+  name: "stripP",
+  description: "Removes all paragraph tags from a string.",
+  logicFactory(libs2) {
+    return (n) => n.replace(/<p>/g, "").replace(/<\/p>/g, "");
+  },
+  inputType: "string",
+  testValue: "<p>My p</p>",
+  type: "formatter"
+}), stripUL = declareFormatter({
+  name: "stripUL",
+  description: "Removes unordered list wrapper tags from a string.",
+  logicFactory(libs2) {
+    return (n) => n.replace(/<ul>/g, "").replace(/<\/ul>/g, "");
+  },
+  inputType: "string",
+  testValue: "<ul><li>My list</li></ul>",
+  type: "formatter"
+}), toKebabCase = declareFormatter({
+  name: "toKebabCase",
+  description: "Takes a camelCase or PascalCase string and converts it to kebab-case.",
+  logicFactory(libs2) {
+    return (n) => typeof n == "string" ? (n = n.charAt(0).toLowerCase() + n.substring(1), n.replace(/([A-Z])/g, "-$1").toLowerCase()) : "invalid string passed to toKebabCase()";
+  },
+  inputType: "string",
+  testValue: "camelCaseText",
+  type: "formatter"
+}), toSpacedCase = declareFormatter({
+  name: "toSpacedCase",
+  description: "Takes a camelCase or PascalCase string and adds spaces (I know Spaced Case isn't a thing, deal with it).",
+  logicFactory(libs2) {
+    return (n) => typeof n == "string" ? n.replace(/([A-Z])/g, " $1").toLowerCase().trim() : "invalid string passed to toSpacedCase()";
+  },
+  inputType: "string",
+  testValue: "camelCaseText",
+  type: "formatter"
+}), upperCaseFirst = declareFormatter({
+  name: "upperCaseFirst",
+  description: "Converts the first letter of a string to uppercase",
+  logicFactory(libs2) {
+    return (n) => n.charAt(0).toUpperCase() + n.slice(1);
+  },
+  inputType: "string",
+  testValue: "my name",
+  type: "formatter"
+}), formatters = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  abbreviate,
+  abs,
+  bucket,
+  commas,
+  date,
+  dollar,
+  formatFieldName,
+  grewTo,
+  grewWord,
+  growing,
+  growth,
+  growthPct,
+  growthWord,
+  highWord,
+  increaseWord,
+  increasedWord,
+  increasing,
+  largerThan,
+  list,
+  longWord,
+  lowerCaseFirst,
+  moreFewerWord,
+  moreLess,
+  moreWord,
+  olderWord,
+  olderYounger,
+  plural,
+  pxToInt,
+  salary,
+  stripEntities: stripEntities$1,
+  stripHTML: stripHTML$1,
+  stripOL,
+  stripP,
+  stripUL,
+  toKebabCase,
+  toSpacedCase,
+  upperCaseFirst
+});
+const verbose$3 = getLogging();
+verbose$3 && console.log(`Loaded formatters: ${Object.keys(formatters)}`);
+class FormatterModel extends Model {
+}
+function initModel$8(sequelize) {
+  return FormatterModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      autoIncrement: !0
+    },
+    name: {
+      type: DataTypes.STRING,
+      defaultValue: ""
+    },
+    content: {
+      type: DataTypes.JSONB,
+      defaultValue: {
+        description: "",
+        testValue: "Foo",
+        type: FORMATTER_TYPES.FORMATTER,
+        inputType: FORMATTER_INPUT_TYPES.STRING,
+        logic: "return n;"
+      }
+    }
+  }, {
+    sequelize,
+    modelName: "formatter",
+    tableName: "bespoke_reports_formatter",
+    freezeTableName: !0,
+    timestamps: !1,
+    hooks: {
+      async afterSync(options) {
+        const existingFormatters = await FormatterModel.findAll();
+        if (options.force || existingFormatters.length === 0) {
+          const defaultFormatters = Object.entries(declaredFormatters).map(([name, content]) => ({ name, content }));
+          await FormatterModel.bulkCreate(defaultFormatters);
+        }
+      }
+    }
+  }), () => FormatterModel;
+}
+class ImageModel extends Model {
+  getContent(locale) {
+    const { contentByLocale } = this;
+    if (!contentByLocale)
+      throw new Error("This ImageModel entity didn't include its ImageContentModel association.");
+    const content = contentByLocale.find((item) => item.locale === locale);
+    if (!content)
+      throw new Error(`Missing SearchContent for locale '${locale}' on Search ID '${this.id}'`);
+    return content;
+  }
+}
+function initModel$7(sequelize) {
+  return ImageModel.init({
+    id: {
+      autoIncrement: !0,
+      primaryKey: !0,
+      type: DataTypes.INTEGER
+    },
+    url: {
+      type: DataTypes.TEXT,
+      unique: !0
+    },
+    author: DataTypes.TEXT,
+    license: DataTypes.TEXT,
+    splash: DataTypes.BLOB,
+    thumb: DataTypes.BLOB
+  }, {
+    sequelize,
+    modelName: "image",
+    tableName: "bespoke_reports_image",
+    freezeTableName: !0
+  }), (models) => (ImageModel.hasMany(models.image_content, {
+    foreignKey: "id",
+    sourceKey: "id",
+    as: "contentByLocale"
+  }), ImageModel);
+}
+class ImageContentModel extends Model {
+}
+function initModel$6(sequelize) {
+  return ImageContentModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_image",
+        key: "id"
+      }
+    },
+    locale: {
+      type: DataTypes.STRING,
+      primaryKey: !0
+    },
+    meta: DataTypes.TEXT
+  }, {
+    sequelize,
+    modelName: "image_content",
+    tableName: "bespoke_reports_image_content",
+    freezeTableName: !0,
+    timestamps: !1
+  }), () => ImageContentModel;
+}
+var __defProp$h = Object.defineProperty, __defProps$b = Object.defineProperties, __getOwnPropDescs$b = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$n = Object.getOwnPropertySymbols, __hasOwnProp$n = Object.prototype.hasOwnProperty, __propIsEnum$n = Object.prototype.propertyIsEnumerable, __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$h = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$n.call(b, prop) && __defNormalProp$h(a, prop, b[prop]);
+  if (__getOwnPropSymbols$n)
+    for (var prop of __getOwnPropSymbols$n(b))
+      __propIsEnum$n.call(b, prop) && __defNormalProp$h(a, prop, b[prop]);
+  return a;
+}, __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
+class ReportModel extends Model {
+  toJSON() {
+    const attributes = this.get({ plain: !0 }), { dimensions = [], sections = [] } = this;
+    return __spreadProps$b(__spreadValues$h({}, attributes), {
+      settings: attributes.settings,
+      date: new Date(this.date || Date.now()).toISOString(),
+      dimensions: dimensions.map((item) => item.toJSON()),
+      sections: sections.map((item) => item.toJSON())
+    });
+  }
+}
+function initModel$5(sequelize) {
+  return ReportModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      autoIncrement: !0
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: !1,
+      defaultValue: ""
+    },
+    visible: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: !0
+    },
+    date: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW
+    },
+    type: {
+      type: DataTypes.STRING,
+      defaultValue: "report",
+      validate: {
+        isIn: [["report", "story"]]
+      }
+    },
+    settings: {
+      type: DataTypes.JSON,
+      defaultValue: {}
+    }
+  }, {
+    sequelize,
+    modelName: "report",
+    tableName: "bespoke_reports_report",
+    freezeTableName: !0,
+    timestamps: !1
+  }), (models) => (ReportModel.hasMany(models.dimension, {
+    foreignKey: "report_id",
+    sourceKey: "id",
+    as: "dimensions"
+  }), ReportModel.hasMany(models.section, {
+    foreignKey: "report_id",
+    sourceKey: "id",
+    as: "sections"
+  }), ReportModel);
+}
+var __defProp$g = Object.defineProperty, __defProps$a = Object.defineProperties, __getOwnPropDescs$a = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$m = Object.getOwnPropertySymbols, __hasOwnProp$m = Object.prototype.hasOwnProperty, __propIsEnum$m = Object.prototype.propertyIsEnumerable, __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$g = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$m.call(b, prop) && __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$m)
+    for (var prop of __getOwnPropSymbols$m(b))
+      __propIsEnum$m.call(b, prop) && __defNormalProp$g(a, prop, b[prop]);
+  return a;
+}, __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+class DimensionModel extends Model {
+  toJSON() {
+    const attributes = this.get({ plain: !0 }), { variants = [] } = this;
+    return __spreadProps$a(__spreadValues$g({}, attributes), {
+      variants: variants.map((item) => item.toJSON())
+    });
+  }
+}
+function initModel$4(sequelize) {
+  return DimensionModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      autoIncrement: !0
+    },
+    report_id: {
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_report",
+        key: "id"
+      }
+    },
+    name: {
+      type: DataTypes.STRING,
+      defaultValue: ""
+    },
+    settings: {
+      type: DataTypes.JSONB,
+      defaultValue: {}
+    },
+    ordering: {
+      type: DataTypes.INTEGER,
+      defaultValue: 0
+    },
+    visible: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: !0
+    }
+  }, {
+    sequelize,
+    modelName: "dimension",
+    tableName: "bespoke_reports_report_dimension",
+    freezeTableName: !0,
+    timestamps: !1
+  }), (models) => (DimensionModel.hasMany(models.variant, {
+    foreignKey: "dimension_id",
+    sourceKey: "id",
+    as: "variants",
+    constraints: !1
+  }), DimensionModel.belongsTo(models.report, {
+    foreignKey: "report_id",
+    targetKey: "id",
+    as: "report",
+    constraints: !1
+  }), DimensionModel);
+}
+class VariantModel extends Model {
+  get report() {
+    var _a;
+    return (_a = this.dimension) == null ? void 0 : _a.report;
+  }
+  toJSON() {
+    return this.get({ plain: !0 });
+  }
+}
+function initModel$3(sequelize) {
+  return VariantModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      autoIncrement: !0
+    },
+    dimension_id: {
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_report_dimension",
+        key: "id"
+      }
+    },
+    slug: {
+      type: DataTypes.STRING,
+      defaultValue: ""
+    },
+    name: {
+      type: DataTypes.STRING,
+      defaultValue: ""
+    },
+    settings: {
+      type: DataTypes.JSONB,
+      defaultValue: {}
+    },
+    config: {
+      type: DataTypes.JSONB,
+      defaultValue: {}
+    },
+    visible: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: !0
+    }
+  }, {
+    sequelize,
+    modelName: "variant",
+    tableName: "bespoke_reports_report_dimension_variant",
+    freezeTableName: !0,
+    timestamps: !1
+  }), (models) => (VariantModel.hasMany(models.search, {
+    foreignKey: "variant_id",
+    sourceKey: "id",
+    as: "members",
+    constraints: !1
+  }), VariantModel.belongsTo(models.dimension, {
+    foreignKey: "dimension_id",
+    targetKey: "id",
+    as: "dimension",
+    constraints: !1
+  }), VariantModel);
+}
+class SearchModel extends Model {
+  getContent(locale) {
+    const { contentByLocale } = this;
+    if (!contentByLocale)
+      throw new Error("This SearchModel entity didn't include its SearchContentModel association.");
+    const content = contentByLocale.find((item) => item.locale === locale);
+    if (!content)
+      throw new Error(`Missing SearchContent for locale '${locale}' on Search ID '${this.id}'`);
+    return content;
+  }
+}
+function initModel$2(sequelize) {
+  return SearchModel.init({
+    id: {
+      primaryKey: !0,
+      type: DataTypes.TEXT
+    },
+    zvalue: DataTypes.DOUBLE,
+    slug: DataTypes.TEXT,
+    image_id: {
+      type: DataTypes.INTEGER,
+      references: {
+        model: "bespoke_reports_image",
+        key: "id"
+      }
+    },
+    content_id: {
+      autoIncrement: !0,
+      type: DataTypes.INTEGER,
+      unique: !0
+    },
+    variant_id: {
+      primaryKey: !0,
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_report_dimension_variant",
+        key: "id"
+      }
+    },
+    dimension_id: {
+      primaryKey: !0,
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_report_dimension",
+        key: "id"
+      }
+    },
+    report_id: {
+      primaryKey: !0,
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_report",
+        key: "id"
+      }
+    },
+    visible: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: !0
+    }
+  }, {
+    sequelize,
+    modelName: "search",
+    tableName: "bespoke_reports_search",
+    freezeTableName: !0,
+    timestamps: !1
+  }), (models) => (SearchModel.belongsTo(models.variant, {
+    foreignKey: "variant_id",
+    targetKey: "id",
+    as: "variant",
+    constraints: !1
+  }), SearchModel.belongsTo(models.dimension, {
+    foreignKey: "dimension_id",
+    targetKey: "id",
+    as: "dimension",
+    constraints: !1
+  }), SearchModel.belongsTo(models.report, {
+    foreignKey: "report_id",
+    targetKey: "id",
+    as: "report",
+    constraints: !1
+  }), SearchModel.belongsTo(models.image, {
+    foreignKey: "image_id",
+    targetKey: "id",
+    as: "image",
+    constraints: !1
+  }), SearchModel.hasMany(models.search_content, {
+    foreignKey: "id",
+    sourceKey: "content_id",
+    as: "contentByLocale"
+  }), SearchModel);
+}
+class SearchContentModel extends Model {
+}
+function initModel$1(sequelize) {
+  return SearchContentModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_search",
+        key: "content_id"
+      }
+    },
+    locale: {
+      type: DataTypes.STRING,
+      primaryKey: !0
+    },
+    name: DataTypes.TEXT,
+    annotations: {
+      type: DataTypes.JSONB,
+      defaultValue: {}
+    },
+    attributes: {
+      type: DataTypes.JSONB,
+      defaultValue: {}
+    },
+    keywords: DataTypes.ARRAY(DataTypes.TEXT)
+  }, {
+    sequelize,
+    modelName: "search_content",
+    tableName: "bespoke_reports_search_content",
+    freezeTableName: !0,
+    timestamps: !1
+  }), () => SearchContentModel;
+}
+var __defProp$f = Object.defineProperty, __defProps$9 = Object.defineProperties, __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$l = Object.getOwnPropertySymbols, __hasOwnProp$l = Object.prototype.hasOwnProperty, __propIsEnum$l = Object.prototype.propertyIsEnumerable, __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$f = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$l.call(b, prop) && __defNormalProp$f(a, prop, b[prop]);
+  if (__getOwnPropSymbols$l)
+    for (var prop of __getOwnPropSymbols$l(b))
+      __propIsEnum$l.call(b, prop) && __defNormalProp$f(a, prop, b[prop]);
+  return a;
+}, __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+class SectionModel extends Model {
+  toJSON() {
+    const attributes = this.get({ plain: !0 }), { blocks = [] } = this;
+    return __spreadProps$9(__spreadValues$f({}, attributes), {
+      blocks: blocks.map((item) => item.toJSON())
+    });
+  }
+}
+function initModel(sequelize) {
+  return SectionModel.init({
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: !0,
+      autoIncrement: !0
+    },
+    settings: {
+      type: DataTypes.JSON,
+      defaultValue: {}
+    },
+    heading: {
+      type: DataTypes.INTEGER,
+      defaultValue: 1
+    },
+    ordering: DataTypes.STRING,
+    report_id: {
+      type: DataTypes.INTEGER,
+      onDelete: "cascade",
+      references: {
+        model: "bespoke_reports_report",
+        key: "id"
+      }
+    }
+  }, {
+    sequelize,
+    modelName: "section",
+    tableName: "bespoke_reports_section",
+    freezeTableName: !0,
+    timestamps: !1
+  }), (models) => (SectionModel.hasMany(models.block, {
+    foreignKey: "section_id",
+    sourceKey: "id",
+    as: "blocks"
+  }), SectionModel);
+}
+const modelFactoryMap = {
+  block: initModel$b,
+  block_content: initModel$a,
+  block_input: initModel$9,
+  formatter: initModel$8,
+  image: initModel$7,
+  image_content: initModel$6,
+  report: initModel$5,
+  dimension: initModel$4,
+  variant: initModel$3,
+  search: initModel$2,
+  search_content: initModel$1,
+  section: initModel
+}, verbose$2 = getLogging(), connectionString = process.env.REPORTS_DB_CONNECTION || "", shouldWipe = yn(process.env.REPORTS_DB_WIPE);
+if (!connectionString)
+  throw new Error(`
+    Env var 'REPORTS_DB_CONNECTION' is not present.
+    This is required to connect to a database to save the Reports CMS changes.
+  `);
+function memoizeResult(factory) {
+  let result;
+  return (...args) => (result = result || factory(...args), result);
+}
+const getDB = memoizeResult(() => {
+  let sequelize;
+  try {
+    verbose$2 && console.log("INITIALIZING DB CONNECTION"), sequelize = new Sequelize(connectionString, {
+      logging: !1,
+      dialectModule: pg
+    });
+  } catch (e) {
+    throw new Error(`
+      Could not connect to the database using the given connection string.
+      Please check that the connection string 'REPORTS_DB_CONNECTION' is correct.
+      Details:
+      ${e.message}
+    `);
+  }
+  return Object.values(modelFactoryMap).map((modelFactory) => modelFactory(sequelize)).map((modelAssociator) => modelAssociator(sequelize.models)), sequelize.sync({ force: shouldWipe }).catch((err) => {
+    throw err instanceof Error$1 && (console.error(
+      "=".repeat(40),
+      `
+Error initializing sequelize connection:
+`,
+      err.stack || err.message
+    ), process.exit(1)), err;
+  }).then(() => sequelize.models);
+});
+class BackendError extends Error {
+  constructor(code, message) {
+    super(message), this.code = code;
+  }
+  toJSON() {
+    return failureResult(this);
+  }
+  static is(obj) {
+    return Object.prototype.hasOwnProperty.call(obj, "code") && typeof obj.code == "number";
+  }
+}
+function successResult(result) {
+  return { ok: !0, status: 200, data: result };
+}
+function failureResult(err) {
+  return { ok: !1, status: BackendError.is(err) ? err.code : 500, error: err.message };
+}
+function resultWrapper(method) {
+  return (param) => method(param).then(successResult, failureResult);
+}
+function pickMethod(api, operation, entity) {
+  const name = `${operation}${capitalize(entity)}`;
+  return api[name];
+}
+function capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1);
+}
+var getLocales = () => {
+  var _a;
+  const localeDefault2 = process.env.NEXT_PUBLIC_REPORTS_LOCALE_DEFAULT || "en", locales2 = ((_a = process.env.NEXT_PUBLIC_REPORTS_LOCALES) == null ? void 0 : _a.split(",")) || [localeDefault2];
+  return locales2.includes(localeDefault2) || locales2.push(localeDefault2), { localeDefault: localeDefault2, locales: locales2 };
+};
+const keyDiver = (obj, str) => str && typeof str == "string" ? str.split(".").reduce((o, i) => o[i], obj) : obj;
+function stripHTML(n) {
+  const entities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#x27;": "'",
+    "&#x60;": "`",
+    "&nbsp;": ""
+  }, source = `(?:${Object.keys(entities).join("|")})`, testRegexp = RegExp(source), replaceRegexp = RegExp(source, "g"), s = String(n).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  return testRegexp.test(s) ? s.replace(replaceRegexp, (match) => entities[match]) : s;
+}
+function stripEntities(n) {
+  return typeof n == "string" ? String(n).replace(/&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-f]{1,6});/ig, " ") : n;
+}
+function slugify(str) {
+  return str ? slugifyFn(
+    stripEntities(stripHTML(str)),
+    {
+      replacement: "-",
+      remove: /[*+~.()'"!:@]/g,
+      lower: !0,
+      strict: !0,
+      trim: !0
+    }
+  ) : "";
+}
+const { localeDefault: localeDefault$3 } = getLocales();
+function ingestMembersFactory(db) {
+  const { search: Search, search_content: SearchContent } = db;
+  return ingestMembers;
+  async function ingestMembers(variant) {
+    const { id, config = {} } = variant, defaultLocale = config[localeDefault$3] ? localeDefault$3 : Object.keys(config)[0], {
+      accessor,
+      path,
+      idKey,
+      labelKey
+    } = config[localeDefault$3];
+    if (!path || !idKey || !labelKey)
+      return;
+    const memberFetch = await axios.get(path).catch((e) => ({ data: [], error: e })), members = keyDiver(memberFetch.data, accessor);
+    try {
+      await ingestDefaultMembers(variant, defaultLocale, members);
+    } catch (error) {
+      const errorMsg = `[ERROR] Ingesting default member items for ${defaultLocale}`;
+      throw console.error(errorMsg, error), new BackendError(500, errorMsg);
+    }
+    const ingestions = Object.entries(config).map(async ([locale, config2]) => {
+      const {
+        path: path2,
+        accessor: accessor2,
+        idKey: idKey2,
+        labelKey: labelKey2,
+        attributes = []
+      } = config2;
+      if (!path2 || !idKey2 || !labelKey2)
+        return;
+      const memberFetch2 = await axios.get(path2).catch((e) => ({ data: [], error: e })), members2 = keyDiver(memberFetch2.data, accessor2), contentHash = await Search.findAll({ where: { variant_id: id } }).then((arr) => Object.fromEntries(
+        arr.map((content) => [content.id, content.content_id])
+      )), contentMembers = members2.map((d) => ({
+        id: contentHash[d[idKey2]],
+        locale,
+        name: d[labelKey2],
+        attributes: Object.fromEntries(
+          attributes.map((attr) => [
+            attr.name,
+            attr.type === "constant" ? attr.value : d[attr.value] || ""
+          ])
+        )
+      }));
+      try {
+        await SearchContent.bulkCreate(contentMembers);
+      } catch (error) {
+        const errorMsg = `[ERROR] Ingesting search content items for ${locale}`;
+        throw console.error(errorMsg, error), new BackendError(500, errorMsg);
+      }
+    });
+    await Promise.all(ingestions);
+  }
+  async function ingestDefaultMembers(variant, locale, members) {
+    const { id, dimension_id, slug } = variant, { report_id } = variant.dimension, { idKey, labelKey } = variant.config[locale], allSlugsFromOtherMembers = await Search.findAll({
+      attributes: ["slug", [fn("COUNT", col("variant.id")), "slugCount"]],
+      include: {
+        association: "variant",
+        attributes: [],
+        required: !1,
+        right: !0,
+        where: { dimension_id, slug }
+      },
+      group: "search.slug"
+    }).then((arr) => Object.fromEntries(arr.map((item) => {
+      const count = item.getDataValue("slugCount");
+      return [item.slug, Number.parseInt(`${count}`, 10)];
+    }))), searchMembers = members.map((member) => {
+      const slug2 = slugify(member[labelKey]), memberId = member[idKey];
+      return {
+        id: memberId,
+        slug: allSlugsFromOtherMembers[slug2] > 1 ? `${slug2}-${memberId}` : slug2,
+        variant_id: id,
+        dimension_id,
+        report_id,
+        zvalue: Math.random()
+      };
+    });
+    try {
+      await Search.destroy({ where: { variant_id: id } }), await Search.bulkCreate(searchMembers);
+    } catch (error) {
+      throw console.error(`[ERROR] Ingesting search members for ${locale}`, error), new Error(error);
+    }
+  }
+}
+var __defProp$e = Object.defineProperty, __defProps$8 = Object.defineProperties, __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$k = Object.getOwnPropertySymbols, __hasOwnProp$k = Object.prototype.hasOwnProperty, __propIsEnum$k = Object.prototype.propertyIsEnumerable, __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$e = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$k.call(b, prop) && __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$k)
+    for (var prop of __getOwnPropSymbols$k(b))
+      __propIsEnum$k.call(b, prop) && __defNormalProp$e(a, prop, b[prop]);
+  return a;
+}, __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+function readMemberFactory(db) {
+  const { search: Search } = db;
+  return readMember;
+  async function readMember(params) {
+    const {
+      mode,
+      ids,
+      slugs,
+      all,
+      locale
+    } = params, whereClause = {
+      content_id: []
+    };
+    if (mode === "ids")
+      whereClause.content_id = ids;
+    else if (mode === "slugs") {
+      const entities = await Search.findAll({
+        attributes: ["content_id"],
+        where: {
+          slug: slugs.map((item) => item.memberSlug)
+        },
+        include: {
+          association: "variant",
+          attributes: ["id", "name", "slug"],
+          required: !1,
+          where: {
+            slug: slugs.map((item) => item.variantSlug)
+          }
+        }
+      });
+      whereClause.content_id = entities.map((item) => item.content_id);
+    }
+    const contentWhereClause = {
+      locale: all ? { [Op.ne]: null } : locale
+    }, memberSearchResults = await Search.findAll({
+      where: whereClause,
+      include: [{
+        association: "report",
+        attributes: ["id", "name"]
+      }, {
+        association: "dimension",
+        attributes: ["id", "name", "ordering"]
+      }, {
+        association: "variant",
+        attributes: ["id", "name", "slug"]
+      }, {
+        association: "image",
+        attributes: ["id", "author", "url", "license"],
+        include: [{
+          association: "contentByLocale",
+          where: contentWhereClause
+        }]
+      }, {
+        association: "contentByLocale",
+        where: contentWhereClause
+      }]
+    });
+    if (memberSearchResults.length !== (mode === "ids" ? ids.length : slugs.length))
+      throw new BackendError(404, "One of the members was not found.");
+    memberSearchResults.sort(
+      (a, b) => whereClause.content_id.indexOf(a.content_id) - whereClause.content_id.indexOf(b.content_id)
+    );
+    const normalizedResults = memberSearchResults.map((item) => {
+      const newItem = __spreadProps$8(__spreadValues$e({}, item.toJSON()), {
+        report_name: item.report.name,
+        dimension_name: item.dimension.name,
+        variant_name: item.variant.name,
+        variant_slug: item.variant.slug
+      });
+      if (!all) {
+        const localizedItem = item.getContent(locale);
+        if (newItem.locale = localizedItem.locale, newItem.name = localizedItem.name, newItem.attributes = localizedItem.attributes, newItem.keywords = localizedItem.keywords, delete newItem.contentByLocale, item.image) {
+          const localizedImage = item.image.getContent(locale);
+          newItem.image = __spreadProps$8(__spreadValues$e({}, item.image), {
+            meta: localizedImage.meta
+          }), delete newItem.image.contentByLocale;
+        }
+      }
+      return delete newItem.report, delete newItem.dimension, delete newItem.variant, newItem;
+    });
+    return {
+      meta: {
+        locale: stripHTML(locale),
+        mode,
+        ids,
+        slugs
+      },
+      results: normalizedResults
+    };
+  }
+}
+function readMemberImageFactory(db) {
+  const { search: Search } = db;
+  return readMemberImage;
+  async function readMemberImage(params) {
+    const member = await Search.findOne({
+      where: { content_id: params.member },
+      include: [
+        {
+          association: "image",
+          attributes: ["id", "author", "url", "license", params.size],
+          include: [{
+            association: "contentByLocale"
+          }]
+        },
+        {
+          association: "report",
+          attributes: ["id", "name"]
+        },
+        {
+          association: "dimension",
+          attributes: ["id", "name", "ordering"]
+        },
+        {
+          association: "variant",
+          attributes: ["id", "name", "slug"]
+        }
+      ]
+    });
+    if (member && member.image) {
+      if (member.image[params.size])
+        return member.image[params.size];
+    } else
+      return Buffer.from(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkkAQAAB8AG7jymN8AAAAASUVORK5CYII=",
+        "base64"
+      );
+    throw new BackendError(404, "error in image, member not found");
+  }
+}
+require("lunr-languages/lunr.stemmer.support")(lunr);
+const whitelist = ["ar", "da", "de", "du", "en", "es", "fi", "hi", "hu", "it", "ja", "jp", "nl", "no", "pt", "ro", "ru", "sv", "ta", "th", "tr", "vi", "zh"], verbose$1 = getLogging(), { locales: locales$4 } = getLocales(), enabledLocales = locales$4.filter((d) => whitelist.includes(d)), nonEnLocales = enabledLocales.filter((d) => whitelist.includes(d)).filter((d) => d !== "en");
+for (const locale of nonEnLocales)
+  require(`lunr-languages/lunr.${locale}`)(lunr);
+let search;
+const getSearchIndexByLocale = async (db, forceRegenerate = !1) => {
+  if (forceRegenerate && (verbose$1 && console.log("REGENERATING SEARCH INDEX"), search = void 0), search)
+    return search;
+  try {
+    verbose$1 && console.log("INITIALIZING SEARCH INDEX");
+    const results = await db.search.findAll({ include: [{ association: "contentByLocale" }] }).then((arr) => arr.map((d) => d.toJSON())).catch(() => []), searchIndexByLocale = {};
+    for (const locale of enabledLocales)
+      searchIndexByLocale[locale] = lunr(function() {
+        locale && locale !== "en" && this.use(lunr[locale]), this.ref("content_id"), this.field("id"), this.field("name"), this.field("keywords"), this.field("attr"), this.pipeline.reset(), this.searchPipeline.reset(), results.forEach((result) => {
+          const content = result.contentByLocale.find((d) => d.locale === locale);
+          if (content) {
+            const payload = {
+              id: result.id,
+              content_id: result.content_id,
+              name: content.name,
+              keywords: content.keywords,
+              attributes: content.attributes
+            };
+            this.add(payload, { boost: result.zvalue });
+          }
+        }, this);
+      });
+    search = searchIndexByLocale;
+  } catch (e) {
+    throw new Error(`
+      Could not initialize Lunr search engine.
+      Details:
+      ${e.message}
+    `);
+  }
+  return search;
+};
+var __defProp$d = Object.defineProperty, __defProps$7 = Object.defineProperties, __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$j = Object.getOwnPropertySymbols, __hasOwnProp$j = Object.prototype.hasOwnProperty, __propIsEnum$j = Object.prototype.propertyIsEnumerable, __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$d = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$j.call(b, prop) && __defNormalProp$d(a, prop, b[prop]);
+  if (__getOwnPropSymbols$j)
+    for (var prop of __getOwnPropSymbols$j(b))
+      __propIsEnum$j.call(b, prop) && __defNormalProp$d(a, prop, b[prop]);
+  return a;
+}, __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
+const { localeDefault: localeDefault$2 } = getLocales();
+function dbSearchMemberFactory(db) {
+  const { search: Search } = db;
+  return searchMember;
+  async function searchMember(params) {
+    const searchIndexByLocale = await getSearchIndexByLocale(db);
+    let resultsIds = [];
+    const {
+      query,
+      locale,
+      limit,
+      format,
+      visible,
+      variant,
+      dimension,
+      report,
+      all,
+      noImage,
+      includes,
+      sort,
+      direction = "ASC"
+    } = params;
+    if (query && query !== "" && searchIndexByLocale[locale]) {
+      const terms = query.split(" ").map((d) => `+${d}*`).join(" ");
+      resultsIds = searchIndexByLocale[locale].search(terms).map((d) => parseInt(d.ref, 10));
+    }
+    const whereClause = __spreadValues$d(__spreadValues$d(__spreadValues$d(__spreadValues$d(__spreadValues$d({}, visible ? { visible } : {}), noImage ? { image_id: { [Op.eq]: null } } : {}), variant.length ? { variant_id: variant } : {}), dimension.length ? { dimension_id: dimension } : {}), report.length ? { report_id: report } : {}), contentWhereClause = {
+      locale: all ? { [Op.ne]: null } : locale
+    };
+    query === "" && (resultsIds = (await Search.findAll({
+      attributes: [
+        "id",
+        "content_id",
+        "report_id",
+        [literal("rank() over(partition by report_id order by zvalue desc)"), "rank"]
+      ],
+      where: whereClause,
+      include: [{
+        association: "contentByLocale",
+        where: contentWhereClause
+      }]
+    }).then((arr) => arr.map((d) => d.toJSON()))).filter((item) => parseInt(item.rank, 10) <= limit).map((d) => d.content_id)), whereClause.content_id = resultsIds;
+    const includeClause = [{
+      association: "contentByLocale",
+      where: contentWhereClause
+    }];
+    includes && includeClause.push({
+      association: "report",
+      attributes: ["id", "name"]
+    }, {
+      association: "dimension",
+      attributes: ["id", "name"]
+    }, {
+      association: "variant",
+      attributes: ["id", "slug", "name"]
+    });
+    const orderClause = [["zvalue", "DESC NULLS LAST"]];
+    sort && sort !== "name" && orderClause.unshift([sort, direction.toUpperCase()]);
+    const results = await Search.findAll({
+      limit: query ? limit : void 0,
+      where: whereClause,
+      include: includeClause,
+      order: orderClause
+    });
+    if (sort === "name") {
+      const sortDirection = direction.toUpperCase() === "ASC" ? 1 : -1;
+      results.sort((a, b) => {
+        const aValue = a.getContent(localeDefault$2), bValue = b.getContent(localeDefault$2);
+        return aValue && bValue ? aValue.name > bValue.name ? 1 * sortDirection : -1 * sortDirection : 0;
+      });
+    }
+    const resultFormatter = format === "nested" ? nestedFormatter : plainFormatter;
+    return {
+      meta: __spreadValues$d({
+        origin: "lunr"
+      }, Object.fromEntries(
+        Object.entries(params).map((entry) => [entry[0], stripHTML(entry[1])])
+      )),
+      results: results.map(resultFormatter)
+    };
+    function nestedFormatter(item) {
+      return item.toJSON();
+    }
+    function plainFormatter(item) {
+      const localizedItem = item.getContent(locale);
+      return __spreadProps$7(__spreadValues$d({}, item.toJSON()), {
+        locale: localizedItem.locale,
+        name: localizedItem.name,
+        attributes: localizedItem.attributes,
+        keywords: localizedItem.keywords
+      });
+    }
+  }
+}
+var __defProp$c = Object.defineProperty, __getOwnPropSymbols$i = Object.getOwnPropertySymbols, __hasOwnProp$i = Object.prototype.hasOwnProperty, __propIsEnum$i = Object.prototype.propertyIsEnumerable, __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$c = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$i.call(b, prop) && __defNormalProp$c(a, prop, b[prop]);
+  if (__getOwnPropSymbols$i)
+    for (var prop of __getOwnPropSymbols$i(b))
+      __propIsEnum$i.call(b, prop) && __defNormalProp$c(a, prop, b[prop]);
+  return a;
+};
+function updateMemberFactory(db) {
+  const {
+    image: Image,
+    image_content: ImageContent,
+    search: Search,
+    search_content: SearchContent
+  } = db;
+  return updateMember;
+  async function updateMember(params) {
+    const {
+      content_id,
+      contentByLocale,
+      image,
+      image_id
+    } = params;
+    let returnQuery = { where: { content_id } };
+    const oldRecord = await Search.findOne(returnQuery);
+    if (await Search.update(params, { where: { content_id } }), contentByLocale) {
+      for (let index = 0; index < contentByLocale.length; index++) {
+        const searchContent = contentByLocale[index];
+        await SearchContent.update({
+          name: searchContent.name,
+          keywords: searchContent.keywords
+        }, { where: { id: searchContent.id, locale: searchContent.locale } });
+      }
+      const relevantInclude = {
+        include: [
+          { association: "contentByLocale", separate: !0 }
+        ]
+      };
+      returnQuery = __spreadValues$c(__spreadValues$c({}, returnQuery), relevantInclude);
+    }
+    if (image) {
+      if (image.id && (await Image.update(__spreadValues$c({}, image), { where: { id: image.id } }), image.contentByLocale))
+        for (let index = 0; index < image.contentByLocale.length; index++) {
+          const imageContent = image.contentByLocale[index];
+          await ImageContent.update({
+            meta: imageContent.meta
+          }, { where: { id: imageContent.id, locale: imageContent.locale } });
+        }
+    } else
+      !image_id && oldRecord.image_id && (await db.search.findAll({
+        where: { image_id: oldRecord.image_id }
+      })).length === 0 && await Image.destroy({
+        where: { id: oldRecord.image_id }
+      });
+    return Search.findOne(returnQuery);
+  }
+}
+function dbMemberFactory(db) {
+  return {
+    ingestMembers: ingestMembersFactory(db),
+    readMember: readMemberFactory(db),
+    searchMember: dbSearchMemberFactory(db),
+    updateMember: updateMemberFactory(db),
+    readMemberImage: readMemberImageFactory(db)
+  };
+}
+var __defProp$b = Object.defineProperty, __getOwnPropSymbols$h = Object.getOwnPropertySymbols, __hasOwnProp$h = Object.prototype.hasOwnProperty, __propIsEnum$h = Object.prototype.propertyIsEnumerable, __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$b = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$h.call(b, prop) && __defNormalProp$b(a, prop, b[prop]);
+  if (__getOwnPropSymbols$h)
+    for (var prop of __getOwnPropSymbols$h(b))
+      __propIsEnum$h.call(b, prop) && __defNormalProp$b(a, prop, b[prop]);
+  return a;
+};
+const blockQuery = {
+  include: [
+    { association: "contentByLocale", separate: !0 },
+    { association: "inputs" },
+    { association: "consumers" }
+  ]
+}, dimensionQuery = {
+  include: [
+    { association: "variants", separate: !0 }
+  ]
+}, sectionQuery = {
+  include: [
+    __spreadValues$b({ association: "blocks", separate: !0 }, blockQuery)
+  ]
+}, reportQuery = {
+  include: [
+    __spreadValues$b({ association: "dimensions", separate: !0 }, dimensionQuery),
+    __spreadValues$b({ association: "sections", separate: !0 }, sectionQuery)
+  ]
+}, imageQueryThumbOnly = [
+  {
+    association: "image",
+    attributes: {
+      exclude: ["splash"]
+    },
+    include: [
+      { association: "contentByLocale" }
+    ]
+  },
+  { association: "contentByLocale" }
+];
+var __defProp$a = Object.defineProperty, __defProps$6 = Object.defineProperties, __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$g = Object.getOwnPropertySymbols, __hasOwnProp$g = Object.prototype.hasOwnProperty, __propIsEnum$g = Object.prototype.propertyIsEnumerable, __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$a = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$g.call(b, prop) && __defNormalProp$a(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b))
+      __propIsEnum$g.call(b, prop) && __defNormalProp$a(a, prop, b[prop]);
+  return a;
+}, __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b)), __objRest$6 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$g.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$g.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
+function dbBlockFactory(db) {
+  const { block: Block, block_content: BlockContent, block_input: BlockInput } = db;
+  return {
+    createBlock,
+    readBlock,
+    updateBlock,
+    deleteBlock
+  };
+  async function createBlock(data) {
+    const _a = data, { locale } = _a, blockData = __objRest$6(_a, ["locale"]);
+    return (await Block.create(__spreadProps$6(__spreadValues$a({}, blockData), {
+      consumers: [],
+      inputs: [],
+      contentByLocale: [{ locale }]
+    }), {
+      include: blockQuery.include
+    })).toJSON();
+  }
+  async function readBlock({ id, include } = {}) {
+    const idList = id == null ? [] : [].concat(id), entities = await Block.findAll({
+      where: idList.length > 0 ? { id: idList } : void 0,
+      include: include ? blockQuery.include : void 0
+    });
+    if (idList.length === 0 || entities.length === idList.length)
+      return entities.map((entity) => entity.toJSON());
+    const found = entities.map((entity) => entity.id), missing = idList.filter((item) => !found.includes(item));
+    throw new BackendError(404, `Block(id=[${missing}]) does not exist.`);
+  }
+  async function updateBlock(data) {
+    const _a = data, {
+      id,
+      contentByLocale,
+      consumers,
+      inputs,
+      inputAction
+    } = _a, blockData = __objRest$6(_a, [
+      "id",
+      "contentByLocale",
+      "consumers",
+      "inputs",
+      "inputAction"
+    ]), entity = await Block.findByPk(id, {
+      include: blockQuery.include,
+      rejectOnEmpty: !0
+    });
+    if (entity.set(blockData), contentByLocale) {
+      const contentList = Object.values(contentByLocale);
+      await BlockContent.bulkCreate(contentList, {
+        updateOnDuplicate: ["content"]
+      });
+    }
+    return inputAction && (inputAction.operation === "create" ? await BlockInput.create(inputAction.input) : await BlockInput.destroy({ where: inputAction.input })), await entity.save(), await entity.reload(), entity.toJSON();
+  }
+  async function deleteBlock(id) {
+    const entity = await Block.findByPk(id, { rejectOnEmpty: !0 });
+    return await entity.destroy(), { id, parentType: "section", parentId: entity.section_id };
+  }
+}
+var __getOwnPropSymbols$f = Object.getOwnPropertySymbols, __hasOwnProp$f = Object.prototype.hasOwnProperty, __propIsEnum$f = Object.prototype.propertyIsEnumerable, __objRest$5 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$f.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$f.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
+function dbDimensionFactory(db) {
+  const { dimension: Dimension } = db;
+  return {
+    createDimension,
+    readDimension,
+    updateDimension,
+    deleteDimension
+  };
+  async function createDimension(data) {
+    return (await Dimension.create({
+      name: data.name,
+      report_id: data.report_id,
+      variants: []
+    }, {
+      include: dimensionQuery.include
+    })).toJSON();
+  }
+  async function readDimension({ id, include } = {}) {
+    const idList = id == null ? [] : [].concat(id), entities = await Dimension.findAll({
+      where: idList.length > 0 ? { id: idList } : void 0,
+      include: include ? dimensionQuery.include : void 0
+    });
+    if (idList.length === 0 || entities.length === idList.length)
+      return entities.map((entity) => entity.toJSON());
+    const found = entities.map((entity) => entity.id), missing = idList.filter((item) => !found.includes(item));
+    throw new BackendError(404, `Dimension(id=[${missing}]) does not exist.`);
+  }
+  async function updateDimension(data) {
+    const _a = data, { id, variants } = _a, dimensionData = __objRest$5(_a, ["id", "variants"]), entity = await Dimension.findByPk(id, {
+      include: dimensionQuery.include,
+      rejectOnEmpty: !0
+    });
+    return entity.set(dimensionData), await entity.save(), entity.toJSON();
+  }
+  async function deleteDimension(id) {
+    const entity = await Dimension.findByPk(id, { rejectOnEmpty: !0 });
+    return await entity.destroy(), { id, parentType: "report", parentId: entity.report_id };
+  }
+}
+var __getOwnPropSymbols$e = Object.getOwnPropertySymbols, __hasOwnProp$e = Object.prototype.hasOwnProperty, __propIsEnum$e = Object.prototype.propertyIsEnumerable, __objRest$4 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$e.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$e)
+    for (var prop of __getOwnPropSymbols$e(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$e.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
+function dbFormatterFactory(db) {
+  const { formatter: Formatter } = db;
+  return {
+    createFormatter,
+    readFormatter,
+    updateFormatter,
+    deleteFormatter
+  };
+  async function createFormatter(data) {
+    return (await Formatter.create(data)).toJSON();
+  }
+  async function readFormatter({ id } = {}) {
+    const idList = id == null ? [] : [].concat(id), entities = await Formatter.findAll({
+      where: idList.length > 0 ? { id: idList } : void 0
+    });
+    if (idList.length === 0 || entities.length === idList.length)
+      return entities.map((entity) => entity.toJSON());
+    const found = entities.map((entity) => entity.id), missing = idList.filter((item) => !found.includes(item));
+    throw new BackendError(404, `Formatter(id=[${missing}]) does not exist.`);
+  }
+  async function updateFormatter(data) {
+    const _a = data, { id } = _a, formatterData = __objRest$4(_a, ["id"]), entity = await Formatter.findByPk(id, { rejectOnEmpty: !0 });
+    return await entity.update(formatterData), entity.toJSON();
+  }
+  async function deleteFormatter(id) {
+    return await (await Formatter.findByPk(id, { rejectOnEmpty: !0 })).destroy(), { id };
+  }
+}
+var __getOwnPropSymbols$d = Object.getOwnPropertySymbols, __hasOwnProp$d = Object.prototype.hasOwnProperty, __propIsEnum$d = Object.prototype.propertyIsEnumerable, __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$d.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$d)
+    for (var prop of __getOwnPropSymbols$d(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$d.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
+function dbReportFactory(db) {
+  const { report: Report } = db;
+  return {
+    createReport,
+    readReport,
+    updateReport,
+    deleteReport
+  };
+  async function createReport(data) {
+    return (await Report.create({
+      name: data.name,
+      sections: [],
+      dimensions: []
+    }, {
+      include: reportQuery.include
+    })).toJSON();
+  }
+  async function readReport({ id, include } = {}) {
+    const idList = id == null ? [] : [].concat(id), entities = await Report.findAll({
+      where: idList.length > 0 ? { id: idList } : void 0,
+      include: include ? reportQuery.include : void 0
+    });
+    if (idList.length === 0 || entities.length === idList.length)
+      return entities.map((entity) => entity.toJSON());
+    const found = entities.map((entity) => entity.id), missing = idList.filter((item) => !found.includes(item));
+    throw new BackendError(404, `Report(id=${missing}) does not exist.`);
+  }
+  async function updateReport(data) {
+    const _a = data, {
+      id,
+      dimensions,
+      sections
+    } = _a, reportData = __objRest$3(_a, [
+      "id",
+      "dimensions",
+      "sections"
+    ]), entity = await Report.findByPk(id, {
+      include: reportQuery.include,
+      rejectOnEmpty: !0
+    });
+    return entity.set(reportData), await entity.save(), await entity.reload(), entity.toJSON();
+  }
+  async function deleteReport(id) {
+    return await (await Report.findByPk(id, { rejectOnEmpty: !0 })).destroy(), { id };
+  }
+}
+var __getOwnPropSymbols$c = Object.getOwnPropertySymbols, __hasOwnProp$c = Object.prototype.hasOwnProperty, __propIsEnum$c = Object.prototype.propertyIsEnumerable, __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$c.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$c)
+    for (var prop of __getOwnPropSymbols$c(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$c.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
+function dbSectionFactory(db) {
+  const { section: Section } = db;
+  return {
+    createSection,
+    readSection,
+    updateSection,
+    deleteSection
+  };
+  async function createSection(data) {
+    return (await Section.create({
+      ordering: data.ordering,
+      report_id: data.report_id,
+      blocks: []
+    }, {
+      include: sectionQuery.include
+    })).toJSON();
+  }
+  async function readSection({ id, include } = {}) {
+    const idList = id == null ? [] : [].concat(id), entities = await Section.findAll({
+      where: idList.length > 0 ? { id: idList } : void 0,
+      include: include ? sectionQuery.include : void 0
+    });
+    if (idList.length === 0 || entities.length === idList.length)
+      return entities.map((entity) => entity.toJSON());
+    const found = entities.map((entity) => entity.id), missing = idList.filter((item) => !found.includes(item));
+    throw new BackendError(404, `Section(id=${missing}) does not exist.`);
+  }
+  async function updateSection(data) {
+    const _a = data, { id, blocks } = _a, sectionData = __objRest$2(_a, ["id", "blocks"]), entity = await Section.findByPk(id, {
+      include: sectionQuery.include,
+      rejectOnEmpty: !0
+    });
+    return entity.set(sectionData), await entity.save(), await entity.reload(), entity.toJSON();
+  }
+  async function deleteSection(id) {
+    const entity = await Section.findByPk(id, { rejectOnEmpty: !0 });
+    return await entity.destroy(), { id, parentType: "report", parentId: entity.report_id };
+  }
+}
+var __getOwnPropSymbols$b = Object.getOwnPropertySymbols, __hasOwnProp$b = Object.prototype.hasOwnProperty, __propIsEnum$b = Object.prototype.propertyIsEnumerable, __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$b.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$b.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
+function dbVariantFactory(db, crud) {
+  const { variant: Variant } = db;
+  return {
+    createVariant,
+    readVariant,
+    updateVariant,
+    deleteVariant,
+    validateVariantSlug
+  };
+  async function createVariant(body) {
+    const { dimension_id: dimension, name, slug } = body, validSlug = await validateVariantSlug({ dimension, slug });
+    return (await Variant.create({
+      dimension_id: dimension,
+      name,
+      slug: validSlug.valid ? validSlug.candidate : validSlug.suggestion
+    })).toJSON();
+  }
+  async function readVariant({ id } = {}) {
+    const idList = id == null ? [] : [].concat(id), entities = await Variant.findAll({
+      where: idList.length > 0 ? { id: idList } : void 0
+    });
+    if (idList.length === 0 || entities.length === idList.length)
+      return entities.map((entity) => entity.toJSON());
+    const found = entities.map((entity) => entity.id), missing = idList.filter((item) => !found.includes(item));
+    throw new BackendError(404, `Variant(id=${missing}) does not exist.`);
+  }
+  async function updateVariant(data) {
+    const _a = data, { id } = _a, variantData = __objRest$1(_a, ["id"]), entity = await Variant.findByPk(id, {
+      include: [{ association: "dimension" }],
+      rejectOnEmpty: !0
+    });
+    return entity.update(variantData), await crud.ingestMembers(entity), await getSearchIndexByLocale(db, !0), await entity.reload(), entity.toJSON();
+  }
+  async function deleteVariant(id) {
+    const entity = await Variant.findByPk(id, { rejectOnEmpty: !0 });
+    return await entity.destroy(), getSearchIndexByLocale(db, !0), { id, parentType: "dimension", parentId: entity.dimension_id };
+  }
+  async function validateVariantSlug({ dimension, slug }) {
+    const allSlugsFromOtherDimensions = await Variant.findAll({
+      attributes: ["slug", [fn("COUNT", col("id")), "slugCount"]],
+      where: {
+        dimension_id: { [Op.ne]: dimension }
+      },
+      group: "slug"
+    }).then((arr) => Object.fromEntries(arr.map((item) => {
+      const count = item.getDataValue("slugCount");
+      return [item.slug, Number.parseInt(`${count}`, 10)];
+    })));
+    let suggestion = slug, iteration = 1, valid = !0;
+    for (; allSlugsFromOtherDimensions[suggestion]; )
+      valid = !1, suggestion = `${slug}-${iteration}`, iteration++;
+    return {
+      candidate: slug,
+      dimension_id: dimension,
+      suggestion,
+      valid
+    };
+  }
+}
+var __defProp$9 = Object.defineProperty, __getOwnPropSymbols$a = Object.getOwnPropertySymbols, __hasOwnProp$a = Object.prototype.hasOwnProperty, __propIsEnum$a = Object.prototype.propertyIsEnumerable, __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$9 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$a.call(b, prop) && __defNormalProp$9(a, prop, b[prop]);
+  if (__getOwnPropSymbols$a)
+    for (var prop of __getOwnPropSymbols$a(b))
+      __propIsEnum$a.call(b, prop) && __defNormalProp$9(a, prop, b[prop]);
+  return a;
+};
+function dbEntityFactory(dbModels) {
+  const simpleFactories = __spreadValues$9(__spreadValues$9(__spreadValues$9(__spreadValues$9(__spreadValues$9(__spreadValues$9({}, dbBlockFactory(dbModels)), dbDimensionFactory(dbModels)), dbFormatterFactory(dbModels)), dbMemberFactory(dbModels)), dbReportFactory(dbModels)), dbSectionFactory(dbModels)), crud = __spreadValues$9(__spreadValues$9({}, simpleFactories), dbVariantFactory(dbModels, simpleFactories));
+  return {
+    createFormatter: resultWrapper(crud.createFormatter),
+    deleteFormatter: resultWrapper(crud.deleteFormatter),
+    readFormatter: resultWrapper(crud.readFormatter),
+    updateFormatter: resultWrapper(crud.updateFormatter),
+    createReport: resultWrapper(crud.createReport),
+    deleteReport: resultWrapper(crud.deleteReport),
+    readReport: resultWrapper(crud.readReport),
+    updateReport: resultWrapper(crud.updateReport),
+    createDimension: resultWrapper(crud.createDimension),
+    deleteDimension: resultWrapper(crud.deleteDimension),
+    readDimension: resultWrapper(crud.readDimension),
+    updateDimension: resultWrapper(crud.updateDimension),
+    createVariant: resultWrapper(crud.createVariant),
+    readVariant: resultWrapper(crud.readVariant),
+    updateVariant: resultWrapper(crud.updateVariant),
+    deleteVariant: resultWrapper(crud.deleteVariant),
+    validateVariantSlug: resultWrapper(crud.validateVariantSlug),
+    createSection: resultWrapper(crud.createSection),
+    readSection: resultWrapper(crud.readSection),
+    updateSection: resultWrapper(crud.updateSection),
+    deleteSection: resultWrapper(crud.deleteSection),
+    createBlock: resultWrapper(crud.createBlock),
+    deleteBlock: resultWrapper(crud.deleteBlock),
+    readBlock: resultWrapper(crud.readBlock),
+    updateBlock: resultWrapper(crud.updateBlock),
+    readMember: resultWrapper(crud.readMember),
+    searchMember: resultWrapper(crud.searchMember),
+    updateMember: resultWrapper(crud.updateMember),
+    readMemberImage: resultWrapper(crud.readMemberImage)
+  };
+}
+const catcher = (e) => {
+  throw console.error("/methods/helpers/uploadImage.ts:", e), new Error(e.message);
+}, splashWidth = Number(process.env.NEXT_PUBLIC_IMAGE_SPLASH_WIDTH) || 1400, thumbWidth = Number(process.env.NEXT_PUBLIC_IMAGE_THUMB_WIDTH) || 400, uploadImage = async (db, id, imageData) => {
+  const configs = [
+    { type: "splash", res: splashWidth },
+    { type: "thumb", res: thumbWidth }
+  ];
+  for (const config of configs) {
+    const buffer = await sharp(imageData).resize(config.res).toFormat("jpeg").jpeg({ force: !0 }).toBuffer().catch(catcher);
+    await db.image.update({ [config.type]: buffer }, { where: { id } }).catch(catcher);
+  }
+};
+var __defProp$8 = Object.defineProperty, __getOwnPropSymbols$9 = Object.getOwnPropertySymbols, __hasOwnProp$9 = Object.prototype.hasOwnProperty, __propIsEnum$9 = Object.prototype.propertyIsEnumerable, __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$8 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$9.call(b, prop) && __defNormalProp$8(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b))
+      __propIsEnum$9.call(b, prop) && __defNormalProp$8(a, prop, b[prop]);
+  return a;
+};
+const validLicenses = ["4", "5", "7", "8", "9", "10"], validLicensesString = validLicenses.join(), { locales: locales$3 } = getLocales();
+let flickr;
+if (process.env.FLICKR_API_KEY)
+  try {
+    flickr = new FlickrSDK(process.env.FLICKR_API_KEY);
+  } catch (e) {
+    throw console.error("Flickr ERROR:", e), new Error(e.message);
+  }
+async function searchFlickrProvider(db, params) {
+  try {
+    const searchParams = {
+      prompt: params.prompt || ""
+    };
+    if (!flickr)
+      throw console.log("Flickr is not initialized. Check the credentials"), new Error("Flickr is not initialized. Check the credentials");
+    const q = searchParams.prompt, photos = (await flickr.photos.search({
+      text: q,
+      license: validLicensesString,
+      sort: "relevance"
+    }).then((resp) => resp.body)).photos.photo, fetches = photos.reduce(
+      (acc, d) => acc.concat(flickr.photos.getSizes({ photo_id: d.id })),
+      []
+    ), imagesResults = (await Promise.all(fetches).then((results2) => results2)).reduce((acc, d, i) => {
+      const small = d.body.sizes.size.find((s) => s.label === "Small 320");
+      return small && acc.push({
+        id: photos[i].id,
+        source: small.source
+      }), acc;
+    }, []);
+    return {
+      meta: {
+        prompt: stripHTML(searchParams.prompt)
+      },
+      results: imagesResults
+    };
+  } catch (error) {
+    throw console.log(error), new Error("Error in search flickr provider");
+  }
+}
+async function saveFlickrProvider(db, params) {
+  try {
+    const { content_id, image_id } = params, searchParams = {
+      content_id: stripHTML(`${content_id}`) || "",
+      id: stripHTML(`${image_id}`) || ""
+    }, url = `https://flic.kr/p/${Base58.int_to_base58(image_id)}`;
+    if (!flickr)
+      throw new Error("Flickr API Key not configured");
+    const info = await flickr.photos.getInfo({ photo_id: image_id }).then((resp) => resp.body);
+    let newRow;
+    if (info)
+      if (validLicenses.includes(info.photo.license)) {
+        const searchRow = await db.search.findOne({ where: { content_id } }), imageRow = await db.image.findOne({ where: { url } });
+        if (searchRow) {
+          if (imageRow)
+            await db.search.update({ image_id: imageRow.id }, { where: { content_id } });
+          else {
+            const sizeObj = await flickr.photos.getSizes({ photo_id: image_id }).then((resp) => resp.body);
+            let image = sizeObj.sizes.size.find(
+              (d) => parseInt(d.width, 10) >= 1600
+            );
+            if (image || (image = sizeObj.sizes.size.find(
+              (d) => parseInt(d.width, 10) >= 1e3
+            )), image || (image = sizeObj.sizes.size.find(
+              (d) => parseInt(d.width, 10) >= 500
+            )), !image || !image.source)
+              throw new Error("Flickr Source Error, try another image.");
+            const imageData = await axios.get(image.source, { responseType: "arraybuffer" }).then((d) => d.data), currentPhotoLicense = (await flickr.photos.licenses.getInfo().then((resp) => resp.body.licenses.license)).find((l) => l.id === parseInt(info.photo.license, 10)), payload = {
+              url,
+              author: info.photo.owner.realname || info.photo.owner.username,
+              license: currentPhotoLicense ? `${currentPhotoLicense.name}: ${currentPhotoLicense.url}` : ""
+            }, newImage = await db.image.create(payload);
+            await db.image_content.destroy({ where: { id: newImage.id } });
+            const contentPayload = locales$3.map((locale) => ({
+              id: newImage.id,
+              locale,
+              meta: info.photo.title._content
+            }));
+            await db.image_content.bulkCreate(contentPayload), await db.search.update({ image_id: newImage.id }, { where: { content_id } }), await uploadImage(db, newImage.id, imageData);
+          }
+          const newRow2 = await db.search.findOne({
+            where: { content_id },
+            include: imageQueryThumbOnly
+          });
+          newRow2 && newRow2.image && (newRow2.image.thumb = Boolean(newRow2.image.thumb));
+        } else
+          throw new Error("Error updating Search");
+      } else
+        throw new Error("Bad License");
+    else
+      throw new Error("Malformed URL");
+    return {
+      meta: __spreadValues$8({}, searchParams),
+      results: newRow
+    };
+  } catch (error) {
+    throw console.log(error), new Error("Error in save flickr provider");
+  }
+}
+function endpoint(method, path, handler) {
+  return { method, path, handler };
+}
+function parseFiniteNumber(value) {
+  const num = Number.parseInt(`${value || ""}`, 10);
+  if (Number.isNaN(num) || !Number.isFinite(num))
+    throw new BackendError(400, `Invalid numeric parameter: ${value}`);
+  return num;
+}
+function normalizeList(value) {
+  return value == null || value === "" ? [] : value.toString().split(",");
+}
+const { localeDefault: localeDefault$1 } = getLocales();
+function endpointMemberFactory(operations) {
+  const {
+    readMember,
+    searchMember,
+    updateMember,
+    readMemberImage
+  } = operations;
+  return [
+    endpoint("GET", "read/members", async (req) => {
+      const params = parseReadMemberParams(req.query);
+      if (params.ids.length > 1 && params.slugs.length > 1)
+        throw new BackendError(400, "Both 'ids' and 'slugs' are filled. Pick one.");
+      if (params.ids.length === 0 && params.slugs.length === 0)
+        throw new BackendError(400, "Params 'ids' and 'slugs' are missing. Fill one.");
+      if ((params.mode === "ids" ? params.ids.length : params.slugs.length) > 5)
+        throw new BackendError(400, "Too many 'ids' and 'slugs' in the request. Try with less than 5.");
+      return readMember(params);
+    }),
+    endpoint("GET", "search/members", (req) => {
+      const params = parseSearchMemberParams(req.query);
+      return searchMember(params);
+    }),
+    endpoint("POST", "update/member", (req) => {
+      const { body } = req;
+      return updateMember(body);
+    }),
+    endpoint("GET", "member/image.png", (req) => {
+      const size = normalizeList(req.query.size)[0];
+      return readMemberImage({
+        member: parseFiniteNumber(req.query.member),
+        size: size && size === "large" ? "large" : "thumb"
+      });
+    })
+  ];
+}
+function parseReadMemberParams(query) {
+  const ids = normalizeList(query.ids).map(parseFiniteNumber), locale = normalizeList(query.locale)[0] || localeDefault$1 || "en", localeIsAll = locale === "all";
+  return {
+    all: localeIsAll,
+    ids,
+    locale: localeIsAll ? localeDefault$1 : locale,
+    mode: ids.length > 0 ? "ids" : "slugs",
+    slugs: normalizeList(query.slugs).map((token) => {
+      const [variantSlug, memberSlug] = token.split("/");
+      return { variantSlug, memberSlug };
+    })
+  };
+}
+function parseSearchMemberParams(query) {
+  var _a;
+  const locale = normalizeList(query.locale)[0] || localeDefault$1 || "en", localeIsAll = locale === "all", format = normalizeList(query.format)[0], formatIsNested = format ? format === "nested" : localeIsAll;
+  return {
+    query: normalizeList(query.query || query.q)[0] || "",
+    locale: localeIsAll ? localeDefault$1 : locale,
+    limit: (_a = normalizeList(query.limit).map(parseFiniteNumber)[0]) != null ? _a : 5,
+    format: formatIsNested ? "nested" : "plain",
+    includes: yn(query.includes, { default: !0 }),
+    visible: yn(query.visible, { default: !0 }),
+    noImage: yn(query.noImage, { default: !1 }),
+    variant: normalizeList(query.variant).map(parseFiniteNumber),
+    dimension: normalizeList(query.dimension).map(parseFiniteNumber),
+    report: normalizeList(query.report).map(parseFiniteNumber),
+    all: localeIsAll,
+    sort: normalizeList(query.sort)[0],
+    direction: normalizeList(query.direction)[0]
+  };
+}
+var __defProp$7 = Object.defineProperty, __defProps$5 = Object.defineProperties, __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$8 = Object.getOwnPropertySymbols, __hasOwnProp$8 = Object.prototype.hasOwnProperty, __propIsEnum$8 = Object.prototype.propertyIsEnumerable, __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$8.call(b, prop) && __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(b))
+      __propIsEnum$8.call(b, prop) && __defNormalProp$7(a, prop, b[prop]);
+  return a;
+}, __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+async function searchLocalProvider(db, params) {
+  const dbSearchMember = dbSearchMemberFactory(db), searchParams = parseSearchMemberParams({
+    query: params.prompt,
+    limit: "50",
+    visible: "false"
+  }), imagesResults = (await dbSearchMember(searchParams)).results.filter((member) => member.image_id).map((member) => ({
+    id: member.image_id,
+    source: `/api/cms/member/image.png?member=${member.content_id}&size=thumb`
+  }));
+  return {
+    meta: {
+      prompt: stripHTML(searchParams.query)
+    },
+    results: imagesResults
+  };
+}
+async function saveLocalProvider(db, params) {
+  const { search: Search } = db, { content_id, image_id } = params;
+  await Search.update({ image_id }, { where: { content_id } });
+  const item = await Search.findOne({
+    where: { content_id },
+    include: imageQueryThumbOnly
+  }).then((item2) => {
+    if (!item2)
+      return null;
+    const plainItem = item2.toJSON();
+    return __spreadProps$5(__spreadValues$7({}, plainItem), {
+      image: __spreadProps$5(__spreadValues$7({}, item2.image.toJSON()), {
+        thumb: !!item2.image.thumb
+      })
+    });
+  });
+  return {
+    meta: {
+      id: image_id,
+      content_id
+    },
+    results: item
+  };
+}
+var __defProp$6 = Object.defineProperty, __getOwnPropSymbols$7 = Object.getOwnPropertySymbols, __hasOwnProp$7 = Object.prototype.hasOwnProperty, __propIsEnum$7 = Object.prototype.propertyIsEnumerable, __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$7.call(b, prop) && __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b))
+      __propIsEnum$7.call(b, prop) && __defNormalProp$6(a, prop, b[prop]);
+  return a;
+};
+const { locales: locales$2 } = getLocales();
+let unsplash;
+if (process.env.UNSPLASH_API_KEY)
+  try {
+    unsplash = createApi({
+      accessKey: process.env.UNSPLASH_API_KEY
+    });
+  } catch (e) {
+    throw console.error("Unsplash error:", e), new Error(e.message);
+  }
+async function searchUnsplashProvider(db, params) {
+  try {
+    const searchParams = {
+      prompt: params.prompt || ""
+    };
+    if (!unsplash)
+      throw new Error("Unsplash API Key not configured");
+    const q = searchParams.prompt, imagesResults = (await unsplash.search.getPhotos({
+      query: q,
+      perPage: 30
+    }).then((resp) => resp.response.results)).map((image) => ({
+      id: image.id,
+      source: image.urls.thumb
+    }));
+    return {
+      meta: {
+        prompt: stripHTML(searchParams.prompt)
+      },
+      results: imagesResults
+    };
+  } catch (error) {
+    throw console.log(error), new Error("Error in search unsplash provider");
+  }
+}
+async function saveUnsplashProvider(db, params) {
+  try {
+    const { content_id, image_id } = params, saveParams = {
+      content_id: stripHTML(`${content_id}`) || "",
+      id: stripHTML(`${image_id}`) || ""
+    };
+    if (!unsplash)
+      throw console.log("Unsplash is not initialized. Check the credentials"), new Error("Unsplash is not initialized. Check the credentials");
+    const info = await unsplash.photos.get({ photoId: image_id }).then((resp) => resp.response);
+    let newRow;
+    if (info) {
+      const searchRow = await db.search.findOne({ where: { content_id } }), url = info.links.html, imageRow = await db.image.findOne({ where: { url } });
+      if (searchRow) {
+        if (imageRow)
+          await db.search.update({ image_id: imageRow.id }, { where: { content_id } });
+        else {
+          const imageData = await axios.get(info.urls.full, { responseType: "arraybuffer" }).then((d) => d.data), payload = {
+            url,
+            author: info.user.name || info.user.username,
+            license: "Free Unsplash license: https://unsplash.com/license"
+          }, newImage = await db.image.create(payload);
+          await db.image_content.destroy({ where: { id: newImage.id } });
+          const contentPayload = locales$2.map((locale) => ({
+            id: newImage.id,
+            locale,
+            meta: info.description || info.alt_description
+          }));
+          await db.image_content.bulkCreate(contentPayload), await db.search.update({ image_id: newImage.id }, { where: { content_id } }), await uploadImage(db, newImage.id, imageData);
+        }
+        const newRow2 = await db.search.findOne({
+          where: { content_id },
+          include: imageQueryThumbOnly
+        });
+        newRow2 && newRow2.image && (newRow2.image.thumb = Boolean(newRow2.image.thumb));
+      } else
+        throw new Error("Error updating Search");
+    } else
+      throw new Error("Malformed URL");
+    return {
+      meta: __spreadValues$6({}, saveParams),
+      results: newRow
+    };
+  } catch (error) {
+    throw console.log(error), new Error("Error in save unsplash provider");
+  }
+}
+var __defProp$5 = Object.defineProperty, __getOwnPropSymbols$6 = Object.getOwnPropertySymbols, __hasOwnProp$6 = Object.prototype.hasOwnProperty, __propIsEnum$6 = Object.prototype.propertyIsEnumerable, __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$6.call(b, prop) && __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b))
+      __propIsEnum$6.call(b, prop) && __defNormalProp$5(a, prop, b[prop]);
+  return a;
+};
+const { locales: locales$1 } = getLocales();
+async function saveUploadProvider(db, params) {
+  try {
+    const { content_id, image_source, files } = params, saveParams = {
+      content_id: stripHTML(`${content_id}`) || ""
+    };
+    if (await db.search.findOne({ where: { content_id } }) && files) {
+      const imageData = await fs.readFileSync(files.file.path), payload = {
+        url: image_source,
+        author: "",
+        license: ""
+      }, newImage = await db.image.create(payload);
+      await db.image_content.destroy({ where: { id: newImage.id } });
+      const contentPayload = locales$1.map((locale) => ({
+        id: newImage.id,
+        locale,
+        meta: ""
+      }));
+      await db.image_content.bulkCreate(contentPayload), await db.search.update({ image_id: newImage.id }, { where: { content_id } }), await uploadImage(db, newImage.id, imageData);
+    }
+    const newRow = await db.search.findOne({
+      where: { content_id },
+      include: imageQueryThumbOnly
+    });
+    return newRow && newRow.image && (newRow.image.thumb = Boolean(newRow.image.thumb)), {
+      meta: __spreadValues$5({}, saveParams),
+      results: newRow
+    };
+  } catch (error) {
+    throw console.log(error), new Error("Error in save upload provider");
+  }
+}
+const saveProviders = {
+  local: saveLocalProvider,
+  flickr: saveFlickrProvider,
+  unsplash: saveUnsplashProvider,
+  upload: saveUploadProvider
+};
+function dbImageSaveFactory(db, provider) {
+  const saveProvider = saveProviders[provider];
+  if (!saveProvider)
+    throw new BackendError(500, `Wrong provider dbImageSaveFactory.ts: ${provider}`);
+  return resultWrapper((params) => saveProvider(db, params));
+}
+const searchProviders = {
+  local: searchLocalProvider,
+  flickr: searchFlickrProvider,
+  unsplash: searchUnsplashProvider
+};
+function dbImageSearchFactory(db, provider) {
+  const searchProvider = searchProviders[provider];
+  if (!searchProvider)
+    throw new BackendError(500, `Wrong provider dbImageSearchFactory.ts: ${provider}`);
+  return resultWrapper((params) => searchProvider(db, params));
+}
+var __defProp$4 = Object.defineProperty, __defProps$4 = Object.defineProperties, __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$5 = Object.getOwnPropertySymbols, __hasOwnProp$5 = Object.prototype.hasOwnProperty, __propIsEnum$5 = Object.prototype.propertyIsEnumerable, __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$5.call(b, prop) && __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b))
+      __propIsEnum$5.call(b, prop) && __defNormalProp$4(a, prop, b[prop]);
+  return a;
+}, __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+function dbReadMetadataFactory(db) {
+  const { report: Report } = db;
+  return dbReadMetadata;
+  async function dbReadMetadata(_params) {
+    return {
+      data: (await Report.findAll({
+        attributes: ["id", "name"],
+        include: [{
+          attributes: ["id", "name"],
+          association: "dimensions",
+          separate: !0,
+          include: [
+            {
+              attributes: ["id", "name", "slug"],
+              association: "variants",
+              separate: !0
+            }
+          ]
+        }]
+      })).map((report) => __spreadProps$4(__spreadValues$4({}, report.toJSON()), {
+        mode: report.dimensions.length === 1 ? REPORT_MODES.UNILATERAL : REPORT_MODES.MULTILATERAL
+      }))
+    };
+  }
+}
+function dbRegenerateSearchFactory(db) {
+  return async (_params) => (await getSearchIndexByLocale(db, !0), { error: !1 });
+}
+var __defProp$3 = Object.defineProperty, __defProps$3 = Object.defineProperties, __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$4 = Object.getOwnPropertySymbols, __hasOwnProp$4 = Object.prototype.hasOwnProperty, __propIsEnum$4 = Object.prototype.propertyIsEnumerable, __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$4.call(b, prop) && __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b))
+      __propIsEnum$4.call(b, prop) && __defNormalProp$3(a, prop, b[prop]);
+  return a;
+}, __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+const { locales, localeDefault } = getLocales(), addProfilesData = (items, metadata) => {
+  if (!items)
+    return [];
+  let profileResults = [];
+  return metadata.forEach((report) => {
+    const results = items.filter((result) => result.metadata.report.id === report.id);
+    if (results.length > 0)
+      if (report.mode === REPORT_MODES.UNILATERAL) {
+        const dimension = report.dimensions[0];
+        dimension.variants.forEach((variant) => {
+          const members = results.filter(
+            (result) => result.metadata.dimension.id === dimension.id && result.metadata.variant.id === variant.id
+          );
+          members.length > 0 && (profileResults = profileResults.concat(members.map((member) => ({
+            path: `/${variant.slug}/${member.slug}`,
+            name: member.name,
+            report: {
+              id: report.id,
+              name: report.name,
+              mode: report.mode
+            },
+            members: [member],
+            id: `r-${report.id}-${[member].map((m) => `${m.id}`).join("-")}`
+          }))));
+        });
+      } else
+        report.mode;
+  }), profileResults;
+}, formatNested = (items, metadata) => {
+  if (!items)
+    return [];
+  let report, dimension, variant;
+  return items.map((item) => (report = __spreadValues$3({}, metadata.find((r) => r.id === item.report_id)), dimension = __spreadValues$3({}, report.dimensions.find((d) => d.id === item.dimension_id)), variant = __spreadValues$3({}, dimension.variants.find((v) => v.id === item.variant_id)), delete report.dimensions, delete dimension.variants, {
+    name: item.name,
+    confidence: item.zvalue,
+    metadata: {
+      id: item.id,
+      slug: item.slug,
+      report,
+      dimension,
+      variant
+    },
+    id: item.content_id,
+    slug: item.slug
+  }));
+};
+function dbSearchReportFactory(db) {
+  const dbSearchMember = dbSearchMemberFactory(db), dbReadMetadata = dbReadMetadataFactory(db);
+  return dbSearchReport;
+  async function dbSearchReport(params) {
+    const format = params.format || "results", locale = locales.includes(params.locale) ? params.locale : localeDefault, memberSearchResponse = await dbSearchMember(__spreadProps$3(__spreadValues$3({}, params), {
+      format: "plain",
+      locale: stripHTML(locale),
+      visible: !0
+    }));
+    let reportSearchResults = memberSearchResponse.results ? memberSearchResponse.results : [], tempResults;
+    const metadata = (await dbReadMetadata()).data;
+    switch (format) {
+      case "profiles":
+        tempResults = formatNested(reportSearchResults, metadata), reportSearchResults = addProfilesData(tempResults, metadata);
+        break;
+    }
+    return {
+      meta: __spreadProps$3(__spreadValues$3({}, memberSearchResponse.meta), {
+        format
+      }),
+      results: reportSearchResults
+    };
+  }
+}
+function dbUrlProxyFactory() {
+  return async (request) => {
+    var _a;
+    const config = typeof request == "string" ? { url: request } : request;
+    try {
+      const response = await axios.request(config);
+      return {
+        ok: !0,
+        status: response.status,
+        data: response.data
+      };
+    } catch (err) {
+      throw new BackendError(((_a = err.response) == null ? void 0 : _a.status) || 500, err.message);
+    }
+  };
+}
+var __defProp$2 = Object.defineProperty, __defProps$2 = Object.defineProperties, __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$3 = Object.getOwnPropertySymbols, __hasOwnProp$3 = Object.prototype.hasOwnProperty, __propIsEnum$3 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$3.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b))
+      __propIsEnum$3.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  return a;
+}, __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+function useDatabaseApi(_, __, api) {
+  return getDB().then((dbModels) => {
+    Object.assign(api, apiFactory(dbModels));
+  });
+}
+function apiFactory(dbModels) {
+  return __spreadProps$2(__spreadValues$2({}, dbEntityFactory(dbModels)), {
+    searchReport: resultWrapper(dbSearchReportFactory(dbModels)),
+    readMetadata: resultWrapper(dbReadMetadataFactory(dbModels)),
+    regenerateSearch: resultWrapper(dbRegenerateSearchFactory(dbModels)),
+    imageFlickrSearch: dbImageSearchFactory(dbModels, "flickr"),
+    imageLocalSearch: dbImageSearchFactory(dbModels, "local"),
+    imageUnsplashSearch: dbImageSearchFactory(dbModels, "unsplash"),
+    imageFlickrSave: dbImageSaveFactory(dbModels, "flickr"),
+    imageLocalSave: dbImageSaveFactory(dbModels, "local"),
+    imageUnsplashSave: dbImageSaveFactory(dbModels, "unsplash"),
+    imageUploadSave: dbImageSaveFactory(dbModels, "upload"),
+    urlProxy: dbUrlProxyFactory()
+  });
+}
+var __defProp$1 = Object.defineProperty, __defProps$1 = Object.defineProperties, __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$2.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b))
+      __propIsEnum$2.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
+  return a;
+}, __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+async function parseBody(req) {
+  const form = new formidable.IncomingForm();
+  form.encoding = "utf-8";
+  const bodyData = await new Promise((resolve, reject) => {
+    form.parse(req, (err, fields, files) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve({ fields, files });
+    });
+  });
+  return __spreadProps$1(__spreadValues$1({}, bodyData.fields), {
+    files: bodyData.files
+  });
+}
+function endpointCRUDFactory(api, entity) {
+  const crudCreate = pickMethod(api, "create", entity), crudRead = pickMethod(api, "read", entity), crudUpdate = pickMethod(api, "update", entity), crudDelete = pickMethod(api, "delete", entity);
+  return [
+    endpoint("POST", `create/${entity}`, (req) => {
+      const { body } = req;
+      return crudCreate(body);
+    }),
+    endpoint("GET", `read/${entity}`, (req) => {
+      const params = req.query, id = normalizeList(params.id).map(parseFiniteNumber);
+      return crudRead({ id, include: yn(params.include) });
+    }),
+    endpoint("POST", `update/${entity}`, (req) => {
+      const { body } = req;
+      return crudUpdate(body);
+    }),
+    endpoint("DELETE", `delete/${entity}`, (req) => {
+      const id = parseFiniteNumber(req.body.id);
+      return crudDelete(id);
+    })
+  ];
+}
+function endpointVariantCRUDFactory(api) {
+  const { validateVariantSlug } = api;
+  return [
+    ...endpointCRUDFactory(api, "variant"),
+    endpoint("GET", "validate/variant", (req) => {
+      const params = req.query, dimension = parseFiniteNumber(params.dimension);
+      return validateVariantSlug({ dimension, slug: slugify(params.slug) });
+    })
+  ];
+}
+function endpointImageSaveFactory(operations, provider) {
+  const saveMethodKey = `image${capitalize(provider)}Save`, saveMethod = operations[saveMethodKey];
+  return endpoint("POST", `images/save/${provider}`, (req) => {
+    const params = req.body;
+    if (!params.content_id)
+      throw new BackendError(400, "Missing 'content_id' parameter.");
+    if (!params.image_id)
+      throw new BackendError(400, "Missing 'image_id' parameter.");
+    return saveMethod(params);
+  });
+}
+function endpointImageSearchFactory(operations, provider) {
+  const searchMethodKey = `image${capitalize(provider)}Search`, searchMethod = operations[searchMethodKey];
+  return endpoint("GET", `images/search/${provider}`, async (req) => {
+    const prompt = normalizeList(req.query.prompt)[0];
+    if (!prompt)
+      throw new BackendError(400, "Empty 'prompt' param.");
+    return searchMethod({ prompt });
+  });
+}
+function endpointReadMetadataFactory(operations) {
+  const { readMetadata } = operations;
+  return endpoint("GET", "read/metadata", () => readMetadata({}));
+}
+function endpointRegenerateSearchFactory(operations) {
+  const { regenerateSearch } = operations;
+  return endpoint("POST", "search/regenerate", () => regenerateSearch(void 0));
+}
+var __defProp = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$1 = Object.getOwnPropertySymbols, __hasOwnProp$1 = Object.prototype.hasOwnProperty, __propIsEnum$1 = Object.prototype.propertyIsEnumerable, __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$1.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b))
+      __propIsEnum$1.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  return a;
+}, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function endpointSearchReportFactory(operations) {
+  const { searchReport } = operations;
+  return endpoint("GET", "search/reports", (req) => {
+    const params = parseSearchReportParams(req.query);
+    return searchReport(params);
+  });
+}
+function parseSearchReportParams(query) {
+  return __spreadProps(__spreadValues({}, parseSearchMemberParams(query)), {
+    format: normalizeList(query.format)[0]
+  });
+}
+function endpointUrlProxyFactory(operations) {
+  const { urlProxy } = operations;
+  return endpoint("GET", "url/proxy", (req) => {
+    const { url, method } = req.query;
+    return console.log("endpointUrlProxy", url), urlProxy({
+      url: normalizeList(url)[0],
+      method: normalizeList(method)[0] === "POST" ? "POST" : "GET"
+    });
+  });
+}
+var __getOwnPropSymbols = Object.getOwnPropertySymbols, __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable, __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
+const verbose = getLogging();
+function endpointKey(method, path) {
+  return `${method.toUpperCase()} ${path.toLowerCase()}`;
+}
+function getEndpointMap(db) {
+  const api = apiFactory(db);
+  return Object.fromEntries([
+    ...endpointCRUDFactory(api, "block"),
+    ...endpointCRUDFactory(api, "dimension"),
+    ...endpointCRUDFactory(api, "formatter"),
+    ...endpointCRUDFactory(api, "report"),
+    ...endpointCRUDFactory(api, "section"),
+    ...endpointVariantCRUDFactory(api),
+    ...endpointMemberFactory(api),
+    endpointSearchReportFactory(api),
+    endpointReadMetadataFactory(api),
+    endpointRegenerateSearchFactory(api),
+    endpointImageSaveFactory(api, "flickr"),
+    endpointImageSaveFactory(api, "local"),
+    endpointImageSaveFactory(api, "unsplash"),
+    endpointImageSaveFactory(api, "upload"),
+    endpointImageSearchFactory(api, "flickr"),
+    endpointImageSearchFactory(api, "local"),
+    endpointImageSearchFactory(api, "unsplash"),
+    endpointUrlProxyFactory(api)
+  ].map(({ handler, method, path }) => [endpointKey(method, path), handler]));
+}
+const endpointMap = getDB().then(getEndpointMap);
+async function endpointNextJsHandlerFactory(req, res) {
+  await NextCors(req, res, {
+    methods: ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
+    origin: "*"
+  });
+  const { query: queryParams, method } = req, _a = queryParams, { path } = _a, query = __objRest(_a, ["path"]);
+  if (path && method) {
+    const handler = await endpointMap.then((map) => {
+      const pathString = [].concat(path).join("/"), key = endpointKey(method, pathString);
+      return map[key];
+    });
+    if (handler)
+      return ["POST", "DELETE"].includes(method) && (req.body = await parseBody(req)), Promise.resolve(req).then(handler).then((result) => {
+        if ("error" in result)
+          throw new BackendError(result.status, result.error);
+        if (result.data instanceof Buffer) {
+          const image = result.data;
+          res.writeHead(result.status, { "Content-Type": "image/png" }).end(image, "binary");
+        } else
+          res.status(result.status).json({ data: result.data });
+      }).catch((err) => {
+        verbose && console.trace(err), res.status(err.code).json({ error: err.message });
+      });
+  } else
+    path || await endpointMap.then(console.log);
+  return res.status(404).json({ error: "No matching route", path, query });
+}
+const reportsCrosswalkEntrypointFn = (crosswalk) => {
+  const crosswalkFn = crosswalk;
+  return async function(req, res) {
+    const response = await crosswalkFn({ test: "pala" });
+    return res.json(response);
+  };
+};
+export {
+  reportsCrosswalkEntrypointFn as ReportCrosswalkHandler,
+  apiFactory as dbApiFactory,
+  endpointKey,
+  endpointNextJsHandlerFactory,
+  getDB,
+  useDatabaseApi
+};