@tileflow/interactions 0.0.0-bootstrap.0

package/dist/index.js

@@ -0,0 +1,639 @@
+// src/contracts.ts
+import { z } from "zod/mini";
+var tileflowInteractionSchemaVersion = 1;
+var tileflowPoiCategories = [
+  "arts-entertainment",
+  "education",
+  "food-drink",
+  "landmark",
+  "lodging",
+  "medical",
+  "park-nature",
+  "public-services",
+  "religion",
+  "retail",
+  "sport-leisure",
+  "transport",
+  "visitor-amenity"
+];
+var tileflowInteractionLimits = {
+  maxAnnotations: 1e3,
+  maxAriaLabelLength: 256,
+  maxBindings: 100,
+  maxCategories: 32,
+  maxColorLength: 64,
+  maxContentTextLength: 4096,
+  maxDocumentBytes: 256e3,
+  maxDocumentDepth: 64,
+  maxDocumentNodes: 2e4,
+  maxDocumentProperties: 5e4,
+  maxFeatureIdLength: 128,
+  maxFieldSelectorLength: 128,
+  maxIdLength: 64,
+  maxTargetNameLength: 128,
+  maxViewNameLength: 64
+};
+function auditTileflowInteractionJsonDocument(input) {
+  try {
+    const stack = [{ depth: 0, value: input }];
+    const seen = /* @__PURE__ */ new WeakSet();
+    if (isObject(input)) seen.add(input);
+    let bytes = 0;
+    let nodes = 1;
+    let properties = 0;
+    const consumeBytes = (addition) => {
+      if (!Number.isSafeInteger(addition) || addition < 0 || addition > tileflowInteractionLimits.maxDocumentBytes - bytes) {
+        return false;
+      }
+      bytes += addition;
+      return true;
+    };
+    const enqueue = (value, depth) => {
+      if (depth > tileflowInteractionLimits.maxDocumentDepth) return "depth";
+      if (isObject(value)) {
+        if (seen.has(value)) return "invalid";
+        seen.add(value);
+      }
+      stack.push({ depth, value });
+      return void 0;
+    };
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      if (!entry) return { ok: false, reason: "invalid" };
+      const { depth, value } = entry;
+      if (value === null) {
+        if (!consumeBytes(4)) return { ok: false, reason: "bytes" };
+        continue;
+      }
+      if (typeof value === "boolean") {
+        if (!consumeBytes(value ? 4 : 5)) return { ok: false, reason: "bytes" };
+        continue;
+      }
+      if (typeof value === "number") {
+        if (!Number.isFinite(value)) return { ok: false, reason: "invalid" };
+        const length = value === 0 ? 1 : String(value).length;
+        if (!consumeBytes(length)) return { ok: false, reason: "bytes" };
+        continue;
+      }
+      if (typeof value === "string") {
+        const length = jsonStringByteLength(
+          value,
+          tileflowInteractionLimits.maxDocumentBytes - bytes
+        );
+        if (length === void 0) return { ok: false, reason: "bytes" };
+        bytes += length;
+        continue;
+      }
+      if (!isObject(value)) return { ok: false, reason: "invalid" };
+      const array = Array.isArray(value);
+      const prototype = Object.getPrototypeOf(value);
+      if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) {
+        return { ok: false, reason: "invalid" };
+      }
+      if (array) {
+        const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+        if (!lengthDescriptor || !("value" in lengthDescriptor) || typeof lengthDescriptor.value !== "number" || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0) {
+          return { ok: false, reason: "invalid" };
+        }
+        const length = lengthDescriptor.value;
+        if (length > tileflowInteractionLimits.maxDocumentProperties - properties) {
+          return { ok: false, reason: "properties" };
+        }
+        properties += length;
+        if (length > 0 && depth >= tileflowInteractionLimits.maxDocumentDepth) {
+          return { ok: false, reason: "depth" };
+        }
+        const syntaxBytes = length === 0 ? 2 : length + 1;
+        if (!consumeBytes(syntaxBytes)) return { ok: false, reason: "bytes" };
+        const keys2 = Reflect.ownKeys(value);
+        const children2 = [];
+        let sawLength = false;
+        for (const key of keys2) {
+          if (typeof key !== "string") return { ok: false, reason: "invalid" };
+          if (key === "length") {
+            sawLength = true;
+            continue;
+          }
+          if (!isCanonicalArrayIndex(key, length)) return { ok: false, reason: "invalid" };
+          const descriptor = Object.getOwnPropertyDescriptor(value, key);
+          if (!isEnumerableDataDescriptor(descriptor)) return { ok: false, reason: "invalid" };
+          children2.push(descriptor.value);
+        }
+        if (!sawLength || children2.length > length) return { ok: false, reason: "invalid" };
+        if (children2.length > tileflowInteractionLimits.maxDocumentNodes - nodes) {
+          return { ok: false, reason: "nodes" };
+        }
+        nodes += children2.length;
+        const holes = length - children2.length;
+        if (!consumeBytes(holes * 4)) return { ok: false, reason: "bytes" };
+        for (const child of children2) {
+          const failure = enqueue(child, depth + 1);
+          if (failure) return { ok: false, reason: failure };
+        }
+        continue;
+      }
+      const keys = Reflect.ownKeys(value);
+      if (keys.length > tileflowInteractionLimits.maxDocumentProperties - properties) {
+        return { ok: false, reason: "properties" };
+      }
+      if (keys.length > tileflowInteractionLimits.maxDocumentNodes - nodes) {
+        return { ok: false, reason: "nodes" };
+      }
+      if (keys.length > 0 && depth >= tileflowInteractionLimits.maxDocumentDepth) {
+        return { ok: false, reason: "depth" };
+      }
+      properties += keys.length;
+      nodes += keys.length;
+      if (!consumeBytes(keys.length === 0 ? 2 : keys.length * 2 + 1)) {
+        return { ok: false, reason: "bytes" };
+      }
+      const children = [];
+      for (const key of keys) {
+        if (typeof key !== "string" || key === "__proto__" || key === "constructor" || key === "prototype") {
+          return { ok: false, reason: "invalid" };
+        }
+        const keyBytes = jsonStringByteLength(
+          key,
+          tileflowInteractionLimits.maxDocumentBytes - bytes
+        );
+        if (keyBytes === void 0) return { ok: false, reason: "bytes" };
+        bytes += keyBytes;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!isEnumerableDataDescriptor(descriptor)) return { ok: false, reason: "invalid" };
+        children.push(descriptor.value);
+      }
+      for (const child of children) {
+        const failure = enqueue(child, depth + 1);
+        if (failure) return { ok: false, reason: failure };
+      }
+    }
+    return { bytes, ok: true };
+  } catch {
+    return { ok: false, reason: "invalid" };
+  }
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function isEnumerableDataDescriptor(descriptor) {
+  return Boolean(descriptor?.enumerable && "value" in descriptor);
+}
+function isCanonicalArrayIndex(key, length) {
+  if (!/^(?:0|[1-9]\d*)$/u.test(key)) return false;
+  const index = Number(key);
+  return Number.isSafeInteger(index) && index >= 0 && index < length && String(index) === key;
+}
+function jsonStringByteLength(value, maximum) {
+  let bytes = 2;
+  if (bytes > maximum) return void 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    let addition;
+    if (code === 34 || code === 92) addition = 2;
+    else if (code <= 31) {
+      addition = code === 8 || code === 9 || code === 10 || code === 12 || code === 13 ? 2 : 6;
+    } else if (code <= 127) addition = 1;
+    else if (code <= 2047) addition = 2;
+    else if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        addition = 4;
+        index += 1;
+      } else addition = 6;
+    } else if (code >= 56320 && code <= 57343) addition = 6;
+    else addition = 3;
+    if (addition > maximum - bytes) return void 0;
+    bytes += addition;
+  }
+  return bytes;
+}
+var portableIdPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u;
+var semanticDomainPattern = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/u;
+var fieldSelectorPattern = /^[A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z_][A-Za-z0-9_-]*)*$/u;
+var unsafeFieldSegments = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var safeCssColorPattern = /^(?:#(?:[\da-f]{3}|[\da-f]{4}|[\da-f]{6}|[\da-f]{8})|[a-z]+|(?:color|hsla?|hwb|lab|lch|oklab|oklch|rgba?)\([A-Za-z0-9.,%+\- /]+\))$/iu;
+var portableIdSchema = z.string().check(
+  z.minLength(1),
+  z.maxLength(tileflowInteractionLimits.maxIdLength),
+  z.regex(portableIdPattern, "Expected a portable identifier")
+);
+var targetNameSchema = z.string().check(
+  z.trim(),
+  z.minLength(1),
+  z.maxLength(tileflowInteractionLimits.maxTargetNameLength),
+  z.refine((value) => !hasControlCharacters(value), {
+    message: "Target names may not contain control characters"
+  })
+);
+function hasControlCharacters(value) {
+  return [...value].some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127;
+  });
+}
+var coordinateSchema = z.tuple([z.number(), z.number()]).check(
+  z.refine(([lng, lat]) => lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90, {
+    message: "Expected [longitude, latitude] within world bounds"
+  })
+);
+var featureIdSchema = z.union([
+  z.int(),
+  z.string().check(z.minLength(1), z.maxLength(tileflowInteractionLimits.maxFeatureIdLength))
+]);
+var tileflowInteractionJsonValueSchema = z.custom(
+  (value) => auditTileflowInteractionJsonDocument(value).ok,
+  "Expected a bounded, finite JSON value"
+);
+var textContentSchema = z.strictObject({
+  kind: z.literal("text"),
+  text: z.string().check(z.maxLength(tileflowInteractionLimits.maxContentTextLength))
+});
+var fieldContentSchema = z.strictObject({
+  fallback: z.optional(
+    z.string().check(z.maxLength(tileflowInteractionLimits.maxContentTextLength))
+  ),
+  field: z.string().check(
+    z.minLength(1),
+    z.maxLength(tileflowInteractionLimits.maxFieldSelectorLength),
+    z.regex(fieldSelectorPattern, "Expected a dotted declarative field selector"),
+    z.refine((field) => field.split(".").every((segment) => !unsafeFieldSegments.has(segment)), {
+      message: "Field selectors may not contain unsafe object keys"
+    })
+  ),
+  kind: z.literal("field")
+});
+var viewContentSchema = z.strictObject({
+  kind: z.literal("view"),
+  name: z.string().check(
+    z.minLength(1),
+    z.maxLength(tileflowInteractionLimits.maxViewNameLength),
+    z.regex(portableIdPattern, "Expected a portable view name")
+  )
+});
+var tileflowInteractionContentSchema = z.discriminatedUnion("kind", [
+  textContentSchema,
+  fieldContentSchema,
+  viewContentSchema
+]);
+var annotationMarkerSchema = z.strictObject({
+  color: z.optional(
+    z.string().check(
+      z.trim(),
+      z.minLength(1),
+      z.maxLength(tileflowInteractionLimits.maxColorLength),
+      z.regex(safeCssColorPattern, "Expected a bounded CSS color without URL or variable input")
+    )
+  ),
+  content: z.optional(tileflowInteractionContentSchema)
+});
+var annotationSurfaceSchema = z.strictObject({ content: tileflowInteractionContentSchema });
+var tileflowAnnotationSchema = z.strictObject({
+  ariaLabel: z.string().check(z.trim(), z.minLength(1), z.maxLength(tileflowInteractionLimits.maxAriaLabelLength)),
+  coordinate: coordinateSchema,
+  data: z.optional(tileflowInteractionJsonValueSchema),
+  id: portableIdSchema,
+  kind: z.literal("marker"),
+  marker: z.optional(annotationMarkerSchema),
+  popup: z.optional(annotationSurfaceSchema),
+  tooltip: z.optional(annotationSurfaceSchema)
+});
+var tileflowAnnotationsSchema = z.array(tileflowAnnotationSchema).check(z.maxLength(tileflowInteractionLimits.maxAnnotations));
+var annotationTargetSelectorSchema = z.strictObject({
+  id: portableIdSchema,
+  kind: z.literal("annotation")
+});
+var semanticFeatureTargetSelectorSchema = z.strictObject({
+  categories: z.optional(
+    z.array(z.enum(tileflowPoiCategories)).check(z.minLength(1), z.maxLength(tileflowInteractionLimits.maxCategories))
+  ),
+  domain: z.string().check(
+    z.minLength(1),
+    z.maxLength(tileflowInteractionLimits.maxTargetNameLength),
+    z.regex(semanticDomainPattern, "Expected a dotted semantic domain")
+  ),
+  kind: z.literal("semantic-feature")
+});
+var styleLayerTargetSelectorSchema = z.strictObject({
+  kind: z.literal("style-layer"),
+  layerId: targetNameSchema
+});
+var mapTargetSelectorSchema = z.strictObject({ kind: z.literal("map") });
+var tileflowInteractionTargetSchema = z.discriminatedUnion("kind", [
+  annotationTargetSelectorSchema,
+  semanticFeatureTargetSelectorSchema,
+  styleLayerTargetSelectorSchema,
+  mapTargetSelectorSchema
+]);
+var tileflowInteractionBindingSchema = z.strictObject({
+  id: portableIdSchema,
+  popup: z.optional(annotationSurfaceSchema),
+  target: tileflowInteractionTargetSchema,
+  tooltip: z.optional(annotationSurfaceSchema)
+});
+var tileflowInteractionBindingsSchema = z.array(tileflowInteractionBindingSchema).check(z.maxLength(tileflowInteractionLimits.maxBindings));
+var annotationTargetSchema = z.strictObject({
+  id: portableIdSchema,
+  kind: z.literal("annotation")
+});
+var semanticFeatureTargetSchema = z.strictObject({
+  domain: z.string().check(
+    z.minLength(1),
+    z.maxLength(tileflowInteractionLimits.maxTargetNameLength),
+    z.regex(semanticDomainPattern, "Expected a dotted semantic domain")
+  ),
+  featureId: featureIdSchema,
+  kind: z.literal("semantic-feature")
+});
+var styleFeatureTargetSchema = z.strictObject({
+  featureId: featureIdSchema,
+  kind: z.literal("style-feature"),
+  layerId: targetNameSchema
+});
+var mapTargetSchema = z.strictObject({ coordinate: coordinateSchema, kind: z.literal("map") });
+var tileflowInteractionTargetRefSchema = z.discriminatedUnion("kind", [
+  annotationTargetSchema,
+  semanticFeatureTargetSchema,
+  styleFeatureTargetSchema,
+  mapTargetSchema
+]);
+var tileflowInteractionStateSchema = z.strictObject({
+  popup: z.nullable(tileflowInteractionTargetRefSchema)
+});
+var tileflowInteractionActionSchema = z.discriminatedUnion("type", [
+  z.strictObject({ target: tileflowInteractionTargetRefSchema, type: z.literal("open-popup") }),
+  z.strictObject({ type: z.literal("close-popup") })
+]);
+
+// src/reducer.ts
+var initialTileflowInteractionState = Object.freeze({
+  popup: null
+});
+function reduceTileflowInteractionState(state, action) {
+  if (action.type === "close-popup") {
+    return state.popup === null ? state : { popup: null };
+  }
+  if (tileflowInteractionTargetRefsEqual(state.popup, action.target)) {
+    return state;
+  }
+  return { popup: action.target };
+}
+function tileflowInteractionTargetRefsEqual(left, right) {
+  if (left === right) return true;
+  if (left === null || right === null || left.kind !== right.kind) return false;
+  switch (left.kind) {
+    case "annotation":
+      return left.id === right.id;
+    case "semantic-feature": {
+      const candidate = right;
+      return left.domain === candidate.domain && left.featureId === candidate.featureId;
+    }
+    case "style-feature": {
+      const candidate = right;
+      return left.layerId === candidate.layerId && left.featureId === candidate.featureId;
+    }
+    case "map": {
+      const candidate = right;
+      return left.coordinate[0] === candidate.coordinate[0] && left.coordinate[1] === candidate.coordinate[1];
+    }
+  }
+}
+
+// src/reference.ts
+var tileflowInteractionReference = Object.freeze({
+  actions: ["open-popup", "close-popup"],
+  annotationKinds: ["marker"],
+  contentKinds: ["text", "field", "view"],
+  entrypoints: ["@tileflow/interactions", "@tileflow/interactions/maplibre"],
+  eventTypes: [
+    "target:enter",
+    "target:leave",
+    "target:focus",
+    "target:blur",
+    "target:activate",
+    "popup:open",
+    "popup:close"
+  ],
+  limits: tileflowInteractionLimits,
+  semanticDomains: ["poi"],
+  state: { popup: "TileflowInteractionTargetRef | null" },
+  targetAvailability: {
+    annotation: {
+      binding: "reserved",
+      inlineSurfaces: "available",
+      stateReference: "available"
+    },
+    map: "reserved",
+    "semantic-feature": { availableDomains: ["poi"] },
+    "style-layer": "reserved"
+  },
+  targetKinds: ["annotation", "semantic-feature", "style-layer", "map"],
+  version: tileflowInteractionSchemaVersion
+});
+
+// src/validation.ts
+function validateTileflowAnnotations(input) {
+  const invalidDocument = () => invalidAnnotationsDocument();
+  try {
+    const topLevelLength = inspectTopLevelArrayLength(input);
+    if (!topLevelLength.ok) return invalidDocument();
+    if (topLevelLength.length !== void 0 && topLevelLength.length > tileflowInteractionLimits.maxAnnotations) {
+      return {
+        diagnostics: [
+          diagnostic(
+            "LIMIT_EXCEEDED",
+            "",
+            `Annotations exceed the ${tileflowInteractionLimits.maxAnnotations}-item limit.`
+          )
+        ],
+        ok: false
+      };
+    }
+    const audit = auditTileflowInteractionJsonDocument(input);
+    if (!audit.ok) {
+      return {
+        diagnostics: [documentAuditDiagnostic("Annotations", audit, invalidDocumentMessage)],
+        ok: false
+      };
+    }
+    let parsed;
+    try {
+      parsed = tileflowAnnotationsSchema.safeParse(input);
+    } catch {
+      return invalidDocument();
+    }
+    if (!parsed.success) {
+      return {
+        diagnostics: parsed.error.issues.map(
+          (issue) => diagnostic("INVALID_ANNOTATION", jsonPointer(issue.path), issue.message)
+        ),
+        ok: false
+      };
+    }
+    const duplicateDiagnostics = [];
+    const firstIndexById = /* @__PURE__ */ new Map();
+    for (const [index, annotation] of parsed.data.entries()) {
+      const firstIndex = firstIndexById.get(annotation.id);
+      if (firstIndex === void 0) {
+        firstIndexById.set(annotation.id, index);
+        continue;
+      }
+      duplicateDiagnostics.push(
+        diagnostic(
+          "DUPLICATE_ANNOTATION_ID",
+          `/${index}/id`,
+          `Annotation id "${annotation.id}" duplicates /${firstIndex}/id.`
+        )
+      );
+    }
+    if (duplicateDiagnostics.length > 0) {
+      return { diagnostics: duplicateDiagnostics, ok: false };
+    }
+    return { annotations: parsed.data, diagnostics: [], ok: true };
+  } catch {
+    return invalidDocument();
+  }
+}
+function validateTileflowInteractionBindings(input) {
+  const invalidDocument = () => invalidBindingsDocument();
+  try {
+    const topLevelLength = inspectTopLevelArrayLength(input);
+    if (!topLevelLength.ok) return invalidDocument();
+    if (topLevelLength.length !== void 0 && topLevelLength.length > tileflowInteractionLimits.maxBindings) {
+      return {
+        diagnostics: [
+          diagnostic(
+            "LIMIT_EXCEEDED",
+            "",
+            `Interaction bindings exceed the ${tileflowInteractionLimits.maxBindings}-item limit.`
+          )
+        ],
+        ok: false
+      };
+    }
+    const audit = auditTileflowInteractionJsonDocument(input);
+    if (!audit.ok) {
+      return {
+        diagnostics: [
+          documentAuditDiagnostic("Interaction bindings", audit, invalidBindingsDocumentMessage)
+        ],
+        ok: false
+      };
+    }
+    let parsed;
+    try {
+      parsed = tileflowInteractionBindingsSchema.safeParse(input);
+    } catch {
+      return invalidDocument();
+    }
+    if (!parsed.success) {
+      return {
+        diagnostics: parsed.error.issues.map(
+          (issue) => diagnostic("INVALID_DOCUMENT", jsonPointer(issue.path), issue.message)
+        ),
+        ok: false
+      };
+    }
+    const firstIndexById = /* @__PURE__ */ new Map();
+    const diagnostics = [];
+    for (const [index, binding] of parsed.data.entries()) {
+      const firstIndex = firstIndexById.get(binding.id);
+      if (firstIndex === void 0) {
+        firstIndexById.set(binding.id, index);
+        continue;
+      }
+      diagnostics.push(
+        diagnostic(
+          "INVALID_DOCUMENT",
+          `/${index}/id`,
+          `Interaction id "${binding.id}" duplicates /${firstIndex}/id.`
+        )
+      );
+    }
+    return diagnostics.length > 0 ? { diagnostics, ok: false } : { bindings: parsed.data, diagnostics: [], ok: true };
+  } catch {
+    return invalidDocument();
+  }
+}
+function inspectTopLevelArrayLength(input) {
+  try {
+    if (!Array.isArray(input)) return { ok: true };
+    const descriptor = Object.getOwnPropertyDescriptor(input, "length");
+    if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "number" || !Number.isSafeInteger(descriptor.value) || descriptor.value < 0) {
+      return { ok: false };
+    }
+    return { length: descriptor.value, ok: true };
+  } catch {
+    return { ok: false };
+  }
+}
+var invalidDocumentMessage = "Annotations must be a finite, acyclic JSON document.";
+var invalidBindingsDocumentMessage = "Interaction bindings must be a finite, acyclic JSON document.";
+function invalidAnnotationsDocument() {
+  return {
+    diagnostics: [diagnostic("INVALID_DOCUMENT", "", invalidDocumentMessage)],
+    ok: false
+  };
+}
+function invalidBindingsDocument() {
+  return {
+    diagnostics: [diagnostic("INVALID_DOCUMENT", "", invalidBindingsDocumentMessage)],
+    ok: false
+  };
+}
+function documentAuditDiagnostic(subject, audit, invalidMessage) {
+  switch (audit.reason) {
+    case "bytes":
+      return diagnostic(
+        "LIMIT_EXCEEDED",
+        "",
+        `${subject} exceed the ${tileflowInteractionLimits.maxDocumentBytes}-byte document limit.`
+      );
+    case "depth":
+      return diagnostic(
+        "LIMIT_EXCEEDED",
+        "",
+        `${subject} exceed the ${tileflowInteractionLimits.maxDocumentDepth}-level document depth limit.`
+      );
+    case "nodes":
+      return diagnostic(
+        "LIMIT_EXCEEDED",
+        "",
+        `${subject} exceed the ${tileflowInteractionLimits.maxDocumentNodes}-node document limit.`
+      );
+    case "properties":
+      return diagnostic(
+        "LIMIT_EXCEEDED",
+        "",
+        `${subject} exceed the ${tileflowInteractionLimits.maxDocumentProperties}-property document limit.`
+      );
+    case "invalid":
+      return diagnostic("INVALID_DOCUMENT", "", invalidMessage);
+  }
+}
+function diagnostic(code, path, message) {
+  return { code, level: "error", message, path };
+}
+function jsonPointer(path) {
+  return path.map((segment) => String(segment).replaceAll("~", "~0").replaceAll("/", "~1")).map((segment) => `/${segment}`).join("");
+}
+export {
+  initialTileflowInteractionState,
+  reduceTileflowInteractionState,
+  tileflowAnnotationSchema,
+  tileflowAnnotationsSchema,
+  tileflowInteractionActionSchema,
+  tileflowInteractionBindingSchema,
+  tileflowInteractionBindingsSchema,
+  tileflowInteractionContentSchema,
+  tileflowInteractionJsonValueSchema,
+  tileflowInteractionLimits,
+  tileflowInteractionReference,
+  tileflowInteractionSchemaVersion,
+  tileflowInteractionStateSchema,
+  tileflowInteractionTargetRefSchema,
+  tileflowInteractionTargetRefsEqual,
+  tileflowInteractionTargetSchema,
+  tileflowPoiCategories,
+  validateTileflowAnnotations,
+  validateTileflowInteractionBindings
+};