@docx-editor.dev/pro 2.0.1 → 2.1.1

package/dist/define-custom-node-BTTX66B3.d.ts

@@ -0,0 +1,500 @@
+import { EditorModule } from '@docx-editor.dev/core/editor';
+import { OoxmlPart } from '@docx-editor.dev/core/store';
+
+/**
+ * Licensing, v1: honor system.
+ *
+ * The key is accepted and remembered so that adding offline (Ed25519)
+ * verification later is not a breaking change — but nothing validates it,
+ * nothing warns, nothing renders differently, and NOTHING EVER LEAVES THE
+ * PROCESS: no network request is made for licensing, ever. That last property
+ * is a spec requirement (`pro-licensing`), not an implementation detail.
+ */
+/** Accepted by every pro entry point. */
+interface ProLicenseOptions {
+    /**
+     * Your license key from docx-editor.dev. Optional in v1: unlicensed use in
+     * development and evaluation is permitted, production use requires a
+     * license (see LICENSE.md) — the package trusts you either way.
+     */
+    readonly licenseKey?: string;
+}
+
+/**
+ * The review module: comments, tracked changes, and markup rendering as an
+ * `EditorModule` for `createDocxEditor({ modules })`.
+ *
+ * Registering it is the whole enablement story: the review chrome slots light
+ * up through the same `toolbarCommandState` they were disabled by, suggesting
+ * mode becomes reachable, and the editor renders revisions in markup rather
+ * than the free tier's final-state projection.
+ */
+
+/**
+ * How {@link reviewModule} is configured. Carries only the licence key today, so
+ * `reviewModule()` with no argument is the ordinary call.
+ *
+ * @public
+ */
+interface ReviewModuleOptions extends ProLicenseOptions {
+}
+/** Build the review module. Construction never validates the key and never touches the network. */
+declare function reviewModule(options?: ReviewModuleOptions): EditorModule;
+
+/**
+ * The Standard Schema interface, vendored.
+ *
+ * Any zod, valibot or arktype schema satisfies it. See https://standardschema.dev.
+ *
+ * Reduced to the parts used here rather than copied: the spec's namespace, `Props`,
+ * `SuccessResult`/`FailureResult`, `PathSegment` and `InferInput` are all absent. Assignability
+ * with a real schema is what matters, and is checked against zod in the tests.
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+}
+/** What a Standard Schema validation answers. */
+type StandardSchemaResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly StandardSchemaIssue[];
+};
+/** One validation failure. `path` is what tells a host WHICH field was wrong. */
+interface StandardSchemaIssue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | {
+        readonly key: PropertyKey;
+    })[] | undefined;
+}
+/**
+ * The type a schema produces, for a definition to hand back to its host.
+ *
+ * `unknown` for a definition with no schema, which is the honest description of an unchecked
+ * payload — not `never`, which would make the field unusable rather than merely unguaranteed.
+ */
+type InferSchemaOutput<Schema> = 0 extends 1 & Schema ? any : Schema extends StandardSchemaV1<unknown, infer Output> ? Output : unknown;
+/**
+ * The type a schema ACCEPTS, which is what a write has to satisfy.
+ *
+ * Different from the output whenever the schema transforms — a zod `.default()` or `.transform()`
+ * takes one shape and produces another — so a write typed by the output would reject the very
+ * value the schema was written to accept.
+ */
+type InferSchemaInput<Schema> = 0 extends 1 & Schema ? any : Schema extends StandardSchemaV1<infer Input, unknown> ? Input : unknown;
+/**
+ * Why a payload was refused.
+ *
+ * `malformed` is not valid JSON at all; `invalid` parsed but did not match the schema; `async`
+ * is a schema whose validation returns a promise, which cannot be used here (see below).
+ */
+type CustomNodeDataRejection = 'malformed' | 'invalid' | 'async';
+/** What {@link parseCustomNodeData} answers. */
+type CustomNodeDataResult<Output> = {
+    readonly ok: true;
+    readonly value: Output;
+} | {
+    readonly ok: false;
+    readonly reason: CustomNodeDataRejection;
+    /** Human-readable, for a host to log. Never rendered as markup by this package. */
+    readonly issues: readonly string[];
+};
+/**
+ * The largest payload this will parse, in UTF-16 code units.
+ *
+ * A file-supplied length must never reach an allocation, and `JSON.parse` on a hostile string
+ * is the allocation. 256 KB is far past any legitimate chip payload and far short of anything
+ * that hurts.
+ */
+declare const MAX_CUSTOM_NODE_DATA_LENGTH: number;
+/**
+ * Parse a payload out of a data part and validate it against the definition's schema.
+ *
+ * Synchronous on purpose. This runs inside the read path, where recognition happens for every
+ * node in the document before anything paints, and an async boundary there would mean a
+ * document that renders its chips a frame later than its text. A schema with an async refinement
+ * is refused (`async`) rather than awaited, so the limitation is visible instead of silent.
+ *
+ * A payload with no schema comes back as the parsed JSON, typed `unknown` — the host asked for
+ * no guarantees and gets none, rather than getting a lie. It is also a NULL-PROTOTYPE object on
+ * that path, where a schema-validated one is whatever the validator rebuilt: `hasOwnProperty`
+ * and `instanceof Object` do not hold on the former.
+ */
+declare function parseCustomNodeData<Schema extends StandardSchemaV1 | undefined>(schema: Schema, raw: string): CustomNodeDataResult<Schema extends StandardSchemaV1 ? InferSchemaOutput<Schema> : unknown>;
+/**
+ * Serialize a payload for a data part. Refuses what cannot round-trip through JSON.
+ *
+ * NOT symmetric with {@link parseCustomNodeData}: a key named `__proto__`, `constructor` or
+ * `prototype` is written here and dropped on the way back, because a payload arriving from a
+ * file is the hazard and a payload leaving this process is not. A host that needs those keys
+ * needs a different name for them.
+ */
+declare function serializeCustomNodeData(value: unknown): CustomNodeDataResult<string>;
+
+/** A recognized custom node: one inline SDT whose tag matched a definition. */
+interface RecognizedCustomNode {
+    /** The definition's `name`. */
+    readonly name: string;
+    /** Attrs after the definition's `fromDocx` had its say. Untrusted input. */
+    readonly attrs: Readonly<Record<string, string>>;
+    /** The SDT's literal content text — what Word users see and may have edited. */
+    readonly text: string;
+    /** The SDT node's stable id in the canonical tree. */
+    readonly nodeId: string;
+    /** The raw `w:tag` the node was recognized from. */
+    readonly tag: string;
+    /**
+     * The payload the node's control binds to, validated against the definition's `schema`.
+     *
+     * `undefined` when the node carries none, when the binding named a store node the document
+     * does not hold, or when the payload failed its schema — the last of which is reported
+     * through {@link customNodesModule}'s `onDiagnostic` rather than swallowed. A chip that
+     * vanished because one field was wrong would be worse than a chip with no data.
+     *
+     * With a schema declared this is that schema's output type; without one it is whatever JSON
+     * the file held, which is the honest description of an unchecked payload.
+     */
+    readonly data?: unknown;
+}
+/** A payload as the store holds it, before any schema has looked at it. Untrusted file input. */
+interface CustomNodePayloadSource {
+    readonly nodeId: string;
+    readonly label: string;
+    readonly data: string;
+}
+/**
+ * Something worth telling an integrator about a document, which is never worth throwing over.
+ *
+ * A payload arrives from a file the sender wrote, so "it did not match the schema" is an
+ * ordinary property of an ordinary document — not an exception. It is reported and the node
+ * still renders.
+ */
+interface CustomNodeDiagnostic {
+    /**
+     * `payload-invalid` — a payload was found and did not match the schema.
+     * `payload-missing` — the control's binding names a store node the document does not hold.
+     *
+     * The second is what a half-stripped export or a hand-edited file leaves behind, and it used
+     * to be indistinguishable from "this node carries no payload": both arrive as `data:
+     * undefined` and neither said anything.
+     */
+    readonly code: 'payload-invalid' | 'payload-missing';
+    /** The definition whose schema refused it. */
+    readonly name: string;
+    /** The control's canonical node id, so a host can locate it. */
+    readonly nodeId: string;
+    /** Human-readable, one per failing field. Never rendered as markup by this package. */
+    readonly issues: readonly string[];
+}
+/**
+ * One integrator-defined inline node, anchored on a run-level SDT whose `w:tag` carries its
+ * identity.
+ *
+ * A definition claims a tag PREFIX, so `acme` recognizes every `acme:*` tag. An SDT whose prefix
+ * no definition claims stays literal — which is also what the free tier and Word itself render,
+ * so an unrecognized node never loses content or locks editing.
+ *
+ * Build one with {@link defineCustomNode}, which validates the shape, then register it through
+ * {@link customNodesModule}.
+ *
+ * @example
+ * ```ts
+ * const citation = defineCustomNode({
+ *   name: 'citation',
+ *   tagPrefix: 'acme',
+ *   chrome: { color: '#2563eb' },
+ *   onClick: (node) => openCitation(node.attrs.key),
+ * });
+ * ```
+ *
+ * @public
+ */
+interface CustomNodeDefinition<Schema extends StandardSchemaV1 | undefined = any> {
+    /** Node type name — the second segment of the tag (`<prefix>:<name>?…`). */
+    readonly name: string;
+    /** Tag prefix this definition claims (`acme` claims `acme:*`). No colons. */
+    readonly tagPrefix: string;
+    /**
+     * What the document SHOWS for this node, from its payload.
+     *
+     * The one thing most definitions need beyond an identity and a schema:
+     *
+     * ```ts
+     * defineCustomNode({
+     *   name: 'citation',
+     *   tagPrefix: 'docx',
+     *   schema: CitationData,
+     *   text: (data) => `(${data.authors[0]} ${data.year})`,
+     * });
+     * ```
+     *
+     * With it, a write takes the payload alone — `insertCustomNode(editor, Citation, { data })` —
+     * and the words in the paragraph are computed, so they cannot drift from the data they
+     * describe. Without it, pass `text` on every call and keep the two in step yourself.
+     *
+     * Word paints a bound control's text from the payload and will not let a user type into it,
+     * so this is the only thing that decides what a reader sees.
+     */
+    readonly text?: (data: InferSchemaOutput<Schema>) => string;
+    /**
+     * Extra identity to put in the `w:tag`, from the payload. Rarely needed.
+     *
+     * The tag already carries `<prefix>:<name>`, which is what recognition matches on, so most
+     * nodes need nothing here. Add it when a reader that opens the document WITHOUT the payload
+     * store should still be able to tell which one this is — a `sourceId` on a citation, say.
+     *
+     * Word caps the encoded tag at 64 characters, prefix and name included.
+     */
+    readonly tagAttrs?: (data: InferSchemaOutput<Schema>) => Readonly<Record<string, string>>;
+    /**
+     * Recognition hook. Receives the decoded attrs and the SDT's literal text
+     * (so label drift from Word edits is visible) and returns the attrs the node
+     * should carry — or null to leave this SDT unrecognized and literal.
+     *
+     * Every input value originates in a file an attacker controls; treat it as
+     * untrusted and never build DOM or URLs from it without sanitizing.
+     */
+    readonly fromDocx?: (input: {
+        readonly attrs: Readonly<Record<string, string>>;
+        readonly text: string;
+        /**
+         * The bound payload, already through `schema` — so this is the type the definition
+         * declared, not `unknown`. Undefined when the node carries none or it did not match.
+         */
+        readonly data?: InferSchemaOutput<Schema>;
+    }) => Readonly<Record<string, string>> | null;
+    /**
+     * Chip appearance, HOST-authored (never file data). `color` tints the chip
+     * and its border; applied by `CustomNodeChrome` from `@docx-editor.dev/pro/react`.
+     */
+    readonly chrome?: {
+        readonly color?: string;
+    };
+    /** Click on the painted chip. UI state belongs in `CustomNodeChrome`'s `onNodeClick`. */
+    readonly onClick?: (node: ActivatedCustomNode) => void;
+    /** Pointer enters the painted chip. */
+    readonly onHover?: (node: ActivatedCustomNode) => void;
+    /**
+     * Contribute a card to the review sidebar for every recognized node of this
+     * definition, anchored at the node's range. Return null to skip one node.
+     *
+     * `attrs` and `text` originate in the file — untrusted; the returned strings
+     * are rendered as TEXT by the pane, never markup. The context-menu section
+     * reuses this hook for its info block and may invoke it with `text: ''` when
+     * no review module is registered (the DOM decode alone cannot see the text).
+     */
+    readonly reviewCard?: (node: {
+        readonly attrs: Readonly<Record<string, string>>;
+        readonly text: string;
+        /** The bound payload, already through `schema` — see {@link CustomNodeDefinition.fromDocx}. */
+        readonly data?: InferSchemaOutput<Schema>;
+    }) => {
+        readonly title: string;
+        readonly detail?: string;
+    } | null;
+    /**
+     * The "Edit {label}" row the context menu shows at the top when the
+     * right-click lands on the node's chip. The HOST owns the dialog.
+     *
+     * Re-author with `updateCustomNode(editor, definition, node.nodeId, attrs, text, { data })`:
+     * one transaction, one undo step. The activation carries `nodeId`, the node's `text` and its
+     * `data`, which is everything a prefilled form needs.
+     */
+    readonly onEdit?: (node: ActivatedCustomNode) => void;
+    /**
+     * Display name for chrome — the "Edit {label}" context-menu row. Defaults to
+     * `name`. Host-authored, never file data; provide a localized string.
+     */
+    readonly label?: string;
+    /**
+     * The shape of this node's payload, as a zod (or valibot, or arktype) schema.
+     *
+     * A payload lives in a customXml data part, so it arrives from a file the sender controls.
+     * Declaring the shape means it is parsed and checked ONCE, at the read boundary, after which
+     * the `data` handed to the hooks is the type that was asked for rather than something every
+     * caller has to re-guard. Without one, `data` is whatever JSON the file held, typed
+     * `unknown`, which is the honest description of an unchecked payload.
+     *
+     * Any Standard Schema satisfies this, which is what zod produces:
+     *
+     * ```ts
+     * const Citation = z.object({ sourceId: z.string(), year: z.number() });
+     * defineCustomNode({ name: 'citation', tagPrefix: 'acme', schema: Citation });
+     * ```
+     *
+     * Validated on the way IN as well as on the way out, so a payload that does not match is
+     * refused at the insert rather than written and rejected on the next open.
+     */
+    readonly schema?: Schema;
+    /**
+     * The customXml store this definition's payloads live in.
+     *
+     * One store per namespace, per document, so this is what decides whether two definitions
+     * share a store or get one each. Defaults to a namespace derived from `tagPrefix`, which
+     * means a host that never thinks about it still gets one store per prefix and never collides
+     * with another integrator's.
+     *
+     * Set it to interoperate with something that already reads a namespace of its own. Whatever
+     * it is, it must be free of quotes and angle brackets: it is written into an XPath prefix
+     * declaration, where there is no escape for either.
+     */
+    readonly payloadNamespace?: string;
+    /**
+     * What happens to this node when a document is exported OUTSIDE the system that made it.
+     *
+     * A host may not want its own markup travelling in a file its users download: a `w:tag`
+     * naming the tool, or a payload with no meaning anywhere else. This declares the fate, and
+     * the save that applies it picks the pipeline — so one document can serialize one way at
+     * rest and another on the way out.
+     *
+     *  - `true` (default) — the node and its payload survive untouched.
+     *  - `'text'` — the control is unwrapped: a reader still sees the words, while the tag, the
+     *    binding and the payload are gone. Right for a citation, whose text is the point of it.
+     *  - `false` — the node goes, and takes its content with it.
+     *
+     * Applied by `prepareForExport`, which is a pipeline of its own rather than something
+     * `save()` does — that is what lets one document serialize one way at rest and another on the
+     * way out.
+     *
+     * IT DOES NOT MAKE A DOCUMENT ANONYMOUS. It removes this library's markup and nothing else. A
+     * `.docx` carries its origin in `docProps/app.xml`, `docProps/core.xml`, comment and revision
+     * authors, rsids and custom document properties.
+     */
+    readonly preserveOnExport?: boolean | 'text';
+}
+/**
+ * A definition, plus what {@link defineCustomNode} attaches to it.
+ *
+ * You author a {@link CustomNodeDefinition}; you are handed one of these. The difference is
+ * `dataOf`, which cannot be written by hand because it closes over the schema you just declared.
+ */
+interface CustomNode<Schema extends StandardSchemaV1 | undefined = any> extends CustomNodeDefinition<Schema> {
+    /**
+     * This node's payload, from a surface that carries every definition's under one type.
+     *
+     * `RecognizedCustomNode.data`, `ActivatedCustomNode.data` and `ReviewCustomItem.data` are all
+     * `unknown`, because each of those can be any registered definition's node. This narrows one
+     * to THIS definition and validates its payload against THIS schema, so a host reads a typed
+     * value without importing its own validator at the call site:
+     *
+     * ```ts
+     * const survey = Iceberg.dataOf(node); // IcebergData | undefined
+     * ```
+     *
+     * `undefined` when the node is a different definition's, carries no payload, or holds one the
+     * schema rejects — the three cases a caller has to handle anyway.
+     *
+     * `name` is checked when present and never required, so this also works on a host's own object
+     * that kept only the payload:
+     *
+     * ```ts
+     * const survey = Iceberg.dataOf(popoverState); // { data } is enough
+     * ```
+     */
+    readonly dataOf: (node: {
+        readonly name?: string;
+        readonly data?: unknown;
+    } | null | undefined) => InferSchemaOutput<Schema> | undefined;
+}
+/**
+ * A definition of any payload shape, spelled out.
+ *
+ * The AUTHORED shape, which is what every collection and every internal helper takes: they read
+ * `name`, `schema`, `text` and `preserveOnExport` and never need `dataOf`. A {@link CustomNode}
+ * is assignable to it, so `defineCustomNode`'s result goes wherever this is asked for.
+ *
+ * The same thing bare `CustomNodeDefinition` already means — the interface defaults its
+ * parameter to `any` for exactly this reason. `CustomNodeDefinition<Schema>` is INVARIANT in
+ * `Schema`, because the schema's output type appears in the PARAMETER of `fromDocx` and
+ * `reviewCard`; that is what makes those hooks typed, and it also means two definitions with
+ * different schemas are not assignable to one another. Had the default been `undefined`, the
+ * obvious annotation — `const nodes: CustomNodeDefinition[] = [citation, figure]` — would fail
+ * with a message naming neither the cause nor this alias.
+ *
+ * The cost, stated plainly: `data` is unchecked wherever a definition is held under this type.
+ * Pull one out of a registry and `insertCustomNode(editor, def, attrs, text, { data })` accepts
+ * any shape at all. Payload typing lives where the definition is WRITTEN — `defineCustomNode`
+ * infers the schema, and its hooks are typed from it.
+ */
+type AnyCustomNodeDefinition = CustomNodeDefinition;
+/**
+ * A chip activation: identity + attrs, plus where it sits.
+ *
+ * `attrs` are the definition's OWN shape — the raw tag decode has already been
+ * through `fromDocx`, exactly as the review derivation runs it, so every
+ * surface (click, hover, edit, cards) sees one attrs vocabulary. `text` and
+ * `nodeId` are present when the surface could resolve them (a registered
+ * review module resolves both).
+ */
+interface ActivatedCustomNode {
+    readonly name: string;
+    readonly attrs: Readonly<Record<string, string>>;
+    readonly tag: string;
+    /** Viewport-relative rect of the chip's boundary, for anchoring host UI. */
+    readonly rect: DOMRect;
+    /** The SDT node's canonical id — the address `removeContentControl` takes. */
+    readonly nodeId?: string;
+    /** The node's literal content text, when resolvable. */
+    readonly text?: string;
+    /**
+     * The node's payload, when the surface could resolve one.
+     *
+     * Present only where the review derivation has already run — a chip's own click and hover
+     * resolve through the review item, which is what carries the payload. Undefined otherwise,
+     * and undefined for a node whose payload failed its schema.
+     */
+    readonly data?: unknown;
+}
+/**
+ * Whether an opaque registry value is a custom-node definition.
+ *
+ * The engine carries registered definitions as unknowns (`getCustomNodeDefinitions`), so
+ * every pro surface that reads them back narrows through this ONE guard.
+ */
+declare function isCustomNodeDefinition(candidate: unknown): candidate is AnyCustomNodeDefinition;
+/** Validate and freeze a definition. Throws on a shape mistake — author error, not file input. */
+declare function defineCustomNode<Schema extends StandardSchemaV1 | undefined = undefined>(definition: CustomNodeDefinition<Schema>): CustomNode<Schema>;
+/**
+ * How {@link customNodesModule} is configured.
+ *
+ * @public
+ */
+interface CustomNodesModuleOptions extends ProLicenseOptions {
+    /** The definitions this editor recognizes. A tag prefix no definition claims stays literal. */
+    readonly nodes: readonly AnyCustomNodeDefinition[];
+    /**
+     * Told about a document, never about a bug: a payload that failed its schema, so far.
+     *
+     * A payload comes from a file the sender wrote, so a mismatch is an ordinary property of an
+     * ordinary document. The node still renders, without its `data`; this is how an integrator
+     * finds out rather than wondering why one chip's dialog is empty.
+     */
+    readonly onDiagnostic?: (diagnostic: CustomNodeDiagnostic) => void;
+}
+/** Register custom node definitions with `createDocxEditor({ modules })`. */
+declare function customNodesModule(options: CustomNodesModuleOptions): EditorModule;
+/**
+ * Every recognized custom node in one story, in document order.
+ *
+ * Tag-prefix keyed, exactly as the change specifies: an inline SDT whose tag
+ * decodes to a registered `<prefix>:<name>` pair is offered to that
+ * definition's `fromDocx`; everything else — foreign tags, unregistered
+ * prefixes, a `fromDocx` veto — stays a literal SDT.
+ */
+interface RecognizeCustomNodesOptions {
+    /** The payload each control binds, from `customNodePayloadsByControl`. */
+    readonly payloads?: ReadonlyMap<string, CustomNodePayloadSource>;
+    /** Told about a node whose payload could not be read. Omitted, nothing is reported. */
+    readonly onDiagnostic?: (diagnostic: CustomNodeDiagnostic) => void;
+}
+declare function recognizeCustomNodes(part: OoxmlPart, definitions: readonly AnyCustomNodeDefinition[], options?: RecognizeCustomNodesOptions): RecognizedCustomNode[];
+
+export { type AnyCustomNodeDefinition as A, type CustomNodeDiagnostic as C, type InferSchemaInput as I, MAX_CUSTOM_NODE_DATA_LENGTH as M, type ProLicenseOptions as P, type RecognizedCustomNode as R, type StandardSchemaV1 as S, type CustomNodeDefinition as a, type ActivatedCustomNode as b, type CustomNode as c, type CustomNodeDataRejection as d, type CustomNodeDataResult as e, type CustomNodePayloadSource as f, type CustomNodesModuleOptions as g, type InferSchemaOutput as h, type RecognizeCustomNodesOptions as i, type ReviewModuleOptions as j, type StandardSchemaIssue as k, type StandardSchemaResult as l, customNodesModule as m, defineCustomNode as n, isCustomNodeDefinition as o, parseCustomNodeData as p, reviewModule as q, recognizeCustomNodes as r, serializeCustomNodeData as s };

package/dist/index.cjs

@@ -1 +1 @@
-'use strict';var chunkTNSHSAA4_cjs=require('./chunk-TNSHSAA4.cjs'),store=require('@docx-editor.dev/core/store');function x(e){return e.surface??null}function v(e,n,a,t,o={}){let r=x(e);if(!r)return {ok:false,code:"notFound",reason:"no document is mounted"};let s=chunkTNSHSAA4_cjs.b(n.tagPrefix,n.name,a);if(!s.ok)return {ok:false,code:"invalidArgs",reason:`the encoded tag is ${s.length} characters; Word caps w:tag at 64 \u2014 shorten the attrs (the customXml data-part escape hatch is not built yet)`};let i=o.at??r.state().selection.head,c=o.lock===void 0?"contentLocked":o.lock,u=r.session.applyTreeOps([{op:"insertInlineContentControl",paragraphId:i.paragraphId,offset:i.offset,tag:s.tag,text:t,...o.alias===void 0?{}:{alias:o.alias},...c===false?{}:{lock:c}}]);return u.committed?{ok:true,changed:true}:{ok:false,code:"unsupported",reason:typeof u.reason=="string"?u.reason:"the insert was refused"}}function m(e){return e.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g,"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&apos;")}function R(e,n,a,t={}){if(!chunkTNSHSAA4_cjs.e.test(e.tagPrefix)||!chunkTNSHSAA4_cjs.e.test(e.name))return {ok:false,code:"invalidArgs",reason:"the definition identity must match defineCustomNode\u2019s charset ([A-Za-z0-9_.-])"};let o=chunkTNSHSAA4_cjs.b(e.tagPrefix,e.name,n);if(!o.ok)return {ok:false,code:"invalidArgs",reason:`the encoded tag is ${o.length} characters; Word caps w:tag at 64 \u2014 shorten the attrs`};let r=t.lock===void 0?"contentLocked":t.lock,s=t.id!==void 0&&Number.isInteger(t.id)&&t.id>0?t.id:store.fnv1a32(`${o.tag}\0${a}`)&2147483647||1,i=(t.alias!==void 0?`<w:alias w:val="${m(t.alias)}"/>`:"")+`<w:tag w:val="${m(o.tag)}"/><w:id w:val="${s}"/>`+(r===false?"":`<w:lock w:val="${r}"/>`),c=`<w:r><w:t xml:space="preserve">${m(a)}</w:t></w:r>`;return {ok:true,xml:`<w:sdt><w:sdtPr>${i}</w:sdtPr><w:sdtContent>${c}</w:sdtContent></w:sdt>`}}Object.defineProperty(exports,"MAX_TAG_LENGTH",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.a}});Object.defineProperty(exports,"customNodesModule",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.g}});Object.defineProperty(exports,"decodeCustomNodeTag",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.c}});Object.defineProperty(exports,"defineCustomNode",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.f}});Object.defineProperty(exports,"encodeCustomNodeTag",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.b}});Object.defineProperty(exports,"isCustomNodeDefinition",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.d}});Object.defineProperty(exports,"recognizeCustomNodes",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.h}});Object.defineProperty(exports,"removeCustomNode",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.j}});Object.defineProperty(exports,"reviewModule",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.i}});Object.defineProperty(exports,"updateCustomNode",{enumerable:true,get:function(){return chunkTNSHSAA4_cjs.k}});exports.customNodeXml=R;exports.insertCustomNode=v;
+'use strict';var chunkMNK6DXJQ_cjs=require('./chunk-MNK6DXJQ.cjs'),store=require('@docx-editor.dev/core/store');function b(e,o={}){let r=U(e);if(!r)return [];let t=o.nodes??e.getCustomNodeDefinitions().filter(chunkMNK6DXJQ_cjs.j);if(t.length===0)return [];let s=r.session.part();return chunkMNK6DXJQ_cjs.n(s,t,{payloads:store.customNodePayloadsByControl(r.session.currentPackage(),s.name),onDiagnostic:o.onDiagnostic??(d=>{e.reportCustomNodeDiagnostic(d);})})}function U(e){return e.surface??null}function E(e,o,r={}){if(r.destination==="internal")return {ok:true,bytes:e,unwrapped:0,removed:0};let t=store.readOoxmlPackage(e);if(!t.ok)return {ok:false,reason:`the document could not be read: ${t.reason}`};let s=new Map;for(let i of o)s.set(`${i.tagPrefix}:${i.name}`,i);let d=i=>{let m=chunkMNK6DXJQ_cjs.c(i);if(!m)return "keep";let x=s.get(`${m.prefix}:${m.name}`);return x?x.preserveOnExport==="text"?"text":x.preserveOnExport===false?"remove":"keep":"keep"},p=[...new Set(o.filter(i=>i.preserveOnExport!==void 0).filter(i=>i.preserveOnExport!==true).map(chunkMNK6DXJQ_cjs.h))],n=t.package,u=0,c=0,g=B(n);for(let i of g){let m=store.withExportedCustomNodes(n,{storyPartName:i,namespaces:[],decide:d});if(!m.ok)return {ok:false,reason:m.reason};n=m.pkg,u+=m.unwrapped,c+=m.removed;}let l=store.withExportedCustomNodes(n,{storyPartName:n.mainDocumentPart,namespaces:p,decide:()=>"keep"});return l.ok?(n=l.pkg,{ok:true,bytes:store.writeOoxmlPackage(n),unwrapped:u,removed:c}):{ok:false,reason:l.reason}}function B(e){let o=[];for(let[r,t]of e.parts)r!==e.mainDocumentPart&&store.storyRootsOf(t).length!==0&&o.push(r);return [e.mainDocumentPart,...o]}async function V(e,o={}){let r=o.nodes??e.getCustomNodeDefinitions().filter(chunkMNK6DXJQ_cjs.j),t=await e.save();return E(new Uint8Array(t),r,{...o.destination===void 0?{}:{destination:o.destination}})}function a(e){return e.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g,"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&apos;")}function J(e,o,r,t={}){if(!chunkMNK6DXJQ_cjs.k.test(e.tagPrefix)||!chunkMNK6DXJQ_cjs.k.test(e.name))return {ok:false,code:"invalidArgs",reason:"the definition identity must match defineCustomNode\u2019s charset ([A-Za-z0-9_.-])"};let s=chunkMNK6DXJQ_cjs.b(e.tagPrefix,e.name,o);if(!s.ok)return {ok:false,code:"invalidArgs",reason:`the encoded tag is ${s.length} characters; Word caps w:tag at 64 \u2014 shorten the attrs`};let d=t.lock===void 0?"contentLocked":t.lock,p=t.id!==void 0&&Number.isInteger(t.id)&&t.id>0?t.id:store.fnv1a32(`${s.tag}\0${r}`)&2147483647||1,n=t.data===void 0?null:K(e,t,r);if(n&&"reason"in n)return {ok:false,code:"invalidArgs",reason:n.reason};let u=(t.alias!==void 0?`<w:alias w:val="${a(t.alias)}"/>`:"")+`<w:tag w:val="${a(s.tag)}"/><w:id w:val="${p}"/>`+(d===false?"":`<w:lock w:val="${d}"/>`)+(n?`<w:dataBinding w:prefixMappings="${a(n.binding.prefixMappings)}" w:xpath="${a(n.binding.xpath)}" w:storeItemID="${a(n.binding.storeItemId)}"/>`:""),c=`<w:r><w:t xml:space="preserve">${a(r)}</w:t></w:r>`;return {ok:true,xml:`<w:sdt><w:sdtPr>${u}</w:sdtPr><w:sdtContent>${c}</w:sdtContent></w:sdt>`,...n?{store:n.store}:{}}}function K(e,o,r){let t=chunkMNK6DXJQ_cjs.i(e,o.data);if(!t.ok)return {reason:t.reason};let s=chunkMNK6DXJQ_cjs.h(e),d=o.storeIndex!==void 0&&Number.isInteger(o.storeIndex)&&o.storeIndex>0?o.storeIndex:1,p=o.nodeId??"cx1",n=`/customXml/item${String(d)}.xml`,u=`/customXml/itemProps${String(d)}.xml`,c=store.datastoreItemIdFor(`${s} ${n} ${p}`),g=store.customNodeBinding({partName:n,propsPartName:u,itemId:c,namespaceUri:s},chunkMNK6DXJQ_cjs.g,p);if(!g)return {reason:`the payload cannot be addressed by an XPath: check nodeId (${p}) and payloadNamespace`};let l=r===r.trim()?`<label>${a(r)}</label>`:`<label xml:space="preserve">${a(r)}</label>`;return {binding:g,store:{itemPartName:n,itemXml:`<${chunkMNK6DXJQ_cjs.g} xmlns="${a(s)}"><node id="${a(p)}">${l}<data>${a(t.data)}</data></node></${chunkMNK6DXJQ_cjs.g}>`,propsPartName:u,propsXml:`<ds:datastoreItem ds:itemID="${a(c)}" xmlns:ds="${store.DATASTORE_NAMESPACE_URI}"><ds:schemaRefs><ds:schemaRef ds:uri="${a(s)}"/></ds:schemaRefs></ds:datastoreItem>`,storeItemId:c,relationships:[{from:"/word/document.xml",type:store.CUSTOM_XML_REL,target:`../customXml/item${String(d)}.xml`},{from:n,type:store.CUSTOM_XML_PROPS_REL,target:`itemProps${String(d)}.xml`}],contentTypeOverride:{partName:u,contentType:store.CUSTOM_XML_PROPS_TYPE}}}}Object.defineProperty(exports,"CUSTOM_NODE_STORE_ROOT",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.g}});Object.defineProperty(exports,"MAX_CUSTOM_NODE_DATA_LENGTH",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.d}});Object.defineProperty(exports,"MAX_TAG_LENGTH",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.a}});Object.defineProperty(exports,"customNodeNamespace",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.h}});Object.defineProperty(exports,"customNodesModule",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.m}});Object.defineProperty(exports,"decodeCustomNodeTag",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.c}});Object.defineProperty(exports,"defineCustomNode",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.l}});Object.defineProperty(exports,"encodeCustomNodeTag",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.b}});Object.defineProperty(exports,"insertCustomNode",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.p}});Object.defineProperty(exports,"isCustomNodeDefinition",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.j}});Object.defineProperty(exports,"parseCustomNodeData",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.e}});Object.defineProperty(exports,"recognizeCustomNodes",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.n}});Object.defineProperty(exports,"removeCustomNode",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.q}});Object.defineProperty(exports,"reviewModule",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.o}});Object.defineProperty(exports,"serializeCustomNodeData",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.f}});Object.defineProperty(exports,"updateCustomNode",{enumerable:true,get:function(){return chunkMNK6DXJQ_cjs.r}});exports.customNodeXml=J;exports.customNodesOf=b;exports.prepareForExport=E;exports.saveForExport=V;