@opra/common 0.33.13 → 1.0.0-alpha.10

package/esm/helpers/type-guards.js

@@ -1,48 +1,41 @@
 export function isConstructor(fn) {
-    return typeof fn === 'function' && fn.prototype &&
+    return (typeof fn === 'function' &&
+        fn.prototype &&
         fn.prototype.constructor === fn &&
         fn.prototype.constructor.name !== 'Function' &&
-        fn.prototype.constructor.name !== 'embedded';
+        fn.prototype.constructor.name !== 'embedded');
 }
-export function isStream(stream) {
-    return stream !== null
-        && typeof stream === 'object'
-        && typeof stream.pipe === 'function';
+export function isStream(x) {
+    return x !== null && typeof x === 'object' && typeof x.pipe === 'function';
 }
 export function isReadable(x) {
-    return isStream(x)
-        && typeof x._read === 'function'
-        && typeof x._readableState === 'object';
+    return isStream(x) && typeof x._read === 'function' && typeof x._readableState === 'object';
 }
 export function isWritable(x) {
-    return isStream(x)
-        && typeof x._write === 'function';
+    return isStream(x) && typeof x._write === 'function';
 }
 export function isReadableStream(x) {
-    return isStream(x)
-        && typeof x.getReader === 'function'
-        && typeof x.pipeThrough === 'function'
-        && typeof x.pipeTo === 'function';
+    return (isStream(x) &&
+        typeof x.getReader === 'function' &&
+        typeof x.pipeThrough === 'function' &&
+        typeof x.pipeTo === 'function');
 }
 export function isBlob(x) {
-    return x !== null
-        && typeof x === 'object'
-        && typeof x.size === 'number'
-        && typeof x.arrayBuffer === 'function'
-        && typeof x.stream === 'function';
+    return (x !== null &&
+        typeof x === 'object' &&
+        typeof x.size === 'number' &&
+        typeof x.arrayBuffer === 'function' &&
+        typeof x.stream === 'function');
 }
 export function isFormData(x) {
-    return x !== null
-        && typeof x.constructor === 'function'
-        && x.constructor.name === 'FormData'
-        && typeof x.append === 'function'
-        && typeof x.getAll === 'function';
+    return (x !== null &&
+        typeof x.constructor === 'function' &&
+        x.constructor.name === 'FormData' &&
+        typeof x.append === 'function' &&
+        typeof x.getAll === 'function');
 }
 export function isURL(x) {
-    return x !== null
-        && typeof x == 'object'
-        && typeof x.host === 'string'
-        && typeof x.href === 'string';
+    return x !== null && typeof x == 'object' && typeof x.host === 'string' && typeof x.href === 'string';
 }
 export function isIterable(x) {
     return Symbol.iterator in x;

package/esm/http/enums/http-status-messages.js

@@ -1,65 +1,65 @@
 export const HttpStatusMessages = {
-    "100": "Continue",
-    "101": "Switching Protocols",
-    "102": "Processing",
-    "103": "Early Hints",
-    "200": "OK",
-    "201": "Created",
-    "202": "Accepted",
-    "203": "Non-Authoritative Information",
-    "204": "No Content",
-    "205": "Reset Content",
-    "206": "Partial Content",
-    "207": "Multi-Status",
-    "208": "Already Reported",
-    "226": "IM Used",
-    "300": "Multiple Choices",
-    "301": "Moved Permanently",
-    "302": "Found",
-    "303": "See Other",
-    "304": "Not Modified",
-    "305": "Use Proxy",
-    "307": "Temporary Redirect",
-    "308": "Permanent Redirect",
-    "400": "Bad Request",
-    "401": "Unauthorized",
-    "402": "Payment Required",
-    "403": "Forbidden",
-    "404": "Not Found",
-    "405": "Method Not Allowed",
-    "406": "Not Acceptable",
-    "407": "Proxy Authentication Required",
-    "408": "Request Timeout",
-    "409": "Conflict",
-    "410": "Gone",
-    "411": "Length Required",
-    "412": "Precondition Failed",
-    "413": "Payload Too Large",
-    "414": "URI Too Long",
-    "415": "Unsupported Media Type",
-    "416": "Range Not Satisfiable",
-    "417": "Expectation Failed",
-    "418": "I'm a Teapot",
-    "421": "Misdirected Request",
-    "422": "Unprocessable Entity",
-    "423": "Locked",
-    "424": "Failed Dependency",
-    "425": "Too Early",
-    "426": "Upgrade Required",
-    "428": "Precondition Required",
-    "429": "Too Many Requests",
-    "431": "Request Header Fields Too Large",
-    "451": "Unavailable For Legal Reasons",
-    "500": "Internal Server Error",
-    "501": "Not Implemented",
-    "502": "Bad Gateway",
-    "503": "Service Unavailable",
-    "504": "Gateway Timeout",
-    "505": "HTTP Version Not Supported",
-    "506": "Variant Also Negotiates",
-    "507": "Insufficient Storage",
-    "508": "Loop Detected",
-    "509": "Bandwidth Limit Exceeded",
-    "510": "Not Extended",
-    "511": "Network Authentication Required"
+    '100': 'Continue',
+    '101': 'Switching Protocols',
+    '102': 'Processing',
+    '103': 'Early Hints',
+    '200': 'OK',
+    '201': 'Created',
+    '202': 'Accepted',
+    '203': 'Non-Authoritative Information',
+    '204': 'No Content',
+    '205': 'Reset Content',
+    '206': 'Partial Content',
+    '207': 'Multi-Status',
+    '208': 'Already Reported',
+    '226': 'IM Used',
+    '300': 'Multiple Choices',
+    '301': 'Moved Permanently',
+    '302': 'Found',
+    '303': 'See Other',
+    '304': 'Not Modified',
+    '305': 'Use Proxy',
+    '307': 'Temporary Redirect',
+    '308': 'Permanent Redirect',
+    '400': 'Bad Request',
+    '401': 'Unauthorized',
+    '402': 'Payment Required',
+    '403': 'Forbidden',
+    '404': 'Not Found',
+    '405': 'Method Not Allowed',
+    '406': 'Not Acceptable',
+    '407': 'Proxy Authentication Required',
+    '408': 'Request Timeout',
+    '409': 'Conflict',
+    '410': 'Gone',
+    '411': 'Length Required',
+    '412': 'Precondition Failed',
+    '413': 'Payload Too Large',
+    '414': 'URI Too Long',
+    '415': 'Unsupported Media Type',
+    '416': 'Range Not Satisfiable',
+    '417': 'Expectation Failed',
+    '418': "I'm a Teapot",
+    '421': 'Misdirected Request',
+    '422': 'Unprocessable Entity',
+    '423': 'Locked',
+    '424': 'Failed Dependency',
+    '425': 'Too Early',
+    '426': 'Upgrade Required',
+    '428': 'Precondition Required',
+    '429': 'Too Many Requests',
+    '431': 'Request Header Fields Too Large',
+    '451': 'Unavailable For Legal Reasons',
+    '500': 'Internal Server Error',
+    '501': 'Not Implemented',
+    '502': 'Bad Gateway',
+    '503': 'Service Unavailable',
+    '504': 'Gateway Timeout',
+    '505': 'HTTP Version Not Supported',
+    '506': 'Variant Also Negotiates',
+    '507': 'Insufficient Storage',
+    '508': 'Loop Detected',
+    '509': 'Bandwidth Limit Exceeded',
+    '510': 'Not Extended',
+    '511': 'Network Authentication Required',
 };

package/esm/http/enums/mime-types.enum.js

@@ -0,0 +1,14 @@
+// noinspection JSUnusedGlobalSymbols
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#successful_responses
+ */
+export var MimeTypes;
+(function (MimeTypes) {
+    MimeTypes["json"] = "application/json";
+    MimeTypes["opra_response_json"] = "application/opra.response+json";
+    MimeTypes["xml"] = "application/XML";
+    MimeTypes["text"] = "text/plain";
+    MimeTypes["html"] = "text/html";
+    MimeTypes["markdown"] = "text/markdown";
+    MimeTypes["binary"] = "binary/octet-stream";
+})(MimeTypes || (MimeTypes = {}));

package/esm/http/index.js

@@ -1,5 +1,4 @@
-export * from './opra-url.js';
-export * from './opra-url-path.js';
 export * from './enums/http-headers-codes.enum.js';
 export * from './enums/http-status-codes.enum.js';
 export * from './enums/http-status-messages.js';
+export * from './enums/mime-types.enum.js';

package/esm/i18n/i18n.js

@@ -1,5 +1,5 @@
-import { splitString, tokenize } from 'fast-tokenizer';
 import i18next from '@browsery/i18next';
+import { splitString, tokenize } from 'fast-tokenizer';
 import { unescapeString } from './string-utils.js';
 export const BaseI18n = Object.getPrototypeOf(i18next.createInstance()).constructor;
 export class I18n extends BaseI18n {
@@ -38,7 +38,7 @@ export class I18n extends BaseI18n {
         const objectStack = new WeakMap();
         return this._deepTranslate(input, objectStack, options);
     }
-    createInstance(options = {}, callback) {
+    createInstance(options, callback) {
         return new I18n(options, callback);
     }
     static createInstance(options, callback) {
@@ -75,9 +75,9 @@ export class I18n extends BaseI18n {
                         keys.push(token2);
                     }
                     const k = keys.length > 1 ? '$t(' + keys.join(',') + ')' : keys[0];
-                    s += (fallback
+                    s += fallback
                         ? this.t(k, fallback, { ...options, ...opts })
-                        : this.t(k, { ...options, ...opts }));
+                        : this.t(k, { ...options, ...opts });
                     continue;
                 }
                 s += token;
@@ -96,10 +96,15 @@ export class I18n extends BaseI18n {
         if (typeof input === 'object') {
             if (Buffer.isBuffer(input))
                 return input;
-            if (Buffer.isBuffer(input) || input instanceof Symbol ||
-                input instanceof RegExp || input instanceof Map || input instanceof Set ||
-                input instanceof WeakMap || input instanceof WeakSet)
+            if (Buffer.isBuffer(input) ||
+                input instanceof Symbol ||
+                input instanceof RegExp ||
+                input instanceof Map ||
+                input instanceof Set ||
+                input instanceof WeakMap ||
+                input instanceof WeakSet) {
                 return input;
+            }
             const out = {};
             objectStack.set(input, out);
             const keys = Object.keys(input);

package/esm/i18n/index.js

@@ -2,5 +2,5 @@ import { I18n } from './i18n.js';
 export * from './i18n.js';
 export * from './translate.js';
 const i18n = I18n.createInstance();
-i18n.init().catch(() => void 0);
+i18n.init().catch(() => undefined);
 export { i18n };

package/esm/i18n/translate.js

@@ -3,9 +3,9 @@ const bracketRegEx = /(\))/g;
 export function translate(key, arg0, arg1) {
     const options = arg0 && typeof arg0 === 'object' ? arg0 : undefined;
     const fallback = typeof arg0 === 'string' ? arg0 : arg1;
-    return '$t(' +
+    return ('$t(' +
         key +
         (options ? ',' + JSON.stringify(options) : '') +
         (fallback ? '?' + escapeString(fallback).replace(bracketRegEx, '\\$1') : '') +
-        ')';
+        ')');
 }

package/esm/index.js

@@ -1,9 +1,9 @@
-export * from './types.js';
 export * from './document/index.js';
 export * from './exception/index.js';
-export * from './filter/index.js'; // todo  review
+export * from './filter/index.js';
 export * from './helpers/index.js';
 export * from './http/index.js';
 export * from './i18n/index.js';
 export * from './schema/index.js';
+export * from './types.js';
 export { uid } from 'uid';

package/esm/schema/http/http-controller.interface.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @namespace HttpController
+ */
+export var HttpController;
+(function (HttpController) {
+    HttpController.Kind = 'HttpController';
+})(HttpController || (HttpController = {}));

package/esm/schema/http/http-operation.interface.js

@@ -0,0 +1,4 @@
+export var HttpOperation;
+(function (HttpOperation) {
+    HttpOperation.Kind = 'HttpOperation';
+})(HttpOperation || (HttpOperation = {}));

package/esm/schema/index.js

@@ -1,2 +1,27 @@
-import * as OpraSchema from './opra-schema.ns.js';
-export { OpraSchema };
+import * as constants_ from './constants.js';
+import * as complexType_ from './data-type/complex-type.interface.js';
+import * as enumType_ from './data-type/enum-type.interface.js';
+import * as mappedType_ from './data-type/mapped-type.interface.js';
+import * as mixinType_ from './data-type/mixin-type.interface.js';
+import * as simpleType_ from './data-type/simple-type.interface.js';
+import * as controller_ from './http/http-controller.interface.js';
+import * as operation_ from './http/http-operation.interface.js';
+import * as typeGuards_ from './type-guards.js';
+export var OpraSchema;
+(function (OpraSchema) {
+    OpraSchema.SpecVersion = constants_.SpecVersion;
+    OpraSchema.ComplexType = complexType_.ComplexType;
+    OpraSchema.EnumType = enumType_.EnumType;
+    OpraSchema.MappedType = mappedType_.MappedType;
+    OpraSchema.MixinType = mixinType_.MixinType;
+    OpraSchema.SimpleType = simpleType_.SimpleType;
+    OpraSchema.HttpController = controller_.HttpController;
+    OpraSchema.HttpOperation = operation_.HttpOperation;
+    OpraSchema.isComplexType = typeGuards_.isComplexType;
+    OpraSchema.isDataType = typeGuards_.isDataType;
+    OpraSchema.isSimpleType = typeGuards_.isSimpleType;
+    OpraSchema.isMixinType = typeGuards_.isMixinType;
+    OpraSchema.isMappedType = typeGuards_.isMappedType;
+    OpraSchema.isEnumType = typeGuards_.isEnumType;
+    OpraSchema.isHttpController = typeGuards_.isHttpController;
+})(OpraSchema || (OpraSchema = {}));

package/esm/schema/type-guards.js

@@ -3,17 +3,15 @@ import { EnumType } from './data-type/enum-type.interface.js';
 import { MappedType } from './data-type/mapped-type.interface.js';
 import { MixinType } from './data-type/mixin-type.interface.js';
 import { SimpleType } from './data-type/simple-type.interface.js';
-import { Collection } from './resource/collection.interface.js';
-import { Container } from './resource/container.interface.js';
-import { Singleton } from './resource/singleton.interface.js';
-import { Storage } from './resource/storage.interface.js';
+import { HttpController } from './http/http-controller.interface.js';
 export function isDataType(obj) {
-    return obj && typeof obj === 'object' &&
+    return (obj &&
+        typeof obj === 'object' &&
         (obj.kind === ComplexType.Kind ||
             obj.kind === EnumType.Kind ||
             obj.kind === MappedType.Kind ||
             obj.kind === SimpleType.Kind ||
-            obj.kind === MixinType.Kind);
+            obj.kind === MixinType.Kind));
 }
 export function isComplexType(obj) {
     return obj && typeof obj === 'object' && obj.kind === ComplexType.Kind;
@@ -30,22 +28,6 @@ export function isMappedType(obj) {
 export function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === EnumType.Kind;
 }
-export function isResource(obj) {
-    return obj && typeof obj === 'object' &&
-        (obj.kind === Container.Kind ||
-            obj.kind === Collection.Kind ||
-            obj.kind === Singleton.Kind ||
-            obj.kind === Storage.Kind);
-}
-export function isCollection(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Collection.Kind;
-}
-export function isSingleton(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Singleton.Kind;
-}
-export function isStorage(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Storage.Kind;
-}
-export function isContainer(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Container.Kind;
+export function isHttpController(obj) {
+    return obj && typeof obj === 'object' && obj.kind === HttpController.Kind;
 }

package/esm/schema/value.interface.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.10",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -23,9 +23,11 @@
     "build:browser": "node esbuild.mjs",
     "postbuild": "cp package.json ../../LICENSE ../../build/common && cp ../../package.cjs.json ../../build/common/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
+    "lint:fix": "eslint . --max-warnings=0 --fix",
+    "format": "prettier . --write --log-level=warn",
     "check": "madge --circular src/**",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
+    "test": "jest --passWithNoTests",
+    "cover": "jest --passWithNoTests --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all",
     "clean:test": "ts-cleanup -s test --all",
@@ -34,29 +36,29 @@
     "antlr4": "java -jar ./tools/antlr4-4.12.1-SNAPSHOT-complete.jar -Dlanguage=TypeScript ./src/filter/antlr/OpraFilter.g4 -visitor"
   },
   "dependencies": {
-    "@browsery/antlr4": "^0.9.0",
-    "@browsery/highland": "^0.6.0",
-    "@browsery/http-parser": "^0.4.0",
-    "@browsery/i18next": "^0.7.2",
-    "fast-tokenizer": "^1.2.2",
+    "@browsery/antlr4": "^4.13.1-patch-1",
+    "@browsery/highland": "^2.13.5",
+    "@browsery/http-parser": "^0.5.8",
+    "@browsery/i18next": "^23.11.5",
+    "fast-tokenizer": "^1.3.0",
     "lodash.omit": "^4.5.0",
     "putil-isplainobject": "^1.1.5",
     "putil-merge": "^3.12.1",
     "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.6.5",
-    "reflect-metadata": "^0.1.14",
+    "reflect-metadata": "^0.2.2",
     "uid": "^2.0.1",
-    "valgen": "^5.2.0"
+    "valgen": "^5.4.1"
   },
   "devDependencies": {
     "@browsery/fs": "^0.4.0",
-    "@browsery/stream": "^0.6.0",
-    "@browsery/util": "^0.4.0",
+    "@browsery/stream": "^4.3.0",
+    "@browsery/util": "^0.12.5",
     "@types/encodeurl": "^1.0.2",
     "@types/lodash.omit": "^4.5.9",
-    "@types/validator": "^13.11.8",
+    "@types/validator": "^13.12.0",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^3.1.1"
+    "ts-gems": "^3.4.0"
   },
   "engines": {
     "node": ">=16.0",
@@ -76,4 +78,4 @@
     "opra",
     "common"
   ]
-}
+}

package/types/document/api-document.d.ts

@@ -1,58 +1,35 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../helpers/index.js';
 import { OpraSchema } from '../schema/index.js';
-import type { Collection } from './resource/collection.js';
-import { Container } from './resource/container.js';
-import type { Resource } from './resource/resource.js';
-import type { Singleton } from './resource/singleton.js';
-import type { Storage } from './resource/storage.js';
-import { TypeDocument } from './type-document.js';
-export declare class ApiDocument extends TypeDocument {
-    root: Container;
+import { DataTypeMap } from './common/data-type-map.js';
+import { DocumentElement } from './common/document-element.js';
+import { kTypeNSMap } from './constants.js';
+import { DataType } from './data-type/data-type.js';
+import type { EnumType } from './data-type/enum-type.js';
+import type { HttpApi } from './http/http-api.js';
+/**
+ *
+ * @class ApiDocument
+ */
+export declare class ApiDocument extends DocumentElement {
+    protected [kTypeNSMap]: WeakMap<DataType, string>;
+    readonly id: string;
+    url?: string;
+    info: OpraSchema.DocumentInfo;
+    references: ResponsiveMap<ApiDocument>;
+    types: DataTypeMap;
+    api?: HttpApi;
+    constructor();
     /**
-     * Returns Resource instance by path. Returns undefined if not found
+     * Returns NS of datatype. Returns undefined if not found
+     * @param nameOrCtor
      */
-    getResource(path: string): Resource;
-    getResource(path: string, silent: false): Resource;
-    getResource(path: string, silent: true): Resource | undefined;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getContainer(path: string): Container;
-    getContainer(path: string, silent: false): Container;
-    getContainer(path: string, silent: true): Container | undefined;
-    getContainer(path: string, silent?: boolean): Container | undefined;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getCollection(path: string): Collection;
-    getCollection(path: string, silent: false): Collection;
-    getCollection(path: string, silent: true): Collection | undefined;
-    getCollection(path: string, silent?: boolean): Collection | undefined;
-    /**
-     * Returns Singleton resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getSingleton(path: string): Singleton;
-    getSingleton(path: string, silent: false): Singleton;
-    getSingleton(path: string, silent: true): Singleton | undefined;
-    getSingleton(path: string, silent?: boolean): Singleton | undefined;
-    /**
-     * Returns Storage resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getStorage(path: string): Storage;
-    getStorage(path: string, silent: false): Storage;
-    getStorage(path: string, silent: true): Storage | undefined;
-    getStorage(path: string, silent?: boolean): Storage | undefined;
+    getDataTypeNs(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject | DataType): string | undefined;
+    findDocument(id: string): ApiDocument | undefined;
+    toJSON(): OpraSchema.ApiDocument;
     /**
      * Export as Opra schema definition object
      */
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.ApiDocument;
+    export(): OpraSchema.ApiDocument;
+    protected _findDataType(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject, visitedRefs?: WeakMap<ApiDocument, boolean>): DataType | undefined;
 }

package/types/document/common/api-base.d.ts

@@ -0,0 +1,17 @@
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
+import { DocumentElement } from './document-element.js';
+import type { DocumentInitContext } from './document-init-context';
+export declare namespace ApiBase {
+    interface InitArguments extends Pick<OpraSchema.Api, 'description' | 'name'> {
+    }
+}
+export declare abstract class ApiBase extends DocumentElement {
+    readonly owner: ApiDocument | ApiBase;
+    abstract readonly protocol: OpraSchema.Protocol;
+    name: string;
+    description?: string;
+    protected constructor(owner: ApiDocument | ApiBase);
+    toJSON(): OpraSchema.Api;
+    protected _initialize(init: ApiBase.InitArguments, context: DocumentInitContext): Promise<void>;
+}

package/types/document/common/data-type-map.d.ts

@@ -0,0 +1,23 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { DataType } from '../data-type/data-type.js';
+declare const kMap: unique symbol;
+declare const kCtorMap: unique symbol;
+/**
+ * @class DataTypeMap
+ */
+export declare class DataTypeMap {
+    protected [kMap]: ResponsiveMap<DataType>;
+    protected [kCtorMap]: WeakMap<object | Function | Type<any>, string>;
+    get size(): number;
+    forEach(callbackFn: (value: DataType, key: string, map: ReadonlyMap<string, DataType>) => void, thisArg?: any): void;
+    get(nameOrCtor: string | Type | Function | object): DataType | undefined;
+    set(name: string, dataType: DataType): void;
+    has(nameOrCtor: string | Type | Function | object | DataType): boolean;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<DataType>;
+    entries(): IterableIterator<[string, DataType]>;
+    sort(compareFn?: (a: string, b: string) => number): this;
+    [Symbol.iterator](): IterableIterator<[string, DataType]>;
+}
+export {};

package/types/document/common/document-element.d.ts

@@ -0,0 +1,23 @@
+import { DocumentNode } from './document-node.js';
+interface DocumentElementConstructor {
+    new (owner?: DocumentElement): DocumentElement;
+    prototype: DocumentElement;
+}
+/**
+ * @class DocumentElement
+ */
+export interface DocumentElement extends DocumentElementClass {
+}
+/**
+ *
+ * @constructor DocumentElement
+ */
+export declare const DocumentElement: DocumentElementConstructor;
+/**
+ * @class DocumentElement
+ */
+declare abstract class DocumentElementClass {
+    readonly owner?: DocumentElement;
+    readonly node: DocumentNode;
+}
+export {};