@tileflow/static 0.1.0-alpha.27 → 0.1.0-alpha.29

package/dist/scene.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { S as StaticMapError } from './errors-CSz1xaDx.js';
-import { j as StaticSceneInput, i as StaticScene } from './scene-contract-Cr6BNLz0.js';
-export { M as MAX_OVERLAY_LATITUDE, S as StaticAttributionMode, a as StaticAttributionPosition, b as StaticAttributionRequest, c as StaticCoordinate, d as StaticMapFormat, g as StaticOverlayPlacement, h as StaticPadding, k as StaticSymbolAnchor, l as StaticSymbolCollision, m as StaticSymbolLabelAppearance, n as StaticSymbolLabelPosition, o as StaticSymbolLanguage, p as isSupportedStaticSymbolCodePoint, s as staticAttributionPositionSchema, q as staticAttributionRequestSchema, r as staticOverlayPlacements, u as staticSceneLimits, v as staticSceneSchema, w as staticSceneSchemaVersion, x as staticSymbolAnchors, y as staticSymbolCollisions, z as staticSymbolLabelAppearances, A as staticSymbolLabelPositions, B as staticSymbolLanguages } from './scene-contract-Cr6BNLz0.js';
+import { a as StaticSceneInput, f as StaticScene } from './scene-contract-NFnIcQtt.js';
+export { M as MAX_OVERLAY_LATITUDE, g as StaticAttributionMode, S as StaticAttributionPosition, h as StaticAttributionRequest, i as StaticCoordinate, j as StaticMapFormat, k as StaticOverlayPlacement, n as StaticPadding, o as StaticSymbolAnchor, q as StaticSymbolCollision, r as StaticSymbolLabelAppearance, t as StaticSymbolLabelPosition, u as StaticSymbolLanguage, v as isSupportedStaticSymbolCodePoint, w as staticAttributionPositionSchema, x as staticAttributionRequestSchema, y as staticOverlayPlacements, z as staticSceneLimits, A as staticSceneSchema, B as staticSceneSchemaVersion, C as staticSymbolAnchors, D as staticSymbolCollisions, E as staticSymbolLabelAppearances, F as staticSymbolLabelPositions, G as staticSymbolLanguages } from './scene-contract-NFnIcQtt.js';
 
 declare const autoFitDetailsSchema: z.ZodObject<{
     overlay: z.ZodOptional<z.ZodObject<{
@@ -82,11 +82,13 @@ declare const staticSymbolTooLargeDetailsSchema: z.ZodObject<{
 }, z.core.$strict>;
 type StaticMapRequestErrorDetails = StaticAutoFitDetails | z.infer<typeof staticIconUnavailableDetailsSchema> | z.infer<typeof staticOverlayInvalidDetailsSchema> | z.infer<typeof staticLabelUnsupportedDetailsSchema> | z.infer<typeof staticSymbolTooLargeDetailsSchema>;
 declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
     code: z.ZodLiteral<"AUTO_FIT_EMPTY">;
     reason: z.ZodLiteral<"NO_FITTABLE_OVERLAYS">;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"AUTO_FIT_AMBIGUOUS">;
     details: z.ZodObject<{
         overlay: z.ZodOptional<z.ZodObject<{
@@ -124,9 +126,9 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
         }, z.core.$strict>>;
     }, z.core.$strict>;
     reason: z.ZodLiteral<"ANTIMERIDIAN_WRAP_REQUIRED">;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"AUTO_FIT_IMPOSSIBLE">;
     details: z.ZodOptional<z.ZodObject<{
         overlay: z.ZodOptional<z.ZodObject<{
@@ -169,9 +171,9 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
         INSUFFICIENT_VIEWPORT: "INSUFFICIENT_VIEWPORT";
         PROJECTED_FOOTPRINT_OUTSIDE_VIEWPORT: "PROJECTED_FOOTPRINT_OUTSIDE_VIEWPORT";
     }>;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_OVERLAY_INVALID">;
     details: z.ZodObject<{
         latitude: z.ZodNumber;
@@ -189,9 +191,9 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
         }, z.core.$strict>;
     }, z.core.$strict>;
     reason: z.ZodLiteral<"OVERLAY_LATITUDE_OUT_OF_RANGE">;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_MAP_LABEL_UNSUPPORTED">;
     details: z.ZodObject<{
         codePoint: z.ZodNumber;
@@ -202,9 +204,9 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
         }, z.core.$strict>;
     }, z.core.$strict>;
     reason: z.ZodLiteral<"UNSUPPORTED_GLYPH">;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_MAP_ICON_UNAVAILABLE">;
     details: z.ZodObject<{
         icon: z.ZodString;
@@ -218,14 +220,14 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
         ICON_NOT_FOUND: "ICON_NOT_FOUND";
         MANAGED_SPRITE_REQUIRED: "MANAGED_SPRITE_REQUIRED";
     }>;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_MAP_PLACEMENT_UNAVAILABLE">;
     reason: z.ZodLiteral<"MAP_REDEPLOY_REQUIRED">;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_MAP_SYMBOL_TOO_LARGE">;
     details: z.ZodObject<{
         height: z.ZodNumber;
@@ -238,26 +240,24 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
         width: z.ZodNumber;
     }, z.core.$strict>;
     reason: z.ZodLiteral<"COMPOSED_IMAGE_TOO_LARGE">;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_MAP_ATTRIBUTION_UNSUPPORTED">;
     reason: z.ZodEnum<{
         UNSUPPORTED_DECLARATION: "UNSUPPORTED_DECLARATION";
         UNSUPPORTED_GLYPH: "UNSUPPORTED_GLYPH";
     }>;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_MAP_ATTRIBUTION_TOO_LARGE">;
     reason: z.ZodLiteral<"CONTENT_LIMIT_EXCEEDED">;
+}, z.core.$strict>, z.ZodObject<{
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_MAP_ATTRIBUTION_DOES_NOT_FIT">;
     reason: z.ZodLiteral<"BLOCK_DOES_NOT_FIT">;
-    error: z.ZodString;
-    retryable: z.ZodLiteral<false>;
 }, z.core.$strict>], "code">;
 type StaticMapRequestErrorResponse = z.infer<typeof staticMapRequestErrorResponseSchema>;
 type StaticAutoFitErrorResponse = Extract<StaticMapRequestErrorResponse, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tileflow/static",
-  "version": "0.1.0-alpha.27",
+  "version": "0.1.0-alpha.29",
   "license": "Apache-2.0",
   "description": "Static map request schemas and helpers for Tileflow.",
   "type": "module",
@@ -21,18 +21,11 @@
     "maplibre",
     "tiles"
   ],
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "LICENSE"
   ],
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
     "./client": {
       "types": "./dist/client.d.ts",
       "import": "./dist/client.js",
@@ -58,10 +51,10 @@
     "access": "public"
   },
   "dependencies": {
-    "zod": "^4.4.3"
+    "zod": "^4.6.7"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/scene.ts src/overlays.ts src/manifest.ts src/client.ts --format esm --dts --clean --splitting && node ../../scripts/canonicalize-zod-enums.mjs dist",
+    "build": "tsup src/scene.ts src/overlays.ts src/manifest.ts src/client.ts --format esm --dts --clean --splitting && node ../../scripts/canonicalize-zod-enums.mjs dist",
     "verify": "pnpm --silent --dir ../.. static-text:check && tsx --test test/*.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "tsc -p tsconfig.json --noEmit"

package/dist/chunk-4GPRPR33.js

@@ -1,380 +0,0 @@
-import {
-  StaticMapError,
-  StaticMapRequestError,
-  staticMapErrorResponseSchema,
-  staticMapRequestErrorResponseSchema,
-  validateStaticScene
-} from "./chunk-ALFVZ3PC.js";
-import {
-  isSafeHttpUrl,
-  jsonByteLength,
-  stableStringify
-} from "./chunk-6DWVCK64.js";
-
-// src/client.ts
-import { z } from "zod";
-var maxStaticMapResponseBytes = 64 * 1024;
-var staticMapIdempotencyKeyPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
-var STATIC_MAP_RESULT_MEDIA_TYPE = "application/vnd.tileflow.static-map-result+json;version=1";
-var preparedStaticMapRequestBodies = /* @__PURE__ */ new WeakMap();
-var staticMapReadyResultBaseSchema = z.object({
-  cached: z.boolean(),
-  hash: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
-  imageUrl: z.string().trim().url().max(2048).refine(isSafeHttpUrl, { message: "Expected an http(s) URL without credentials" }),
-  operationId: z.string().min(20).max(68),
-  remainingUnits: z.number().int().nonnegative().nullable(),
-  status: z.literal("ready"),
-  unitCost: z.literal(15)
-}).strict();
-var safeAttributionTextSchema = z.string().min(1).max(16384).refine(hasNoControlCharacters, { message: "Attribution text contains control characters" });
-var staticMapAttributionEntrySchema = z.object({
-  authority: z.enum(["platform-notice", "team-declared"]),
-  links: z.array(
-    z.object({
-      label: safeAttributionTextSchema,
-      url: z.string().trim().url().max(2048).refine(isSafeHttpUrl, {
-        message: "Expected an http(s) URL without credentials or a fragment"
-      })
-    }).strict()
-  ).max(8),
-  text: safeAttributionTextSchema
-}).strict();
-var staticMapAttributionResultSchema = z.object({
-  entries: z.array(staticMapAttributionEntrySchema).max(18),
-  mode: z.enum(["embedded", "external"]),
-  position: z.enum(["top-left", "top-right", "bottom-left", "bottom-right"]).nullable()
-}).strict().superRefine((result, context) => {
-  if (result.mode === "external" && result.position !== null || result.mode === "embedded" && result.position === null) {
-    context.addIssue({
-      code: "custom",
-      message: "Attribution position must match its mode",
-      path: ["position"]
-    });
-  }
-  if (jsonByteLength(result) > 32 * 1024) {
-    context.addIssue({ code: "custom", message: "Attribution result exceeds 32 KiB" });
-  }
-});
-var staticMapHostedResultSchema = staticMapReadyResultBaseSchema.extend({
-  attribution: staticMapAttributionResultSchema,
-  resultVersion: z.literal(1)
-}).strict();
-var staticMapProcessingResultSchema = z.object({
-  operationId: z.string().min(20).max(68),
-  retryAfterMs: z.number().int().min(0).max(5e3),
-  status: z.literal("processing")
-}).strict();
-function validateStaticMapIdempotencyKey(value) {
-  if (typeof value !== "string" || !staticMapIdempotencyKeyPattern.test(value)) {
-    return {
-      error: "Idempotency key must contain 8-128 ASCII letters, digits, dot, underscore, colon, or hyphen and start with a letter or digit",
-      ok: false
-    };
-  }
-  return { key: value, ok: true };
-}
-function createStaticMapIdempotencyKey() {
-  const key = `static_${crypto.randomUUID()}`;
-  if (!validateStaticMapIdempotencyKey(key).ok) {
-    throw new Error("Unable to create a valid Tileflow Static Maps idempotency key");
-  }
-  return key;
-}
-function prepareStaticMapRequest(scene) {
-  const validation = validateStaticScene(scene);
-  if (!validation.ok) {
-    if (isStaticMapRequestFailure(validation)) {
-      const { ok: _ok, ...response } = validation;
-      throw new StaticMapRequestError(response);
-    }
-    throw new Error(`Invalid Tileflow static scene: ${validation.error}`);
-  }
-  const prepared = Object.freeze({
-    sceneKey: stableStringify(validation.scene)
-  });
-  preparedStaticMapRequestBodies.set(prepared, JSON.stringify(validation.scene));
-  return prepared;
-}
-async function createStaticMap(scene, options) {
-  return requestStaticMap(scene, options, "/v1/static/maps");
-}
-async function precacheStaticMap(scene, options) {
-  return requestStaticMap(scene, options, "/v1/static/maps/precache");
-}
-async function requestStaticMap(scene, options, path) {
-  const preparedRequest = prepareStaticMapRequest(scene);
-  const { apiUrl = "https://api.tileflow.dev", ...requestOptions } = options;
-  return requestStaticMapUntilReady(preparedRequest, {
-    ...requestOptions,
-    createUrl: `${normalizeUrl(apiUrl)}${path}`
-  });
-}
-async function requestStaticMapUntilReady(request, options) {
-  const body = preparedStaticMapRequestBodies.get(request);
-  if (body === void 0) {
-    throw new Error("Tileflow static map request must be created with prepareStaticMapRequest");
-  }
-  const idempotency = validateStaticMapIdempotencyKey(options.idempotencyKey);
-  if (!idempotency.ok) {
-    throw new Error(`Invalid Tileflow Static Maps idempotency key: ${idempotency.error}`);
-  }
-  const maxWaitMs = boundedClientDuration(options.maxWaitMs, 3e4, 100, 12e4, "maxWaitMs");
-  const pollIntervalMs = boundedClientDuration(
-    options.pollIntervalMs,
-    500,
-    0,
-    5e3,
-    "pollIntervalMs"
-  );
-  const fetcher = options.fetch ?? fetch;
-  const createUrl = normalizeStaticMapEndpointUrl(options.createUrl);
-  const headers = {
-    Accept: STATIC_MAP_RESULT_MEDIA_TYPE,
-    "Content-Type": "application/json",
-    "Idempotency-Key": idempotency.key
-  };
-  if (options.apiKey) {
-    headers.Authorization = `Bearer ${options.apiKey}`;
-  }
-  if (options.mapId !== void 0) {
-    if (!/^map_[A-Za-z0-9_-]{16}$/u.test(options.mapId)) {
-      throw new Error("Invalid Tileflow Map ID.");
-    }
-    headers["X-Tileflow-Map-Id"] = options.mapId;
-  }
-  return runWithinStaticMapBudget(maxWaitMs, options.signal, async (signal) => {
-    let operationId = null;
-    while (true) {
-      const response = await fetcher(createUrl, {
-        body,
-        headers,
-        method: "POST",
-        signal
-      });
-      throwIfAborted(signal);
-      if (!response.ok) {
-        const errorBody = await readStaticMapErrorBody(response, 8 * 1024);
-        throwIfAborted(signal);
-        if (response.status === 422) {
-          const requestError = staticMapRequestErrorResponseSchema.safeParse(errorBody);
-          if (requestError.success) {
-            throw new StaticMapRequestError(requestError.data, response.status);
-          }
-        }
-        const structured = staticMapErrorResponseSchema.safeParse(errorBody);
-        if (structured.success) {
-          throw new StaticMapError(structured.data, response.status);
-        }
-        throw new Error(`Tileflow static map failed (${response.status}).`);
-      }
-      const json = await readJsonResponse(response);
-      throwIfAborted(signal);
-      if (response.status !== 202) {
-        const parsed = staticMapHostedResultSchema.safeParse(json);
-        if (!parsed.success) {
-          throw new Error(
-            `Tileflow static map returned an invalid response: ${parsed.error.message}`
-          );
-        }
-        assertStaticMapOperationIdentity(operationId, parsed.data.operationId);
-        return parsed.data;
-      }
-      const pending = staticMapProcessingResultSchema.safeParse(json);
-      if (!pending.success) {
-        throw new Error(
-          `Tileflow static map returned an invalid response: ${pending.error.message}`
-        );
-      }
-      assertStaticMapOperationIdentity(operationId, pending.data.operationId);
-      operationId ??= pending.data.operationId;
-      await delay(Math.max(pollIntervalMs, pending.data.retryAfterMs), signal);
-    }
-  });
-}
-function hasNoControlCharacters(value) {
-  return !Array.from(value).some((character) => {
-    const codePoint = character.codePointAt(0) ?? 0;
-    return codePoint <= 31 || codePoint === 127;
-  });
-}
-function boundedClientDuration(value, fallback, minimum, maximum, name) {
-  const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved < minimum || resolved > maximum) {
-    throw new Error(
-      `Tileflow Static Maps ${name} must be an integer from ${minimum} to ${maximum}`
-    );
-  }
-  return resolved;
-}
-async function readJsonResponse(response) {
-  const source = await readBoundedResponseText(response, maxStaticMapResponseBytes, "64 KiB");
-  try {
-    return JSON.parse(source);
-  } catch {
-    throw new Error("Tileflow static map returned an invalid response: expected JSON");
-  }
-}
-async function readStaticMapErrorBody(response, maximumBytes) {
-  try {
-    const source = await readBoundedResponseText(response, maximumBytes, `${maximumBytes} bytes`);
-    return JSON.parse(source);
-  } catch {
-    return null;
-  }
-}
-function isStaticMapRequestFailure(value) {
-  if (!("code" in value)) return false;
-  const { ok: _ok, ...response } = value;
-  return staticMapRequestErrorResponseSchema.safeParse(response).success;
-}
-async function readBoundedResponseText(response, maximumBytes, displayLimit) {
-  if (!response.body) return "";
-  const reader = response.body.getReader();
-  const chunks = [];
-  let byteLength = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    byteLength += value.byteLength;
-    if (byteLength > maximumBytes) {
-      await reader.cancel();
-      throw new Error(
-        `Tileflow static map returned an invalid response: response exceeded ${displayLimit}`
-      );
-    }
-    chunks.push(value);
-  }
-  const bytes = new Uint8Array(byteLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-  } catch {
-    throw new Error("Tileflow static map returned an invalid response: expected UTF-8 JSON");
-  }
-}
-async function runWithinStaticMapBudget(maxWaitMs, externalSignal, operation) {
-  const controller = new AbortController();
-  const timeoutError = new Error(`Tileflow static map timed out after ${maxWaitMs}ms`);
-  const abortFromCaller = () => controller.abort(externalSignal?.reason);
-  if (externalSignal?.aborted) {
-    abortFromCaller();
-  } else {
-    externalSignal?.addEventListener("abort", abortFromCaller, { once: true });
-  }
-  const timeout = setTimeout(() => controller.abort(timeoutError), maxWaitMs);
-  try {
-    throwIfAborted(controller.signal);
-    const pending = operation(controller.signal);
-    return await raceWithAbort(pending, controller.signal);
-  } finally {
-    clearTimeout(timeout);
-    externalSignal?.removeEventListener("abort", abortFromCaller);
-  }
-}
-function delay(milliseconds, signal) {
-  if (milliseconds === 0) {
-    throwIfAborted(signal);
-    return Promise.resolve();
-  }
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, milliseconds);
-    const onAbort = () => {
-      clearTimeout(timeout);
-      reject(abortReason(signal));
-    };
-    if (signal.aborted) {
-      onAbort();
-    } else {
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-  });
-}
-function raceWithAbort(operation, signal) {
-  if (signal.aborted) return Promise.reject(abortReason(signal));
-  return new Promise((resolve, reject) => {
-    const onAbort = () => {
-      cleanup();
-      reject(abortReason(signal));
-    };
-    const cleanup = () => signal.removeEventListener("abort", onAbort);
-    signal.addEventListener("abort", onAbort, { once: true });
-    operation.then(
-      (value) => {
-        cleanup();
-        resolve(value);
-      },
-      (error) => {
-        cleanup();
-        reject(error);
-      }
-    );
-  });
-}
-function throwIfAborted(signal) {
-  if (signal.aborted) throw abortReason(signal);
-}
-function abortReason(signal) {
-  if (signal.reason instanceof Error) return signal.reason;
-  const error = new Error("Tileflow static map request was aborted");
-  error.name = "AbortError";
-  return error;
-}
-function assertStaticMapOperationIdentity(expected, actual) {
-  if (expected !== null && actual !== expected) {
-    throw new Error("Tileflow static map changed operation identity while polling");
-  }
-}
-function normalizeUrl(value) {
-  const url = new URL(value);
-  if (!isSafeHttpUrl(value) || url.search) {
-    throw new TypeError(
-      "Tileflow Static Maps apiUrl must be HTTP(S) without credentials, query, or fragment"
-    );
-  }
-  return url.toString().replace(/\/+$/, "");
-}
-function normalizeStaticMapEndpointUrl(value) {
-  if (value.startsWith("/")) {
-    if (value.startsWith("//") || value.length > 2048 || /[\\?#]/u.test(value) || hasControlCharacter(value)) {
-      throw new TypeError(
-        "Tileflow Static Maps createUrl must be HTTP(S) without credentials, query, or fragment or a safe root-relative path"
-      );
-    }
-    return value;
-  }
-  const url = new URL(value);
-  if (!isSafeHttpUrl(value) || url.search) {
-    throw new TypeError(
-      "Tileflow Static Maps createUrl must be HTTP(S) without credentials, query, or fragment or a safe root-relative path"
-    );
-  }
-  return url.toString();
-}
-function hasControlCharacter(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    const codePoint = value.charCodeAt(index);
-    if (codePoint <= 31 || codePoint === 127) return true;
-  }
-  return false;
-}
-
-export {
-  STATIC_MAP_RESULT_MEDIA_TYPE,
-  staticMapAttributionEntrySchema,
-  staticMapAttributionResultSchema,
-  staticMapHostedResultSchema,
-  staticMapProcessingResultSchema,
-  validateStaticMapIdempotencyKey,
-  createStaticMapIdempotencyKey,
-  prepareStaticMapRequest,
-  createStaticMap,
-  precacheStaticMap,
-  requestStaticMapUntilReady
-};