@apollohg/react-native-rich-text-editor 2.0.0

package/dist/NativeEditorCreateJson.js

@@ -0,0 +1,474 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V2JsonSerializationWriter = void 0;
+exports.invalidV2JsonValue = invalidV2JsonValue;
+exports.chargeV2JsonWork = chargeV2JsonWork;
+exports.chargeV2JsonBytes = chargeV2JsonBytes;
+exports.chargeV2JsonSerializationWork = chargeV2JsonSerializationWork;
+exports.chargeV2JsonSerializationBytes = chargeV2JsonSerializationBytes;
+exports.utf8V2JsonByteLength = utf8V2JsonByteLength;
+exports.serializeV2JsonNumber = serializeV2JsonNumber;
+exports.chargeV2JsonStringBytes = chargeV2JsonStringBytes;
+exports.normalizeV2JsonValue = normalizeV2JsonValue;
+exports.appendV2JsonString = appendV2JsonString;
+exports.serializeV2CreateEnvelope = serializeV2CreateEnvelope;
+const NativeEditorCreateValidation_1 = require("./NativeEditorCreateValidation");
+function invalidV2JsonValue(label) {
+    throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)(`NativeEditorBridge: invalid ${label} for v2 create`);
+}
+function chargeV2JsonWork(state, label) {
+    if (state.work >= NativeEditorCreateValidation_1.V2_CREATE_JSON_MAX_WORK)
+        invalidV2JsonValue(label);
+    state.work += 1;
+}
+function chargeV2JsonBytes(budget, amount, label) {
+    if (!Number.isSafeInteger(amount) ||
+        amount < 0 ||
+        amount > NativeEditorCreateValidation_1.V2_CREATE_JSON_MAX_BYTES - budget.bytes) {
+        invalidV2JsonValue(label);
+    }
+    budget.bytes += amount;
+}
+function chargeV2JsonSerializationWork(state, label) {
+    if (state.work >= NativeEditorCreateValidation_1.V2_CREATE_WIRE_MAX_BYTES)
+        invalidV2JsonValue(label);
+    state.work += 1;
+}
+function chargeV2JsonSerializationBytes(state, amount, label) {
+    if (!Number.isSafeInteger(amount) ||
+        amount < 0 ||
+        amount > NativeEditorCreateValidation_1.V2_CREATE_WIRE_MAX_BYTES - state.bytes) {
+        invalidV2JsonValue(label);
+    }
+    state.bytes += amount;
+}
+function utf8V2JsonByteLength(value) {
+    let bytes = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const code = NativeEditorCreateValidation_1.V2_CREATE_STRING_CHAR_CODE_AT.call(value, index);
+        if (code <= 0x7f) {
+            bytes += 1;
+        }
+        else if (code <= 0x7ff) {
+            bytes += 2;
+        }
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            const next = index + 1 < value.length
+                ? NativeEditorCreateValidation_1.V2_CREATE_STRING_CHAR_CODE_AT.call(value, index + 1)
+                : -1;
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                bytes += 4;
+                index += 1;
+            }
+            else {
+                bytes += 3;
+            }
+        }
+        else {
+            bytes += 3;
+        }
+    }
+    return bytes;
+}
+function serializeV2JsonNumber(value, label) {
+    if (!Number.isFinite(value))
+        invalidV2JsonValue(label);
+    return value === 0 ? '0' : NativeEditorCreateValidation_1.V2_CREATE_NUMBER_TO_STRING.call(value);
+}
+function chargeV2JsonStringBytes(value, budget, label) {
+    chargeV2JsonBytes(budget, 2, label);
+    for (let index = 0; index < value.length; index += 1) {
+        const code = NativeEditorCreateValidation_1.V2_CREATE_STRING_CHAR_CODE_AT.call(value, index);
+        if (code === 0x22 || code === 0x5c || code === 0x08 || code === 0x09) {
+            chargeV2JsonBytes(budget, 2, label);
+        }
+        else if (code === 0x0a || code === 0x0c || code === 0x0d) {
+            chargeV2JsonBytes(budget, 2, label);
+        }
+        else if (code <= 0x1f) {
+            chargeV2JsonBytes(budget, 6, label);
+        }
+        else if (code <= 0x7f) {
+            chargeV2JsonBytes(budget, 1, label);
+        }
+        else if (code <= 0x7ff) {
+            chargeV2JsonBytes(budget, 2, label);
+        }
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            const next = index + 1 < value.length
+                ? NativeEditorCreateValidation_1.V2_CREATE_STRING_CHAR_CODE_AT.call(value, index + 1)
+                : -1;
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                chargeV2JsonBytes(budget, 4, label);
+                index += 1;
+            }
+            else {
+                chargeV2JsonBytes(budget, 6, label);
+            }
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            chargeV2JsonBytes(budget, 6, label);
+        }
+        else {
+            chargeV2JsonBytes(budget, 3, label);
+        }
+    }
+}
+function normalizeV2JsonValue(value, label, traversal, budget = { bytes: 0 }) {
+    let normalizedRoot;
+    const frames = [
+        { type: 'value', value, depth: 0, target: null, key: null },
+    ];
+    const installNormalizedValue = (target, key, normalized) => {
+        if (target === null) {
+            normalizedRoot = normalized;
+            return;
+        }
+        if (key === null)
+            invalidV2JsonValue(label);
+        Object.defineProperty(target, key, {
+            configurable: true,
+            enumerable: true,
+            value: normalized,
+            writable: true,
+        });
+    };
+    while (frames.length > 0) {
+        const frame = frames.pop();
+        if (frame === undefined)
+            invalidV2JsonValue(label);
+        if (frame.type === 'array') {
+            if (frame.nextKeyIndex === frame.keys.length) {
+                if (frame.elementCount !== frame.length)
+                    invalidV2JsonValue(label);
+                Object.setPrototypeOf(frame.normalized, null);
+                continue;
+            }
+            const key = frame.keys[frame.nextKeyIndex];
+            if (key === 'length') {
+                frames.push({ ...frame, nextKeyIndex: frame.nextKeyIndex + 1 });
+                continue;
+            }
+            if (typeof key !== 'string' || !/^(0|[1-9]\d*)$/.test(key)) {
+                invalidV2JsonValue(label);
+            }
+            const index = Number(key);
+            if (!Number.isSafeInteger(index) ||
+                index !== frame.elementCount ||
+                index < 0 ||
+                index >= frame.length) {
+                invalidV2JsonValue(label);
+            }
+            const descriptor = Object.getOwnPropertyDescriptor(frame.value, key);
+            if (descriptor === undefined ||
+                !('value' in descriptor) ||
+                descriptor.enumerable !== true) {
+                invalidV2JsonValue(label);
+            }
+            if (frame.elementCount > 0)
+                chargeV2JsonBytes(budget, 1, label);
+            frames.push({
+                ...frame,
+                nextKeyIndex: frame.nextKeyIndex + 1,
+                elementCount: frame.elementCount + 1,
+            });
+            frames.push({
+                type: 'value',
+                value: descriptor.value,
+                depth: frame.depth,
+                target: frame.normalized,
+                key: frame.elementCount,
+            });
+            continue;
+        }
+        if (frame.type === 'object') {
+            if (frame.nextKeyIndex === frame.keys.length)
+                continue;
+            const key = frame.keys[frame.nextKeyIndex];
+            if (typeof key !== 'string')
+                invalidV2JsonValue(label);
+            const descriptor = Object.getOwnPropertyDescriptor(frame.value, key);
+            if (descriptor === undefined ||
+                !('value' in descriptor) ||
+                descriptor.enumerable !== true) {
+                invalidV2JsonValue(label);
+            }
+            if (descriptor.value === undefined) {
+                frames.push({
+                    ...frame,
+                    nextKeyIndex: frame.nextKeyIndex + 1,
+                });
+                continue;
+            }
+            if (frame.fieldCount > 0)
+                chargeV2JsonBytes(budget, 1, label);
+            chargeV2JsonStringBytes(key, budget, label);
+            chargeV2JsonBytes(budget, 1, label);
+            frames.push({
+                ...frame,
+                nextKeyIndex: frame.nextKeyIndex + 1,
+                fieldCount: frame.fieldCount + 1,
+            });
+            frames.push({
+                type: 'value',
+                value: descriptor.value,
+                depth: frame.depth,
+                target: frame.normalized,
+                key,
+            });
+            continue;
+        }
+        if (frame.depth > NativeEditorCreateValidation_1.V2_CREATE_JSON_MAX_DEPTH)
+            invalidV2JsonValue(label);
+        chargeV2JsonWork(traversal, label);
+        if (frame.value === null) {
+            chargeV2JsonBytes(budget, 4, label);
+            installNormalizedValue(frame.target, frame.key, frame.value);
+            continue;
+        }
+        if (typeof frame.value === 'string') {
+            chargeV2JsonStringBytes(frame.value, budget, label);
+            installNormalizedValue(frame.target, frame.key, frame.value);
+            continue;
+        }
+        if (typeof frame.value === 'boolean') {
+            chargeV2JsonBytes(budget, frame.value ? 4 : 5, label);
+            installNormalizedValue(frame.target, frame.key, frame.value);
+            continue;
+        }
+        if (typeof frame.value === 'number') {
+            const serialized = serializeV2JsonNumber(frame.value, label);
+            chargeV2JsonBytes(budget, serialized.length, label);
+            installNormalizedValue(frame.target, frame.key, frame.value);
+            continue;
+        }
+        if (typeof frame.value !== 'object')
+            invalidV2JsonValue(label);
+        if (traversal.seen.has(frame.value))
+            invalidV2JsonValue(label);
+        traversal.seen.add(frame.value);
+        chargeV2JsonBytes(budget, 2, label);
+        const childDepth = frame.depth + 1;
+        if (Array.isArray(frame.value)) {
+            const prototype = Object.getPrototypeOf(frame.value);
+            if (prototype !== Array.prototype && prototype !== null)
+                invalidV2JsonValue(label);
+            const lengthDescriptor = Object.getOwnPropertyDescriptor(frame.value, 'length');
+            if (lengthDescriptor === undefined ||
+                !('value' in lengthDescriptor) ||
+                typeof lengthDescriptor.value !== 'number') {
+                invalidV2JsonValue(label);
+            }
+            const normalized = [];
+            installNormalizedValue(frame.target, frame.key, normalized);
+            frames.push({
+                type: 'array',
+                value: frame.value,
+                normalized,
+                keys: Reflect.ownKeys(frame.value),
+                length: lengthDescriptor.value,
+                depth: childDepth,
+                nextKeyIndex: 0,
+                elementCount: 0,
+            });
+            continue;
+        }
+        if (!(0, NativeEditorCreateValidation_1.isV2CreateRecord)(frame.value))
+            invalidV2JsonValue(label);
+        const normalized = (0, NativeEditorCreateValidation_1.emptyV2CreateRecord)();
+        installNormalizedValue(frame.target, frame.key, normalized);
+        frames.push({
+            type: 'object',
+            value: frame.value,
+            normalized,
+            keys: Reflect.ownKeys(frame.value),
+            depth: childDepth,
+            nextKeyIndex: 0,
+            fieldCount: 0,
+        });
+    }
+    if (normalizedRoot === undefined)
+        invalidV2JsonValue(label);
+    return normalizedRoot;
+}
+class V2JsonSerializationWriter {
+    constructor() {
+        this._chunks = [];
+        this._current = '';
+    }
+    append(value, state, label) {
+        chargeV2JsonSerializationBytes(state, utf8V2JsonByteLength(value), label);
+        this._current += value;
+        if (this._current.length >= NativeEditorCreateValidation_1.V2_CREATE_JSON_OUTPUT_CHUNK_SIZE) {
+            this._chunks.push(this._current);
+            this._current = '';
+        }
+    }
+    finish() {
+        if (this._current.length > 0)
+            this._chunks.push(this._current);
+        return this._chunks.join('');
+    }
+}
+exports.V2JsonSerializationWriter = V2JsonSerializationWriter;
+function appendV2JsonString(writer, value, state, label) {
+    writer.append('"', state, label);
+    let segmentStart = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        chargeV2JsonSerializationWork(state, label);
+        const code = NativeEditorCreateValidation_1.V2_CREATE_STRING_CHAR_CODE_AT.call(value, index);
+        let escape;
+        switch (code) {
+            case 0x08:
+                escape = '\\b';
+                break;
+            case 0x09:
+                escape = '\\t';
+                break;
+            case 0x0a:
+                escape = '\\n';
+                break;
+            case 0x0c:
+                escape = '\\f';
+                break;
+            case 0x0d:
+                escape = '\\r';
+                break;
+            case 0x22:
+                escape = '\\"';
+                break;
+            case 0x5c:
+                escape = '\\\\';
+                break;
+            default:
+                if (code <= 0x1f) {
+                    escape = `\\u00${code.toString(16).padStart(2, '0')}`;
+                }
+                else if (code >= 0xd800 && code <= 0xdbff) {
+                    const next = index + 1 < value.length
+                        ? NativeEditorCreateValidation_1.V2_CREATE_STRING_CHAR_CODE_AT.call(value, index + 1)
+                        : -1;
+                    if (next >= 0xdc00 && next <= 0xdfff) {
+                        chargeV2JsonSerializationWork(state, label);
+                        index += 1;
+                    }
+                    else {
+                        escape = `\\u${code.toString(16).padStart(4, '0')}`;
+                    }
+                }
+                else if (code >= 0xdc00 && code <= 0xdfff) {
+                    escape = `\\u${code.toString(16).padStart(4, '0')}`;
+                }
+                break;
+        }
+        if (escape === undefined)
+            continue;
+        if (segmentStart < index) {
+            writer.append(NativeEditorCreateValidation_1.V2_CREATE_STRING_SLICE.call(value, segmentStart, index), state, label);
+        }
+        writer.append(escape, state, label);
+        segmentStart = index + 1;
+    }
+    if (segmentStart < value.length) {
+        writer.append(NativeEditorCreateValidation_1.V2_CREATE_STRING_SLICE.call(value, segmentStart), state, label);
+    }
+    writer.append('"', state, label);
+}
+function serializeV2CreateEnvelope(value) {
+    const label = 'v2 create config';
+    const writer = new V2JsonSerializationWriter();
+    const state = { bytes: 0, work: 0 };
+    const frames = [{ type: 'value', value, depth: 0 }];
+    while (frames.length > 0) {
+        const frame = frames.pop();
+        if (frame === undefined)
+            invalidV2JsonValue(label);
+        if (frame.type === 'array') {
+            if (frame.index === frame.length) {
+                writer.append(']', state, label);
+                continue;
+            }
+            if (frame.index > 0)
+                writer.append(',', state, label);
+            const descriptor = Object.getOwnPropertyDescriptor(frame.value, String(frame.index));
+            if (descriptor === undefined ||
+                !('value' in descriptor) ||
+                descriptor.enumerable !== true) {
+                invalidV2JsonValue(label);
+            }
+            frames.push({ ...frame, index: frame.index + 1 });
+            frames.push({ type: 'value', value: descriptor.value, depth: frame.depth + 1 });
+            continue;
+        }
+        if (frame.type === 'object') {
+            if (frame.index === frame.keys.length) {
+                writer.append('}', state, label);
+                continue;
+            }
+            if (frame.index > 0)
+                writer.append(',', state, label);
+            const key = frame.keys[frame.index];
+            const descriptor = Object.getOwnPropertyDescriptor(frame.value, key);
+            if (descriptor === undefined ||
+                !('value' in descriptor) ||
+                descriptor.enumerable !== true) {
+                invalidV2JsonValue(label);
+            }
+            appendV2JsonString(writer, key, state, label);
+            writer.append(':', state, label);
+            frames.push({ ...frame, index: frame.index + 1 });
+            frames.push({ type: 'value', value: descriptor.value, depth: frame.depth + 1 });
+            continue;
+        }
+        if (frame.depth > NativeEditorCreateValidation_1.V2_CREATE_ENVELOPE_JSON_MAX_DEPTH)
+            invalidV2JsonValue(label);
+        chargeV2JsonSerializationWork(state, label);
+        if (frame.value === null) {
+            writer.append('null', state, label);
+        }
+        else if (typeof frame.value === 'string') {
+            appendV2JsonString(writer, frame.value, state, label);
+        }
+        else if (typeof frame.value === 'boolean') {
+            writer.append(frame.value ? 'true' : 'false', state, label);
+        }
+        else if (typeof frame.value === 'number') {
+            writer.append(serializeV2JsonNumber(frame.value, label), state, label);
+        }
+        else if (Array.isArray(frame.value)) {
+            if (Object.getPrototypeOf(frame.value) !== null)
+                invalidV2JsonValue(label);
+            const lengthDescriptor = Object.getOwnPropertyDescriptor(frame.value, 'length');
+            if (lengthDescriptor === undefined ||
+                !('value' in lengthDescriptor) ||
+                typeof lengthDescriptor.value !== 'number') {
+                invalidV2JsonValue(label);
+            }
+            writer.append('[', state, label);
+            frames.push({
+                type: 'array',
+                value: frame.value,
+                length: lengthDescriptor.value,
+                depth: frame.depth,
+                index: 0,
+            });
+        }
+        else if ((0, NativeEditorCreateValidation_1.isV2CreateRecord)(frame.value) && Object.getPrototypeOf(frame.value) === null) {
+            const keys = Reflect.ownKeys(frame.value);
+            if (keys.some((key) => typeof key !== 'string'))
+                invalidV2JsonValue(label);
+            writer.append('{', state, label);
+            frames.push({
+                type: 'object',
+                value: frame.value,
+                keys: keys,
+                depth: frame.depth,
+                index: 0,
+            });
+        }
+        else {
+            invalidV2JsonValue(label);
+        }
+    }
+    return writer.finish();
+}

package/dist/NativeEditorCreateValidation.d.ts

@@ -0,0 +1,32 @@
+import { type NativeEditorCreateConfig } from './NativeEditorTypes';
+export declare const V2_CREATE_CONFIG_KEYS: Set<string>;
+export declare const V2_CREATE_POLICY_KEYS: Set<string>;
+export declare const V2_CREATE_LIMIT_KEYS: Set<string>;
+export declare const V2_CREATE_RESOURCE_LIMIT_KEYS: Set<string>;
+export declare const V2_CREATE_EDITING_LIMIT_KEYS: Set<string>;
+export declare const V2_CREATE_COLLABORATION_LIMIT_KEYS: Set<string>;
+export declare const V2_CREATE_INITIALIZATION_KEYS: Readonly<Record<string, ReadonlySet<string>>>;
+export declare const V2_CREATE_ROOM_SNAPSHOT_KEYS: Set<string>;
+export declare const V2_CREATE_SNAPSHOT_METADATA_KEYS: Set<string>;
+export declare const V2_CREATE_MAX_U32 = 4294967295;
+export declare const V2_CREATE_JSON_MAX_BYTES: number;
+export declare const V2_CREATE_JSON_MAX_DEPTH: number;
+export declare const V2_CREATE_JSON_MAX_WORK: number;
+export declare const V2_CREATE_ENVELOPE_MAX_BYTES: number;
+export declare const V2_CREATE_WIRE_MAX_BYTES: number;
+export declare const V2_CREATE_ENVELOPE_JSON_MAX_DEPTH: number;
+export declare const V2_CREATE_JSON_OUTPUT_CHUNK_SIZE: number;
+export declare const V2_CREATE_STRING_CHAR_CODE_AT: (index: number) => number;
+export declare const V2_CREATE_STRING_SLICE: (start?: number, end?: number) => string;
+export declare const V2_CREATE_NUMBER_TO_STRING: (radix?: number) => string;
+export declare class NativeEditorCreateConfigError extends Error {
+    constructor(message: string);
+}
+export declare function invalidV2CreateRequestError(message: string): NativeEditorCreateConfigError;
+export declare function validateV2CreateLimits(limits: NativeEditorCreateConfig['limits']): void;
+export declare function emptyV2CreateRecord(): Record<string, unknown>;
+export declare function isV2CreateRecord(value: unknown): value is Record<string, unknown>;
+export declare function hasOwnV2CreateKey(value: Record<string, unknown>, key: string): boolean;
+export declare function ownV2CreateValue(value: Record<string, unknown>, key: string): unknown;
+export declare function requireKnownV2CreateKeys(value: unknown, allowed: ReadonlySet<string>, label: string): asserts value is Record<string, unknown>;
+export declare function normalizeV2CreateRecord(value: Record<string, unknown>, allowed: ReadonlySet<string>, label: string): Record<string, unknown>;

package/dist/NativeEditorCreateValidation.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeEditorCreateConfigError = exports.V2_CREATE_NUMBER_TO_STRING = exports.V2_CREATE_STRING_SLICE = exports.V2_CREATE_STRING_CHAR_CODE_AT = exports.V2_CREATE_JSON_OUTPUT_CHUNK_SIZE = exports.V2_CREATE_ENVELOPE_JSON_MAX_DEPTH = exports.V2_CREATE_WIRE_MAX_BYTES = exports.V2_CREATE_ENVELOPE_MAX_BYTES = exports.V2_CREATE_JSON_MAX_WORK = exports.V2_CREATE_JSON_MAX_DEPTH = exports.V2_CREATE_JSON_MAX_BYTES = exports.V2_CREATE_MAX_U32 = exports.V2_CREATE_SNAPSHOT_METADATA_KEYS = exports.V2_CREATE_ROOM_SNAPSHOT_KEYS = exports.V2_CREATE_INITIALIZATION_KEYS = exports.V2_CREATE_COLLABORATION_LIMIT_KEYS = exports.V2_CREATE_EDITING_LIMIT_KEYS = exports.V2_CREATE_RESOURCE_LIMIT_KEYS = exports.V2_CREATE_LIMIT_KEYS = exports.V2_CREATE_POLICY_KEYS = exports.V2_CREATE_CONFIG_KEYS = void 0;
+exports.invalidV2CreateRequestError = invalidV2CreateRequestError;
+exports.validateV2CreateLimits = validateV2CreateLimits;
+exports.emptyV2CreateRecord = emptyV2CreateRecord;
+exports.isV2CreateRecord = isV2CreateRecord;
+exports.hasOwnV2CreateKey = hasOwnV2CreateKey;
+exports.ownV2CreateValue = ownV2CreateValue;
+exports.requireKnownV2CreateKeys = requireKnownV2CreateKeys;
+exports.normalizeV2CreateRecord = normalizeV2CreateRecord;
+const ResourceLimits_1 = require("./ResourceLimits");
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+exports.V2_CREATE_CONFIG_KEYS = new Set([
+    'initialization',
+    'schema',
+    'fragmentName',
+    'policy',
+    'limits',
+]);
+exports.V2_CREATE_POLICY_KEYS = new Set([
+    'maxLength',
+    'readOnly',
+    'inputFilter',
+    'allowBase64Images',
+]);
+exports.V2_CREATE_LIMIT_KEYS = new Set(['resource', 'editing', 'collaboration']);
+exports.V2_CREATE_RESOURCE_LIMIT_KEYS = new Set([
+    'maxInputBytes',
+    'maxDocumentNodes',
+    'maxDocumentDepth',
+    'maxSchemaNodes',
+    'maxSchemaExpressionBytes',
+    'maxCollaborationMessageBytes',
+    'maxEncodedStateBytes',
+]);
+exports.V2_CREATE_EDITING_LIMIT_KEYS = new Set([
+    'maxOperationsPerTransaction',
+    'maxUndoGroups',
+    'maxUndoRetainedUnits',
+    'maxDerivedOutputBytes',
+]);
+exports.V2_CREATE_COLLABORATION_LIMIT_KEYS = new Set([
+    'maxFramesPerMessage',
+    'maxFrameBytes',
+    'maxAggregateResponseBytes',
+    'maxAwarenessPeers',
+    'maxAwarenessPeerBytes',
+    'maxAwarenessBytes',
+    'maxPendingOutboxMessages',
+    'maxPendingOutboxBytes',
+    'maxPendingDependencyUpdateBytes',
+    'maxPendingDependencyUpdateWork',
+]);
+exports.V2_CREATE_INITIALIZATION_KEYS = {
+    localEmpty: new Set(['type']),
+    localJson: new Set(['type', 'json']),
+    localHtml: new Set(['type', 'html']),
+    room: new Set(['type', 'documentId', 'lineageId', 'snapshot']),
+};
+exports.V2_CREATE_ROOM_SNAPSHOT_KEYS = new Set(['metadata', 'encodedState']);
+exports.V2_CREATE_SNAPSHOT_METADATA_KEYS = new Set([
+    'formatVersion',
+    'documentId',
+    'lineageId',
+    'fragmentName',
+    'schemaFingerprint',
+]);
+exports.V2_CREATE_MAX_U32 = 4294967295;
+exports.V2_CREATE_JSON_MAX_BYTES = ResourceLimits_1.HARD_EDITOR_RESOURCE_LIMITS.maxInputBytes;
+exports.V2_CREATE_JSON_MAX_DEPTH = ResourceLimits_1.HARD_EDITOR_RESOURCE_LIMITS.maxDocumentDepth * 2 + 16;
+exports.V2_CREATE_JSON_MAX_WORK = ResourceLimits_1.HARD_EDITOR_RESOURCE_LIMITS.maxInputBytes;
+exports.V2_CREATE_ENVELOPE_MAX_BYTES = 64 * 1024;
+exports.V2_CREATE_WIRE_MAX_BYTES = exports.V2_CREATE_JSON_MAX_BYTES * 7 + exports.V2_CREATE_ENVELOPE_MAX_BYTES + 2;
+exports.V2_CREATE_ENVELOPE_JSON_MAX_DEPTH = exports.V2_CREATE_JSON_MAX_DEPTH + 8;
+exports.V2_CREATE_JSON_OUTPUT_CHUNK_SIZE = 64 * 1024;
+exports.V2_CREATE_STRING_CHAR_CODE_AT = String.prototype.charCodeAt;
+exports.V2_CREATE_STRING_SLICE = String.prototype.slice;
+exports.V2_CREATE_NUMBER_TO_STRING = Number.prototype.toString;
+class NativeEditorCreateConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NativeEditorCreateConfigError';
+    }
+}
+exports.NativeEditorCreateConfigError = NativeEditorCreateConfigError;
+function invalidV2CreateRequestError(message) {
+    return new NativeEditorCreateConfigError(message);
+}
+function validateV2CreateLimits(limits) {
+    try {
+        (0, ResourceLimits_1.validateEditorCreateLimits)(limits);
+    }
+    catch (error) {
+        if (!(error instanceof NativeEditorBoundaryError_1.NativeEditorBoundaryError))
+            throw error;
+        throw new NativeEditorBoundaryError_1.NativeEditorEngineBoundaryError({
+            domain: 'boundary',
+            code: error.code,
+            message: error.message,
+            requestId: null,
+            operationIndex: null,
+            limit: error.limit == null ? null : String(error.limit),
+            actual: error.actual == null ? null : String(error.actual),
+            details: error.details ?? null,
+        });
+    }
+}
+function emptyV2CreateRecord() {
+    return Object.create(null);
+}
+function isV2CreateRecord(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function hasOwnV2CreateKey(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function ownV2CreateValue(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined)
+        return undefined;
+    if (!('value' in descriptor)) {
+        throw invalidV2CreateRequestError(`NativeEditorBridge: accessor ${key} is not allowed for v2 create`);
+    }
+    return descriptor.value;
+}
+function requireKnownV2CreateKeys(value, allowed, label) {
+    if (!isV2CreateRecord(value) ||
+        Reflect.ownKeys(value).some((key) => typeof key !== 'string' || !allowed.has(key))) {
+        throw invalidV2CreateRequestError(`NativeEditorBridge: invalid ${label} for v2 create`);
+    }
+}
+function normalizeV2CreateRecord(value, allowed, label) {
+    requireKnownV2CreateKeys(value, allowed, label);
+    const normalized = emptyV2CreateRecord();
+    for (const key of allowed) {
+        if (!hasOwnV2CreateKey(value, key))
+            continue;
+        const fieldValue = ownV2CreateValue(value, key);
+        if (fieldValue === null) {
+            throw invalidV2CreateRequestError(`NativeEditorBridge: invalid ${label} for v2 create`);
+        }
+        if (fieldValue !== undefined)
+            normalized[key] = fieldValue;
+    }
+    return normalized;
+}