@noeos/verification-engine 0.0.0

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

@@ -0,0 +1,297 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonText = parseJsonText;
+const node_util_1 = require("node:util");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const diagnostic_collector_js_1 = require("./diagnostic-collector.js");
+const json_value_validation_js_1 = require("./json-value-validation.js");
+const utf8_validation_js_1 = require("./utf8-validation.js");
+const result_helpers_js_1 = require("./result-helpers.js");
+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 (0, json_value_validation_js_1.validateJsonValue)(parsed.value, limits);
+}
+function decodeInput(input, limits) {
+    if (node_util_1.types.isProxy(input))
+        return failureWithSyntax();
+    if (input instanceof Uint8Array) {
+        if (input.length > limits.maxPayloadBytes)
+            return (0, result_helpers_js_1.failureWithCode)("INPUT_LIMIT_EXCEEDED", "input");
+        return (0, utf8_validation_js_1.decodeUtf8)(input);
+    }
+    if (typeof input !== "string")
+        return failureWithSyntax();
+    if (!(0, utf8_validation_js_1.hasWellFormedUnicode)(input))
+        return failureWithSyntax();
+    const encoded = (0, utf8_validation_js_1.encodeUtf8)(input, limits.maxPayloadBytes);
+    if (!encoded.ok)
+        return encoded;
+    return (0, operation_result_js_1.success)(input);
+}
+function failureWithSyntax() {
+    return (0, result_helpers_js_1.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 (0, operation_result_js_1.success)(value);
+        }
+        catch (error) {
+            if (error instanceof JsonParseFailure) {
+                const collector = new diagnostic_collector_js_1.DiagnosticCollector(this.limits);
+                collector.addCode(error.code, "input", { path: error.path, position: this.offset });
+                return (0, operation_result_js_1.failure)(collector.finish());
+            }
+            const collector = new diagnostic_collector_js_1.DiagnosticCollector(this.limits);
+            collector.addCode("JSON_SYNTAX_INVALID", "input", { position: this.offset });
+            return (0, operation_result_js_1.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 (!(0, utf8_validation_js_1.hasWellFormedUnicode)(output))
+                    this.fail("UTF8_INVALID", path);
+                const encoded = (0, utf8_validation_js_1.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 diagnostic_collector_js_1.DiagnosticCollector(this.limits);
+        collector.addCode("JSON_SYNTAX_INVALID", "input", { position: this.offset });
+        return (0, operation_result_js_1.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/cjs/validation/json-value-validation.js

@@ -0,0 +1,155 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateJsonValue = validateJsonValue;
+const node_util_1 = require("node:util");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const diagnostic_collector_js_1 = require("./diagnostic-collector.js");
+const object_inspection_js_1 = require("./object-inspection.js");
+const utf8_validation_js_1 = require("./utf8-validation.js");
+function validateJsonValue(value, limits) {
+    const collector = new diagnostic_collector_js_1.DiagnosticCollector(limits);
+    const active = new WeakSet();
+    const validated = validateValue(value, "", 0, limits, collector, active);
+    const diagnostics = collector.finish();
+    if (validated === undefined || collector.hasErrors())
+        return (0, operation_result_js_1.failure)(diagnostics);
+    return (0, operation_result_js_1.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 (node_util_1.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 = (0, utf8_validation_js_1.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 ||
+        !(0, object_inspection_js_1.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 || !(0, object_inspection_js_1.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 = (0, object_inspection_js_1.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/cjs/validation/limit-validation.js

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

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

@@ -0,0 +1,60 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectPlainObject = inspectPlainObject;
+exports.inspectExactProperties = inspectExactProperties;
+exports.isDataPropertyDescriptor = isDataPropertyDescriptor;
+exports.isPlainObject = isPlainObject;
+const node_util_1 = require("node:util");
+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. */
+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;
+}
+function isDataPropertyDescriptor(descriptor) {
+    return "value" in descriptor;
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || node_util_1.types.isProxy(value))
+        return false;
+    const prototype = Reflect.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePosition = validatePosition;
+const position_js_1 = require("../domain/position.js");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const result_helpers_js_1 = require("./result-helpers.js");
+function validatePosition(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        return (0, result_helpers_js_1.failureWithCode)("INPUT_TYPE_INVALID", "input");
+    }
+    return (0, operation_result_js_1.success)(position_js_1.Position.fromValidated(value));
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failureWithCode = failureWithCode;
+const operation_result_js_1 = require("../domain/operation-result.js");
+const diagnostic_collector_js_1 = require("./diagnostic-collector.js");
+function failureWithCode(code, phase) {
+    return (0, operation_result_js_1.failure)([(0, diagnostic_collector_js_1.createDiagnostic)(code, phase)]);
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasWellFormedUnicode = hasWellFormedUnicode;
+exports.utf8ByteLength = utf8ByteLength;
+exports.encodeUtf8 = encodeUtf8;
+exports.decodeUtf8 = decodeUtf8;
+const operation_result_js_1 = require("../domain/operation-result.js");
+const result_helpers_js_1 = require("./result-helpers.js");
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+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;
+}
+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;
+}
+function encodeUtf8(value, maxBytes) {
+    if (typeof value !== "string" || !hasWellFormedUnicode(value)) {
+        return (0, result_helpers_js_1.failureWithCode)("UTF8_INVALID", "input");
+    }
+    const bytes = encoder.encode(value);
+    if (bytes.length > maxBytes)
+        return (0, result_helpers_js_1.failureWithCode)("INPUT_LIMIT_EXCEEDED", "input");
+    return (0, operation_result_js_1.success)(bytes);
+}
+function decodeUtf8(value) {
+    if (value.length >= 3 && value[0] === 0xef && value[1] === 0xbb && value[2] === 0xbf) {
+        return (0, result_helpers_js_1.failureWithCode)("UTF8_INVALID", "input");
+    }
+    try {
+        const decoded = decoder.decode(value);
+        return (0, operation_result_js_1.success)(decoded);
+    }
+    catch {
+        return (0, result_helpers_js_1.failureWithCode)("UTF8_INVALID", "input");
+    }
+}