@overturo/js 0.0.0-stage → 1.5.2

package/dist/field/index.js

@@ -0,0 +1,1251 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// node_modules/ajv/dist/runtime/ucs2length.js
+var require_ucs2length = __commonJS({
+  "node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function ucs2length(str) {
+      const len = str.length;
+      let length = 0;
+      let pos = 0;
+      let value;
+      while (pos < len) {
+        length++;
+        value = str.charCodeAt(pos++);
+        if (value >= 55296 && value <= 56319 && pos < len) {
+          value = str.charCodeAt(pos);
+          if ((value & 64512) === 56320)
+            pos++;
+        }
+      }
+      return length;
+    }
+    exports.default = ucs2length;
+    ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
+  }
+});
+
+// src/constants.ts
+var EMBED_DEFAULTS = {
+  width: "100%",
+  minHeight: "400px",
+  maxHeight: "none",
+  border: "none",
+  borderRadius: "0",
+  background: "transparent"
+};
+var EMBED_STYLE_KEYS = Object.keys(EMBED_DEFAULTS);
+var DEFAULT_BASE_URL = "https://overturo.com";
+var CONSENT_FIELD_ELEMENT_NAME = "overturo-consent-field";
+
+// src/field/constants.ts
+var FIELD_PROTOCOL_VERSION = 1;
+var FIELD_ELEMENT_NAME = CONSENT_FIELD_ELEMENT_NAME;
+var FIELD_MESSAGE_TYPES = {
+  READY: "overturo-field:ready",
+  STATE: "overturo-field:state",
+  RESIZE: "overturo-field:resize",
+  COMPLETE: "overturo-field:complete",
+  ERROR: "overturo-field:error",
+  SUBMIT_REQUESTED: "overturo-field:submit_requested",
+  INIT: "overturo-field:init",
+  CAPTURE: "overturo-field:capture",
+  RESET: "overturo-field:reset"
+};
+var FIELD_DOCUMENT_PATH = "/decisions/fields";
+
+// src/field/appearance.ts
+var APPEARANCE_KEYS = ["fontFamily", "fontSize", "text", "muted", "accent", "border", "radius", "density"];
+function sanitiseAppearance(input) {
+  const out = {};
+  if (!input || typeof input !== "object") return out;
+  for (const key of APPEARANCE_KEYS) {
+    const value = input[key];
+    if (typeof value === "string" && value.length <= 64) out[key] = value;
+  }
+  return out;
+}
+function encodeAppearance(input) {
+  const clean = sanitiseAppearance(input);
+  if (Object.keys(clean).length === 0) return "";
+  const json = JSON.stringify(clean);
+  const b64 = btoa(unescape(encodeURIComponent(json)));
+  return `#a=${b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`;
+}
+
+// src/generated/field-v1/envelope.js
+var envelope_default = validate22;
+var schema33 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/field-v1/envelope.json", "title": "Embedded consent field envelope v1", "type": "object", "additionalProperties": false, "required": ["type", "version", "payload", "ts", "message_id"], "properties": { "type": { "type": "string", "enum": ["overturo-field:ready", "overturo-field:state", "overturo-field:resize", "overturo-field:complete", "overturo-field:error", "overturo-field:submit_requested", "overturo-field:init", "overturo-field:capture", "overturo-field:reset"] }, "version": { "type": "integer", "const": 1 }, "payload": { "type": "object", "additionalProperties": true }, "ts": { "type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$" }, "message_id": { "type": "string", "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" } } };
+var pattern4 = new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$", "u");
+var pattern5 = new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$", "u");
+function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate22.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.type === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.version === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "version" }, message: "must have required property 'version'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.payload === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "payload" }, message: "must have required property 'payload'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.ts === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "ts" }, message: "must have required property 'ts'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.message_id === void 0) {
+      const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "message_id" }, message: "must have required property 'message_id'" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!(key0 === "type" || key0 === "version" || key0 === "payload" || key0 === "ts" || key0 === "message_id")) {
+        const err5 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.type !== void 0) {
+      let data0 = data.type;
+      if (typeof data0 !== "string") {
+        const err6 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+      if (!(data0 === "overturo-field:ready" || data0 === "overturo-field:state" || data0 === "overturo-field:resize" || data0 === "overturo-field:complete" || data0 === "overturo-field:error" || data0 === "overturo-field:submit_requested" || data0 === "overturo-field:init" || data0 === "overturo-field:capture" || data0 === "overturo-field:reset")) {
+        const err7 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/enum", keyword: "enum", params: { allowedValues: schema33.properties.type.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+    if (data.version !== void 0) {
+      let data1 = data.version;
+      if (!(typeof data1 == "number" && (!(data1 % 1) && !isNaN(data1)))) {
+        const err8 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+      if (1 !== data1) {
+        const err9 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/const", keyword: "const", params: { allowedValue: 1 }, message: "must be equal to constant" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.payload !== void 0) {
+      let data2 = data.payload;
+      if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+      } else {
+        const err10 = { instancePath: instancePath + "/payload", schemaPath: "#/properties/payload/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.ts !== void 0) {
+      let data3 = data.ts;
+      if (typeof data3 === "string") {
+        if (!pattern4.test(data3)) {
+          const err11 = { instancePath: instancePath + "/ts", schemaPath: "#/properties/ts/pattern", keyword: "pattern", params: { pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$" }, message: 'must match pattern "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$"' };
+          if (vErrors === null) {
+            vErrors = [err11];
+          } else {
+            vErrors.push(err11);
+          }
+          errors++;
+        }
+      } else {
+        const err12 = { instancePath: instancePath + "/ts", schemaPath: "#/properties/ts/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.message_id !== void 0) {
+      let data4 = data.message_id;
+      if (typeof data4 === "string") {
+        if (!pattern5.test(data4)) {
+          const err13 = { instancePath: instancePath + "/message_id", schemaPath: "#/properties/message_id/pattern", keyword: "pattern", params: { pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" }, message: 'must match pattern "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"' };
+          if (vErrors === null) {
+            vErrors = [err13];
+          } else {
+            vErrors.push(err13);
+          }
+          errors++;
+        }
+      } else {
+        const err14 = { instancePath: instancePath + "/message_id", schemaPath: "#/properties/message_id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err15 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err15];
+    } else {
+      vErrors.push(err15);
+    }
+    errors++;
+  }
+  validate22.errors = vErrors;
+  return errors === 0;
+}
+validate22.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/ready.js
+var ready_default = validate25;
+function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate25.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+  } else {
+    const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err0];
+    } else {
+      vErrors.push(err0);
+    }
+    errors++;
+  }
+  validate25.errors = vErrors;
+  return errors === 0;
+}
+validate25.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/state.js
+var state_default = validate28;
+var schema39 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/field-v1/state.json", "title": "STATE payload", "type": "object", "additionalProperties": true, "required": ["decisions"], "properties": { "decisions": { "type": "object", "additionalProperties": { "type": "string", "enum": ["granted", "declined"] } } } };
+function validate28(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate28.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.decisions === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "decisions" }, message: "must have required property 'decisions'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.decisions !== void 0) {
+      let data0 = data.decisions;
+      if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+        for (const key0 in data0) {
+          let data1 = data0[key0];
+          if (typeof data1 !== "string") {
+            const err1 = { instancePath: instancePath + "/decisions/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/decisions/additionalProperties/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err1];
+            } else {
+              vErrors.push(err1);
+            }
+            errors++;
+          }
+          if (!(data1 === "granted" || data1 === "declined")) {
+            const err2 = { instancePath: instancePath + "/decisions/" + key0.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/decisions/additionalProperties/enum", keyword: "enum", params: { allowedValues: schema39.properties.decisions.additionalProperties.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+              vErrors = [err2];
+            } else {
+              vErrors.push(err2);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err3 = { instancePath: instancePath + "/decisions", schemaPath: "#/properties/decisions/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err4 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err4];
+    } else {
+      vErrors.push(err4);
+    }
+    errors++;
+  }
+  validate28.errors = vErrors;
+  return errors === 0;
+}
+validate28.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/resize.js
+var resize_default = validate27;
+function validate27(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate27.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.height === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "height" }, message: "must have required property 'height'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.height !== void 0) {
+      let data0 = data.height;
+      if (!(typeof data0 == "number" && (!(data0 % 1) && !isNaN(data0)))) {
+        const err1 = { instancePath: instancePath + "/height", schemaPath: "#/properties/height/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err1];
+        } else {
+          vErrors.push(err1);
+        }
+        errors++;
+      }
+      if (typeof data0 == "number") {
+        if (data0 < 0 || isNaN(data0)) {
+          const err2 = { instancePath: instancePath + "/height", schemaPath: "#/properties/height/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+          if (vErrors === null) {
+            vErrors = [err2];
+          } else {
+            vErrors.push(err2);
+          }
+          errors++;
+        }
+      }
+    }
+  } else {
+    const err3 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err3];
+    } else {
+      vErrors.push(err3);
+    }
+    errors++;
+  }
+  validate27.errors = vErrors;
+  return errors === 0;
+}
+validate27.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/complete.js
+var complete_default = validate21;
+var schema32 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/field-v1/complete.json", "title": "COMPLETE payload (the capture token)", "type": "object", "additionalProperties": true, "required": ["token", "committed"], "properties": { "token": { "type": "string", "minLength": 1 }, "committed": { "type": "boolean" }, "record_id": { "type": ["string", "null"] } } };
+var func1 = require_ucs2length().default;
+function validate21(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate21.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.token === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "token" }, message: "must have required property 'token'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.committed === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "committed" }, message: "must have required property 'committed'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.token !== void 0) {
+      let data0 = data.token;
+      if (typeof data0 === "string") {
+        if (func1(data0) < 1) {
+          const err2 = { instancePath: instancePath + "/token", schemaPath: "#/properties/token/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err2];
+          } else {
+            vErrors.push(err2);
+          }
+          errors++;
+        }
+      } else {
+        const err3 = { instancePath: instancePath + "/token", schemaPath: "#/properties/token/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.committed !== void 0) {
+      if (typeof data.committed !== "boolean") {
+        const err4 = { instancePath: instancePath + "/committed", schemaPath: "#/properties/committed/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.record_id !== void 0) {
+      let data2 = data.record_id;
+      if (typeof data2 !== "string" && data2 !== null) {
+        const err5 = { instancePath: instancePath + "/record_id", schemaPath: "#/properties/record_id/type", keyword: "type", params: { type: schema32.properties.record_id.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err6 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err6];
+    } else {
+      vErrors.push(err6);
+    }
+    errors++;
+  }
+  validate21.errors = vErrors;
+  return errors === 0;
+}
+validate21.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/error.js
+var error_default = validate23;
+var func12 = require_ucs2length().default;
+function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate23.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.code === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "code" }, message: "must have required property 'code'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.code !== void 0) {
+      let data0 = data.code;
+      if (typeof data0 === "string") {
+        if (func12(data0) < 1) {
+          const err1 = { instancePath: instancePath + "/code", schemaPath: "#/properties/code/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+          if (vErrors === null) {
+            vErrors = [err1];
+          } else {
+            vErrors.push(err1);
+          }
+          errors++;
+        }
+      } else {
+        const err2 = { instancePath: instancePath + "/code", schemaPath: "#/properties/code/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    if (data.message !== void 0) {
+      if (typeof data.message !== "string") {
+        const err3 = { instancePath: instancePath + "/message", schemaPath: "#/properties/message/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err4 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err4];
+    } else {
+      vErrors.push(err4);
+    }
+    errors++;
+  }
+  validate23.errors = vErrors;
+  return errors === 0;
+}
+validate23.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/submit_requested.js
+var submit_requested_default = validate29;
+function validate29(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate29.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+  } else {
+    const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err0];
+    } else {
+      vErrors.push(err0);
+    }
+    errors++;
+  }
+  validate29.errors = vErrors;
+  return errors === 0;
+}
+validate29.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/init.js
+var init_default = validate24;
+function validate24(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate24.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.locale !== void 0) {
+      if (typeof data.locale !== "string") {
+        const err0 = { instancePath: instancePath + "/locale", schemaPath: "#/properties/locale/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err0];
+        } else {
+          vErrors.push(err0);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err1 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err1];
+    } else {
+      vErrors.push(err1);
+    }
+    errors++;
+  }
+  validate24.errors = vErrors;
+  return errors === 0;
+}
+validate24.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/capture.js
+var capture_default = validate20;
+var schema31 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/field-v1/capture.json", "title": "CAPTURE payload (host \u2192 frame; what only the host knows)", "type": "object", "additionalProperties": true, "properties": { "subject": { "type": "object", "additionalProperties": true, "properties": { "email": { "type": "string" }, "external_id": { "type": "string" } } }, "page_url": { "type": ["string", "null"] }, "form_id": { "type": ["string", "null"] }, "submitter": { "type": ["string", "null"] }, "commit": { "type": "boolean" } } };
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate20.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.subject !== void 0) {
+      let data0 = data.subject;
+      if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+        if (data0.email !== void 0) {
+          if (typeof data0.email !== "string") {
+            const err0 = { instancePath: instancePath + "/subject/email", schemaPath: "#/properties/subject/properties/email/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err0];
+            } else {
+              vErrors.push(err0);
+            }
+            errors++;
+          }
+        }
+        if (data0.external_id !== void 0) {
+          if (typeof data0.external_id !== "string") {
+            const err1 = { instancePath: instancePath + "/subject/external_id", schemaPath: "#/properties/subject/properties/external_id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err1];
+            } else {
+              vErrors.push(err1);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err2 = { instancePath: instancePath + "/subject", schemaPath: "#/properties/subject/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    if (data.page_url !== void 0) {
+      let data3 = data.page_url;
+      if (typeof data3 !== "string" && data3 !== null) {
+        const err3 = { instancePath: instancePath + "/page_url", schemaPath: "#/properties/page_url/type", keyword: "type", params: { type: schema31.properties.page_url.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.form_id !== void 0) {
+      let data4 = data.form_id;
+      if (typeof data4 !== "string" && data4 !== null) {
+        const err4 = { instancePath: instancePath + "/form_id", schemaPath: "#/properties/form_id/type", keyword: "type", params: { type: schema31.properties.form_id.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.submitter !== void 0) {
+      let data5 = data.submitter;
+      if (typeof data5 !== "string" && data5 !== null) {
+        const err5 = { instancePath: instancePath + "/submitter", schemaPath: "#/properties/submitter/type", keyword: "type", params: { type: schema31.properties.submitter.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.commit !== void 0) {
+      if (typeof data.commit !== "boolean") {
+        const err6 = { instancePath: instancePath + "/commit", schemaPath: "#/properties/commit/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err7 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err7];
+    } else {
+      vErrors.push(err7);
+    }
+    errors++;
+  }
+  validate20.errors = vErrors;
+  return errors === 0;
+}
+validate20.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/field-v1/reset.js
+var reset_default = validate26;
+function validate26(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate26.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+  } else {
+    const err0 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err0];
+    } else {
+      vErrors.push(err0);
+    }
+    errors++;
+  }
+  validate26.errors = vErrors;
+  return errors === 0;
+}
+validate26.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/field/protocol.ts
+var VALIDATORS = {
+  [FIELD_MESSAGE_TYPES.READY]: ready_default,
+  [FIELD_MESSAGE_TYPES.STATE]: state_default,
+  [FIELD_MESSAGE_TYPES.RESIZE]: resize_default,
+  [FIELD_MESSAGE_TYPES.COMPLETE]: complete_default,
+  [FIELD_MESSAGE_TYPES.ERROR]: error_default,
+  [FIELD_MESSAGE_TYPES.SUBMIT_REQUESTED]: submit_requested_default,
+  [FIELD_MESSAGE_TYPES.INIT]: init_default,
+  [FIELD_MESSAGE_TYPES.CAPTURE]: capture_default,
+  [FIELD_MESSAGE_TYPES.RESET]: reset_default
+};
+var envelopeFn = envelope_default;
+function validateFieldEnvelope(message) {
+  const valid = envelopeFn(message);
+  return { valid, errors: valid ? null : envelopeFn.errors ?? null };
+}
+function validateFieldPayload(message) {
+  const validator = VALIDATORS[message.type];
+  if (!validator) return { valid: false, errors: [{ message: `Unknown type ${message.type}` }] };
+  const valid = validator(message.payload);
+  return { valid, errors: valid ? null : validator.errors ?? null };
+}
+function validateField(message) {
+  const envelopeResult = validateFieldEnvelope(message);
+  if (!envelopeResult.valid) return envelopeResult;
+  return validateFieldPayload(message);
+}
+function fieldEnvelope(type, payload) {
+  return { type, version: FIELD_PROTOCOL_VERSION, payload, ts: (/* @__PURE__ */ new Date()).toISOString(), message_id: uuidV4() };
+}
+function uuidV4() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+
+// src/errors.ts
+var OverturoError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OverturoError";
+  }
+};
+var OverturoValidationError = class extends OverturoError {
+  constructor(message) {
+    super(message);
+    this.name = "OverturoValidationError";
+  }
+};
+
+// src/forms/intercept.ts
+var DEFAULT_TOKEN_FIELD = "overturo_capture_token";
+var CAPTURED_MARK = "overturoCaptured";
+var CAPTURE_TIMEOUT_MS = 5e3;
+var attached = /* @__PURE__ */ new WeakMap();
+function interceptSubmit(form, opts, run) {
+  if (attached.has(form)) {
+    throw new OverturoValidationError("duplicate_attach: this form already has a capture interception; detach it before attaching again");
+  }
+  attached.set(form, true);
+  let inFlight = false;
+  const tokenField = opts.tokenFieldName ?? DEFAULT_TOKEN_FIELD;
+  const handler = (ev) => {
+    if (form.dataset[CAPTURED_MARK] === "1") {
+      delete form.dataset[CAPTURED_MARK];
+      return;
+    }
+    ev.preventDefault();
+    ev.stopImmediatePropagation();
+    if (inFlight) return;
+    inFlight = true;
+    form.querySelector(`input[name="${tokenField}"]`)?.remove();
+    const submitter = ev.submitter ?? null;
+    void (async () => {
+      try {
+        const { token } = await withTimeout(run({ submitter }), CAPTURE_TIMEOUT_MS);
+        setHiddenInput(form, tokenField, token);
+      } catch (e) {
+        opts.onError?.(e);
+      } finally {
+        inFlight = false;
+        if (opts.submitAfterCapture !== false) {
+          form.dataset[CAPTURED_MARK] = "1";
+          resubmit(form, submitter);
+        }
+      }
+    })();
+  };
+  form.addEventListener("submit", handler, { capture: true });
+  return () => {
+    attached.delete(form);
+    form.removeEventListener("submit", handler, { capture: true });
+    delete form.dataset[CAPTURED_MARK];
+    form.querySelector(`input[name="${tokenField}"]`)?.remove();
+  };
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new OverturoValidationError(`capture timed out after ${ms} ms; the form submits without a capture token`)),
+      ms
+    );
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+function resubmit(form, submitter) {
+  if (submitter && submitter.isConnected && typeof form.requestSubmit === "function") {
+    try {
+      form.requestSubmit(submitter);
+      return;
+    } catch {
+    }
+  }
+  if (typeof form.requestSubmit === "function") form.requestSubmit();
+  else if (submitter && typeof submitter.click === "function") submitter.click();
+  else form.submit();
+}
+function setHiddenInput(form, name, value) {
+  let input = form.querySelector(`input[name="${name}"]`);
+  if (!input) {
+    input = document.createElement("input");
+    input.type = "hidden";
+    input.name = name;
+    form.appendChild(input);
+  }
+  input.value = value;
+}
+
+// src/forms/presentation.ts
+function resolveControl(root, selector) {
+  const el = root.querySelector(selector);
+  return el instanceof HTMLInputElement ? el : null;
+}
+
+// src/element_base.ts
+var ElementBase = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+
+// src/field/element.ts
+var FIELD_ALREADY_DEFINED_CODE = "OVERTURO_FIELD_ELEMENT_ALREADY_DEFINED";
+var FieldCaptureError = class extends Error {
+  constructor(code, message) {
+    super(message || code);
+    this.name = "FieldCaptureError";
+    this.code = code;
+  }
+};
+var _internals, _shadow, _iframe, _ac, _frameOrigin, _ready, _value, _decisions, _pending, _ConsentFieldElement_instances, mount_fn, _onMessage, post_fn, setValue_fn, emit_fn, teardown_fn;
+var ConsentFieldElement = class extends ElementBase {
+  constructor() {
+    super();
+    __privateAdd(this, _ConsentFieldElement_instances);
+    __privateAdd(this, _internals, null);
+    __privateAdd(this, _shadow);
+    __privateAdd(this, _iframe, null);
+    __privateAdd(this, _ac, null);
+    __privateAdd(this, _frameOrigin, "");
+    __privateAdd(this, _ready, false);
+    __privateAdd(this, _value, "");
+    __privateAdd(this, _decisions, {});
+    __privateAdd(this, _pending, null);
+    __privateAdd(this, _onMessage, (event) => {
+      if (!__privateGet(this, _iframe) || event.origin !== __privateGet(this, _frameOrigin)) return;
+      const source = __privateGet(this, _iframe).contentWindow;
+      if (!source || event.source !== source) return;
+      const result = validateField(event.data);
+      if (!result.valid) {
+        __privateMethod(this, _ConsentFieldElement_instances, emit_fn).call(this, "field:error", { code: "protocol_violation" });
+        return;
+      }
+      const envelope = event.data;
+      switch (envelope.type) {
+        case FIELD_MESSAGE_TYPES.READY:
+          __privateSet(this, _ready, true);
+          this.setAttribute("aria-busy", "false");
+          __privateMethod(this, _ConsentFieldElement_instances, post_fn).call(this, FIELD_MESSAGE_TYPES.INIT, this.getAttribute("locale") ? { locale: this.getAttribute("locale") } : {});
+          __privateMethod(this, _ConsentFieldElement_instances, emit_fn).call(this, "field:ready", {});
+          break;
+        case FIELD_MESSAGE_TYPES.STATE:
+          __privateSet(this, _decisions, { ...envelope.payload.decisions });
+          __privateMethod(this, _ConsentFieldElement_instances, emit_fn).call(this, "field:state", { decisions: this.decisions });
+          break;
+        case FIELD_MESSAGE_TYPES.RESIZE: {
+          const height = envelope.payload.height;
+          if (typeof height === "number" && __privateGet(this, _iframe)) __privateGet(this, _iframe).style.height = `${height}px`;
+          break;
+        }
+        case FIELD_MESSAGE_TYPES.COMPLETE: {
+          const payload = envelope.payload;
+          __privateMethod(this, _ConsentFieldElement_instances, setValue_fn).call(this, payload.token);
+          const outcome = { token: payload.token, committed: payload.committed === true, recordId: payload.record_id ?? null };
+          __privateGet(this, _pending)?.resolve(outcome);
+          __privateSet(this, _pending, null);
+          __privateMethod(this, _ConsentFieldElement_instances, emit_fn).call(this, "field:complete", outcome);
+          break;
+        }
+        case FIELD_MESSAGE_TYPES.ERROR: {
+          const payload = envelope.payload;
+          __privateGet(this, _pending)?.reject(new FieldCaptureError(payload.code, payload.message));
+          __privateSet(this, _pending, null);
+          __privateMethod(this, _ConsentFieldElement_instances, emit_fn).call(this, "field:error", payload);
+          break;
+        }
+        case FIELD_MESSAGE_TYPES.SUBMIT_REQUESTED:
+          this.form?.requestSubmit?.();
+          break;
+      }
+    });
+    __privateSet(this, _shadow, this.attachShadow({ mode: "open" }));
+    if (typeof this.attachInternals === "function") {
+      try {
+        __privateSet(this, _internals, this.attachInternals());
+      } catch {
+        __privateSet(this, _internals, null);
+      }
+    }
+  }
+  /** The capture token once captured; empty before. */
+  get value() {
+    return __privateGet(this, _value);
+  }
+  /** The host form this control belongs to (form association), if any. */
+  get form() {
+    return __privateGet(this, _internals)?.form ?? this.closest("form");
+  }
+  /** The last STATE the frame reported. */
+  get decisions() {
+    return { ...__privateGet(this, _decisions) };
+  }
+  get ready() {
+    return __privateGet(this, _ready);
+  }
+  connectedCallback() {
+    if (!this.style.display) this.style.display = "block";
+    if (!this.hasAttribute("role")) this.setAttribute("role", "group");
+    if (!this.hasAttribute("aria-label")) this.setAttribute("aria-label", this.getAttribute("name") || "Consent choices");
+    this.setAttribute("aria-busy", "true");
+    __privateMethod(this, _ConsentFieldElement_instances, mount_fn).call(this);
+  }
+  disconnectedCallback() {
+    __privateMethod(this, _ConsentFieldElement_instances, teardown_fn).call(this);
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    if (oldValue === newValue || !this.isConnected) return;
+    if (name === "name") {
+      this.setAttribute("aria-label", newValue || "Consent choices");
+      if (__privateGet(this, _iframe)) __privateGet(this, _iframe).title = newValue || "Consent choices";
+      return;
+    }
+    __privateMethod(this, _ConsentFieldElement_instances, teardown_fn).call(this);
+    __privateMethod(this, _ConsentFieldElement_instances, mount_fn).call(this);
+  }
+  /** The facade's handoff: the trust-host base and the publishable key the client was built with. */
+  configure(opts) {
+    this.setAttribute("base-url", opts.flowBaseUrl.replace(/\/+$/, ""));
+    this.setAttribute("publishable-key", opts.publishableKey);
+    if (this.isConnected && !__privateGet(this, _iframe)) __privateMethod(this, _ConsentFieldElement_instances, mount_fn).call(this);
+  }
+  /** Asks the frame to capture; resolves on COMPLETE, rejects on ERROR. */
+  capture(request) {
+    return new Promise((resolve, reject) => {
+      if (!__privateGet(this, _ready) || !__privateGet(this, _frameOrigin)) {
+        reject(new FieldCaptureError("field_not_ready", "The consent field has not finished loading."));
+        return;
+      }
+      if (__privateGet(this, _pending)) {
+        reject(new FieldCaptureError("capture_in_flight", "A capture is already in progress; the first one answers."));
+        return;
+      }
+      __privateSet(this, _pending, { resolve, reject });
+      __privateMethod(this, _ConsentFieldElement_instances, post_fn).call(this, FIELD_MESSAGE_TYPES.CAPTURE, {
+        subject: request.subject ?? {},
+        page_url: request.pageUrl ?? null,
+        form_id: request.formId ?? null,
+        submitter: request.submitter ?? null,
+        commit: request.commit === true
+      });
+    });
+  }
+  /**
+   * 202 D9 — the facade's handoff (`overturo.forms.attach({ field })` lands
+   * here): the 201 submit interception is reused unchanged in shape, and the
+   * capture is asked of this element instead of being read from the DOM.
+   */
+  attachTo(form, opts, client) {
+    if (!this.getAttribute("flow")) this.setAttribute("flow", opts.flowId);
+    if (opts.locale && !this.getAttribute("locale")) this.setAttribute("locale", opts.locale);
+    this.configure(client);
+    return interceptSubmit(form, opts, async ({ submitter }) => {
+      const subject = resolveControl(form, opts.subjectField);
+      const external = opts.externalIdField ? resolveControl(form, opts.externalIdField) : null;
+      const outcome = await this.capture({
+        subject: { email: subject?.value?.trim() || void 0, external_id: external?.value?.trim() || void 0 },
+        pageUrl: typeof window !== "undefined" ? window.location.href : void 0,
+        formId: form.getAttribute("id") || void 0,
+        submitter: submitter?.getAttribute("name") ?? null,
+        commit: opts.commit === true
+      });
+      const result = {
+        token: outcome.token,
+        attestationId: "",
+        committed: outcome.committed,
+        wordingVerdict: "match",
+        recordId: outcome.recordId
+      };
+      opts.onCaptured?.(result);
+      return { token: outcome.token };
+    });
+  }
+  /** Returns every control to its rendered state and clears the token. */
+  reset() {
+    __privateMethod(this, _ConsentFieldElement_instances, post_fn).call(this, FIELD_MESSAGE_TYPES.RESET, {});
+    __privateMethod(this, _ConsentFieldElement_instances, setValue_fn).call(this, "");
+  }
+  /** Form-associated hook: the host form was reset. */
+  formResetCallback() {
+    this.reset();
+  }
+};
+_internals = new WeakMap();
+_shadow = new WeakMap();
+_iframe = new WeakMap();
+_ac = new WeakMap();
+_frameOrigin = new WeakMap();
+_ready = new WeakMap();
+_value = new WeakMap();
+_decisions = new WeakMap();
+_pending = new WeakMap();
+_ConsentFieldElement_instances = new WeakSet();
+mount_fn = function() {
+  const flow = this.getAttribute("flow");
+  const key = this.getAttribute("publishable-key");
+  if (!flow || !key) return;
+  const base = (this.getAttribute("base-url") || defaultBaseUrl()).replace(/\/+$/, "");
+  const url = new URL(`${base}${FIELD_DOCUMENT_PATH}/${encodeURIComponent(flow)}`);
+  url.searchParams.set("pk", key);
+  for (const attr of ["locale", "purposes", "theme"]) {
+    const value = this.getAttribute(attr);
+    if (value) url.searchParams.set(attr, value);
+  }
+  const appearance = this.getAttribute("appearance");
+  if (appearance) {
+    try {
+      url.hash = encodeAppearance(JSON.parse(appearance));
+    } catch {
+      url.hash = "";
+    }
+  }
+  __privateSet(this, _frameOrigin, url.origin);
+  const iframe = document.createElement("iframe");
+  iframe.src = url.toString();
+  iframe.title = this.getAttribute("name") || "Consent choices";
+  iframe.setAttribute("sandbox", "allow-scripts allow-same-origin allow-popups");
+  iframe.setAttribute("referrerpolicy", "strict-origin");
+  iframe.style.cssText = "width:100%;height:0;border:0;display:block;background:transparent;";
+  const nonce = readCspNonce();
+  if (nonce) iframe.setAttribute("nonce", nonce);
+  iframe.addEventListener("error", () => {
+    __privateMethod(this, _ConsentFieldElement_instances, emit_fn).call(this, "field:error", { code: "iframe_load_failed", message: "The consent field failed to load." });
+    this.setAttribute("aria-busy", "false");
+  });
+  __privateSet(this, _ac, new AbortController());
+  window.addEventListener("message", __privateGet(this, _onMessage), { signal: __privateGet(this, _ac).signal });
+  __privateSet(this, _iframe, iframe);
+  __privateGet(this, _shadow).appendChild(iframe);
+};
+_onMessage = new WeakMap();
+post_fn = function(type, payload) {
+  const target = __privateGet(this, _iframe)?.contentWindow;
+  if (!target || !__privateGet(this, _frameOrigin)) return;
+  try {
+    target.postMessage(fieldEnvelope(type, payload), __privateGet(this, _frameOrigin));
+  } catch {
+  }
+};
+setValue_fn = function(token) {
+  __privateSet(this, _value, token);
+  if (__privateGet(this, _internals) && typeof __privateGet(this, _internals).setFormValue === "function") __privateGet(this, _internals).setFormValue(token || null);
+};
+emit_fn = function(name, detail) {
+  this.dispatchEvent(new CustomEvent(name, { detail, bubbles: true, composed: true }));
+};
+teardown_fn = function() {
+  __privateGet(this, _ac)?.abort();
+  __privateSet(this, _ac, null);
+  if (__privateGet(this, _iframe)?.parentNode) __privateGet(this, _iframe).parentNode.removeChild(__privateGet(this, _iframe));
+  __privateSet(this, _iframe, null);
+  __privateSet(this, _ready, false);
+  __privateSet(this, _frameOrigin, "");
+  __privateGet(this, _pending)?.reject(new FieldCaptureError("field_unmounted"));
+  __privateSet(this, _pending, null);
+  this.setAttribute("aria-busy", "true");
+};
+ConsentFieldElement.formAssociated = true;
+ConsentFieldElement.observedAttributes = ["flow", "purposes", "locale", "theme", "name", "appearance", "publishable-key", "base-url"];
+function readCspNonce() {
+  if (typeof document === "undefined") return null;
+  return document.querySelector('meta[name="csp-nonce"]')?.getAttribute("content") ?? null;
+}
+function defaultBaseUrl() {
+  return DEFAULT_BASE_URL;
+}
+function registerConsentFieldElement() {
+  if (typeof customElements === "undefined") return;
+  if (customElements.get(FIELD_ELEMENT_NAME)) {
+    console.warn("[overturo:sdk]", FIELD_ALREADY_DEFINED_CODE, `<${FIELD_ELEMENT_NAME}> already registered; skipping.`);
+    return;
+  }
+  customElements.define(FIELD_ELEMENT_NAME, ConsentFieldElement);
+}
+
+// src/field/index.ts
+registerConsentFieldElement();
+export {
+  APPEARANCE_KEYS,
+  ConsentFieldElement,
+  FIELD_ALREADY_DEFINED_CODE,
+  FIELD_DOCUMENT_PATH,
+  FIELD_ELEMENT_NAME,
+  FIELD_MESSAGE_TYPES,
+  FIELD_PROTOCOL_VERSION,
+  FieldCaptureError,
+  ConsentFieldElement as default,
+  encodeAppearance,
+  fieldEnvelope,
+  registerConsentFieldElement,
+  sanitiseAppearance,
+  validateField,
+  validateFieldEnvelope,
+  validateFieldPayload
+};
+//# sourceMappingURL=index.js.map