smartrte-core 0.2.1 → 1.0.0-beta.1

package/dist/foundation/boundaries.js

@@ -0,0 +1,117 @@
+import { isTextNode } from "./identity.js";
+import { nodeAtPath } from "./positions.js";
+/**
+ * Structural blocks such as quotes, tables, and atoms do not expose a native
+ * caret at their outside edge.  Keep an ordinary editable block beside them
+ * so the start/end of every block container remains addressable.  This is a
+ * model invariant, not a renderer workaround: DOM whitespace is not a
+ * position in the canonical document.
+ */
+const isBoundaryBlock = (node, schema) => {
+    if (isTextNode(node))
+        return false;
+    const spec = schema.nodes[node.type];
+    return spec?.group === "block" && (node.type === "blockquote" ||
+        node.type === "table" ||
+        spec.atomic === true ||
+        spec.isolating === true);
+};
+const acceptsBlockContent = (node, schema) => {
+    if (node.type === "doc")
+        return true;
+    const expression = schema.nodes[node.type]?.content || "";
+    return /(?:^|[|(\s])block(?:[+*?]|$)/.test(expression);
+};
+const isEditableBlock = (node, schema) => {
+    if (isTextNode(node) || schema.nodes[node.type]?.group !== "block")
+        return false;
+    if (["paragraph", "heading", "code_block"].includes(node.type))
+        return true;
+    return /(?:^|[|(\s])inline(?:[+*?]|$)/.test(schema.nodes[node.type]?.content || "");
+};
+const collectIds = (node, ids) => {
+    if (isTextNode(node))
+        return;
+    ids.add(node.id);
+    node.children?.forEach((child) => collectIds(child, ids));
+};
+const uniqueBoundaryId = (base, ids) => {
+    let candidate = base;
+    let suffix = 2;
+    while (ids.has(candidate))
+        candidate = `${base}-${suffix++}`;
+    ids.add(candidate);
+    return candidate;
+};
+const comparePathsDescending = (left, right) => {
+    if (left.length !== right.length)
+        return right.length - left.length;
+    for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+        if (left[index] !== right[index])
+            return right[index] - left[index];
+    }
+    return 0;
+};
+/**
+ * Returns deterministic insert operations for missing outside-edge caret
+ * blocks.  The traversal is scoped by the supplied root path, allowing the
+ * normalizer to remain local for ordinary typing.
+ */
+export const editableBoundaryOperations = (document, schema, rootPath = []) => {
+    const root = nodeAtPath(document, rootPath);
+    if (!root || isTextNode(root))
+        return [];
+    const ids = new Set();
+    let idsCollected = false;
+    collectIds(document, ids);
+    const insertions = [];
+    const seen = new Set();
+    const add = (path, offset, base) => {
+        const key = `${path.join(".")}:${offset}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        // Ordinary text/mark transactions normally need no boundary repair. Do
+        // not pay a document-wide ID scan unless this traversal has actually
+        // found a missing boundary paragraph to insert.
+        if (!idsCollected) {
+            collectIds(document, ids);
+            idsCollected = true;
+        }
+        insertions.push({ path: [...path], offset, id: uniqueBoundaryId(base, ids) });
+    };
+    const visit = (node, path) => {
+        if (isTextNode(node))
+            return;
+        const children = node.children || [];
+        if (acceptsBlockContent(node, schema)) {
+            children.forEach((child, index) => {
+                if (!isBoundaryBlock(child, schema))
+                    return;
+                const previous = children[index - 1];
+                const next = children[index + 1];
+                if (index === 0 || !isEditableBlock(previous, schema)) {
+                    add(path, index, `smart-boundary-${node.id}-before-${child.id}`);
+                }
+                if (index === children.length - 1 || !isEditableBlock(next, schema)) {
+                    add(path, index + 1, `smart-boundary-${node.id}-after-${child.id}`);
+                }
+            });
+        }
+        children.forEach((child, index) => visit(child, [...path, index]));
+    };
+    visit(root, rootPath);
+    insertions.sort((left, right) => comparePathsDescending(left.path, right.path) || right.offset - left.offset);
+    return insertions.map(({ path, offset, id }) => ({
+        type: "insertNode",
+        pos: { path, offset },
+        node: { type: "paragraph", id, children: [] },
+    }));
+};
+export const createEditableBoundaryNormalizer = (options = {}) => ({
+    id: "foundation.editable-boundaries",
+    priority: options.priority ?? 20,
+    normalize: (document, context) => ({
+        operations: editableBoundaryOperations(document, context.schema, context.affectedPath),
+    }),
+});

package/dist/foundation/clipboard/detection.d.ts

@@ -0,0 +1,3 @@
+import { type ClipboardDetection, type RawClipboardPayload } from "./types.js";
+/** Detection selects an optimization/normalizer only; generic parsing remains the fallback. */
+export declare const detectClipboardSource: (payload: RawClipboardPayload) => ClipboardDetection;

package/dist/foundation/clipboard/detection.js

@@ -0,0 +1,29 @@
+import { NATIVE_CLIPBOARD_MIME } from "./types.js";
+const markdownPattern = /^(?:#{1,6}\s|[-*+]\s|\d+\.\s|```|\|.+\|)/m;
+/** Detection selects an optimization/normalizer only; generic parsing remains the fallback. */
+export const detectClipboardSource = (payload) => {
+    const html = payload.html || "";
+    const types = new Set(payload.types || []);
+    if (payload.native || types.has(NATIVE_CLIPBOARD_MIME))
+        return { source: "native", signals: [NATIVE_CLIPBOARD_MIME] };
+    if (/<table\b/i.test(html) && /(?:google-sheets-html-origin|data-sheets-root|mso-number-format|Microsoft Excel)/i.test(html)) {
+        return { source: "spreadsheet", signals: ["table-with-spreadsheet-marker"] };
+    }
+    const wordSignals = [
+        /\bmso-[\w-]+\s*:/i.test(html) && "mso-style",
+        /<!--\[if\s+gte\s+mso/i.test(html) && "mso-conditional-comment",
+        /xmlns:(?:o|w)\s*=/i.test(html) && "office-namespace",
+        /\b(?:data-listid|data-ccp-props|class=["'][^"']*\bSCXW)/i.test(html) && "office-web-marker",
+    ].filter((value) => Boolean(value));
+    if (wordSignals.length)
+        return { source: "word", signals: wordSignals };
+    if (/\bid=["']docs-internal-guid-/i.test(html))
+        return { source: "google-docs", signals: ["docs-internal-guid"] };
+    if (types.has("vscode-editor-data") && markdownPattern.test(payload.plainText || ""))
+        return { source: "markdown", signals: ["vscode-plain-text-structure"] };
+    if (html)
+        return { source: "html", signals: ["text/html"] };
+    if (markdownPattern.test(payload.plainText || ""))
+        return { source: "markdown", signals: ["plain-text-structure"] };
+    return { source: "plain-text", signals: ["text/plain"] };
+};

package/dist/foundation/clipboard/diagnostics.d.ts

@@ -0,0 +1,24 @@
+import type { ClipboardFragment, ClipboardSource, RawClipboardPayload } from "./types.js";
+export interface ClipboardStructuralShape {
+    readonly nodeCounts: Readonly<Record<string, number>>;
+    readonly maxDepth: number;
+    readonly textCodeUnits: number;
+}
+export interface ClipboardDiagnosticReport {
+    readonly version: 1;
+    /** Stable correlation key over the payload bytes; raw content is never included. */
+    readonly fixtureHash: string;
+    readonly detectedSource: ClipboardSource;
+    readonly detectionSignals: readonly string[];
+    readonly mimeTypes: readonly string[];
+    readonly inputBytes: number;
+    readonly status: "parsed" | "rejected";
+    readonly structuralShape: ClipboardStructuralShape | null;
+    /** Normalizer IDs and schema repair codes only; never messages/before/after values. */
+    readonly repairs: readonly string[];
+    readonly failureCode?: "payload-too-large" | "parse-failed";
+}
+/** Produces a telemetry-safe shape report containing no clipboard text, HTML, IDs, or attributes. */
+export declare const reportParsedClipboard: (payload: RawClipboardPayload, fragment: ClipboardFragment) => ClipboardDiagnosticReport;
+/** Produces a telemetry-safe rejection report without exposing an exception message. */
+export declare const reportRejectedClipboard: (payload: RawClipboardPayload, error: unknown) => ClipboardDiagnosticReport;

package/dist/foundation/clipboard/diagnostics.js

@@ -0,0 +1,59 @@
+import { isTextNode } from "../identity.js";
+import { detectClipboardSource } from "./detection.js";
+import { estimateClipboardPayloadBytes } from "./pipeline.js";
+const hashPayload = (payload) => {
+    const entries = payload.representations
+        ? Object.entries(payload.representations)
+        : [["text/html", payload.html || ""], ["text/plain", payload.plainText || ""], ["native", payload.native || ""]];
+    let hash = 2166136261;
+    entries.sort(([left], [right]) => left.localeCompare(right)).forEach(([type, value]) => {
+        const input = `${type}\0${value.length}\0${value}`;
+        for (let index = 0; index < input.length; index += 1)
+            hash = Math.imul(hash ^ input.charCodeAt(index), 16777619);
+    });
+    return (hash >>> 0).toString(16).padStart(8, "0");
+};
+const shapeOf = (root) => {
+    const nodeCounts = {};
+    let maxDepth = 0;
+    let textCodeUnits = 0;
+    const visit = (node, depth) => {
+        nodeCounts[node.type] = (nodeCounts[node.type] || 0) + 1;
+        maxDepth = Math.max(maxDepth, depth);
+        if (isTextNode(node))
+            textCodeUnits += node.text.length;
+        else
+            (node.children || []).forEach((child) => visit(child, depth + 1));
+    };
+    visit(root, 0);
+    return { nodeCounts, maxDepth, textCodeUnits };
+};
+const repairCodes = (fragment) => fragment.repairs.map((entry) => typeof entry === "string" ? entry : entry.code);
+const baseReport = (payload) => {
+    const detection = detectClipboardSource(payload);
+    return {
+        version: 1,
+        fixtureHash: hashPayload(payload),
+        detectedSource: detection.source,
+        detectionSignals: detection.signals,
+        mimeTypes: [...new Set(payload.types || Object.keys(payload.representations || {}))].sort(),
+        inputBytes: estimateClipboardPayloadBytes(payload),
+    };
+};
+/** Produces a telemetry-safe shape report containing no clipboard text, HTML, IDs, or attributes. */
+export const reportParsedClipboard = (payload, fragment) => ({
+    ...baseReport(payload),
+    status: "parsed",
+    structuralShape: shapeOf(fragment.document),
+    repairs: repairCodes(fragment),
+});
+/** Produces a telemetry-safe rejection report without exposing an exception message. */
+export const reportRejectedClipboard = (payload, error) => ({
+    ...baseReport(payload),
+    status: "rejected",
+    structuralShape: null,
+    repairs: [],
+    failureCode: error instanceof Error && error.name === "ClipboardPayloadTooLargeError"
+        ? "payload-too-large"
+        : "parse-failed",
+});

package/dist/foundation/clipboard/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export * from "./detection.js";
+export * from "./pipeline.js";
+export * from "./serialization.js";
+export * from "./normalizers.js";
+export * from "./insertion.js";
+export * from "./transfer.js";
+export * from "./diagnostics.js";

package/dist/foundation/clipboard/index.js

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export * from "./detection.js";
+export * from "./pipeline.js";
+export * from "./serialization.js";
+export * from "./normalizers.js";
+export * from "./insertion.js";
+export * from "./transfer.js";
+export * from "./diagnostics.js";

package/dist/foundation/clipboard/insertion.d.ts

@@ -0,0 +1,22 @@
+import type { SmartDocument, SmartOperation, SmartSchema, SmartSelection } from "../types.js";
+import type { PositionLookup } from "../scope/types.js";
+export interface ClipboardInsertionContext {
+    readonly schema: SmartSchema;
+    readonly positions: PositionLookup;
+    readonly idFactory: () => string;
+}
+export interface ClipboardInsertionResult {
+    readonly operations: readonly SmartOperation[];
+    readonly selectionTarget: {
+        readonly ownerId: string;
+        readonly offset: number;
+    };
+    readonly definingAncestorId: string | null;
+}
+/** External paste is a copy: remint every non-text ID before insertion. */
+export declare const remintClipboardFragmentIds: (fragment: SmartDocument, idFactory: () => string) => SmartDocument;
+/**
+ * Pure canonical-fragment insertion. The caller owns the transaction and maps
+ * `selectionTarget` after applying the returned operations.
+ */
+export declare const insertClipboardFragment: (document: SmartDocument, selection: SmartSelection, fragment: SmartDocument, context: ClipboardInsertionContext) => ClipboardInsertionResult;

package/dist/foundation/clipboard/insertion.js

@@ -0,0 +1,210 @@
+import { isTextNode } from "../identity.js";
+import { comparePos, nodeAtPath } from "../positions.js";
+/** External paste is a copy: remint every non-text ID before insertion. */
+export const remintClipboardFragmentIds = (fragment, idFactory) => {
+    const visit = (node) => isTextNode(node) ? structuredClone(node) : {
+        ...structuredClone(node), id: idFactory(), children: node.children?.map(visit),
+    };
+    return visit(fragment);
+};
+const inlineSize = (node) => isTextNode(node) ? node.text.length : 1;
+const inlineChildren = (node) => node.children || [];
+const inlineLength = (node) => inlineChildren(node).reduce((total, child) => total + inlineSize(child), 0);
+const splitInline = (children, offset) => {
+    const before = [];
+    const after = [];
+    let cursor = 0;
+    children.forEach((node) => {
+        const end = cursor + inlineSize(node);
+        if (end <= offset)
+            before.push(structuredClone(node));
+        else if (cursor >= offset)
+            after.push(structuredClone(node));
+        else if (isTextNode(node)) {
+            const local = offset - cursor;
+            if (local)
+                before.push({ ...node, text: node.text.slice(0, local) });
+            if (local < node.text.length)
+                after.push({ ...node, text: node.text.slice(local) });
+        }
+        else
+            throw new Error("Clipboard insertion cannot split an atomic node.");
+        cursor = end;
+    });
+    if (offset < 0 || offset > cursor)
+        throw new Error("Clipboard insertion offset is out of bounds.");
+    return [before, after];
+};
+const textOf = (node) => isTextNode(node) ? node.text
+    : node.type === "hard_break" ? "\n" : (node.children || []).map(textOf).join(node.type === "paragraph" ? "" : "\n");
+const elementAt = (document, pos) => {
+    const node = nodeAtPath(document, pos.path);
+    if (!node || isTextNode(node))
+        throw new Error("Clipboard insertion requires an element owner.");
+    return node;
+};
+const definingAncestor = (document, path, schema) => {
+    let result = null;
+    for (let depth = 0; depth <= path.length; depth += 1) {
+        const node = nodeAtPath(document, path.slice(0, depth));
+        if (node && !isTextNode(node) && schema.nodes[node.type]?.defining === true)
+            result = node.id;
+    }
+    return result;
+};
+const replacementRange = (selection) => {
+    const compare = comparePos(selection.anchor, selection.head);
+    return compare <= 0 ? { from: selection.anchor, to: selection.head } : { from: selection.head, to: selection.anchor };
+};
+const samePath = (left, right) => left.length === right.length && left.every((value, index) => value === right[index]);
+const listItemPath = (document, path) => {
+    for (let depth = path.length; depth > 0; depth -= 1) {
+        const candidate = nodeAtPath(document, path.slice(0, depth));
+        if (candidate && !isTextNode(candidate) && candidate.type === "list_item")
+            return path.slice(0, depth);
+    }
+    return null;
+};
+/**
+ * Pure canonical-fragment insertion. The caller owns the transaction and maps
+ * `selectionTarget` after applying the returned operations.
+ */
+export const insertClipboardFragment = (document, selection, fragment, context) => {
+    const range = replacementRange(selection);
+    const definingAncestorId = definingAncestor(document, range.from.path, context.schema);
+    if (selection.type === "node") {
+        const parent = nodeAtPath(document, range.from.path);
+        if (!parent || isTextNode(parent) || !parent.children)
+            throw new Error("Node selection parent is invalid.");
+        const selected = parent.children[range.from.offset];
+        if (!selected)
+            throw new Error("Node selection is empty.");
+        const nodes = fragment.children.map((node) => structuredClone(node));
+        const operations = [{ type: "removeNode", pos: range.from, node: selected }];
+        nodes.forEach((node, index) => operations.push({ type: "insertNode", pos: { path: [...range.from.path], offset: range.from.offset + index }, node }));
+        const target = [...nodes].reverse().find((node) => !isTextNode(node));
+        return {
+            operations,
+            selectionTarget: { ownerId: target?.id || parent.id, offset: target ? inlineLength(target) : range.from.offset },
+            definingAncestorId,
+        };
+    }
+    const owner = elementAt(document, range.from);
+    if (owner.type === "code_block") {
+        const [before] = splitInline(inlineChildren(owner), range.from.offset);
+        const [, after] = splitInline(inlineChildren(owner), range.to.path.join("/") === range.from.path.join("/") ? range.to.offset : range.from.offset);
+        const insertedText = fragment.children.map(textOf).join("\n");
+        const afterNode = {
+            ...owner,
+            children: [...before, ...(insertedText ? [{ type: "text", text: insertedText }] : []), ...after]
+                .map((node) => isTextNode(node) ? { type: "text", text: node.text } : node),
+        };
+        const position = context.positions.positionOf(owner.id);
+        if (!position)
+            throw new Error("Code block position is unavailable.");
+        return {
+            operations: [{ type: "replaceNode", pos: position.pos, before: owner, after: afterNode }],
+            selectionTarget: { ownerId: owner.id, offset: range.from.offset + insertedText.length },
+            definingAncestorId: owner.id,
+        };
+    }
+    const itemPath = listItemPath(document, range.from.path);
+    const fragmentBlocks = fragment.children.filter((node) => !isTextNode(node));
+    if (samePath(range.from.path, range.to.path) && range.from.offset === range.to.offset
+        && itemPath && (fragmentBlocks.length > 1 || fragmentBlocks.some((node) => node.type === "list"))) {
+        const item = nodeAtPath(document, itemPath);
+        const list = nodeAtPath(document, itemPath.slice(0, -1));
+        if (!item || isTextNode(item) || !list || isTextNode(list) || list.type !== "list")
+            throw new Error("List paste target is invalid.");
+        const insertedItems = fragmentBlocks.flatMap((block) => block.type === "list"
+            ? (block.children || []).filter((node) => !isTextNode(node) && node.type === "list_item").map((node) => structuredClone(node))
+            : [{ type: "list_item", id: context.idFactory(), children: [structuredClone(block)] }]);
+        const index = itemPath[itemPath.length - 1];
+        const children = [...(list.children || [])];
+        children.splice(index + 1, 0, ...insertedItems);
+        const listPosition = context.positions.positionOf(list.id);
+        if (!listPosition)
+            throw new Error("List position is unavailable.");
+        const target = insertedItems[insertedItems.length - 1];
+        const targetBlock = [...(target.children || [])].reverse().find((node) => !isTextNode(node));
+        return {
+            operations: [{ type: "replaceNode", pos: listPosition.pos, before: list, after: { ...list, children } }],
+            selectionTarget: { ownerId: targetBlock?.id || target.id, offset: targetBlock ? inlineLength(targetBlock) : 0 },
+            definingAncestorId,
+        };
+    }
+    if (!samePath(range.from.path, range.to.path)) {
+        const parentPath = range.from.path.slice(0, -1);
+        if (!samePath(parentPath, range.to.path.slice(0, -1)))
+            throw new Error("Cross-parent clipboard replacement is clamped by scope before insertion.");
+        const parent = nodeAtPath(document, parentPath);
+        const toOwner = elementAt(document, range.to);
+        if (!parent || isTextNode(parent) || !parent.children)
+            throw new Error("Cross-owner parent is invalid.");
+        const fromIndex = range.from.path[range.from.path.length - 1];
+        const toIndex = range.to.path[range.to.path.length - 1];
+        if (fromIndex >= toIndex)
+            throw new Error("Cross-owner clipboard range is invalid.");
+        const [prefix] = splitInline(inlineChildren(owner), range.from.offset);
+        const [, suffix] = splitInline(inlineChildren(toOwner), range.to.offset);
+        const ownerPosition = context.positions.positionOf(owner.id);
+        if (!ownerPosition)
+            throw new Error("Clipboard owner position is unavailable.");
+        const operations = [];
+        for (let index = toIndex; index > fromIndex; index -= 1)
+            operations.push({
+                type: "removeNode", pos: { path: [...parentPath], offset: index }, node: parent.children[index],
+            });
+        const singleInline = fragmentBlocks.length === 1 && ["paragraph", "heading"].includes(fragmentBlocks[0].type);
+        if (singleInline) {
+            const inserted = inlineChildren(fragmentBlocks[0]).map((node) => structuredClone(node));
+            operations.push({ type: "replaceNode", pos: ownerPosition.pos, before: owner, after: { ...owner, children: [...prefix, ...inserted, ...suffix] } });
+            return {
+                operations,
+                selectionTarget: { ownerId: owner.id, offset: prefix.reduce((total, node) => total + inlineSize(node), 0) + inserted.reduce((total, node) => total + inlineSize(node), 0) },
+                definingAncestorId,
+            };
+        }
+        operations.push({ type: "replaceNode", pos: ownerPosition.pos, before: owner, after: { ...owner, children: prefix } });
+        fragmentBlocks.forEach((node, index) => operations.push({ type: "insertNode", pos: { path: [...parentPath], offset: fromIndex + 1 + index }, node: structuredClone(node) }));
+        let target = fragmentBlocks[fragmentBlocks.length - 1];
+        if (suffix.length) {
+            target = { type: "paragraph", id: context.idFactory(), children: suffix };
+            operations.push({ type: "insertNode", pos: { path: [...parentPath], offset: fromIndex + 1 + fragmentBlocks.length }, node: target });
+        }
+        return { operations, selectionTarget: { ownerId: target?.id || owner.id, offset: target ? inlineLength(target) : 0 }, definingAncestorId };
+    }
+    const [prefix] = splitInline(inlineChildren(owner), range.from.offset);
+    const [, suffix] = splitInline(inlineChildren(owner), range.to.offset);
+    const ownerPosition = context.positions.positionOf(owner.id);
+    if (!ownerPosition)
+        throw new Error("Clipboard owner position is unavailable.");
+    const blocks = fragmentBlocks.map((node) => structuredClone(node));
+    const singleInline = blocks.length === 1 && ["paragraph", "heading"].includes(blocks[0].type);
+    if (singleInline) {
+        const inserted = inlineChildren(blocks[0]).map((node) => structuredClone(node));
+        const after = { ...owner, children: [...prefix, ...inserted, ...suffix] };
+        return {
+            operations: [{ type: "replaceNode", pos: ownerPosition.pos, before: owner, after }],
+            selectionTarget: { ownerId: owner.id, offset: prefix.reduce((total, node) => total + inlineSize(node), 0) + inserted.reduce((total, node) => total + inlineSize(node), 0) },
+            definingAncestorId,
+        };
+    }
+    const operations = [{
+            type: "replaceNode", pos: ownerPosition.pos, before: owner, after: { ...owner, children: prefix },
+        }];
+    blocks.forEach((node, index) => operations.push({
+        type: "insertNode", pos: { path: [...ownerPosition.pos.path], offset: ownerPosition.pos.offset + 1 + index }, node,
+    }));
+    let target = blocks[blocks.length - 1];
+    if (suffix.length) {
+        const tail = { type: "paragraph", id: context.idFactory(), children: suffix };
+        operations.push({ type: "insertNode", pos: { path: [...ownerPosition.pos.path], offset: ownerPosition.pos.offset + 1 + blocks.length }, node: tail });
+        target = tail;
+    }
+    return {
+        operations,
+        selectionTarget: { ownerId: target?.id || owner.id, offset: target ? inlineLength(target) : 0 },
+        definingAncestorId,
+    };
+};

package/dist/foundation/clipboard/normalizers.d.ts

@@ -0,0 +1,8 @@
+import type { SourceNormalizer } from "./types.js";
+export declare const wordClipboardNormalizer: SourceNormalizer;
+export declare const googleDocsClipboardNormalizer: SourceNormalizer;
+export declare const spreadsheetClipboardNormalizer: SourceNormalizer;
+export declare const htmlClipboardNormalizer: SourceNormalizer;
+export declare const markdownClipboardNormalizer: SourceNormalizer;
+export declare const plainTextClipboardNormalizer: SourceNormalizer;
+export declare const capturedSourceNormalizers: readonly SourceNormalizer[];