@openeditor/custom-block 0.0.46

package/dist/index.js

@@ -0,0 +1,627 @@
+import { validateDocument } from '@openeditor/core';
+import { defaultDocumentContract } from '@openeditor/extensions';
+
+// src/index.ts
+var OPENEDITOR_CUSTOM_BLOCK_NODE = "customBlock";
+var ID_PATTERN = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/;
+var CUSTOM_BLOCK_DEFINITION_BRAND = /* @__PURE__ */ Symbol.for("@openeditor/custom-block/definition");
+var OPENEDITOR_CUSTOM_BLOCK_ASSET_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+var plainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var positiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+var clone = (value) => structuredClone(value);
+var deepFreeze = (value) => {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) deepFreeze(child);
+  }
+  return value;
+};
+var VALIDATION_LIMITS = { depth: 32, values: 1e4, stringLength: 1e6, arrayLength: 1e4, objectKeys: 1e4 };
+var inspectJson = (value, path = "$.data", depth = 0, budget = { values: 0 }) => {
+  budget.values += 1;
+  if (budget.values > VALIDATION_LIMITS.values) return [{ path, message: "Custom block data exceeds the value limit." }];
+  if (depth > VALIDATION_LIMITS.depth) return [{ path, message: "Custom block data exceeds the nesting limit." }];
+  if (typeof value === "string" && value.length > VALIDATION_LIMITS.stringLength) return [{ path, message: "String exceeds the size limit." }];
+  if (value === null || ["string", "boolean"].includes(typeof value) || typeof value === "number" && Number.isFinite(value)) return [];
+  if (Array.isArray(value)) {
+    if (value.length > VALIDATION_LIMITS.arrayLength) return [{ path, message: "Array exceeds the size limit." }];
+    return value.flatMap((item, index) => inspectJson(item, `${path}[${index}]`, depth + 1, budget));
+  }
+  if (plainObject(value)) {
+    const entries = Object.entries(value);
+    if (entries.length > VALIDATION_LIMITS.objectKeys) return [{ path, message: "Object exceeds the key limit." }];
+    return entries.flatMap(([key, item]) => inspectJson(item, `${path}.${key}`, depth + 1, budget));
+  }
+  return [{ path, message: "Custom block data must contain only JSON values." }];
+};
+var PORTABLE_SCHEMA_TYPES = /* @__PURE__ */ new Set(["any", "string", "number", "boolean", "null", "oneOf", "document", "array", "object"]);
+var PORTABLE_PATH_PATTERN = /^(?:[A-Za-z_][A-Za-z0-9_-]*|\*)(?:\.(?:[A-Za-z_][A-Za-z0-9_-]*|\*))*$/;
+var PORTABLE_FIELD_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z_][A-Za-z0-9_-]*)*$/;
+var requirePortablePath = (value, label, allowWildcards = true) => {
+  if (typeof value !== "string" || !(allowWildcards ? PORTABLE_PATH_PATTERN : PORTABLE_FIELD_PATTERN).test(value)) throw new Error(`Invalid portable constraint ${label}.`);
+};
+var assertPortableSchema = (schema, path = "$.dataSchema", depth = 0) => {
+  if (depth > VALIDATION_LIMITS.depth || !plainObject(schema) || typeof schema.type !== "string" || !PORTABLE_SCHEMA_TYPES.has(schema.type)) throw new Error(`Invalid portable schema at ${path}: type is not supported.`);
+  if (schema.nullable !== void 0 && typeof schema.nullable !== "boolean") throw new Error(`Invalid portable schema at ${path}: nullable must be a boolean.`);
+  if (schema.enum !== void 0 && (!Array.isArray(schema.enum) || inspectJson(schema.enum, `${path}.enum`).length)) throw new Error(`Invalid portable schema at ${path}: enum must contain JSON values.`);
+  const boundedInteger = (name) => {
+    const value = schema[name];
+    if (value !== void 0 && (!Number.isSafeInteger(value) || Number(value) < 0)) throw new Error(`Invalid portable schema at ${path}: ${name} must be a nonnegative integer.`);
+  };
+  if (schema.type === "string") {
+    boundedInteger("minLength");
+    boundedInteger("maxLength");
+    if (schema.minLength !== void 0 && schema.maxLength !== void 0 && Number(schema.minLength) > Number(schema.maxLength)) throw new Error(`Invalid portable schema at ${path}: string bounds are inconsistent.`);
+    if (schema.format !== void 0 && schema.format !== "asset-id") throw new Error(`Invalid portable schema at ${path}: format is not supported.`);
+  } else if (schema.type === "number") {
+    if (schema.integer !== void 0 && typeof schema.integer !== "boolean") throw new Error(`Invalid portable schema at ${path}: integer must be a boolean.`);
+    for (const name of ["minimum", "maximum"]) if (schema[name] !== void 0 && (typeof schema[name] !== "number" || !Number.isFinite(schema[name]))) throw new Error(`Invalid portable schema at ${path}: ${name} must be finite.`);
+    if (schema.minimum !== void 0 && schema.maximum !== void 0 && Number(schema.minimum) > Number(schema.maximum)) throw new Error(`Invalid portable schema at ${path}: number bounds are inconsistent.`);
+  } else if (schema.type === "array") {
+    boundedInteger("minItems");
+    boundedInteger("maxItems");
+    if (schema.minItems !== void 0 && schema.maxItems !== void 0 && Number(schema.minItems) > Number(schema.maxItems)) throw new Error(`Invalid portable schema at ${path}: array bounds are inconsistent.`);
+    if (schema.items !== void 0) assertPortableSchema(schema.items, `${path}.items`, depth + 1);
+  } else if (schema.type === "object") {
+    if (schema.properties !== void 0 && !plainObject(schema.properties)) throw new Error(`Invalid portable schema at ${path}: properties must be an object.`);
+    const properties = plainObject(schema.properties) ? schema.properties : {};
+    for (const [key, child] of Object.entries(properties)) assertPortableSchema(child, `${path}.properties.${key}`, depth + 1);
+    if (schema.required !== void 0 && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string") || new Set(schema.required).size !== schema.required.length)) throw new Error(`Invalid portable schema at ${path}: required must contain unique strings.`);
+    if (Array.isArray(schema.required) && schema.required.some((key) => !(key in properties))) throw new Error(`Invalid portable schema at ${path}: required fields must have schemas.`);
+    if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties !== "boolean") assertPortableSchema(schema.additionalProperties, `${path}.additionalProperties`, depth + 1);
+  } else if (schema.type === "oneOf") {
+    if (!Array.isArray(schema.variants) || schema.variants.length < 1) throw new Error(`Invalid portable schema at ${path}: variants must be a nonempty array.`);
+    schema.variants.forEach((variant, index) => assertPortableSchema(variant, `${path}.variants[${index}]`, depth + 1));
+  }
+};
+var assertPortableConstraints = (constraints) => {
+  if (constraints === void 0) return;
+  if (!Array.isArray(constraints)) throw new Error("Invalid portable constraints: expected an array.");
+  for (const constraint of constraints) {
+    if (!plainObject(constraint) || typeof constraint.kind !== "string") throw new Error("Invalid portable constraint shape.");
+    if (constraint.kind === "unique") requirePortablePath(constraint.array, "array path");
+    else if (constraint.kind === "uniqueBy") {
+      requirePortablePath(constraint.array, "array path");
+      if (!Array.isArray(constraint.keys) || !constraint.keys.length || constraint.keys.some((key) => {
+        try {
+          requirePortablePath(key, "key", false);
+          return false;
+        } catch {
+          return true;
+        }
+      })) throw new Error("Invalid portable constraint keys.");
+    } else if (constraint.kind === "keysIn") {
+      if (constraint.scope !== void 0) requirePortablePath(constraint.scope, "scope path");
+      requirePortablePath(constraint.objects, "objects path");
+      requirePortablePath(constraint.keys, "keys path");
+      if (constraint.requireAll !== void 0 && typeof constraint.requireAll !== "boolean") throw new Error("Invalid portable constraint requireAll flag.");
+    } else if (constraint.kind === "reference") {
+      requirePortablePath(constraint.array, "array path");
+      requirePortablePath(constraint.field, "field", false);
+      requirePortablePath(constraint.targetArray, "target array path");
+      requirePortablePath(constraint.targetField, "target field", false);
+      if (constraint.nullable !== void 0 && typeof constraint.nullable !== "boolean") throw new Error("Invalid portable constraint nullable flag.");
+    } else if (constraint.kind === "acyclic" || constraint.kind === "graph") {
+      requirePortablePath(constraint.array, "array path");
+      requirePortablePath(constraint.id, "id", false);
+      requirePortablePath(constraint.parent, "parent", false);
+      if (constraint.siblingKeys !== void 0 && (!Array.isArray(constraint.siblingKeys) || constraint.siblingKeys.some((key) => {
+        try {
+          requirePortablePath(key, "sibling key", false);
+          return false;
+        } catch {
+          return true;
+        }
+      }))) throw new Error("Invalid portable constraint sibling keys.");
+    } else if (constraint.kind === "url") {
+      requirePortablePath(constraint.path, "URL path");
+      for (const flag of ["allowRelative", "requireSchemeSeparator"]) if (constraint[flag] !== void 0 && typeof constraint[flag] !== "boolean") throw new Error(`Invalid portable constraint ${flag}.`);
+      for (const name of ["schemes", "denySchemes"]) if (constraint[name] !== void 0 && (!Array.isArray(constraint[name]) || constraint[name].some((scheme) => typeof scheme !== "string" || !/^[a-z][a-z\d+.-]*$/.test(scheme)))) throw new Error(`Invalid portable constraint ${name} scheme.`);
+      if (constraint.when !== void 0 && (!plainObject(constraint.when) || (() => {
+        try {
+          requirePortablePath(constraint.when.field, "condition field", false);
+          return false;
+        } catch {
+          return true;
+        }
+      })() || inspectJson(constraint.when.equals, "$.when.equals").length)) throw new Error("Invalid portable constraint condition.");
+    } else throw new Error(`Invalid portable constraint kind "${constraint.kind}".`);
+  }
+};
+var recursivelyFrozen = (value, seen = /* @__PURE__ */ new Set()) => {
+  if (!value || typeof value !== "object") return true;
+  if (seen.has(value)) return true;
+  seen.add(value);
+  return Object.isFrozen(value) && Object.values(value).every((child) => recursivelyFrozen(child, seen));
+};
+var validateValue = (value, schema, path, depth = 0, budget = { values: 0 }) => {
+  budget.values += 1;
+  if (budget.values > VALIDATION_LIMITS.values) return [{ path, message: "Custom block data exceeds the value limit." }];
+  if (depth > VALIDATION_LIMITS.depth) return [{ path, message: "Custom block data exceeds the nesting limit." }];
+  if (value === null && schema.nullable) return [];
+  if (schema.enum && !schema.enum.some((item) => JSON.stringify(item) === JSON.stringify(value))) return [{ path, message: "Value is not in the allowed set." }];
+  const errors = [];
+  if (schema.type === "any") return errors;
+  if (schema.type === "oneOf") {
+    const results = schema.variants.map((variant) => validateValue(value, variant, path, depth + 1, { values: budget.values }));
+    const matches = results.filter((result) => result.length === 0).length;
+    return matches === 1 ? [] : [{ path, message: matches === 0 ? "Value does not match an allowed variant." : "Value matches more than one variant." }];
+  }
+  if (schema.type === "null") return value === null ? errors : [{ path, message: "Expected null." }];
+  if (schema.type === "document") {
+    if (!plainObject(value) || value.type !== "doc" || value.version !== 1 || !Array.isArray(value.content)) return [{ path, message: "Expected an OpenEditor document." }];
+    const result = validateDocument(value, { contract: defaultDocumentContract, limits: { requireNodeIds: true } });
+    return result.valid ? [] : result.issues.map((issue) => ({ path: `${path}${issue.path.slice(1)}`, message: issue.message }));
+  }
+  if (schema.type === "string") {
+    if (typeof value !== "string") return [{ path, message: "Expected a string." }];
+    if (value.length > VALIDATION_LIMITS.stringLength) return [{ path, message: "String exceeds the size limit." }];
+    if (schema.minLength !== void 0 && value.length < schema.minLength) errors.push({ path, message: `Expected at least ${schema.minLength} characters.` });
+    if (schema.maxLength !== void 0 && value.length > schema.maxLength) errors.push({ path, message: `Expected at most ${schema.maxLength} characters.` });
+    if (schema.format === "asset-id" && !OPENEDITOR_CUSTOM_BLOCK_ASSET_ID_PATTERN.test(value)) errors.push({ path, message: "Expected an opaque host asset ID." });
+  } else if (schema.type === "number") {
+    if (typeof value !== "number" || !Number.isFinite(value)) return [{ path, message: "Expected a finite number." }];
+    if (schema.integer && !Number.isInteger(value)) errors.push({ path, message: "Expected an integer." });
+    if (schema.minimum !== void 0 && value < schema.minimum) errors.push({ path, message: `Expected ${schema.minimum} or more.` });
+    if (schema.maximum !== void 0 && value > schema.maximum) errors.push({ path, message: `Expected ${schema.maximum} or less.` });
+  } else if (schema.type === "boolean") {
+    if (typeof value !== "boolean") errors.push({ path, message: "Expected a boolean." });
+  } else if (schema.type === "array") {
+    if (!Array.isArray(value)) return [{ path, message: "Expected an array." }];
+    if (value.length > VALIDATION_LIMITS.arrayLength) return [{ path, message: "Array exceeds the size limit." }];
+    if (schema.minItems !== void 0 && value.length < schema.minItems) errors.push({ path, message: `Expected at least ${schema.minItems} items.` });
+    if (schema.maxItems !== void 0 && value.length > schema.maxItems) errors.push({ path, message: `Expected at most ${schema.maxItems} items.` });
+    if (schema.items) value.forEach((item, index) => errors.push(...validateValue(item, schema.items, `${path}[${index}]`, depth + 1, budget)));
+  } else if (schema.type === "object") {
+    if (!plainObject(value)) return [{ path, message: "Expected an object." }];
+    if (Object.keys(value).length > VALIDATION_LIMITS.objectKeys) return [{ path, message: "Object exceeds the key limit." }];
+    for (const key of schema.required ?? []) if (!(key in value)) errors.push({ path: `${path}.${key}`, message: "Required value is missing." });
+    for (const [key, item] of Object.entries(value)) {
+      const property = schema.properties?.[key];
+      if (property) errors.push(...validateValue(item, property, `${path}.${key}`, depth + 1, budget));
+      else if (schema.additionalProperties === false) errors.push({ path: `${path}.${key}`, message: "Additional values are not allowed." });
+      else if (plainObject(schema.additionalProperties)) errors.push(...validateValue(item, schema.additionalProperties, `${path}.${key}`, depth + 1, budget));
+    }
+  }
+  return errors;
+};
+var validateOpenEditorCustomBlockDataValue = (value, schema) => {
+  const diagnostics = [...inspectJson(value, "$"), ...validateValue(value, schema, "$")].sort((a, b) => a.path.localeCompare(b.path));
+  return diagnostics.length ? { valid: false, diagnostics } : { valid: true, diagnostics: [] };
+};
+var valuesAt = (root, expression) => expression.split(".").filter(Boolean).reduce((current, segment) => current.flatMap((item) => {
+  if (segment === "*") return Array.isArray(item.value) ? item.value.map((value, index) => ({ value, path: `${item.path}[${index}]` })) : [];
+  return plainObject(item.value) && segment in item.value ? [{ value: item.value[segment], path: `${item.path}.${segment}` }] : [];
+}), [{ value: root, path: "$.data" }]);
+var fieldAt = (value, field) => field.split(".").reduce((current, key) => plainObject(current) ? current[key] : void 0, value);
+var hasUnsafeUrlSyntax = (value) => {
+  if (/[\u0000-\u001f\u007f]/.test(value)) return true;
+  const colon = value.indexOf(":");
+  const path = value.indexOf("/");
+  const query = value.indexOf("?");
+  const firstPathOrQuery = Math.min(...[path, query].filter((index) => index >= 0), Number.POSITIVE_INFINITY);
+  return colon >= 0 && colon < firstPathOrQuery && value.slice(0, colon).includes("&");
+};
+var validateConstraints = (data, constraints = []) => {
+  const diagnostics = [];
+  for (const constraint of constraints) {
+    if (constraint.kind === "unique") for (const located of valuesAt(data, constraint.array)) {
+      if (!Array.isArray(located.value)) continue;
+      const seen = /* @__PURE__ */ new Set();
+      located.value.forEach((item, index) => {
+        const key = JSON.stringify(item);
+        if (seen.has(key)) diagnostics.push({ path: `${located.path}[${index}]`, message: "Array values must be unique." });
+        else seen.add(key);
+      });
+    }
+    else if (constraint.kind === "uniqueBy") for (const located of valuesAt(data, constraint.array)) {
+      if (!Array.isArray(located.value)) continue;
+      const seen = /* @__PURE__ */ new Map();
+      located.value.forEach((item, index) => {
+        const key = JSON.stringify(constraint.keys.map((field) => fieldAt(item, field)));
+        if (seen.has(key)) diagnostics.push({ path: `${located.path}[${index}]`, message: `Values must be unique by ${constraint.keys.join(", ")}.` });
+        else seen.set(key, index);
+      });
+    }
+    else if (constraint.kind === "keysIn") {
+      const scopes = constraint.scope ? valuesAt(data, constraint.scope) : [{ value: data, path: "$.data" }];
+      for (const scope of scopes) {
+        const objects = valuesAt(scope.value, constraint.objects);
+        const keySet = valuesAt(scope.value, constraint.keys)[0]?.value;
+        const allowed = new Set(Array.isArray(keySet) ? keySet : []);
+        for (const located of objects) {
+          if (!plainObject(located.value)) continue;
+          const objectPath = `${scope.path}${located.path.slice("$.data".length)}`;
+          for (const key of Object.keys(located.value)) if (!allowed.has(key)) diagnostics.push({ path: `${objectPath}.${key}`, message: "Object key is not in the allowed key collection." });
+          if (constraint.requireAll) {
+            for (const key of allowed) if (typeof key === "string" && !(key in located.value)) diagnostics.push({ path: `${objectPath}.${key}`, message: "Required object key is missing." });
+          }
+        }
+      }
+    } else if (constraint.kind === "reference") {
+      const targets = new Set(valuesAt(data, constraint.targetArray).flatMap((item) => Array.isArray(item.value) ? item.value.map((target) => fieldAt(target, constraint.targetField)) : []));
+      for (const located of valuesAt(data, constraint.array)) if (Array.isArray(located.value)) located.value.forEach((item, index) => {
+        const reference = fieldAt(item, constraint.field);
+        if ((reference === null || reference === void 0) && constraint.nullable) return;
+        if (!targets.has(reference)) diagnostics.push({ path: `${located.path}[${index}].${constraint.field}`, message: "Reference does not identify an available value." });
+      });
+    } else if (constraint.kind === "acyclic" || constraint.kind === "graph") for (const located of valuesAt(data, constraint.array)) {
+      if (!Array.isArray(located.value)) continue;
+      const parents = new Map(located.value.map((item) => [fieldAt(item, constraint.id), fieldAt(item, constraint.parent)]));
+      if (constraint.kind === "graph") {
+        const ids = /* @__PURE__ */ new Set();
+        const siblings = /* @__PURE__ */ new Set();
+        located.value.forEach((item, index) => {
+          const id = fieldAt(item, constraint.id);
+          if (ids.has(id)) diagnostics.push({ path: `${located.path}[${index}].${constraint.id}`, message: "Node identifiers must be unique in the collection." });
+          else ids.add(id);
+        });
+        located.value.forEach((item, index) => {
+          const parent = fieldAt(item, constraint.parent);
+          if (parent !== null && parent !== void 0 && !ids.has(parent)) diagnostics.push({ path: `${located.path}[${index}].${constraint.parent}`, message: "Parent must identify a value in the same collection." });
+          const sibling = JSON.stringify([parent, ...(constraint.siblingKeys ?? []).map((field) => fieldAt(item, field))]);
+          if (siblings.has(sibling)) diagnostics.push({ path: `${located.path}[${index}]`, message: "Sibling ordering values must be unique." });
+          else siblings.add(sibling);
+        });
+      }
+      for (const [id] of parents) {
+        const seen = /* @__PURE__ */ new Set();
+        let current = id;
+        while (current !== null && current !== void 0) {
+          if (seen.has(current)) {
+            diagnostics.push({ path: located.path, message: "Parent references must be acyclic." });
+            break;
+          }
+          seen.add(current);
+          current = parents.get(current);
+        }
+      }
+    }
+    else if (constraint.kind === "url") for (const located of valuesAt(data, constraint.path)) {
+      if (located.value === null || located.value === void 0) continue;
+      if (typeof located.value !== "string") {
+        diagnostics.push({ path: located.path, message: "URL must be a string." });
+        continue;
+      }
+      if (constraint.when) {
+        const parentPath = located.path.replace(/\.[^.\[]+$/, "");
+        const parentExpression = parentPath.replace(/^\$\.data\.?/, "").replace(/\[\d+\]/g, ".*");
+        const parent = valuesAt(data, parentExpression).find((item) => item.path === parentPath)?.value;
+        if (!plainObject(parent) || JSON.stringify(fieldAt(parent, constraint.when.field)) !== JSON.stringify(constraint.when.equals)) continue;
+      }
+      const normalized = located.value.trim();
+      const scheme = /^([a-z][a-z\d+.-]*):/i.exec(normalized)?.[1]?.toLowerCase();
+      const unsafeRelative = !scheme && (!normalized.startsWith("/") || normalized.startsWith("//") || normalized.includes("\\"));
+      if (!scheme && (!constraint.allowRelative || unsafeRelative) || scheme && (constraint.requireSchemeSeparator && !normalized.toLowerCase().startsWith(`${scheme}://`) || constraint.schemes && !constraint.schemes.includes(scheme) || constraint.denySchemes?.includes(scheme)) || hasUnsafeUrlSyntax(normalized)) diagnostics.push({ path: located.path, message: "URL is not allowed." });
+    }
+  }
+  return diagnostics;
+};
+var defineOpenEditorCustomBlock = (input) => {
+  if (!ID_PATTERN.test(input.id)) throw new Error(`OpenEditor custom block IDs must be namespaced lowercase identifiers. Received "${input.id}".`);
+  if (!Number.isSafeInteger(input.version) || input.version < 1) throw new Error("OpenEditor custom block versions must be positive integers.");
+  if (typeof input.label !== "string" || !input.label.trim() || input.label.length > 200) throw new Error("OpenEditor custom block labels must be nonempty strings of 200 characters or less.");
+  assertPortableSchema(input.dataSchema);
+  assertPortableConstraints(input.constraints);
+  if (input.dataSchema.type !== "object") throw new Error('OpenEditor custom block data schemas must have type "object".');
+  const dataSchema = deepFreeze(clone(input.dataSchema));
+  const constraints = input.constraints ? deepFreeze(clone(input.constraints)) : void 0;
+  const migrations = input.migrations ? Object.freeze({ ...input.migrations }) : void 0;
+  const manifest = deepFreeze({ id: input.id, label: input.label, version: input.version, dataSchema, ...constraints ? { constraints } : {} });
+  const definition = { ...input, dataSchema, ...constraints ? { constraints } : {}, ...migrations ? { migrations } : {}, manifest };
+  Object.defineProperty(definition, CUSTOM_BLOCK_DEFINITION_BRAND, { value: true });
+  return Object.freeze(definition);
+};
+var envelopeFromNode = (node) => {
+  const attrs = node.attrs;
+  return attrs && typeof attrs.blockId === "string" && typeof attrs.version === "number" && plainObject(attrs.data) ? { blockId: attrs.blockId, version: attrs.version, data: attrs.data } : null;
+};
+var escapeOpenEditorCustomBlockHtml = (value) => String(value).replace(/[&<>"']/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[character]);
+var SAFE_TAGS = /* @__PURE__ */ new Set(["div", "span", "p", "h1", "h2", "h3", "h4", "h5", "h6", "article", "section", "aside", "blockquote", "figure", "figcaption", "ul", "ol", "li", "dl", "dt", "dd", "table", "caption", "thead", "tbody", "tr", "th", "td", "strong", "em", "u", "s", "code", "pre", "a", "img", "br", "hr"]);
+var SAFE_ATTRS = /* @__PURE__ */ new Set(["aria-label", "aria-current", "role", "title", "href", "src", "alt", "width", "height", "start", "colspan", "rowspan", "scope"]);
+var safeStaticUrl = (value, context) => {
+  const normalized = value.trim();
+  if (!normalized || hasUnsafeUrlSyntax(normalized)) return null;
+  const scheme = /^([a-z][a-z\d+.-]*):/i.exec(normalized)?.[1]?.toLowerCase();
+  if (!scheme) {
+    if (normalized.startsWith("//") || normalized.includes("\\")) return null;
+    return normalized;
+  }
+  const schemes = context === "asset" ? ["http", "https"] : ["http", "https", "mailto", "tel"];
+  return schemes.includes(scheme) ? normalized : null;
+};
+var renderOpenEditorCustomBlockSafeHtml = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  let nodes = 0;
+  let stringBytes = 0;
+  const countRendered = (rendered) => {
+    stringBytes += rendered.length;
+    if (stringBytes > VALIDATION_LIMITS.stringLength) throw new Error("Safe HTML output exceeds its text limit.");
+    return rendered;
+  };
+  const render = (item, depth) => {
+    nodes += 1;
+    if (nodes > VALIDATION_LIMITS.values || depth > VALIDATION_LIMITS.depth) throw new Error("Safe HTML output exceeds its structural limit.");
+    if (item && typeof item === "object") {
+      if (seen.has(item)) throw new Error("Safe HTML output must not contain cycles.");
+      seen.add(item);
+    }
+    const value2 = item;
+    if (value2 === null || value2 === false) return "";
+    if (typeof value2 === "string" || typeof value2 === "number") return countRendered(escapeOpenEditorCustomBlockHtml(value2));
+    if (!plainObject(value2) || typeof value2.tag !== "string" || !SAFE_TAGS.has(value2.tag)) return "";
+    const attrs = Object.entries(value2.attrs ?? {}).flatMap(([name, raw]) => {
+      if (raw === void 0 || !SAFE_ATTRS.has(name) || name === "href" && value2.tag !== "a" || name === "src" && value2.tag !== "img" || name === "start" && value2.tag !== "ol" || ["colspan", "rowspan", "scope"].includes(name) && !["td", "th"].includes(value2.tag)) return [];
+      const safe = name === "href" ? safeStaticUrl(String(raw), "navigation") : name === "src" ? safeStaticUrl(String(raw), "asset") : String(raw);
+      return safe === null ? [] : [countRendered(` ${name}="${escapeOpenEditorCustomBlockHtml(safe)}"`)];
+    }).join("");
+    const children = (value2.children ?? []).map((child) => render(child, depth + 1)).join("");
+    return ["img", "br", "hr"].includes(value2.tag) ? `<${value2.tag}${attrs}>` : `<${value2.tag}${attrs}>${children}</${value2.tag}>`;
+  };
+  return render(value, 0);
+};
+var createOpenEditorCustomBlockRegistry = (definitions, options = {}) => {
+  const byId = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    try {
+      assertPortableSchema(definition.dataSchema);
+      assertPortableConstraints(definition.constraints);
+    } catch {
+      throw new Error(`Invalid custom block definition "${definition.id ?? "unknown"}".`);
+    }
+    if (definition[CUSTOM_BLOCK_DEFINITION_BRAND] !== true || !recursivelyFrozen(definition.dataSchema) || !recursivelyFrozen(definition.constraints) || !recursivelyFrozen(definition.manifest) || !recursivelyFrozen(definition.migrations) || !Object.isFrozen(definition) || !ID_PATTERN.test(definition.id) || !Number.isSafeInteger(definition.version) || definition.version < 1 || definition.dataSchema?.type !== "object" || definition.manifest?.id !== definition.id || definition.manifest?.version !== definition.version || definition.manifest?.dataSchema !== definition.dataSchema || definition.manifest?.constraints !== definition.constraints) throw new Error(`Invalid custom block definition "${definition.id ?? "unknown"}".`);
+    if (byId.has(definition.id)) throw new Error(`Duplicate custom block ID "${definition.id}".`);
+    byId.set(definition.id, definition);
+  }
+  const disabled = new Set(options.disabled ?? []);
+  const resolve = (node) => {
+    const envelope = envelopeFromNode(node);
+    if (node.type !== OPENEDITOR_CUSTOM_BLOCK_NODE || !envelope) return { status: "invalid", node, diagnostics: [{ path: "$", message: "Expected a valid OpenEditor custom block envelope." }] };
+    if (typeof node.attrs?.["openeditor-id"] !== "string" || !node.attrs["openeditor-id"].trim()) return { status: "invalid", node, blockId: envelope.blockId, diagnostics: [{ path: "$.attrs.openeditor-id", message: "Custom block instance ID is required." }] };
+    const definition = byId.get(envelope.blockId);
+    if (!definition) return { status: "missing", node, blockId: envelope.blockId, diagnostics: [] };
+    if (disabled.has(envelope.blockId)) return { status: "disabled", node, blockId: envelope.blockId, diagnostics: [] };
+    if (envelope.version > definition.version) return { status: "incompatible", node, blockId: envelope.blockId, diagnostics: [{ path: "$.version", message: `Stored version ${envelope.version} is newer than supported version ${definition.version}.` }] };
+    let version = envelope.version;
+    let data = clone(envelope.data);
+    try {
+      while (version < definition.version) {
+        const migrate = definition.migrations?.[version];
+        if (!migrate) return { status: "incompatible", node, blockId: envelope.blockId, diagnostics: [{ path: "$.version", message: `No migration exists from version ${version}.` }] };
+        data = clone(migrate(Object.freeze(clone(data))));
+        version += 1;
+      }
+    } catch (error) {
+      return { status: "invalid", node, blockId: envelope.blockId, diagnostics: [{ path: "$.data", message: error instanceof Error ? error.message : "Migration failed." }] };
+    }
+    const diagnostics = [...inspectJson(data), ...validateValue(data, definition.dataSchema, "$.data"), ...validateConstraints(data, definition.constraints)].sort((a, b) => a.path.localeCompare(b.path));
+    try {
+      const refinement = definition.validateData?.(deepFreeze(clone(data)));
+      if (typeof refinement === "string") diagnostics.push({ path: "$.data", message: refinement });
+      else for (const message of refinement ?? []) diagnostics.push({ path: "$.data", message });
+    } catch (error) {
+      diagnostics.push({ path: "$.data", message: error instanceof Error ? error.message : "Custom validation failed." });
+    }
+    if (diagnostics.length) return { status: "invalid", node, blockId: envelope.blockId, diagnostics };
+    const migrated = version !== envelope.version;
+    const readyData = deepFreeze(clone(data));
+    return { status: "ready", definition, data: readyData, migrated, node: migrated ? { ...node, attrs: { ...node.attrs, blockId: definition.id, version, data: readyData } } : node };
+  };
+  const defaultDocumentSafeTree = (document) => {
+    let count = 0;
+    const renderNode = (node, depth = 0) => {
+      count += 1;
+      if (count > VALIDATION_LIMITS.values || depth > VALIDATION_LIMITS.depth) return "";
+      if (node.type === "text") {
+        let output = node.text ?? "";
+        for (const mark of [...node.marks ?? []].reverse()) {
+          if (mark.type === "bold") output = { tag: "strong", children: [output] };
+          else if (mark.type === "italic") output = { tag: "em", children: [output] };
+          else if (mark.type === "underline") output = { tag: "u", children: [output] };
+          else if (mark.type === "strike") output = { tag: "s", children: [output] };
+          else if (mark.type === "code") output = { tag: "code", children: [output] };
+          else if (mark.type === "link" && typeof mark.attrs?.href === "string") output = { tag: "a", attrs: { href: mark.attrs.href }, children: [output] };
+        }
+        return output;
+      }
+      if (node.type === OPENEDITOR_CUSTOM_BLOCK_NODE) {
+        const nested = resolve(node);
+        return nested.status === "ready" ? exportNestedSafeTree(nested) : `[${envelopeFromNode(node)?.blockId ?? "custom block"}: ${nested.status}]`;
+      }
+      const children = node.content?.map((child) => renderNode(child, depth + 1)) ?? [];
+      if (node.type === "image") return { tag: "figure", children: [{ tag: "img", attrs: { alt: typeof node.attrs?.alt === "string" ? node.attrs.alt : "Image" } }] };
+      if (node.type === "page") return { tag: "span", children: children.length ? children : [typeof node.attrs?.title === "string" ? node.attrs.title : "Untitled page"] };
+      if (node.type === "attachment") return { tag: "span", children: [typeof node.attrs?.name === "string" && node.attrs.name ? node.attrs.name : "Attachment"] };
+      const heading = node.type === "heading" ? `h${Math.min(6, Math.max(1, Number(node.attrs?.level) || 2))}` : null;
+      const tag = heading ?? (node.type === "paragraph" ? "p" : node.type === "bulletList" || node.type === "taskList" ? "ul" : node.type === "orderedList" ? "ol" : ["listItem", "taskItem", "toggleListItem"].includes(node.type) ? "li" : node.type === "blockquote" ? "blockquote" : node.type === "codeBlock" ? "pre" : node.type === "table" ? "table" : node.type === "tableRow" ? "tr" : node.type === "tableHeader" ? "th" : node.type === "tableCell" ? "td" : node.type === "hardBreak" ? "br" : node.type === "divider" || node.type === "horizontalRule" ? "hr" : node.type === "callout" ? "aside" : node.type === "diagram" || node.type === "mermaidDiagram" ? "figure" : "div");
+      const attrs = node.type === "orderedList" && positiveInteger(node.attrs?.start) ? { start: Number(node.attrs?.start) } : node.type === "tableHeader" || node.type === "tableCell" ? { ...positiveInteger(node.attrs?.colspan) ? { colspan: Number(node.attrs?.colspan) } : {}, ...positiveInteger(node.attrs?.rowspan) ? { rowspan: Number(node.attrs?.rowspan) } : {}, ...node.type === "tableHeader" && typeof node.attrs?.scope === "string" ? { scope: node.attrs.scope } : {} } : void 0;
+      return { tag, ...attrs ? { attrs } : {}, children };
+    };
+    return { tag: "div", children: document.content.map((node) => renderNode(node)) };
+  };
+  const defaultDocumentText = (document) => {
+    let count = 0;
+    const renderNode = (node, depth = 0) => {
+      count += 1;
+      if (count > VALIDATION_LIMITS.values || depth > VALIDATION_LIMITS.depth) return "";
+      if (node.type === OPENEDITOR_CUSTOM_BLOCK_NODE) {
+        const nested = resolve(node);
+        return nested.status === "ready" ? exportNestedText(nested) : "";
+      }
+      if (node.type === "image") return typeof node.attrs?.alt === "string" ? node.attrs.alt : "Image";
+      if (node.type === "page" && !node.content?.length) return typeof node.attrs?.title === "string" ? node.attrs.title : "Untitled page";
+      if (node.type === "attachment") return typeof node.attrs?.name === "string" && node.attrs.name ? node.attrs.name : "Attachment";
+      if (node.text) return node.text;
+      const content = node.content?.map((child) => renderNode(child, depth + 1)).filter(Boolean) ?? [];
+      return ["doc", "paragraph", "heading", "listItem", "taskItem", "blockquote", "codeBlock", "tableRow", "callout"].includes(node.type) ? content.join("") : content.join("\n");
+    };
+    return renderNode(document).trim();
+  };
+  const fallbackLabel = (node, status) => `Custom block ${envelopeFromNode(node)?.blockId ?? "unknown"} is unavailable: ${status}.`;
+  const fallback = (node, result) => `<p role="status" data-openeditor-custom-block-error="${escapeOpenEditorCustomBlockHtml(result.status)}" data-block-id="${escapeOpenEditorCustomBlockHtml(envelopeFromNode(node)?.blockId ?? "unknown")}">${escapeOpenEditorCustomBlockHtml(fallbackLabel(node, result.status))}</p>`;
+  const exportReadySafeTree = (result) => result.definition.toHtml({ data: result.data, renderDocument: options.renderDocument ?? defaultDocumentSafeTree, documentToText: options.documentToText ?? defaultDocumentText });
+  const exportReadyText = (result) => result.definition.toText({ data: result.data, renderDocument: options.renderDocument ?? defaultDocumentSafeTree, documentToText: options.documentToText ?? defaultDocumentText });
+  const exportNestedSafeTree = (result) => {
+    try {
+      const tree = exportReadySafeTree(result);
+      renderOpenEditorCustomBlockSafeHtml(tree);
+      return tree;
+    } catch {
+      return { tag: "p", attrs: { role: "status" }, children: [fallbackLabel(result.node, "invalid")] };
+    }
+  };
+  const exportNestedText = (result) => {
+    try {
+      return exportReadyText(result);
+    } catch {
+      return fallbackLabel(result.node, "invalid");
+    }
+  };
+  return Object.freeze({
+    definitions: Object.freeze([...definitions]),
+    manifests: Object.freeze(definitions.map((item) => item.manifest)),
+    get: (id) => byId.get(id),
+    isEnabled: (id) => byId.has(id) && !disabled.has(id),
+    resolve,
+    toHtml: (node) => {
+      const result = resolve(node);
+      if (result.status !== "ready") return fallback(node, result);
+      try {
+        const rendered = renderOpenEditorCustomBlockSafeHtml(exportReadySafeTree(result));
+        return rendered || fallback(node, { status: "invalid", node, blockId: result.definition.id, diagnostics: [{ path: "$.toHtml", message: "Static HTML output is invalid." }] });
+      } catch {
+        return fallback(node, { status: "invalid", blockId: result.definition.id});
+      }
+    },
+    toText: (node) => {
+      const result = resolve(node);
+      if (result.status !== "ready") return fallbackLabel(node, result.status);
+      try {
+        return exportReadyText(result);
+      } catch {
+        return fallbackLabel(node, "invalid");
+      }
+    }
+  });
+};
+var createOpenEditorCustomBlockNode = (registry, id, data, options = {}) => {
+  const definition = registry.get(id);
+  if (!definition) throw new Error(`OpenEditor custom block "${id}" is not registered.`);
+  const value = clone(data ?? definition.initialData());
+  const diagnostics = validateValue(value, definition.dataSchema, "$.data");
+  if (diagnostics.length) throw new Error(`Invalid initial data for "${id}": ${diagnostics.map((item) => `${item.path}: ${item.message}`).join("; ")}`);
+  const instanceId = options.instanceId ?? options.createInstanceId?.() ?? globalThis.crypto.randomUUID();
+  if (!instanceId.trim()) throw new Error("OpenEditor custom block instance IDs must not be empty.");
+  const node = { type: OPENEDITOR_CUSTOM_BLOCK_NODE, attrs: { "openeditor-id": instanceId, blockId: definition.id, version: definition.version, data: value } };
+  const resolved = registry.resolve(node);
+  if (resolved.status !== "ready") throw new Error(`Invalid initial data for "${id}": ${resolved.diagnostics.map((item) => `${item.path}: ${item.message}`).join("; ") || resolved.status}`);
+  return node;
+};
+var resolveOpenEditorCustomBlockNode = (registry, node) => registry.resolve(node);
+var validateOpenEditorCustomBlockEnvelope = (value, manifests, options = {}) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const manifest2 of manifests) {
+    if (ids.has(manifest2.id)) return { valid: false, diagnostics: [{ path: "$.manifests", message: `Duplicate custom block manifest "${manifest2.id}".` }] };
+    ids.add(manifest2.id);
+    if (!ID_PATTERN.test(manifest2.id) || !Number.isSafeInteger(manifest2.version) || manifest2.version < 1) return { valid: false, diagnostics: [{ path: "$.manifests", message: "Custom block manifest identity or version is invalid." }] };
+  }
+  if (!plainObject(value) || typeof value.blockId !== "string" || typeof value.version !== "number" || !plainObject(value.data)) return { valid: false, diagnostics: [{ path: "$", message: "Expected a custom block envelope." }] };
+  const manifest = manifests.find((item) => item.id === value.blockId);
+  if (options.mode === "preserve" && (!manifest || options.disabled?.includes(value.blockId) || manifest && value.version !== manifest.version)) {
+    const diagnostics2 = inspectJson(value.data);
+    return diagnostics2.length ? { valid: false, diagnostics: diagnostics2 } : { valid: true, diagnostics: [], status: "preserved" };
+  }
+  if (!manifest) return { valid: false, diagnostics: [{ path: "$.blockId", message: `Unknown custom block "${value.blockId}".` }] };
+  if (value.version !== manifest.version) return { valid: false, diagnostics: [{ path: "$.version", message: `Expected version ${manifest.version}.` }] };
+  const nestedDiagnostics = [];
+  const nestedSeen = /* @__PURE__ */ new WeakSet();
+  const inspectNested = (input, path) => {
+    if (!plainObject(input) || nestedSeen.has(input)) return;
+    nestedSeen.add(input);
+    if (input.type === OPENEDITOR_CUSTOM_BLOCK_NODE && plainObject(input.attrs)) {
+      const nested = validateOpenEditorCustomBlockEnvelope(input.attrs, manifests, options);
+      if (!nested.valid) nestedDiagnostics.push(...nested.diagnostics.map((item) => ({ path: `${path}.attrs${item.path.slice(1)}`, message: item.message })));
+      return;
+    }
+    if (Array.isArray(input.content)) input.content.forEach((item, index) => inspectNested(item, `${path}.content[${index}]`));
+  };
+  const inspectDeclaredDocuments = (input, schema, path) => {
+    if (schema.type === "document") {
+      inspectNested(input, path);
+      return;
+    }
+    if (schema.type === "array" && Array.isArray(input) && schema.items) input.forEach((item, index) => inspectDeclaredDocuments(item, schema.items, `${path}[${index}]`));
+    if (schema.type === "object" && plainObject(input)) for (const [key, item] of Object.entries(input)) {
+      const property = schema.properties?.[key];
+      if (property) inspectDeclaredDocuments(item, property, `${path}.${key}`);
+      else if (plainObject(schema.additionalProperties)) inspectDeclaredDocuments(item, schema.additionalProperties, `${path}.${key}`);
+    }
+    if (schema.type === "oneOf") {
+      for (const variant of schema.variants) if (validateValue(input, variant, path).length === 0) inspectDeclaredDocuments(input, variant, path);
+    }
+  };
+  inspectDeclaredDocuments(value.data, manifest.dataSchema, "$.data");
+  const diagnostics = [...inspectJson(value.data), ...validateValue(value.data, manifest.dataSchema, "$.data"), ...validateConstraints(value.data, manifest.constraints), ...nestedDiagnostics].sort((a, b) => a.path.localeCompare(b.path));
+  if (options.mode === "preserve" && diagnostics.length && inspectJson(value.data).length === 0) return { valid: true, diagnostics, status: "preserved-invalid" };
+  return diagnostics.length ? { valid: false, diagnostics } : { valid: true, diagnostics: [] };
+};
+var extractOpenEditorCustomBlockAssetReferences = (value, manifests) => {
+  const byId = new Map(manifests.map((manifest) => [manifest.id, manifest]));
+  const references = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visitSchema = (input, schema, path) => {
+    if (input === null || input === void 0) return;
+    if (schema.type === "string" && schema.format === "asset-id" && typeof input === "string" && OPENEDITOR_CUSTOM_BLOCK_ASSET_ID_PATTERN.test(input)) {
+      const key = `${path}\0${input}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        references.push({ id: input, path });
+      }
+      return;
+    }
+    if (schema.type === "array" && Array.isArray(input) && schema.items) input.forEach((item, index) => visitSchema(item, schema.items, `${path}[${index}]`));
+    if (schema.type === "object" && plainObject(input)) for (const [key, item] of Object.entries(input)) {
+      const property = schema.properties?.[key];
+      if (property) visitSchema(item, property, `${path}.${key}`);
+      else if (plainObject(schema.additionalProperties)) visitSchema(item, schema.additionalProperties, `${path}.${key}`);
+    }
+    if (schema.type === "document" && plainObject(input)) visitNested(input, path);
+    if (schema.type === "oneOf") for (const variant of schema.variants) {
+      if (validateValue(input, variant, path).length === 0) visitSchema(input, variant, path);
+    }
+  };
+  const visitNested = (input, path) => {
+    if (!plainObject(input)) return;
+    if (input.type === OPENEDITOR_CUSTOM_BLOCK_NODE && plainObject(input.attrs)) {
+      const manifest = typeof input.attrs.blockId === "string" ? byId.get(input.attrs.blockId) : void 0;
+      if (manifest && plainObject(input.attrs.data) && validateOpenEditorCustomBlockEnvelope(input.attrs, manifests).valid) visitSchema(input.attrs.data, manifest.dataSchema, `${path}.attrs.data`);
+      return;
+    }
+    if (Array.isArray(input.content)) input.content.forEach((item, index) => visitNested(item, `${path}.content[${index}]`));
+  };
+  if (plainObject(value) && typeof value.blockId === "string" && plainObject(value.data)) {
+    const manifest = byId.get(value.blockId);
+    if (manifest && validateOpenEditorCustomBlockEnvelope(value, manifests).valid) visitSchema(value.data, manifest.dataSchema, "$.data");
+  }
+  return references;
+};
+var conformOpenEditorCustomBlock = (definition) => {
+  const diagnostics = [];
+  try {
+    const registry = createOpenEditorCustomBlockRegistry([definition]);
+    const node = createOpenEditorCustomBlockNode(registry, definition.id, void 0, { instanceId: "conformance-instance" });
+    const envelope = node.attrs;
+    const validated = validateOpenEditorCustomBlockEnvelope(envelope, registry.manifests);
+    if (!validated.valid) diagnostics.push(...validated.diagnostics);
+    const html = registry.toHtml(node);
+    const text = registry.toText(node);
+    if (html.includes('data-openeditor-custom-block-error="invalid"') || text === `Custom block ${definition.id} is unavailable: invalid.`) diagnostics.push({ path: "$.staticExport", message: "Custom block static export failed conformance." });
+  } catch (error) {
+    diagnostics.push({ path: "$", message: error instanceof Error ? error.message : "Custom block conformance failed." });
+  }
+  return diagnostics;
+};
+
+export { OPENEDITOR_CUSTOM_BLOCK_ASSET_ID_PATTERN, OPENEDITOR_CUSTOM_BLOCK_NODE, conformOpenEditorCustomBlock, createOpenEditorCustomBlockNode, createOpenEditorCustomBlockRegistry, defineOpenEditorCustomBlock, escapeOpenEditorCustomBlockHtml, extractOpenEditorCustomBlockAssetReferences, renderOpenEditorCustomBlockSafeHtml, resolveOpenEditorCustomBlockNode, validateOpenEditorCustomBlockDataValue, validateOpenEditorCustomBlockEnvelope };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map