@noeos/verification-engine 0.0.0

package/dist/esm/validation/identifier-validation.js

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+import { ContextId as ContextIdValue, ProfileId as ProfileIdValue, RecordId as RecordIdValue, SequenceId as SequenceIdValue, } from "../domain/identifiers.js";
+import { success } from "../domain/operation-result.js";
+import { failureWithCode } from "./result-helpers.js";
+const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/u;
+const profilePattern = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/u;
+export function validateRecordId(value) {
+    return validateIdentifier(value, (input) => RecordIdValue.fromValidated(input));
+}
+export function validateSequenceId(value) {
+    return validateIdentifier(value, (input) => SequenceIdValue.fromValidated(input));
+}
+export function validateContextId(value) {
+    return validateIdentifier(value, (input) => ContextIdValue.fromValidated(input));
+}
+export function validateProfileId(value) {
+    if (typeof value !== "string" || !profilePattern.test(value) || value.length > 128) {
+        return failureWithCode("IDENTIFIER_INVALID", "input");
+    }
+    return success(ProfileIdValue.fromValidated(value));
+}
+function validateIdentifier(value, create) {
+    if (typeof value !== "string" || !identifierPattern.test(value) || value.length > 128) {
+        return failureWithCode("IDENTIFIER_INVALID", "input");
+    }
+    return success(create(value));
+}

package/dist/esm/validation/json-text-parser.js

@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: Apache-2.0
+import { types } from "node:util";
+import { failure, success } from "../domain/operation-result.js";
+import { DiagnosticCollector } from "./diagnostic-collector.js";
+import { validateJsonValue } from "./json-value-validation.js";
+import { decodeUtf8, encodeUtf8, hasWellFormedUnicode } from "./utf8-validation.js";
+import { failureWithCode } from "./result-helpers.js";
+export function parseJsonText(input, limits) {
+    const source = decodeInput(input, limits);
+    if (!source.ok)
+        return source;
+    const parser = new JsonTextParser(source.value, limits);
+    const parsed = parser.parse();
+    if (!parsed.ok)
+        return parsed;
+    return validateJsonValue(parsed.value, limits);
+}
+function decodeInput(input, limits) {
+    if (types.isProxy(input))
+        return failureWithSyntax();
+    if (input instanceof Uint8Array) {
+        if (input.length > limits.maxPayloadBytes)
+            return failureWithCode("INPUT_LIMIT_EXCEEDED", "input");
+        return decodeUtf8(input);
+    }
+    if (typeof input !== "string")
+        return failureWithSyntax();
+    if (!hasWellFormedUnicode(input))
+        return failureWithSyntax();
+    const encoded = encodeUtf8(input, limits.maxPayloadBytes);
+    if (!encoded.ok)
+        return encoded;
+    return success(input);
+}
+function failureWithSyntax() {
+    return failureWithCode("JSON_SYNTAX_INVALID", "input");
+}
+class JsonTextParser {
+    source;
+    limits;
+    offset = 0;
+    constructor(source, limits) {
+        this.source = source;
+        this.limits = limits;
+    }
+    parse() {
+        try {
+            this.skipWhitespace();
+            const value = this.parseValue(0, "");
+            this.skipWhitespace();
+            if (this.offset !== this.source.length)
+                return this.syntaxFailure();
+            return success(value);
+        }
+        catch (error) {
+            if (error instanceof JsonParseFailure) {
+                const collector = new DiagnosticCollector(this.limits);
+                collector.addCode(error.code, "input", { path: error.path, position: this.offset });
+                return failure(collector.finish());
+            }
+            const collector = new DiagnosticCollector(this.limits);
+            collector.addCode("JSON_SYNTAX_INVALID", "input", { position: this.offset });
+            return failure(collector.finish());
+        }
+    }
+    parseValue(depth, path) {
+        if (depth > this.limits.maxJsonDepth)
+            this.fail("INPUT_LIMIT_EXCEEDED", path);
+        const character = this.source[this.offset];
+        if (character === "{")
+            return this.parseObject(depth, path);
+        if (character === "[")
+            return this.parseArray(depth, path);
+        if (character === '"')
+            return this.parseString(path);
+        if (character === "t")
+            return this.parseLiteral("true", true);
+        if (character === "f")
+            return this.parseLiteral("false", false);
+        if (character === "n")
+            return this.parseLiteral("null", null);
+        if (character === "-" || isDigit(character))
+            return this.parseNumber(path);
+        this.fail("JSON_SYNTAX_INVALID", path);
+    }
+    parseObject(depth, path) {
+        this.offset += 1;
+        const output = {};
+        const names = new Set();
+        this.skipWhitespace();
+        if (this.consume("}"))
+            return Object.freeze(output);
+        let propertyCount = 0;
+        while (this.offset < this.source.length) {
+            if (propertyCount >= this.limits.maxObjectProperties)
+                this.fail("INPUT_LIMIT_EXCEEDED", path);
+            if (this.source[this.offset] !== '"')
+                this.fail("JSON_SYNTAX_INVALID", path);
+            const key = this.parseString(path);
+            if (names.has(key))
+                this.fail("JSON_DUPLICATE_KEY", `${path}/${escapeJsonPointer(key)}`);
+            names.add(key);
+            this.skipWhitespace();
+            if (!this.consume(":"))
+                this.fail("JSON_SYNTAX_INVALID", path);
+            this.skipWhitespace();
+            const childPath = `${path}/${escapeJsonPointer(key)}`;
+            const value = this.parseValue(depth + 1, childPath);
+            Object.defineProperty(output, key, {
+                configurable: false,
+                enumerable: true,
+                value,
+                writable: false,
+            });
+            propertyCount += 1;
+            this.skipWhitespace();
+            if (this.consume("}"))
+                return Object.freeze(output);
+            if (!this.consume(","))
+                this.fail("JSON_SYNTAX_INVALID", path);
+            this.skipWhitespace();
+        }
+        this.fail("JSON_SYNTAX_INVALID", path);
+    }
+    parseArray(depth, path) {
+        this.offset += 1;
+        const output = [];
+        this.skipWhitespace();
+        if (this.consume("]"))
+            return Object.freeze(output);
+        while (this.offset < this.source.length) {
+            if (output.length >= this.limits.maxArrayElements)
+                this.fail("INPUT_LIMIT_EXCEEDED", path);
+            output.push(this.parseValue(depth + 1, `${path}/${String(output.length)}`));
+            this.skipWhitespace();
+            if (this.consume("]"))
+                return Object.freeze(output);
+            if (!this.consume(","))
+                this.fail("JSON_SYNTAX_INVALID", path);
+            this.skipWhitespace();
+        }
+        this.fail("JSON_SYNTAX_INVALID", path);
+    }
+    parseString(path) {
+        if (!this.consume('"'))
+            this.fail("JSON_SYNTAX_INVALID", path);
+        let output = "";
+        while (this.offset < this.source.length) {
+            const character = this.source.charAt(this.offset);
+            this.offset += 1;
+            if (character === '"') {
+                if (!hasWellFormedUnicode(output))
+                    this.fail("UTF8_INVALID", path);
+                const encoded = encodeUtf8(output, this.limits.maxStringBytes);
+                if (!encoded.ok)
+                    this.fail("INPUT_LIMIT_EXCEEDED", path);
+                return output;
+            }
+            if (character === "\\") {
+                output += this.parseEscape(path);
+                continue;
+            }
+            if (character.charCodeAt(0) <= 0x1f) {
+                this.fail("JSON_SYNTAX_INVALID", path);
+            }
+            output += character;
+        }
+        this.fail("JSON_SYNTAX_INVALID", path);
+    }
+    parseEscape(path) {
+        const escape = this.source[this.offset];
+        this.offset += 1;
+        const simple = {
+            '"': '"',
+            "\\": "\\",
+            "/": "/",
+            b: "\b",
+            f: "\f",
+            n: "\n",
+            r: "\r",
+            t: "\t",
+        };
+        const simpleValue = escape === undefined ? undefined : simple[escape];
+        if (simpleValue !== undefined)
+            return simpleValue;
+        if (escape !== "u")
+            this.fail("JSON_SYNTAX_INVALID", path);
+        const codePoint = this.parseHexCodeUnit(path);
+        if (codePoint >= 0xd800 && codePoint <= 0xdbff) {
+            if (this.source[this.offset] !== "\\" || this.source[this.offset + 1] !== "u") {
+                this.fail("UTF8_INVALID", path);
+            }
+            this.offset += 2;
+            const low = this.parseHexCodeUnit(path);
+            if (low < 0xdc00 || low > 0xdfff)
+                this.fail("UTF8_INVALID", path);
+            return String.fromCodePoint(0x10000 + ((codePoint - 0xd800) << 10) + low - 0xdc00);
+        }
+        if (codePoint >= 0xdc00 && codePoint <= 0xdfff)
+            this.fail("UTF8_INVALID", path);
+        return String.fromCharCode(codePoint);
+    }
+    parseHexCodeUnit(path) {
+        const value = this.source.slice(this.offset, this.offset + 4);
+        if (!/^[0-9a-fA-F]{4}$/u.test(value))
+            this.fail("JSON_SYNTAX_INVALID", path);
+        this.offset += 4;
+        return Number.parseInt(value, 16);
+    }
+    parseNumber(path) {
+        const start = this.offset;
+        if (this.consume("-")) {
+            if (!isDigit(this.source[this.offset]))
+                this.fail("JSON_SYNTAX_INVALID", path);
+        }
+        if (this.consume("0")) {
+            if (isDigit(this.source[this.offset]))
+                this.fail("JSON_SYNTAX_INVALID", path);
+        }
+        else {
+            if (!isNonZeroDigit(this.source[this.offset]))
+                this.fail("JSON_SYNTAX_INVALID", path);
+            while (isDigit(this.source[this.offset]))
+                this.offset += 1;
+        }
+        if (this.consume(".")) {
+            if (!isDigit(this.source[this.offset]))
+                this.fail("JSON_SYNTAX_INVALID", path);
+            while (isDigit(this.source[this.offset]))
+                this.offset += 1;
+        }
+        if (this.source[this.offset] === "e" || this.source[this.offset] === "E") {
+            this.offset += 1;
+            if (this.source[this.offset] === "+" || this.source[this.offset] === "-")
+                this.offset += 1;
+            if (!isDigit(this.source[this.offset]))
+                this.fail("JSON_SYNTAX_INVALID", path);
+            while (isDigit(this.source[this.offset]))
+                this.offset += 1;
+        }
+        const value = Number(this.source.slice(start, this.offset));
+        if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+            this.fail("JSON_NUMBER_UNSAFE", path);
+        }
+        return value;
+    }
+    parseLiteral(literal, value) {
+        if (this.source.slice(this.offset, this.offset + literal.length) !== literal) {
+            this.fail("JSON_SYNTAX_INVALID", "");
+        }
+        this.offset += literal.length;
+        return value;
+    }
+    skipWhitespace() {
+        while (this.source[this.offset] === " " ||
+            this.source[this.offset] === "\n" ||
+            this.source[this.offset] === "\r" ||
+            this.source[this.offset] === "\t") {
+            this.offset += 1;
+        }
+    }
+    consume(expected) {
+        if (this.source[this.offset] !== expected)
+            return false;
+        this.offset += 1;
+        return true;
+    }
+    fail(code, path) {
+        throw new JsonParseFailure(code, path);
+    }
+    syntaxFailure() {
+        const collector = new DiagnosticCollector(this.limits);
+        collector.addCode("JSON_SYNTAX_INVALID", "input", { position: this.offset });
+        return failure(collector.finish());
+    }
+}
+class JsonParseFailure extends Error {
+    code;
+    path;
+    constructor(code, path) {
+        super(code);
+        this.code = code;
+        this.path = path;
+    }
+}
+function isDigit(value) {
+    return value !== undefined && value >= "0" && value <= "9";
+}
+function isNonZeroDigit(value) {
+    return value !== undefined && value >= "1" && value <= "9";
+}
+function escapeJsonPointer(value) {
+    return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}

package/dist/esm/validation/json-value-validation.js

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: Apache-2.0
+import { types } from "node:util";
+import { failure, success } from "../domain/operation-result.js";
+import { DiagnosticCollector } from "./diagnostic-collector.js";
+import { inspectPlainObject, isDataPropertyDescriptor } from "./object-inspection.js";
+import { utf8ByteLength } from "./utf8-validation.js";
+export function validateJsonValue(value, limits) {
+    const collector = new DiagnosticCollector(limits);
+    const active = new WeakSet();
+    const validated = validateValue(value, "", 0, limits, collector, active);
+    const diagnostics = collector.finish();
+    if (validated === undefined || collector.hasErrors())
+        return failure(diagnostics);
+    return success(validated, diagnostics);
+}
+function validateValue(value, path, depth, limits, collector, active) {
+    if (depth > limits.maxJsonDepth) {
+        collector.addCode("INPUT_LIMIT_EXCEEDED", "input", { path });
+        return undefined;
+    }
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "string")
+        return validateString(value, path, limits, collector);
+    if (typeof value === "number")
+        return validateNumber(value, path, collector);
+    if (typeof value !== "object") {
+        collector.addCode("JSON_VALUE_UNSUPPORTED", "input", { path });
+        return undefined;
+    }
+    if (types.isProxy(value) || active.has(value)) {
+        collector.addCode("JSON_VALUE_UNSUPPORTED", "input", { path });
+        return undefined;
+    }
+    active.add(value);
+    try {
+        if (Array.isArray(value))
+            return validateArray(value, path, depth, limits, collector, active);
+        return validateObject(value, path, depth, limits, collector, active);
+    }
+    finally {
+        active.delete(value);
+    }
+}
+function validateString(value, path, limits, collector) {
+    const byteLength = utf8ByteLength(value);
+    if (byteLength === undefined) {
+        collector.addCode("UTF8_INVALID", "input", { path });
+        return undefined;
+    }
+    if (byteLength > limits.maxStringBytes) {
+        collector.addCode("INPUT_LIMIT_EXCEEDED", "input", { path });
+        return undefined;
+    }
+    return value;
+}
+function validateNumber(value, path, collector) {
+    if (!Number.isFinite(value)) {
+        collector.addCode("JSON_NUMBER_UNSAFE", "input", { path });
+        return undefined;
+    }
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+        collector.addCode("JSON_NUMBER_UNSAFE", "input", { path });
+        return undefined;
+    }
+    return value;
+}
+function validateArray(value, path, depth, limits, collector, active) {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const symbols = Object.getOwnPropertySymbols(value);
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    if (symbols.length !== 0 ||
+        lengthDescriptor === undefined ||
+        !isDataPropertyDescriptor(lengthDescriptor)) {
+        collector.addCode("JSON_VALUE_UNSUPPORTED", "input", { path });
+        return undefined;
+    }
+    const length = lengthDescriptor.value;
+    if (typeof length !== "number" ||
+        !Number.isSafeInteger(length) ||
+        length > limits.maxArrayElements) {
+        collector.addCode("INPUT_LIMIT_EXCEEDED", "input", { path });
+        return undefined;
+    }
+    for (const [name, descriptor] of Object.entries(descriptors)) {
+        if (name === "length")
+            continue;
+        if (!isArrayIndex(name) ||
+            descriptor.enumerable !== true ||
+            descriptor.get !== undefined ||
+            descriptor.set !== undefined) {
+            collector.addCode("JSON_VALUE_UNSUPPORTED", "input", { path });
+            return undefined;
+        }
+    }
+    const output = [];
+    for (let index = 0; index < length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === undefined || !isDataPropertyDescriptor(descriptor)) {
+            collector.addCode("JSON_VALUE_UNSUPPORTED", "input", { path });
+            return undefined;
+        }
+        const itemPath = `${path}/${String(index)}`;
+        const item = validateValue(descriptor.value, itemPath, depth + 1, limits, collector, active);
+        if (item === undefined)
+            return undefined;
+        output.push(item);
+    }
+    return Object.freeze(output);
+}
+function validateObject(value, path, depth, limits, collector, active) {
+    const properties = inspectPlainObject(value);
+    if (properties === undefined) {
+        collector.addCode("JSON_VALUE_UNSUPPORTED", "input", { path });
+        return undefined;
+    }
+    if (properties.length > limits.maxObjectProperties) {
+        collector.addCode("INPUT_LIMIT_EXCEEDED", "input", { path });
+        return undefined;
+    }
+    const output = {};
+    for (const [name, property] of properties) {
+        const key = validateString(name, path, limits, collector);
+        if (key === undefined)
+            return undefined;
+        const propertyPath = `${path}/${escapeJsonPointer(key)}`;
+        const item = validateValue(property, propertyPath, depth + 1, limits, collector, active);
+        if (item === undefined)
+            return undefined;
+        if (key === "__proto__") {
+            Object.defineProperty(output, key, {
+                configurable: false,
+                enumerable: true,
+                value: item,
+                writable: false,
+            });
+        }
+        else {
+            output[key] = item;
+        }
+    }
+    return Object.freeze(output);
+}
+function isArrayIndex(name) {
+    if (!/^(?:0|[1-9][0-9]*)$/u.test(name))
+        return false;
+    const value = Number(name);
+    return (Number.isSafeInteger(value) && value >= 0 && value < 4_294_967_295 && String(value) === name);
+}
+function escapeJsonPointer(value) {
+    return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}

package/dist/esm/validation/limit-validation.js

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+import { DEFAULT_LIMITS, HARD_LIMITS } from "../domain/limits.js";
+import { success } from "../domain/operation-result.js";
+import { createDiagnostic } from "./diagnostic-collector.js";
+import { failureWithCode } from "./result-helpers.js";
+import { inspectPlainObject } from "./object-inspection.js";
+const limitKeys = Object.freeze([
+    "maxPayloadBytes",
+    "maxJsonDepth",
+    "maxObjectProperties",
+    "maxArrayElements",
+    "maxStringBytes",
+    "maxNdjsonLineBytes",
+    "maxDiagnostics",
+    "maxFullRecords",
+]);
+export function validateLimits(value) {
+    if (value === undefined)
+        return success(DEFAULT_LIMITS);
+    const properties = inspectPlainObject(value);
+    if (properties === undefined)
+        return failureWithCode("INPUT_TYPE_INVALID", "input");
+    const provided = new Map(properties);
+    for (const name of provided.keys()) {
+        if (!isLimitKey(name))
+            return failureWithCode("INPUT_TYPE_INVALID", "input");
+    }
+    const entries = {
+        maxPayloadBytes: DEFAULT_LIMITS.maxPayloadBytes,
+        maxJsonDepth: DEFAULT_LIMITS.maxJsonDepth,
+        maxObjectProperties: DEFAULT_LIMITS.maxObjectProperties,
+        maxArrayElements: DEFAULT_LIMITS.maxArrayElements,
+        maxStringBytes: DEFAULT_LIMITS.maxStringBytes,
+        maxNdjsonLineBytes: DEFAULT_LIMITS.maxNdjsonLineBytes,
+        maxDiagnostics: DEFAULT_LIMITS.maxDiagnostics,
+        maxFullRecords: DEFAULT_LIMITS.maxFullRecords,
+    };
+    for (const name of limitKeys) {
+        const candidate = provided.has(name) ? provided.get(name) : DEFAULT_LIMITS[name];
+        if (typeof candidate !== "number" ||
+            !Number.isSafeInteger(candidate) ||
+            candidate <= 0 ||
+            candidate > HARD_LIMITS[name]) {
+            return failureWithCode("INPUT_LIMIT_EXCEEDED", "input");
+        }
+        entries[name] = candidate;
+    }
+    const limits = {
+        maxPayloadBytes: entries.maxPayloadBytes,
+        maxJsonDepth: entries.maxJsonDepth,
+        maxObjectProperties: entries.maxObjectProperties,
+        maxArrayElements: entries.maxArrayElements,
+        maxStringBytes: entries.maxStringBytes,
+        maxNdjsonLineBytes: entries.maxNdjsonLineBytes,
+        maxDiagnostics: entries.maxDiagnostics,
+        maxFullRecords: entries.maxFullRecords,
+    };
+    return success(Object.freeze(limits));
+}
+function isLimitKey(value) {
+    return limitKeys.includes(value);
+}
+export function validateLimitValue(value, maximum) {
+    if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
+        return {
+            ok: false,
+            diagnostics: Object.freeze([createDiagnostic("INPUT_LIMIT_EXCEEDED", "input")]),
+        };
+    }
+    return success(value);
+}

package/dist/esm/validation/object-inspection.js

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+import { types } from "node:util";
+export function inspectPlainObject(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0)
+        return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const entries = [];
+    for (const [name, descriptor] of Object.entries(descriptors)) {
+        if (descriptor.enumerable !== true ||
+            descriptor.get !== undefined ||
+            descriptor.set !== undefined ||
+            !isDataPropertyDescriptor(descriptor)) {
+            return undefined;
+        }
+        entries.push([name, descriptor.value]);
+    }
+    return Object.freeze(entries);
+}
+/** Internal fixed-shape inspection that preserves the no-getter/no-proxy boundary. */
+export function inspectExactProperties(value, names) {
+    if (!isPlainObject(value))
+        return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0)
+        return undefined;
+    const ownNames = Object.getOwnPropertyNames(value);
+    if (ownNames.length !== names.length)
+        return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const values = [];
+    for (const name of names) {
+        const descriptor = descriptors[name];
+        if (descriptor === undefined)
+            return undefined;
+        if (descriptor.enumerable !== true ||
+            descriptor.get !== undefined ||
+            descriptor.set !== undefined ||
+            !isDataPropertyDescriptor(descriptor)) {
+            return undefined;
+        }
+        values.push(descriptor.value);
+    }
+    return values;
+}
+export function isDataPropertyDescriptor(descriptor) {
+    return "value" in descriptor;
+}
+export function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || types.isProxy(value))
+        return false;
+    const prototype = Reflect.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/esm/validation/position-validation.js

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+import { Position } from "../domain/position.js";
+import { success } from "../domain/operation-result.js";
+import { failureWithCode } from "./result-helpers.js";
+export function validatePosition(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        return failureWithCode("INPUT_TYPE_INVALID", "input");
+    }
+    return success(Position.fromValidated(value));
+}

package/dist/esm/validation/result-helpers.js

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
+import { failure } from "../domain/operation-result.js";
+import { createDiagnostic } from "./diagnostic-collector.js";
+export function failureWithCode(code, phase) {
+    return failure([createDiagnostic(code, phase)]);
+}

package/dist/esm/validation/utf8-validation.js

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+import { success } from "../domain/operation-result.js";
+import { failureWithCode } from "./result-helpers.js";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+export function hasWellFormedUnicode(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (Number.isNaN(next) || next < 0xdc00 || next > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+export function utf8ByteLength(value) {
+    let length = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit <= 0x7f)
+            length += 1;
+        else if (codeUnit <= 0x7ff)
+            length += 2;
+        else if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (Number.isNaN(next) || next < 0xdc00 || next > 0xdfff)
+                return undefined;
+            length += 4;
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff)
+            return undefined;
+        else
+            length += 3;
+    }
+    return length;
+}
+export function encodeUtf8(value, maxBytes) {
+    if (typeof value !== "string" || !hasWellFormedUnicode(value)) {
+        return failureWithCode("UTF8_INVALID", "input");
+    }
+    const bytes = encoder.encode(value);
+    if (bytes.length > maxBytes)
+        return failureWithCode("INPUT_LIMIT_EXCEEDED", "input");
+    return success(bytes);
+}
+export function decodeUtf8(value) {
+    if (value.length >= 3 && value[0] === 0xef && value[1] === 0xbb && value[2] === 0xbf) {
+        return failureWithCode("UTF8_INVALID", "input");
+    }
+    try {
+        const decoded = decoder.decode(value);
+        return success(decoded);
+    }
+    catch {
+        return failureWithCode("UTF8_INVALID", "input");
+    }
+}