@zudojs/constants 0.1.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zudojs Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -11,24 +11,132 @@ npm install @zudojs/constants
 ## Quick Start
 
 ```typescript
-import { EntityId, Timestamp, HttpStatus, ErrorCode } from "@zudojs/constants";
+import type { UserId, Timestamp } from "@zudojs/constants";
+import {
+  HttpStatus,
+  HttpMethods,
+  createUserId,
+  createTimestamp,
+  resolveEnvironment,
+  formatDuration,
+} from "@zudojs/constants";
 
-const id: EntityId = "user_123";
-const now: Timestamp = new Date();
-const status = HttpStatus.OK;
+const id: UserId = createUserId("user_123");
+const now: Timestamp = createTimestamp(new Date().toISOString());
+const status = HttpStatus.OK; // 200
+const env = resolveEnvironment(); // "development" | "test" | "staging" | "production"
+formatDuration(150_000); // "2m 30s"
 ```
 
-## Features
+All constant objects are `Object.freeze`d `as const` maps, and every map has a
+matching literal-union type (`HttpStatusCode`, `HttpMethod`, `Environment`,
+`LifecycleState`, `SchemaIssueCode`, ...). Sets such as `HTTP_METHODS` and
+`SCHEMA_FORBIDDEN_KEYS` are immutable at runtime: `add`/`delete`/`clear` throw.
 
-- Branded ID types (EntityId, UserId, EventId, etc.)
-- HTTP status codes and constants
-- Error codes and categories
-- Serialization tags and limits
-- Type-safe literal types
+## Modules
 
-## Use Cases
+### `http`
 
-- Type-safe identifiers
-- HTTP constants
-- Error code management
-- Shared enumerations
+- `HttpMethods`, `HTTP_METHODS`, `SAFE_HTTP_METHODS`, `IDEMPOTENT_HTTP_METHODS`
+- `HttpStatus` plus range helpers (`isSuccessStatus`, `isClientError`, ...)
+- `HttpHeader` common header names
+- `ContentTypes`, `Charset` (MIME charset labels), `buildContentType()`
+
+### `environment`
+
+- `Environments`, `ENVIRONMENTS`, `isValidEnvironment()`
+- `resolveEnvironment(env?, options?)`, `isProduction()`, `isDevelopment()`, `isTest()`
+
+`resolveEnvironment` reads `NODE_ENV` (case-insensitively, accepting the
+aliases `dev`/`prod`). An unrecognized value falls back to `"development"` but
+logs a `console.warn` once per distinct value, so a typo such as
+`NODE_ENV=prodution` is never silent. Use `{ strict: true }` to throw an
+`InvalidConstantError` instead, or `{ silent: true }` to suppress the warning.
+
+```typescript
+import { resolveEnvironment, isProduction } from "@zudojs/constants";
+
+resolveEnvironment({ NODE_ENV: "PROD" }); // "production"
+resolveEnvironment({ NODE_ENV: "prodution" }); // "development" + one-time warning
+resolveEnvironment({ NODE_ENV: "prodution" }, { strict: true }); // throws InvalidConstantError
+isProduction(); // reads process.env
+```
+
+### `time`
+
+- `TimeMs` durations (SECOND ... YEAR), `DefaultTimeout`, `DefaultRetry`
+- `TimeUnits` / `TimeUnit`, `toMilliseconds(value, unit)`, `formatDuration(ms)`
+
+```typescript
+import { TimeMs, toMilliseconds, formatDuration } from "@zudojs/constants";
+
+const ttl = 5 * TimeMs.MINUTE; // 300_000
+toMilliseconds(2, "hours"); // 7_200_000
+formatDuration(90_000); // "1m 30s"
+formatDuration(4_500_000); // "1h 15m"
+```
+
+### `common`
+
+- Branded types (`UserId`, `EventId`, `Timestamp`, `Url`, `EmailAddress`, ...)
+  with `createX` factories — the validating ones (`createTimestamp`,
+  `createUrl`, `createEmailAddress`, `createHexString`, `createBase64String`,
+  `createJsonString`) throw `InvalidConstantError` on bad input
+- `Limits`, `Defaults`, `Sentinel` and sentinels `NONE`, `UNINITIALIZED`, `EMPTY`
+- Lifecycle state machine: `LifecycleState`, `LifecyclePhase`, `LIFECYCLE_VALID_TRANSITIONS`, timeouts/retries
+- Schema constants: `SchemaIssueCode`, `SCHEMA_FORBIDDEN_KEYS` (immutable at runtime), `SCHEMA_STRING_FORMATS`
+- Serialization constants: `SerializationFormat`, `SerializationContentType`, `SerializationLimits`, `SerializationTags`
+
+### `validation`
+
+- `ValidationPattern` — the single source of truth for regexes (EMAIL, UUID,
+  UUID_V4, IPV4, IPV6, ISO_DATE_TIME, URL, SEMVER, PHONE, FILE_NAME, ...).
+  `SCHEMA_STRING_FORMATS` re-exports these rather than redefining them.
+- `ValidationLength`, `ValidationRange`
+
+```typescript
+import { ValidationPattern, ValidationLength } from "@zudojs/constants";
+
+ValidationPattern.SEMVER.test("1.0.0-alpha-1"); // true (semver.org grammar)
+ValidationPattern.IPV6.test("::ffff:192.0.2.1"); // true
+ValidationPattern.FILE_NAME.test(".."); // false (path traversal)
+ValidationLength.EMAIL; // 254
+```
+
+### `cache`
+
+- `CacheStrategies`, `CacheDuration`, `buildCacheControl()`
+
+### `priority`
+
+- `Priorities`, `PriorityWeight`, `comparePriority()`
+
+### `runtime`
+
+- Injectable `Clock` / `Random` interfaces with `systemClock` / `systemRandom`
+  (fully `node:crypto`-backed, safe for tokens and salts) and deterministic
+  `createMockClock()` / `createMockRandom(seed)` for tests
+- `MockClock` adds `advance(ms)` and `set(timestampOrDate)`
+
+```typescript
+import {
+  createMockClock,
+  createMockRandom,
+  systemRandom,
+} from "@zudojs/constants";
+
+const clock = createMockClock(0);
+clock.advance(1_000);
+clock.set(new Date("2024-01-01T00:00:00Z"));
+clock.now(); // 1704067200000
+
+const rng = createMockRandom(42); // same seed => same sequence
+rng.randomInt(1, 6);
+
+systemRandom.randomString(32); // CSPRNG-backed
+```
+
+### Errors
+
+- `InvalidConstantError`, `ConstantContextError` (built on `@zudojs/errors`;
+  error codes themselves live in `@zudojs/errors`)

package/dist/cache/cacheControl.type.d.ts

@@ -5,21 +5,24 @@
  */
 import { type CacheStrategy } from "./cacheStrategy.type.js";
 /**
- * Default cache durations in seconds for different resource types.
+ * Default cache durations in **seconds** (the unit `Cache-Control` uses) for
+ * different resource types.
+ *
+ * Derived from {@link TimeMs} (milliseconds) so the two never drift apart.
  */
 export declare const CacheDuration: Readonly<{
     /** No caching */
     readonly NONE: 0;
     /** Very short cache (10 seconds) — API data */
-    readonly SHORT: 10;
+    readonly SHORT: number;
     /** Medium cache (5 minutes) — semi-dynamic content */
-    readonly MEDIUM: 300;
+    readonly MEDIUM: number;
     /** Long cache (1 hour) — static content */
-    readonly LONG: 3600;
+    readonly LONG: number;
     /** Very long cache (1 day) — immutable assets */
-    readonly VERY_LONG: 86400;
+    readonly VERY_LONG: number;
     /** One week — versioned assets */
-    readonly WEEK: 604800;
+    readonly WEEK: number;
 }>;
 /**
  * Options for building a Cache-Control header value.
@@ -31,14 +34,20 @@ export interface CacheControlOptions {
     readonly maxAge?: number;
     /** Stale-while-revalidate duration in seconds */
     readonly staleWhileRevalidate?: number;
-    /** Whether to include the s-maxage directive */
+    /** Shared (proxy) cache max age in seconds — emits the s-maxage directive */
     readonly sharedMaxAge?: number;
 }
 /**
  * Build a Cache-Control header value from options.
  *
+ * When the strategy is `no-store`, all duration directives (`max-age`,
+ * `stale-while-revalidate`, `s-maxage`) are ignored — combining them with
+ * `no-store` is invalid per RFC 9111.
+ *
  * @param options - Cache control options
  * @returns Cache-Control header string
+ * @throws {InvalidConstantError} if any provided duration is not a
+ * non-negative finite integer
  */
 export declare function buildCacheControl(options: CacheControlOptions): string;
 //# sourceMappingURL=cacheControl.type.d.ts.map

package/dist/cache/cacheControl.type.js

@@ -4,32 +4,64 @@
  * @module cache/cacheControl
  */
 import {} from "./cacheStrategy.type.js";
+import { InvalidConstantError } from "../constantsErrors/constantsError.base.js";
 import { TimeMs } from "../time/time.constant.js";
+/** Milliseconds per second, for deriving second-based durations from {@link TimeMs}. */
+const MS_PER_SECOND = TimeMs.SECOND;
 /**
- * Default cache durations in seconds for different resource types.
+ * Default cache durations in **seconds** (the unit `Cache-Control` uses) for
+ * different resource types.
+ *
+ * Derived from {@link TimeMs} (milliseconds) so the two never drift apart.
  */
 export const CacheDuration = Object.freeze({
     /** No caching */
     NONE: 0,
     /** Very short cache (10 seconds) — API data */
-    SHORT: 10,
+    SHORT: (10 * TimeMs.SECOND) / MS_PER_SECOND,
     /** Medium cache (5 minutes) — semi-dynamic content */
-    MEDIUM: 300,
+    MEDIUM: (5 * TimeMs.MINUTE) / MS_PER_SECOND,
     /** Long cache (1 hour) — static content */
-    LONG: 3_600,
+    LONG: TimeMs.HOUR / MS_PER_SECOND,
     /** Very long cache (1 day) — immutable assets */
-    VERY_LONG: 86_400,
+    VERY_LONG: TimeMs.DAY / MS_PER_SECOND,
     /** One week — versioned assets */
-    WEEK: 604_800,
+    WEEK: TimeMs.WEEK / MS_PER_SECOND,
 });
+/**
+ * Assert that a cache duration is a non-negative finite integer.
+ */
+function assertCacheSeconds(name, value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new InvalidConstantError(`buildCacheControl: ${name} must be a non-negative finite integer, got ${String(value)}`);
+    }
+}
 /**
  * Build a Cache-Control header value from options.
  *
+ * When the strategy is `no-store`, all duration directives (`max-age`,
+ * `stale-while-revalidate`, `s-maxage`) are ignored — combining them with
+ * `no-store` is invalid per RFC 9111.
+ *
  * @param options - Cache control options
  * @returns Cache-Control header string
+ * @throws {InvalidConstantError} if any provided duration is not a
+ * non-negative finite integer
  */
 export function buildCacheControl(options) {
+    if (options.maxAge !== undefined) {
+        assertCacheSeconds("maxAge", options.maxAge);
+    }
+    if (options.staleWhileRevalidate !== undefined) {
+        assertCacheSeconds("staleWhileRevalidate", options.staleWhileRevalidate);
+    }
+    if (options.sharedMaxAge !== undefined) {
+        assertCacheSeconds("sharedMaxAge", options.sharedMaxAge);
+    }
     const parts = [options.strategy];
+    if (options.strategy === "no-store") {
+        return parts.join(", ");
+    }
     if (options.maxAge !== undefined) {
         parts.push(`max-age=${options.maxAge}`);
     }

package/dist/common/common.constant.d.ts

@@ -1,9 +1,10 @@
 /**
- * Common default values, limits, and sentinel constants.
+ * Common default values, limits, sentinel constants, and branded-type
+ * factories.
  *
  * @module common/common
  */
-import { type UserId, type EventId, type RequestId, type CorrelationId, type Timestamp } from "./common.type.js";
+import { type UserId, type EventId, type RequestId, type CorrelationId, type SessionId, type TenantId, type MessageId, type MessageCausationId, type TokenId, type Timestamp, type Url, type EmailAddress, type HexString, type Base64String, type JsonString } from "./common.type.js";
 /** Sentinel value indicating absence of a value. */
 export declare const NONE: "NONE";
 /** Sentinel value indicating an uninitialized state. */
@@ -24,10 +25,24 @@ export declare const Limits: Readonly<{
     readonly MAX_PAGE_SIZE: 100;
     /** Default page size for paginated queries */
     readonly DEFAULT_PAGE_SIZE: 20;
-    /** Maximum depth for nested structures */
+    /**
+     * Maximum depth for general nested data structures (e.g. user-supplied
+     * config objects).
+     *
+     * Intentionally distinct from `SCHEMA_DEFAULT_MAX_DEPTH` (100 — recursion
+     * guard for schema validation) and `SerializationLimits.MAX_DEPTH` (128 —
+     * recursion guard for the serializer): those bound internal traversal,
+     * this bounds acceptable user data shape.
+     */
     readonly MAX_NESTING_DEPTH: 10;
-    /** Maximum number of retry attempts */
-    readonly MAX_RETRY_ATTEMPTS: 5;
+    /**
+     * Maximum number of retry attempts a caller may configure (upper bound).
+     *
+     * This is the single source of truth for the retry cap —
+     * `ValidationRange.MAX_RETRIES` derives from it. The out-of-the-box default
+     * is the (smaller) `DefaultRetry.MAX_ATTEMPTS`.
+     */
+    readonly MAX_RETRY_ATTEMPTS: 10;
     /** Maximum number of concurrent operations */
     readonly MAX_CONCURRENCY: 10;
     /** Maximum buffer size (64 KB) */
@@ -39,12 +54,15 @@ export declare const Limits: Readonly<{
  * Default configuration values for common options.
  */
 export declare const Defaults: Readonly<{
-    /** Default character encoding */
+    /** Default character encoding (canonical: {@link Charset.UTF_8}) */
     readonly ENCODING: "utf-8";
-    /** Default MIME type */
+    /** Default MIME type (canonical: {@link ContentTypes.JSON}) */
     readonly CONTENT_TYPE: "application/json";
-    /** Default date format (ISO 8601) */
-    readonly DATE_FORMAT: "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
+    /**
+     * Default date format (ISO 8601 with timezone offset; `XXX` renders `Z`
+     * for UTC or `±hh:mm` otherwise).
+     */
+    readonly DATE_FORMAT: "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
     /** Default time zone */
     readonly TIMEZONE: "UTC";
     /** Default locale */
@@ -64,8 +82,6 @@ export declare const Defaults: Readonly<{
 export declare const Sentinel: Readonly<{
     /** Value indicating null/absence in serialized form */
     readonly NULL: null;
-    /** Value indicating undefined in serialized form */
-    readonly UNDEFINED: undefined;
     /** Marker for deleted soft-delete records */
     readonly DELETED: "__DELETED__";
     /** Marker for placeholder data */
@@ -89,8 +105,61 @@ export declare function createRequestId(id: string): RequestId;
  * Create a branded CorrelationId from a raw string.
  */
 export declare function createCorrelationId(id: string): CorrelationId;
+/**
+ * Create a branded SessionId from a raw string.
+ */
+export declare function createSessionId(id: string): SessionId;
+/**
+ * Create a branded TenantId from a raw string.
+ */
+export declare function createTenantId(id: string): TenantId;
+/**
+ * Create a branded MessageId from a raw string.
+ */
+export declare function createMessageId(id: string): MessageId;
+/**
+ * Create a branded MessageCausationId from a raw string.
+ */
+export declare function createMessageCausationId(id: string): MessageCausationId;
+/**
+ * Create a branded TokenId from a raw string.
+ */
+export declare function createTokenId(id: string): TokenId;
 /**
  * Create a branded Timestamp from an ISO 8601 string.
+ *
+ * @throws {InvalidConstantError} if the input is not a valid ISO 8601
+ * date-time string (e.g. `2024-01-01T00:00:00.000Z`).
  */
 export declare function createTimestamp(iso: string): Timestamp;
+/**
+ * Create a branded Url from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not a parseable URL.
+ */
+export declare function createUrl(url: string): Url;
+/**
+ * Create a branded EmailAddress from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not a valid email address.
+ */
+export declare function createEmailAddress(email: string): EmailAddress;
+/**
+ * Create a branded HexString from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not even-length hexadecimal.
+ */
+export declare function createHexString(hex: string): HexString;
+/**
+ * Create a branded Base64String from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not valid base64.
+ */
+export declare function createBase64String(base64: string): Base64String;
+/**
+ * Create a branded JsonString from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not parseable JSON.
+ */
+export declare function createJsonString(json: string): JsonString;
 //# sourceMappingURL=common.constant.d.ts.map

package/dist/common/common.constant.js

@@ -1,9 +1,13 @@
 /**
- * Common default values, limits, and sentinel constants.
+ * Common default values, limits, sentinel constants, and branded-type
+ * factories.
  *
  * @module common/common
  */
 import {} from "./common.type.js";
+import { ContentTypes, Charset } from "../http/httpContentType.type.js";
+import { ValidationPattern } from "../validation/validation.pattern.type.js";
+import { InvalidConstantError } from "../constantsErrors/constantsError.base.js";
 /** Sentinel value indicating absence of a value. */
 export const NONE = "NONE";
 /** Sentinel value indicating an uninitialized state. */
@@ -24,10 +28,24 @@ export const Limits = Object.freeze({
     MAX_PAGE_SIZE: 100,
     /** Default page size for paginated queries */
     DEFAULT_PAGE_SIZE: 20,
-    /** Maximum depth for nested structures */
+    /**
+     * Maximum depth for general nested data structures (e.g. user-supplied
+     * config objects).
+     *
+     * Intentionally distinct from `SCHEMA_DEFAULT_MAX_DEPTH` (100 — recursion
+     * guard for schema validation) and `SerializationLimits.MAX_DEPTH` (128 —
+     * recursion guard for the serializer): those bound internal traversal,
+     * this bounds acceptable user data shape.
+     */
     MAX_NESTING_DEPTH: 10,
-    /** Maximum number of retry attempts */
-    MAX_RETRY_ATTEMPTS: 5,
+    /**
+     * Maximum number of retry attempts a caller may configure (upper bound).
+     *
+     * This is the single source of truth for the retry cap —
+     * `ValidationRange.MAX_RETRIES` derives from it. The out-of-the-box default
+     * is the (smaller) `DefaultRetry.MAX_ATTEMPTS`.
+     */
+    MAX_RETRY_ATTEMPTS: 10,
     /** Maximum number of concurrent operations */
     MAX_CONCURRENCY: 10,
     /** Maximum buffer size (64 KB) */
@@ -39,12 +57,15 @@ export const Limits = Object.freeze({
  * Default configuration values for common options.
  */
 export const Defaults = Object.freeze({
-    /** Default character encoding */
-    ENCODING: "utf-8",
-    /** Default MIME type */
-    CONTENT_TYPE: "application/json",
-    /** Default date format (ISO 8601) */
-    DATE_FORMAT: "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
+    /** Default character encoding (canonical: {@link Charset.UTF_8}) */
+    ENCODING: Charset.UTF_8,
+    /** Default MIME type (canonical: {@link ContentTypes.JSON}) */
+    CONTENT_TYPE: ContentTypes.JSON,
+    /**
+     * Default date format (ISO 8601 with timezone offset; `XXX` renders `Z`
+     * for UTC or `±hh:mm` otherwise).
+     */
+    DATE_FORMAT: "yyyy-MM-dd'T'HH:mm:ss.SSSXXX",
     /** Default time zone */
     TIMEZONE: "UTC",
     /** Default locale */
@@ -64,8 +85,6 @@ export const Defaults = Object.freeze({
 export const Sentinel = Object.freeze({
     /** Value indicating null/absence in serialized form */
     NULL: null,
-    /** Value indicating undefined in serialized form */
-    UNDEFINED: undefined,
     /** Marker for deleted soft-delete records */
     DELETED: "__DELETED__",
     /** Marker for placeholder data */
@@ -97,10 +116,105 @@ export function createRequestId(id) {
 export function createCorrelationId(id) {
     return id;
 }
+/**
+ * Create a branded SessionId from a raw string.
+ */
+export function createSessionId(id) {
+    return id;
+}
+/**
+ * Create a branded TenantId from a raw string.
+ */
+export function createTenantId(id) {
+    return id;
+}
+/**
+ * Create a branded MessageId from a raw string.
+ */
+export function createMessageId(id) {
+    return id;
+}
+/**
+ * Create a branded MessageCausationId from a raw string.
+ */
+export function createMessageCausationId(id) {
+    return id;
+}
+/**
+ * Create a branded TokenId from a raw string.
+ */
+export function createTokenId(id) {
+    return id;
+}
 /**
  * Create a branded Timestamp from an ISO 8601 string.
+ *
+ * @throws {InvalidConstantError} if the input is not a valid ISO 8601
+ * date-time string (e.g. `2024-01-01T00:00:00.000Z`).
  */
 export function createTimestamp(iso) {
+    if (!ValidationPattern.ISO_DATE_TIME.test(iso) ||
+        Number.isNaN(Date.parse(iso))) {
+        throw new InvalidConstantError(`Invalid ISO 8601 timestamp: ${JSON.stringify(iso)}`);
+    }
     return iso;
 }
+/**
+ * Create a branded Url from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not a parseable URL.
+ */
+export function createUrl(url) {
+    if (!URL.canParse(url)) {
+        throw new InvalidConstantError(`Invalid URL: ${JSON.stringify(url)}`);
+    }
+    return url;
+}
+/**
+ * Create a branded EmailAddress from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not a valid email address.
+ */
+export function createEmailAddress(email) {
+    if (email.length > 254 || !ValidationPattern.EMAIL.test(email)) {
+        throw new InvalidConstantError(`Invalid email address: ${JSON.stringify(email)}`);
+    }
+    return email;
+}
+/**
+ * Create a branded HexString from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not even-length hexadecimal.
+ */
+export function createHexString(hex) {
+    if (hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex)) {
+        throw new InvalidConstantError(`Invalid hex string: ${JSON.stringify(hex)}`);
+    }
+    return hex;
+}
+/**
+ * Create a branded Base64String from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not valid base64.
+ */
+export function createBase64String(base64) {
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(base64)) {
+        throw new InvalidConstantError(`Invalid base64 string: ${JSON.stringify(base64)}`);
+    }
+    return base64;
+}
+/**
+ * Create a branded JsonString from a raw string.
+ *
+ * @throws {InvalidConstantError} if the input is not parseable JSON.
+ */
+export function createJsonString(json) {
+    try {
+        JSON.parse(json);
+    }
+    catch {
+        throw new InvalidConstantError(`Invalid JSON string: ${JSON.stringify(json)}`);
+    }
+    return json;
+}
 //# sourceMappingURL=common.constant.js.map