typedoc 0.28.19 → 0.28.20

package/dist/lib/output/themes/lib.js

@@ -1,218 +0,0 @@
-import { DeclarationReflection, ProjectReflection, ReferenceReflection, ReflectionKind, SignatureReflection, } from "../../models/index.js";
-import { DefaultMap, filterMap, JSX } from "#utils";
-export function stringify(data) {
-    if (typeof data === "bigint") {
-        return data.toString() + "n";
-    }
-    return JSON.stringify(data);
-}
-export function getDisplayName(refl) {
-    let version = "";
-    if ((refl instanceof DeclarationReflection || refl instanceof ProjectReflection) && refl.packageVersion) {
-        version = ` - v${refl.packageVersion}`;
-    }
-    return `${refl.name}${version}`;
-}
-export function toStyleClass(str) {
-    return str.replace(/(\w)([A-Z])/g, (_m, m1, m2) => m1 + "-" + m2).toLowerCase();
-}
-export function getKindClass(refl) {
-    if (refl instanceof ReferenceReflection) {
-        return getKindClass(refl.getTargetReflectionDeep());
-    }
-    return ReflectionKind.classString(refl.kind);
-}
-/**
- * Insert word break tags ``<wbr>`` into the given string.
- *
- * Breaks the given string at ``_``, ``-`` and capital letters.
- *
- * @param str The string that should be split.
- * @return The original string containing ``<wbr>`` tags where possible.
- */
-export function wbr(str) {
-    // Keep this in sync with the same helper in Navigation.ts
-    // We use lookahead/lookbehind to indicate where the string should
-    // be split without consuming a character.
-    // (?<=[^A-Z])(?=[A-Z]) -- regular camel cased text
-    // (?<=[A-Z])(?=[A-Z][a-z]) -- acronym
-    // (?<=[_-])(?=[^_-]) -- snake
-    const parts = str.split(/(?<=[^A-Z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[_-])(?=[^_-])/);
-    return parts.flatMap(p => [p, JSX.createElement("wbr", null)]).slice(0, -1);
-}
-export function join(joiner, list, cb) {
-    const result = [];
-    for (const item of list) {
-        if (result.length > 0) {
-            result.push(joiner);
-        }
-        result.push(cb(item));
-    }
-    return JSX.createElement(JSX.Fragment, null, result);
-}
-export function classNames(names, extraCss) {
-    const css = Object.keys(names)
-        .filter((key) => names[key])
-        .concat(extraCss || "")
-        .join(" ")
-        .trim()
-        .replace(/\s+/g, " ");
-    return css.length ? css : undefined;
-}
-export function hasTypeParameters(reflection) {
-    return ((reflection instanceof DeclarationReflection || reflection instanceof SignatureReflection) &&
-        reflection.typeParameters != null &&
-        reflection.typeParameters.length > 0);
-}
-export function renderTypeParametersSignature(context, typeParameters) {
-    if (!typeParameters || typeParameters.length === 0)
-        return JSX.createElement(JSX.Fragment, null);
-    return (JSX.createElement(JSX.Fragment, null,
-        JSX.createElement("span", { class: "tsd-signature-symbol" }, "<"),
-        join(JSX.createElement("span", { class: "tsd-signature-symbol" }, ", "), typeParameters, (item) => (JSX.createElement(JSX.Fragment, null,
-            (item.flags.isConst || item.varianceModifier) && (JSX.createElement("span", { class: "tsd-signature-keyword" },
-                item.flags.isConst && "const ",
-                item.varianceModifier && `${item.varianceModifier} `)),
-            JSX.createElement("span", { class: "tsd-signature-type tsd-kind-type-parameter" }, item.name),
-            !!item.type && (JSX.createElement(JSX.Fragment, null,
-                " ",
-                JSX.createElement("span", { class: "tsd-signature-keyword" }, "extends"),
-                " ",
-                context.type(item.type)))))),
-        JSX.createElement("span", { class: "tsd-signature-symbol" }, ">")));
-}
-/**
- * Renders the reflection name with an additional `?` if optional.
- */
-export function renderName(refl) {
-    if (refl.flags.isOptional) {
-        return JSX.createElement(JSX.Fragment, null,
-            wbr(refl.name),
-            "?");
-    }
-    return wbr(refl.name);
-}
-// This is cached to avoid slowness with large projects.
-const rootsCache = new WeakMap();
-export function getHierarchyRoots(project) {
-    const cached = rootsCache.get(project);
-    if (cached)
-        return cached;
-    const allClasses = project.getReflectionsByKind(ReflectionKind.ClassOrInterface);
-    const roots = allClasses.filter((refl) => {
-        // If nobody extends this class, there's no possible hierarchy to display.
-        if (!refl.implementedBy && !refl.extendedBy) {
-            return false;
-        }
-        // If we don't extend anything, then we are a root
-        if (!refl.implementedTypes && !refl.extendedTypes) {
-            return true;
-        }
-        // We might still be a root, if our extended/implemented types are not included
-        // in the documentation.
-        const types = [...(refl.implementedTypes || []), ...(refl.extendedTypes || [])];
-        return types.every((type) => !type.visit({
-            reference(ref) {
-                return ref.reflection !== undefined;
-            },
-        }));
-    });
-    const result = roots.sort((a, b) => a.name.localeCompare(b.name));
-    rootsCache.set(project, result);
-    return result;
-}
-export function isNoneSection(section) {
-    return section.title.toLocaleLowerCase() === "none";
-}
-function sortNoneSectionFirst(a, b) {
-    if (isNoneSection(a)) {
-        return -1;
-    }
-    if (isNoneSection(b)) {
-        return 1;
-    }
-    return 0;
-}
-export function getMemberSections(parent, childFilter = () => true) {
-    if (parent.categories?.length) {
-        return filterMap(parent.categories, (cat) => {
-            const children = cat.children.filter(childFilter);
-            if (!children.length)
-                return;
-            return {
-                title: cat.title,
-                description: cat.description,
-                children,
-            };
-        }).sort(sortNoneSectionFirst);
-    }
-    if (parent.groups?.length) {
-        return parent.groups.flatMap((group) => {
-            if (group.categories?.length) {
-                return filterMap(group.categories.slice().sort(sortNoneSectionFirst), (cat) => {
-                    const children = cat.children.filter(childFilter);
-                    if (!children.length)
-                        return;
-                    return {
-                        title: isNoneSection(cat) ? group.title : `${group.title} - ${cat.title}`,
-                        description: cat.description,
-                        children,
-                    };
-                });
-            }
-            const children = group.children.filter(childFilter);
-            if (!children.length)
-                return [];
-            return {
-                title: group.title,
-                description: group.description,
-                children,
-            };
-        }).sort(sortNoneSectionFirst);
-    }
-    if (parent.children?.length) {
-        return [{
-                title: "none",
-                children: parent.children || [],
-            }];
-    }
-    return [];
-}
-const nameCollisionCache = new WeakMap();
-function getNameCollisionCount(project, name) {
-    let collisions = nameCollisionCache.get(project);
-    if (collisions === undefined) {
-        collisions = new DefaultMap(() => 0);
-        for (const reflection of project.getReflectionsByKind(ReflectionKind.SomeExport)) {
-            collisions.set(reflection.name, collisions.get(reflection.name) + 1);
-        }
-        nameCollisionCache.set(project, collisions);
-    }
-    return collisions.get(name);
-}
-function getNamespacedPath(reflection) {
-    const path = [reflection];
-    let parent = reflection.parent;
-    while (parent?.kindOf(ReflectionKind.Namespace)) {
-        path.unshift(parent);
-        parent = parent.parent;
-    }
-    return path;
-}
-/**
- * Returns a (hopefully) globally unique path for the given reflection.
- *
- * This only works for exportable symbols, so e.g. methods are not affected by this.
- *
- * If the given reflection has a globally unique name already, then it will be returned as is. If the name is
- * ambiguous (i.e. there are two classes with the same name in different namespaces), then the namespaces path of the
- * reflection will be returned.
- */
-export function getUniquePath(reflection) {
-    if (reflection.kindOf(ReflectionKind.SomeExport)) {
-        if (getNameCollisionCount(reflection.project, reflection.name) >= 2) {
-            return getNamespacedPath(reflection);
-        }
-    }
-    return [reflection];
-}

package/dist/lib/serialization/components.js

@@ -1 +0,0 @@
-export {};

package/dist/lib/serialization/deserializer.js

@@ -1,235 +0,0 @@
-import { ArrayType, ConditionalType, DeclarationReflection, DocumentReflection, IndexedAccessType, InferredType, IntersectionType, IntrinsicType, LiteralType, MappedType, NamedTupleMember, OptionalType, ParameterReflection, PredicateType, ProjectReflection, QueryType, ReferenceReflection, ReferenceType, Reflection, ReflectionKind, ReflectionType, RestType, SignatureReflection, TemplateLiteralType, TupleType, TypeOperatorType, TypeParameterReflection, UnionType, UnknownType, } from "#models";
-import { assert, insertPrioritySorted } from "#utils";
-import * as JSONOutput from "./schema.js";
-const supportedSchemaVersions = [JSONOutput.SCHEMA_VERSION];
-/**
- * Deserializes TypeDoc's JSON output back to {@link Reflection} instances.
- *
- * @group None
- * @summary Deserializes TypeDoc's JSON output
- */
-export class Deserializer {
-    logger;
-    deferred = [];
-    deserializers = [];
-    activeReflection = [];
-    reflectionBuilders = {
-        declaration(parent, obj) {
-            return new DeclarationReflection(obj.name, obj.kind, parent);
-        },
-        document(parent, obj) {
-            return new DocumentReflection(obj.name, parent, [], {});
-        },
-        param(parent, obj) {
-            return new ParameterReflection(obj.name, obj.kind, parent);
-        },
-        project() {
-            throw new Error("Not supported, use Deserializer.reviveProject(s) instead.");
-        },
-        reference(parent, obj) {
-            // Ugly, but we don't have a reference yet!
-            return new ReferenceReflection(obj.name, 
-            /* target */ parent, parent);
-        },
-        signature(parent, obj) {
-            return new SignatureReflection(obj.name, obj.kind, parent);
-        },
-        typeParam(parent, obj) {
-            return new TypeParameterReflection(obj.name, parent, void 0);
-        },
-    };
-    typeBuilders = {
-        array(obj, de) {
-            return new ArrayType(de.reviveType(obj.elementType));
-        },
-        conditional(obj, de) {
-            return new ConditionalType(de.reviveType(obj.checkType), de.reviveType(obj.extendsType), de.reviveType(obj.trueType), de.reviveType(obj.falseType));
-        },
-        indexedAccess(obj, de) {
-            return new IndexedAccessType(de.reviveType(obj.objectType), de.reviveType(obj.indexType));
-        },
-        inferred(obj, de) {
-            return new InferredType(obj.name, de.reviveType(obj.constraint));
-        },
-        intersection(obj, de) {
-            return new IntersectionType(obj.types.map((t) => de.reviveType(t)));
-        },
-        intrinsic(obj) {
-            return new IntrinsicType(obj.name);
-        },
-        literal(obj) {
-            if (typeof obj.value === "object" && obj.value != null) {
-                return new LiteralType(BigInt(`${obj.value.negative ? "-" : ""}${obj.value.value}`));
-            }
-            return new LiteralType(obj.value);
-        },
-        mapped(obj, de) {
-            return new MappedType(obj.parameter, de.reviveType(obj.parameterType), de.reviveType(obj.templateType), obj.readonlyModifier, obj.optionalModifier, de.reviveType(obj.nameType));
-        },
-        optional(obj, de) {
-            return new OptionalType(de.reviveType(obj.elementType));
-        },
-        predicate(obj, de) {
-            return new PredicateType(obj.name, obj.asserts, de.reviveType(obj.targetType));
-        },
-        query(obj, de) {
-            return new QueryType(de.reviveType(obj.queryType));
-        },
-        reference(obj) {
-            // Correct reference will be restored in fromObject
-            return ReferenceType.createResolvedReference(obj.name, -2, null);
-        },
-        reflection(obj, de) {
-            return new ReflectionType(de.revive(obj.declaration, (o) => de.constructReflection(o)));
-        },
-        rest(obj, de) {
-            return new RestType(de.reviveType(obj.elementType));
-        },
-        templateLiteral(obj, de) {
-            return new TemplateLiteralType(obj.head, obj.tail.map(([t, s]) => [de.reviveType(t), s]));
-        },
-        tuple(obj, de) {
-            return new TupleType(obj.elements?.map((t) => de.reviveType(t)) || []);
-        },
-        namedTupleMember(obj, de) {
-            return new NamedTupleMember(obj.name, obj.isOptional, de.reviveType(obj.element));
-        },
-        typeOperator(obj, de) {
-            return new TypeOperatorType(de.reviveType(obj.target), obj.operator);
-        },
-        union(obj, de) {
-            return new UnionType(obj.types.map((t) => de.reviveType(t)));
-        },
-        unknown(obj) {
-            return new UnknownType(obj.name);
-        },
-    };
-    /**
-     * Only set when deserializing.
-     */
-    projectRoot;
-    oldIdToNewId = {};
-    oldFileIdToNewFileId = {};
-    project;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    addDeserializer(de) {
-        insertPrioritySorted(this.deserializers, de);
-    }
-    /**
-     * Revive a single project into the structure it was originally created with.
-     * This is generally not appropriate for merging multiple projects since projects may
-     * contain reflections in their root, not inside a module.
-     */
-    reviveProject(name, projectObj, options) {
-        assert(this.deferred.length === 0, "Deserializer.defer was called when not deserializing");
-        if (!supportedSchemaVersions.includes(projectObj.schemaVersion)) {
-            throw new Error(`Attempted to deserialize version "${projectObj.schemaVersion}" JSON, which is not supported. Supported versions: ${supportedSchemaVersions.join(", ")}`);
-        }
-        const project = new ProjectReflection(name || projectObj.name, options.registry);
-        this.project = project;
-        this.projectRoot = options.projectRoot;
-        this.oldIdToNewId = { [projectObj.id]: project.id };
-        this.oldFileIdToNewFileId = {};
-        this.fromObject(project, projectObj);
-        const deferred = this.deferred;
-        this.deferred = [];
-        for (const def of deferred) {
-            def(project);
-        }
-        assert(this.deferred.length === 0, "Work may not be double deferred when deserializing.");
-        assert(this.activeReflection.length === 0, "Imbalanced reflection deserialization");
-        this.project = undefined;
-        this.projectRoot = undefined;
-        this.oldIdToNewId = {};
-        this.oldFileIdToNewFileId = {};
-        return project;
-    }
-    reviveProjects(name, projects, options) {
-        if (projects.length === 1 &&
-            !options.alwaysCreateEntryPointModule) {
-            return this.reviveProject(name, projects[0], options);
-        }
-        const project = new ProjectReflection(name, options.registry);
-        this.project = project;
-        this.projectRoot = options.projectRoot;
-        for (const proj of projects) {
-            assert(this.deferred.length === 0, "Deserializer.defer was called when not deserializing");
-            if (!supportedSchemaVersions.includes(proj.schemaVersion)) {
-                throw new Error(`Attempted to deserialize version "${proj.schemaVersion}" JSON, which is not supported. Supported versions: ${supportedSchemaVersions.join(", ")}`);
-            }
-            const projModule = new DeclarationReflection(proj.name, ReflectionKind.Module, project);
-            project.registerReflection(projModule, undefined, undefined);
-            project.addChild(projModule);
-            this.oldIdToNewId = { [proj.id]: projModule.id };
-            this.oldFileIdToNewFileId = {};
-            this.fromObject(projModule, proj);
-            const deferred = this.deferred;
-            this.deferred = [];
-            for (const def of deferred) {
-                def(project);
-            }
-            assert(this.deferred.length === 0, "Work may not be double deferred when deserializing.");
-            assert(this.activeReflection.length === 0, "Imbalanced reflection deserialization");
-        }
-        this.oldIdToNewId = {};
-        this.oldFileIdToNewFileId = {};
-        this.project = undefined;
-        this.projectRoot = undefined;
-        return project;
-    }
-    revive(source, creator) {
-        if (source) {
-            const revived = creator(source);
-            this.fromObject(revived, source);
-            return revived;
-        }
-    }
-    reviveMany(sourceArray, creator) {
-        if (sourceArray) {
-            return sourceArray.map((item) => {
-                const revived = creator(item);
-                this.fromObject(revived, item);
-                return revived;
-            });
-        }
-    }
-    reviveType(obj) {
-        return this.revive(obj, (o) => this.constructType(o));
-    }
-    constructReflection(obj) {
-        assert(this.activeReflection.length > 0);
-        const result = this.reflectionBuilders[obj.variant](this.activeReflection[this.activeReflection.length - 1], obj);
-        this.oldIdToNewId[obj.id] = result.id;
-        this.project.registerReflection(result, undefined, undefined);
-        return result;
-    }
-    constructType(obj) {
-        const result = this.typeBuilders[obj.type](obj, this);
-        return result;
-    }
-    fromObject(receiver, obj) {
-        if (receiver instanceof Reflection) {
-            this.activeReflection.push(receiver);
-        }
-        receiver.fromObject(this, obj);
-        for (const de of this.deserializers) {
-            if (de.supports(receiver, obj)) {
-                de.fromObject(receiver, obj);
-            }
-        }
-        if (receiver instanceof Reflection) {
-            this.activeReflection.pop();
-        }
-    }
-    /**
-     * Defers work until the initial pass of serialization has been completed.
-     * This can be used to set up references which cannot be immediately restored.
-     *
-     * May only be called when deserializing.
-     */
-    defer(cb) {
-        this.deferred.push(cb);
-    }
-}

package/dist/lib/serialization/events.js

@@ -1,18 +0,0 @@
-/**
- * An event emitted by the {@link Serializer} class at the very beginning and
- * ending of the a project serialization process.
- *
- * @see {@link Serializer.EVENT_BEGIN}
- * @see {@link Serializer.EVENT_END}
- */
-export class SerializeEvent {
-    /**
-     * The project the renderer is currently processing.
-     */
-    project;
-    output;
-    constructor(project, output) {
-        this.project = project;
-        this.output = output;
-    }
-}

package/dist/lib/serialization/index.js

@@ -1,4 +0,0 @@
-export { Deserializer } from "./deserializer.js";
-export { SerializeEvent } from "./events.js";
-export * as JSONOutput from "./schema.js";
-export { Serializer } from "./serializer.js";

package/dist/lib/serialization/schema.js

@@ -1,32 +0,0 @@
-/**
- * Contains interfaces which describe the JSON output. Each interface is related to a specific type of serializer.
- *
- * ## Plugins
- * Plugins which modify the serialization process can use declaration merging
- * to add custom properties to the exported interfaces.
- * For example, if your custom serializer adds a property to all {@link Reflection} objects:
- * ```ts
- * declare module 'typedoc/dist/lib/serialization/schema' {
- *     export interface AbstractReflection {
- *         myCustomProp: boolean
- *     }
- * }
- * ```
- *
- * If a plugin defines a new Model type, {@link ModelToObject} will not pick up the serializer type and
- * the resulting type will not be included in the return type of {@link Serializer.toObject}.
- * To fix this, use declaration merging to augment the {@link Serializer} class.
- * ```ts
- * declare module 'typedoc/dist/lib/serialization/serializer' {
- *     export interface Serializer {
- *         toObject(value: CustomModel, obj?: Partial<CustomModel>): CustomOutput
- *     }
- * }
- * ```
- *
- * For documentation on the JSON output properties, view the corresponding model.
- * @summary Contains interfaces which describe the JSON output.
- * @module
- */
-// Keep this in sync with JSON_SCHEMA_VERSION in ProjectReflection.ts
-export const SCHEMA_VERSION = "2.0";

package/dist/lib/serialization/serializer.js

@@ -1,65 +0,0 @@
-import { SerializeEvent } from "./events.js";
-import { EventDispatcher, insertPrioritySorted, removeIfPresent } from "#utils";
-/**
- * Serializes TypeDoc's models to JSON
- *
- * @group None
- * @summary Serializes TypeDoc's models to JSON
- */
-export class Serializer extends EventDispatcher {
-    /**
-     * Triggered when the {@link Serializer} begins transforming a project.
-     * @event
-     */
-    static EVENT_BEGIN = "begin";
-    /**
-     * Triggered when the {@link Serializer} has finished transforming a project.
-     * @event
-     */
-    static EVENT_END = "end";
-    serializers = [];
-    /**
-     * Only set when serializing.
-     */
-    projectRoot;
-    /**
-     * Only set when serializing
-     */
-    project;
-    addSerializer(serializer) {
-        insertPrioritySorted(this.serializers, serializer);
-    }
-    removeSerializer(serializer) {
-        removeIfPresent(this.serializers, serializer);
-    }
-    toObject(value) {
-        if (value === undefined) {
-            return undefined;
-        }
-        return this.serializers
-            .filter((s) => s.supports(value))
-            .reduce((val, s) => s.toObject(value, val, this), value.toObject(this));
-    }
-    toObjectsOptional(value) {
-        if (!value || value.length === 0) {
-            return undefined;
-        }
-        return value.map((val) => this.toObject(val));
-    }
-    /**
-     * Same as toObject but emits {@link Serializer.EVENT_BEGIN} and {@link Serializer.EVENT_END} events.
-     * @param value
-     */
-    projectToObject(value, projectRoot) {
-        this.projectRoot = projectRoot;
-        this.project = value;
-        const eventBegin = new SerializeEvent(value);
-        this.trigger(Serializer.EVENT_BEGIN, eventBegin);
-        const project = this.toObject(value);
-        const eventEnd = new SerializeEvent(value, project);
-        this.trigger(Serializer.EVENT_END, eventEnd);
-        this.project = undefined;
-        this.projectRoot = undefined;
-        return project;
-    }
-}

package/dist/lib/utils/ValidatingFileRegistry.js

@@ -1,52 +0,0 @@
-import { FileRegistry } from "../models/FileRegistry.js";
-import { i18n, NormalizedPathUtils } from "#utils";
-import { existsSync } from "fs";
-export class ValidatingFileRegistry extends FileRegistry {
-    basePath;
-    constructor(basePath = "") {
-        super();
-        this.basePath = basePath;
-    }
-    register(sourcePath, relativePath) {
-        let absolute = NormalizedPathUtils.resolve(NormalizedPathUtils.dirname(sourcePath), relativePath);
-        let absoluteWithoutAnchor = absolute.replace(/#.*/, "");
-        // Note: We allow paths to directories to be registered here, but the AssetsPlugin will not
-        // copy them to the output path. This is so that we can link to directories and associate them
-        // with reflections in packages mode.
-        if (!existsSync(absoluteWithoutAnchor)) {
-            // If the relative path didn't exist normally, also check the path relative to the assetBasePath option
-            if (this.basePath != "") {
-                absolute = NormalizedPathUtils.resolve(this.basePath, relativePath);
-                absoluteWithoutAnchor = absolute.replace(/#.*/, "");
-                if (!existsSync(absoluteWithoutAnchor)) {
-                    return;
-                }
-            }
-            else {
-                return;
-            }
-        }
-        return this.registerAbsolute(absolute);
-    }
-    fromObject(de, obj) {
-        for (const [key, val] of Object.entries(obj.entries)) {
-            const absolute = NormalizedPathUtils.resolve(de.projectRoot, val);
-            if (!existsSync(absolute)) {
-                de.logger.warn(i18n.saved_relative_path_0_resolved_from_1_does_not_exist(val, de.projectRoot));
-                continue;
-            }
-            de.oldFileIdToNewFileId[+key] = this.registerAbsolute(absolute).target;
-        }
-        de.defer((project) => {
-            for (const [media, reflId] of Object.entries(obj.reflections)) {
-                const refl = project.getReflectionById(de.oldIdToNewId[reflId]);
-                if (refl) {
-                    this.mediaToReflection.set(de.oldFileIdToNewFileId[+media], refl.id);
-                }
-                else {
-                    de.logger.warn(i18n.serialized_project_referenced_0_not_part_of_project(reflId.toString()));
-                }
-            }
-        });
-    }
-}

package/dist/lib/utils/component.js

@@ -1,41 +0,0 @@
-import { EventDispatcher } from "#utils";
-/**
- * Component base class.  Has an owner (unless it's the application root component),
- * can dispatch events to its children, and has access to the root Application component.
- *
- * @template O type of component's owner.
- */
-export class AbstractComponent extends EventDispatcher {
-    /**
-     * The owner of this component instance.
-     */
-    _componentOwner;
-    /**
-     * The name of this component as set by the `@Component` decorator.
-     */
-    componentName;
-    /**
-     * Create new Component instance.
-     */
-    constructor(owner) {
-        super();
-        this._componentOwner = owner;
-    }
-    /**
-     * Return the application / root component instance.
-     */
-    get application() {
-        if (this._componentOwner === null) {
-            return this;
-        }
-        return this._componentOwner.application;
-    }
-    /**
-     * Return the owner of this component.
-     */
-    get owner() {
-        return this._componentOwner === null
-            ? this
-            : this._componentOwner;
-    }
-}

package/dist/lib/utils/compress.js

@@ -1,13 +0,0 @@
-import { deflate } from "zlib";
-import { promisify } from "util";
-const deflateP = promisify(deflate);
-/**
- * Compresses a JSON-serializable object into a Base64-encoded deflate string.
- *
- * @param data - The JSON-serializable object to compress.
- * @returns A promise that resolves to a Base64-encoded string of the deflate-compressed data.
- */
-export async function compressJson(data) {
-    const gz = await deflateP(Buffer.from(JSON.stringify(data)));
-    return gz.toString("base64");
-}