@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/core/registry/create-defaults.js

@@ -0,0 +1,42 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var handlers = [];
+/**
+ * @private
+ * Test hook */
+export function resetFeatureCreateDefaultHandlers() {
+    handlers.length = 0;
+}
+/**
+ * @private
+ */
+export function registerFeatureCreateDefaultHandler(handler) {
+    handlers.push(handler);
+}
+/**
+ * @private
+ * Run every registered feature create-default pass, in registration order. */
+export function attachFeatureCreateDefaults(document) {
+    var e_1, _a;
+    try {
+        for (var handlers_1 = __values(handlers), handlers_1_1 = handlers_1.next(); !handlers_1_1.done; handlers_1_1 = handlers_1.next()) {
+            var handler = handlers_1_1.value;
+            handler.attachCreateDefault(document);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (handlers_1_1 && !handlers_1_1.done && (_a = handlers_1.return)) _a.call(handlers_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}

package/src/core/registry/feature-registry.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Stable feature module identifier (e.g. `tables`). Branded so it is not mixed
+ * with relationship or style IDs.
+ */
+export declare type FeatureId = string & {
+    readonly __brand: 'FeatureId';
+};
+export declare function featureId(value: string): FeatureId;
+export interface FeatureRegistration {
+    readonly id: FeatureId;
+}
+/** Test hook: empty the in-memory registry. */
+export declare function resetFeatureRegistry(): void;
+export declare function registerFeature(registration: FeatureRegistration): void;
+/**
+ * Require a registered feature. Unknown ids throw `UNKNOWN_FEATURE`
+ * (TASK-1008 assumption).
+ */
+export declare function ensureFeature(id: string): FeatureRegistration;
+export declare function isFeatureRegistered(id: string): boolean;

package/src/core/registry/feature-registry.js

@@ -0,0 +1,29 @@
+import { DocxError } from '../errors/docx-error';
+export function featureId(value) {
+    if (value.length === 0 || !/^[a-z][a-z0-9-]*$/.test(value)) {
+        throw new DocxError('feature/invalid-id', "Invalid feature id: " + value);
+    }
+    return value;
+}
+var registrations = new Map();
+/** Test hook: empty the in-memory registry. */
+export function resetFeatureRegistry() {
+    registrations.clear();
+}
+export function registerFeature(registration) {
+    registrations.set(registration.id, registration);
+}
+/**
+ * Require a registered feature. Unknown ids throw `UNKNOWN_FEATURE`
+ * (TASK-1008 assumption).
+ */
+export function ensureFeature(id) {
+    var found = registrations.get(id);
+    if (found === undefined) {
+        throw new DocxError('feature/not-registered', "Feature is not registered: " + id);
+    }
+    return found;
+}
+export function isFeatureRegistered(id) {
+    return registrations.has(id);
+}

package/src/core/registry/index.d.ts

@@ -0,0 +1,9 @@
+export { ensureFeature, featureId, isFeatureRegistered, registerFeature, resetFeatureRegistry, } from './feature-registry';
+export { FeatureId, FeatureRegistration } from './feature-registry';
+export { registerFeatureBlockHandler, resetFeatureBlockHandlers, tryParseFeatureBlock, BodyBlockParseContext, FeatureBlockHandler } from './block-handlers';
+export { applyFeatureParts, listFeaturePartHandlers, loadFeatureParts, registerFeaturePartHandler, resetFeaturePartHandlers, FeaturePartHandler, FeaturePartLoadContext } from './part-handlers';
+export { applyFeatureMultiParts, listFeatureMultiPartHandlers, loadFeatureMultiParts, registerFeatureMultiPartHandler, replaceOrAddPackagePart, resetFeatureMultiPartHandlers, usedMainDocumentRelationshipIds, FeatureMultiPartHandler, FeatureMultiPartLoadContext } from './multi-part-handlers';
+export { registerFeatureRunLeafHandler, resetFeatureRunLeafHandlers, FeatureRunLeafHandler } from './run-leaf-handlers';
+export { registerFeatureInlineHandler, resetFeatureInlineHandlers, FeatureInlineHandler } from './inline-handlers';
+export { applyFeaturePackageParts, findPackageRelatedPart, listFeaturePackagePartHandlers, loadFeaturePackageParts, registerFeaturePackagePartHandler, replaceOrAddPackageLevelPart, resetFeaturePackagePartHandlers, usedPackagePartNameKeys, usedPackageRelationshipIds, FeaturePackagePartHandler, FeaturePackagePartLoadContext } from './package-part-handlers';
+export { materializeFeatureSideEffects, registerFeatureBlockParagraphWalker, registerFeatureMaterializeHandler, resetFeatureMaterializeHandlers, visitBlocksInDocumentOrder, visitParagraphsInDocumentOrder, FeatureBlockParagraphWalker, FeatureMaterializeHandler } from './materialize-handlers';

package/src/core/registry/index.js

@@ -0,0 +1,8 @@
+export { ensureFeature, featureId, isFeatureRegistered, registerFeature, resetFeatureRegistry, } from './feature-registry';
+export { registerFeatureBlockHandler, resetFeatureBlockHandlers, tryParseFeatureBlock } from './block-handlers';
+export { applyFeatureParts, listFeaturePartHandlers, loadFeatureParts, registerFeaturePartHandler, resetFeaturePartHandlers } from './part-handlers';
+export { applyFeatureMultiParts, listFeatureMultiPartHandlers, loadFeatureMultiParts, registerFeatureMultiPartHandler, replaceOrAddPackagePart, resetFeatureMultiPartHandlers, usedMainDocumentRelationshipIds } from './multi-part-handlers';
+export { registerFeatureRunLeafHandler, resetFeatureRunLeafHandlers } from './run-leaf-handlers';
+export { registerFeatureInlineHandler, resetFeatureInlineHandlers } from './inline-handlers';
+export { applyFeaturePackageParts, findPackageRelatedPart, listFeaturePackagePartHandlers, loadFeaturePackageParts, registerFeaturePackagePartHandler, replaceOrAddPackageLevelPart, resetFeaturePackagePartHandlers, usedPackagePartNameKeys, usedPackageRelationshipIds } from './package-part-handlers';
+export { materializeFeatureSideEffects, registerFeatureBlockParagraphWalker, registerFeatureMaterializeHandler, resetFeatureMaterializeHandlers, visitBlocksInDocumentOrder, visitParagraphsInDocumentOrder } from './materialize-handlers';

package/src/core/registry/inline-handlers.d.ts

@@ -0,0 +1,20 @@
+import { FeatureInline } from '../../features/document/feature-inline';
+import { OpenXmlElement } from '../xml/index';
+import { FeatureId } from './feature-registry';
+export declare type FeatureInlineContent = {
+    readonly type: 'feature';
+    readonly featureId: FeatureId;
+    readonly value: FeatureInline;
+};
+export interface FeatureInlineHandler {
+    readonly featureId: FeatureId;
+    readonly wmlLocalName: string;
+    /** When omitted, the WordprocessingML transitional namespace is assumed. */
+    readonly namespaceUri?: string;
+    tryParse(element: OpenXmlElement): FeatureInline | undefined;
+}
+/** Test hook */
+export declare function resetFeatureInlineHandlers(): void;
+export declare function registerFeatureInlineHandler(handler: FeatureInlineHandler): void;
+export declare function tryParseFeatureInline(element: OpenXmlElement): FeatureInlineContent | undefined;
+export declare function serializeFeatureInline(inline: FeatureInlineContent): OpenXmlElement;

package/src/core/registry/inline-handlers.js

@@ -0,0 +1,30 @@
+import { WML } from '../../features/document/wml';
+var handlersByLocalName = new Map();
+function elementMatchesHandler(element, handler) {
+    if (element.localName !== handler.wmlLocalName) {
+        return false;
+    }
+    var namespaceUri = handler.namespaceUri != null ? handler.namespaceUri : WML;
+    return element.namespaceUri === namespaceUri;
+}
+/** Test hook */
+export function resetFeatureInlineHandlers() {
+    handlersByLocalName.clear();
+}
+export function registerFeatureInlineHandler(handler) {
+    handlersByLocalName.set(handler.wmlLocalName, handler);
+}
+export function tryParseFeatureInline(element) {
+    var handler = handlersByLocalName.get(element.localName);
+    if (handler === undefined || !elementMatchesHandler(element, handler)) {
+        return undefined;
+    }
+    var value = handler.tryParse(element);
+    if (value === undefined) {
+        return undefined;
+    }
+    return { type: 'feature', featureId: handler.featureId, value: value };
+}
+export function serializeFeatureInline(inline) {
+    return inline.value.toOpenXml();
+}

package/src/core/registry/materialize-handlers.d.ts

@@ -0,0 +1,35 @@
+import { FeatureBlock } from '../../features/document/feature-block';
+import { FeatureId } from './feature-registry';
+import { BlockContent, Paragraph } from '../../features/document/paragraph';
+/**
+ * @private
+ * Minimal document surface required for save-time materialization. */
+export interface MaterializableDocument {
+    listBlocks(): ReadonlyArray<BlockContent>;
+    featurePart(id: FeatureId): unknown;
+}
+/** @public */
+export interface FeatureMaterializeHandler {
+    readonly featureId: FeatureId;
+    materialize(document: MaterializableDocument): void;
+}
+/** @public */
+export interface FeatureBlockParagraphWalker {
+    readonly featureId: FeatureId;
+    visitParagraphs(block: FeatureBlock, visit: (paragraph: Paragraph) => void): void;
+}
+/** @public Test hook */
+export declare function resetFeatureMaterializeHandlers(): void;
+/** @public */
+export declare function registerFeatureMaterializeHandler(handler: FeatureMaterializeHandler): void;
+/** @public */
+export declare function registerFeatureBlockParagraphWalker(walker: FeatureBlockParagraphWalker): void;
+/** @public Visit body blocks and nested feature paragraphs in document order. */
+export declare function visitParagraphsInDocumentOrder(document: MaterializableDocument, visit: (paragraph: Paragraph) => void): void;
+/**
+ * Visit paragraphs inside an ordered block list using registered feature walkers.
+ * @public
+ */
+export declare function visitBlocksInDocumentOrder(blocks: ReadonlyArray<BlockContent>, visit: (paragraph: Paragraph) => void): void;
+/** @public Run every registered feature materialization pass. */
+export declare function materializeFeatureSideEffects(document: MaterializableDocument): void;

package/src/core/registry/materialize-handlers.js

@@ -0,0 +1,75 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var materializeHandlers = [];
+var blockParagraphWalkers = new Map();
+/** @public Test hook */
+export function resetFeatureMaterializeHandlers() {
+    materializeHandlers.length = 0;
+    blockParagraphWalkers.clear();
+}
+/** @public */
+export function registerFeatureMaterializeHandler(handler) {
+    materializeHandlers.push(handler);
+}
+/** @public */
+export function registerFeatureBlockParagraphWalker(walker) {
+    blockParagraphWalkers.set(walker.featureId, walker);
+}
+/** @public Visit body blocks and nested feature paragraphs in document order. */
+export function visitParagraphsInDocumentOrder(document, visit) {
+    visitBlocksInDocumentOrder(document.listBlocks(), visit);
+}
+/**
+ * Visit paragraphs inside an ordered block list using registered feature walkers.
+ * @public
+ */
+export function visitBlocksInDocumentOrder(blocks, visit) {
+    var e_1, _a;
+    try {
+        for (var blocks_1 = __values(blocks), blocks_1_1 = blocks_1.next(); !blocks_1_1.done; blocks_1_1 = blocks_1.next()) {
+            var block = blocks_1_1.value;
+            if (block.type === 'paragraph') {
+                visit(block.paragraph);
+                continue;
+            }
+            if (block.type === 'feature') {
+                var walker = blockParagraphWalkers.get(block.featureId);
+                if (walker !== undefined) {
+                    walker.visitParagraphs(block.value, visit);
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (blocks_1_1 && !blocks_1_1.done && (_a = blocks_1.return)) _a.call(blocks_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+/** @public Run every registered feature materialization pass. */
+export function materializeFeatureSideEffects(document) {
+    var e_2, _a;
+    try {
+        for (var materializeHandlers_1 = __values(materializeHandlers), materializeHandlers_1_1 = materializeHandlers_1.next(); !materializeHandlers_1_1.done; materializeHandlers_1_1 = materializeHandlers_1.next()) {
+            var handler = materializeHandlers_1_1.value;
+            handler.materialize(document);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (materializeHandlers_1_1 && !materializeHandlers_1_1.done && (_a = materializeHandlers_1.return)) _a.call(materializeHandlers_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+}

package/src/core/registry/multi-part-handlers.d.ts

@@ -0,0 +1,37 @@
+import { FeatureMultiPackagePart } from '../../features/document/feature-multi-package-part';
+import { OpcRelationship } from '../opc/relationships';
+import { OpcPackage } from '../opc/package';
+import { PartName } from '../opc/part-name';
+import { ResourceLimitOverrides } from '../security/limits';
+import { FeatureId } from './feature-registry';
+/** @public */
+export interface FeatureMultiPartLoadContext {
+    readonly mainPartName: PartName;
+    readonly limits?: ResourceLimitOverrides | undefined;
+}
+export interface FeatureMultiPartHandler {
+    readonly featureId: FeatureId;
+    readonly relationshipTypes: ReadonlyArray<string>;
+    loadParts(pkg: OpcPackage, ctx: FeatureMultiPartLoadContext): FeatureMultiPackagePart;
+}
+/** Test hook */
+export declare function resetFeatureMultiPartHandlers(): void;
+export declare function registerFeatureMultiPartHandler(handler: FeatureMultiPartHandler): void;
+export declare function listFeatureMultiPartHandlers(): ReadonlyArray<FeatureMultiPartHandler>;
+export declare function loadFeatureMultiParts(pkg: OpcPackage, mainPartName: PartName, limits?: ResourceLimitOverrides): Map<FeatureId, FeatureMultiPackagePart>;
+/**
+ * Relationship ids already claimed on the main document part — package items plus
+ * every multi-part catalog that has already allocated pending entries.
+ *
+ * Materialize handlers for independent features (images, ink, hyperlinks, …) must
+ * share this set so concurrent pending allocations cannot emit the same rId.
+ *
+ * @public
+ */
+export declare function usedMainDocumentRelationshipIds(document: {
+    opcPackage(): OpcPackage;
+    featurePart(id: FeatureId): unknown;
+}): Set<string>;
+export declare function applyFeatureMultiParts(pkg: OpcPackage, mainPartName: PartName, featureParts: ReadonlyMap<FeatureId, FeatureMultiPackagePart>): OpcPackage;
+/** @public Helpers for feature modules implementing {@link FeatureMultiPackagePart}. */
+export declare function replaceOrAddPackagePart(pkg: OpcPackage, mainPartName: PartName, partName: PartName, contentType: string, data: Uint8Array, relationship: OpcRelationship | undefined): OpcPackage;

package/src/core/registry/multi-part-handlers.js

@@ -0,0 +1,206 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { allocateRelationshipId, relationshipsWith } from '../opc/relationships';
+import { partByName, relationshipsForPart, withAddedPart, withContentTypeOverride, withPartRelationships, withReplacedPart } from '../opc/package';
+import { partName } from '../opc/part-name';
+var handlers = [];
+/** Test hook */
+export function resetFeatureMultiPartHandlers() {
+    handlers.length = 0;
+}
+export function registerFeatureMultiPartHandler(handler) {
+    handlers.push(handler);
+}
+export function listFeatureMultiPartHandlers() {
+    return handlers;
+}
+export function loadFeatureMultiParts(pkg, mainPartName, limits) {
+    var e_1, _a;
+    var out = new Map();
+    var ctx = { mainPartName: mainPartName, limits: limits };
+    try {
+        for (var handlers_1 = __values(handlers), handlers_1_1 = handlers_1.next(); !handlers_1_1.done; handlers_1_1 = handlers_1.next()) {
+            var handler = handlers_1_1.value;
+            out.set(handler.featureId, handler.loadParts(pkg, ctx));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (handlers_1_1 && !handlers_1_1.done && (_a = handlers_1.return)) _a.call(handlers_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return out;
+}
+function mergeRelationships(existing, add) {
+    var e_2, _a;
+    if (add.length === 0) {
+        return existing;
+    }
+    var used = new Set(existing.items.map(function (item) { return item.id; }));
+    var next = __spread(existing.items);
+    var _loop_1 = function (rel) {
+        if (next.some(function (item) { return item.type === rel.type && item.target === rel.target; })) {
+            return "continue";
+        }
+        var id = rel.id;
+        while (used.has(id)) {
+            id = allocateRelationshipId(used);
+        }
+        used.add(id);
+        next.push(__assign({}, rel, { id: id }));
+    };
+    try {
+        for (var add_1 = __values(add), add_1_1 = add_1.next(); !add_1_1.done; add_1_1 = add_1.next()) {
+            var rel = add_1_1.value;
+            _loop_1(rel);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (add_1_1 && !add_1_1.done && (_a = add_1.return)) _a.call(add_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return relationshipsWith(next, existing.opaque);
+}
+/**
+ * Relationship ids already claimed on the main document part — package items plus
+ * every multi-part catalog that has already allocated pending entries.
+ *
+ * Materialize handlers for independent features (images, ink, hyperlinks, …) must
+ * share this set so concurrent pending allocations cannot emit the same rId.
+ *
+ * @public
+ */
+export function usedMainDocumentRelationshipIds(document) {
+    var e_3, _a, e_4, _b, e_5, _c;
+    var main = partName('/word/document.xml');
+    var used = new Set();
+    try {
+        for (var _d = __values(relationshipsForPart(document.opcPackage(), main).items), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var rel = _e.value;
+            used.add(rel.id);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    try {
+        for (var handlers_2 = __values(handlers), handlers_2_1 = handlers_2.next(); !handlers_2_1.done; handlers_2_1 = handlers_2.next()) {
+            var handler = handlers_2_1.value;
+            var part = document.featurePart(handler.featureId);
+            if (part === undefined || part === null || typeof part !== 'object') {
+                continue;
+            }
+            var catalog = part;
+            if (typeof catalog.pendingRelationshipIds !== 'function') {
+                continue;
+            }
+            try {
+                for (var _f = __values(catalog.pendingRelationshipIds()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var id = _g.value;
+                    used.add(id);
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (handlers_2_1 && !handlers_2_1.done && (_b = handlers_2.return)) _b.call(handlers_2);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return used;
+}
+export function applyFeatureMultiParts(pkg, mainPartName, featureParts) {
+    var e_6, _a;
+    var next = pkg;
+    try {
+        for (var handlers_3 = __values(handlers), handlers_3_1 = handlers_3.next(); !handlers_3_1.done; handlers_3_1 = handlers_3.next()) {
+            var handler = handlers_3_1.value;
+            var state = featureParts.get(handler.featureId);
+            if (state === undefined || !state.isDirty()) {
+                continue;
+            }
+            next = state.applyToPackage(next, mainPartName);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (handlers_3_1 && !handlers_3_1.done && (_a = handlers_3.return)) _a.call(handlers_3);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return next;
+}
+/** @public Helpers for feature modules implementing {@link FeatureMultiPackagePart}. */
+export function replaceOrAddPackagePart(pkg, mainPartName, partName, contentType, data, relationship) {
+    var next = pkg;
+    var existing = partByName(next, partName);
+    if (existing === undefined) {
+        next = withAddedPart(next, { name: partName, contentType: contentType, data: data });
+        next = withContentTypeOverride(next, partName, contentType);
+        if (relationship !== undefined) {
+            var merged = mergeRelationships(relationshipsForPart(next, mainPartName), [relationship]);
+            next = withPartRelationships(next, mainPartName, merged);
+        }
+        return next;
+    }
+    next = withReplacedPart(next, partName, data);
+    return next;
+}

package/src/core/registry/package-part-handlers.d.ts

@@ -0,0 +1,28 @@
+import { FeaturePackageLevelPart } from '../../features/document/feature-package-level-part';
+import { OpcRelationship } from '../opc/relationships';
+import { OpcPackage, PackagePart } from '../opc/package';
+import { PartName } from '../opc/part-name';
+import { ResourceLimitOverrides } from '../security/limits';
+import { FeatureId } from './feature-registry';
+/** @public */
+export interface FeaturePackagePartLoadContext {
+    readonly limits?: ResourceLimitOverrides | undefined;
+}
+export interface FeaturePackagePartHandler {
+    readonly featureId: FeatureId;
+    loadParts(pkg: OpcPackage, ctx: FeaturePackagePartLoadContext): FeaturePackageLevelPart;
+}
+/** Test hook */
+export declare function resetFeaturePackagePartHandlers(): void;
+export declare function registerFeaturePackagePartHandler(handler: FeaturePackagePartHandler): void;
+export declare function listFeaturePackagePartHandlers(): ReadonlyArray<FeaturePackagePartHandler>;
+export declare function loadFeaturePackageParts(pkg: OpcPackage, limits?: ResourceLimitOverrides): Map<FeatureId, FeaturePackageLevelPart>;
+export declare function applyFeaturePackageParts(pkg: OpcPackage, featureParts: ReadonlyMap<FeatureId, FeaturePackageLevelPart>): OpcPackage;
+/** @public Helpers for feature modules implementing {@link FeaturePackageLevelPart}. */
+export declare function findPackageRelatedPart(pkg: OpcPackage, relationshipType: string): {
+    readonly relationship: OpcRelationship;
+    readonly part: PackagePart;
+} | undefined;
+export declare function replaceOrAddPackageLevelPart(pkg: OpcPackage, partNameValue: PartName, contentType: string, data: Uint8Array, relationship: OpcRelationship | undefined): OpcPackage;
+export declare function usedPackagePartNameKeys(pkg: OpcPackage): Set<string>;
+export declare function usedPackageRelationshipIds(pkg: OpcPackage): Set<string>;