@open-audio-stack/core 0.0.1

package/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/README.md

@@ -0,0 +1,43 @@
+# open-audio-stack-core
+
+Open-source audio plugin management software using:
+
+- NodeJS 20.x
+- TypeScript 5.x
+- eslint 9.x
+- prettier 3.x
+- vitest 1.x
+
+## Installation
+
+Install dependencies using:
+
+    npm install
+
+## Usage
+
+Run dev commands using:
+
+    npm run lint
+    npm run format
+    npm run dev
+    npm test
+
+Create a build using:
+
+    npm run build
+
+## Deployment
+
+This package is versioned using git tags:
+
+    npm version patch
+    git push && git push origin --tags
+
+GitHub Actions will automatically publish the package to npm:
+
+    https://www.npmjs.com/package/@open-audio-stack/core
+
+## Contact
+
+For more information please contact kmturley

package/build/Config.d.ts

@@ -0,0 +1,39 @@
+import { Architecture } from './types/Architecture.js';
+import { ConfigInterface } from './types/Config.js';
+import { FileFormat } from './types/FileFormat.js';
+import { FileType } from './types/FileType.js';
+import { License } from './types/License.js';
+import { PluginFormat } from './types/PluginFormat.js';
+import { PluginType } from './types/PluginType.js';
+import { PresetFormat } from './types/PresetFormat.js';
+import { PresetType } from './types/PresetType.js';
+import { ProjectFormat } from './types/ProjectFormat.js';
+import { ProjectType } from './types/ProjectType.js';
+import { SystemType } from './types/SystemType.js';
+export default class Config {
+    config: ConfigInterface;
+    constructor(config: ConfigInterface);
+    get(): ConfigInterface;
+    architecture(type: Architecture): import("./types/Architecture.js").ArchitectureOption;
+    architectures(): import("./types/Architecture.js").ArchitectureOption[];
+    fileFormat(format: FileFormat): import("./types/FileFormat.js").FileFormatOption;
+    fileFormats(): import("./types/FileFormat.js").FileFormatOption[];
+    fileType(type: FileType): import("./types/FileType.js").FileTypeOption;
+    fileTypes(): import("./types/FileType.js").FileTypeOption[];
+    license(type: License): import("./types/License.js").LicenseOption;
+    licenses(): import("./types/License.js").LicenseOption[];
+    pluginFormat(format: PluginFormat): import("./types/PluginFormat.js").PluginFormatOption;
+    pluginFormats(): import("./types/PluginFormat.js").PluginFormatOption[];
+    pluginType(type: PluginType): import("./types/PluginType.js").PluginTypeOption;
+    pluginTypes(): import("./types/PluginType.js").PluginTypeOption[];
+    presetFormat(format: PresetFormat): import("./types/PresetFormat.js").PresetFormatOption;
+    presetFormats(): import("./types/PresetFormat.js").PresetFormatOption[];
+    presetType(type: PresetType): import("./types/PresetType.js").PresetTypeOption;
+    presetTypes(): import("./types/PresetType.js").PresetTypeOption[];
+    projectFormat(format: ProjectFormat): import("./types/ProjectFormat.js").ProjectFormatOption;
+    projectFormats(): import("./types/ProjectFormat.js").ProjectFormatOption[];
+    projectType(type: ProjectType): import("./types/ProjectType.js").ProjectTypeOption;
+    projectTypes(): import("./types/ProjectType.js").ProjectTypeOption[];
+    system(type: SystemType): import("./types/SystemType.js").SystemTypeOption;
+    systems(): import("./types/SystemType.js").SystemTypeOption[];
+}

package/build/Config.js

@@ -0,0 +1,93 @@
+import { architectures } from './types/Architecture.js';
+import { fileFormats } from './types/FileFormat.js';
+import { fileTypes } from './types/FileType.js';
+import { licenses } from './types/License.js';
+import { pluginFormats } from './types/PluginFormat.js';
+import { pluginTypes } from './types/PluginType.js';
+import { presetFormats } from './types/PresetFormat.js';
+import { presetTypes } from './types/PresetType.js';
+import { projectFormats } from './types/ProjectFormat.js';
+import { projectTypes } from './types/ProjectType.js';
+import { systemTypes } from './types/SystemType.js';
+export default class Config {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    get() {
+        return this.config;
+    }
+    // Architectures.
+    architecture(type) {
+        return architectures.filter(architecture => type === architecture.value)[0];
+    }
+    architectures() {
+        return architectures;
+    }
+    // File formats and types.
+    fileFormat(format) {
+        return fileFormats.filter(fileFormat => format === fileFormat.value)[0];
+    }
+    fileFormats() {
+        return fileFormats;
+    }
+    fileType(type) {
+        return fileTypes.filter(fileType => type === fileType.value)[0];
+    }
+    fileTypes() {
+        return fileTypes;
+    }
+    // Licenses
+    license(type) {
+        return licenses.filter(license => type === license.value)[0];
+    }
+    licenses() {
+        return licenses;
+    }
+    // Plugin formats and types.
+    pluginFormat(format) {
+        return pluginFormats.filter(pluginFormat => format === pluginFormat.value)[0];
+    }
+    pluginFormats() {
+        return pluginFormats;
+    }
+    pluginType(type) {
+        return pluginTypes.filter(pluginType => type === pluginType.value)[0];
+    }
+    pluginTypes() {
+        return pluginTypes;
+    }
+    // Preset formats and types.
+    presetFormat(format) {
+        return presetFormats.filter(presetFormat => format === presetFormat.value)[0];
+    }
+    presetFormats() {
+        return presetFormats;
+    }
+    presetType(type) {
+        return presetTypes.filter(presetType => type === presetType.value)[0];
+    }
+    presetTypes() {
+        return presetTypes;
+    }
+    // Project formats and types.
+    projectFormat(format) {
+        return projectFormats.filter(projectFormat => format === projectFormat.value)[0];
+    }
+    projectFormats() {
+        return projectFormats;
+    }
+    projectType(type) {
+        return projectTypes.filter(projectType => type === projectType.value)[0];
+    }
+    projectTypes() {
+        return projectTypes;
+    }
+    // Systems.
+    system(type) {
+        return systemTypes.filter(system => type === system.value)[0];
+    }
+    systems() {
+        return systemTypes;
+    }
+}

package/build/FileSystem.d.ts

@@ -0,0 +1,33 @@
+import { PackageInterface } from '../src/types/Package.js';
+export default class FileSystem {
+    constructor();
+    dirApp(): string;
+    dirCreate(dir: string): string | false;
+    dirDelete(dir: string): false | void;
+    dirEmpty(dir: string): boolean;
+    dirExists(dir: string): boolean;
+    dirIs(dir: string): boolean;
+    dirMove(dir: string, dirNew: string): void | boolean;
+    dirOpen(dir: string): Buffer;
+    dirPackage(pkg: PackageInterface): string;
+    dirPlugins(): string;
+    dirPresets(): string;
+    dirProjects(): string;
+    dirRead(dir: string, options?: any): string[];
+    dirRename(dir: string, dirNew: string): void | boolean;
+    fileCreate(filePath: string, data: string | Buffer): void;
+    fileDate(filePath: string): Date;
+    fileDelete(filePath: string): boolean | void;
+    fileExec(filePath: string): void;
+    fileExists(filePath: string): boolean;
+    fileJsonCreate(filePath: string, data: object): void;
+    fileMove(filePath: string, newPath: string): void | boolean;
+    fileOpen(filePath: string): Buffer;
+    fileRead(filePath: string): Buffer;
+    fileReadJson(filePath: string): any;
+    fileReadString(filePath: string): string;
+    fileReadYaml(filePath: string): unknown;
+    fileSize(filePath: string): number;
+    zipCreate(filesPath: string, zipPath: string): void;
+    zipExtract(content: any, dirPath: string): void;
+}

package/build/FileSystem.js

@@ -0,0 +1,201 @@
+import AdmZip from 'adm-zip';
+import { execSync } from 'child_process';
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'fs';
+import { globSync } from 'glob';
+import { moveSync } from 'fs-extra/esm';
+import os from 'os';
+import path from 'path';
+import yaml from 'js-yaml';
+export default class FileSystem {
+    constructor() { }
+    dirApp() {
+        if (process.platform === 'win32')
+            return process.env.APPDATA || os.homedir();
+        else if (process.platform === 'darwin')
+            return path.join(os.homedir(), 'Library', 'Preferences');
+        return path.join(os.homedir(), '.local', 'share');
+    }
+    dirCreate(dir) {
+        if (!this.dirExists(dir)) {
+            console.log('+', dir);
+            mkdirSync(dir, { recursive: true });
+            return dir;
+        }
+        return false;
+    }
+    dirDelete(dir) {
+        if (this.dirExists(dir)) {
+            console.log('-', dir);
+            return rmSync(dir, { recursive: true });
+        }
+        return false;
+    }
+    dirEmpty(dir) {
+        const files = readdirSync(dir);
+        return files.length === 0 || (files.length === 1 && files[0] === '.DS_Store');
+    }
+    dirExists(dir) {
+        return existsSync(dir);
+    }
+    dirIs(dir) {
+        return statSync(dir).isDirectory();
+    }
+    dirMove(dir, dirNew) {
+        if (this.dirExists(dir)) {
+            console.log('-', dir);
+            console.log('+', dirNew);
+            return moveSync(dir, dirNew, { overwrite: true });
+        }
+        return false;
+    }
+    dirOpen(dir) {
+        let command = '';
+        if (process.env.CI)
+            return new Buffer('');
+        if (process.platform === 'win32')
+            command = 'open';
+        else if (process.platform === 'darwin')
+            command = 'start ""';
+        else
+            command = 'xdg-open';
+        console.log('⎋', `${command} "${dir}"`);
+        return execSync(`${command} "${dir}"`);
+    }
+    dirPackage(pkg) {
+        const parts = pkg.slug.split('/');
+        parts.push(pkg.version);
+        return path.join(...parts);
+    }
+    dirPlugins() {
+        if (process.platform === 'win32')
+            return path.join('Program Files', 'Common Files');
+        else if (process.platform === 'darwin')
+            return path.join(os.homedir(), 'Library', 'Audio', 'Plug-ins');
+        return path.join('usr', 'local', 'lib');
+    }
+    dirPresets() {
+        if (process.platform === 'win32')
+            return path.join(os.homedir(), 'Documents', 'VST3 Presets');
+        else if (process.platform === 'darwin')
+            return path.join(os.homedir(), 'Library', 'Audio', 'Presets');
+        return path.join(os.homedir(), '.vst3', 'presets');
+    }
+    dirProjects() {
+        // Windows throws permissions errors if you scan hidden folders
+        // Therefore set to a more specific path than Documents
+        if (process.platform === 'win32')
+            return path.join(os.homedir(), 'Documents', 'Audio');
+        else if (process.platform === 'darwin')
+            return path.join(os.homedir(), 'Documents', 'Audio');
+        return path.join(os.homedir(), 'Documents', 'Audio');
+    }
+    dirRead(dir, options) {
+        console.log('⌕', dir);
+        // Glob now expects forward slashes on Windows
+        // Convert backslashes from path.join() to forwardslashes
+        if (process.platform === 'win32') {
+            dir = dir.replace(/\\/g, '/');
+        }
+        return globSync(dir, options);
+    }
+    dirRename(dir, dirNew) {
+        if (this.dirExists(dir)) {
+            return moveSync(dir, dirNew, { overwrite: true });
+        }
+        return false;
+    }
+    fileCreate(filePath, data) {
+        console.log('+', filePath);
+        return writeFileSync(filePath, data);
+    }
+    fileDate(filePath) {
+        return statSync(filePath).mtime;
+    }
+    fileDelete(filePath) {
+        if (this.fileExists(filePath)) {
+            console.log('-', filePath);
+            return unlinkSync(filePath);
+        }
+        return false;
+    }
+    fileExec(filePath) {
+        return chmodSync(filePath, '755');
+    }
+    fileExists(filePath) {
+        return existsSync(filePath);
+    }
+    fileJsonCreate(filePath, data) {
+        return this.fileCreate(filePath, JSON.stringify(data, null, 2));
+    }
+    fileMove(filePath, newPath) {
+        if (this.fileExists(filePath)) {
+            console.log('-', filePath);
+            console.log('+', newPath);
+            return moveSync(filePath, newPath, { overwrite: true });
+        }
+        return false;
+    }
+    fileOpen(filePath) {
+        let command = '';
+        if (process.env.CI)
+            return new Buffer('');
+        if (process.platform === 'win32')
+            command = 'open';
+        else if (process.platform === 'darwin')
+            command = 'start ""';
+        else
+            command = 'xdg-open';
+        console.log('⎋', `${command} "${filePath}"`);
+        return execSync(`${command} "${filePath}"`);
+    }
+    fileRead(filePath) {
+        console.log('⎋', filePath);
+        return readFileSync(filePath);
+    }
+    fileReadJson(filePath) {
+        if (this.fileExists(filePath)) {
+            console.log('⎋', filePath);
+            return JSON.parse(readFileSync(filePath).toString());
+        }
+        return false;
+    }
+    fileReadString(filePath) {
+        console.log('⎋', filePath);
+        return readFileSync(filePath).toString();
+    }
+    fileReadYaml(filePath) {
+        const file = this.fileReadString(filePath);
+        return yaml.load(file);
+    }
+    fileSize(filePath) {
+        return statSync(filePath).size;
+    }
+    zipCreate(filesPath, zipPath) {
+        if (this.fileExists(zipPath)) {
+            unlinkSync(zipPath);
+        }
+        const zip = new AdmZip();
+        const pathList = this.dirRead(filesPath);
+        pathList.forEach(pathItem => {
+            console.log('⎋', pathItem);
+            try {
+                if (this.dirIs(pathItem)) {
+                    zip.addLocalFolder(pathItem, path.basename(pathItem));
+                }
+                else {
+                    zip.addLocalFile(pathItem);
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+        });
+        console.log('+', zipPath);
+        return zip.writeZip(zipPath);
+    }
+    zipExtract(content, dirPath) {
+        console.log('⎋', dirPath);
+        const zip = new AdmZip(content);
+        return zip.extractAllTo(dirPath);
+    }
+}

package/build/Registry.d.ts

@@ -0,0 +1,22 @@
+import { PackageInterface, PackageValidationError, PackageVersions, PackageVersionType } from './types/Package.js';
+import { RegistryInterface } from './types/Registry.js';
+export default class Registry {
+    registry: RegistryInterface;
+    constructor(registry: RegistryInterface);
+    packageAdd(slug: string): {
+        slug: string;
+        version: string;
+        versions: {};
+    };
+    packageVersionAdd(slug: string, version: string, pkgVersion: PackageVersionType): void;
+    package(slug: string): PackageInterface;
+    packages(): import("./types/Registry.js").RegistryPackages;
+    packageVersionLatest(versions: PackageVersions): string;
+    get(): RegistryInterface;
+    name(): string;
+    url(): string;
+    version(): string;
+    packageRemove(slug: string): void;
+    packageVersionRemove(slug: string, version: string): void;
+    packageVersionValidate(pkgVersion: PackageVersionType): PackageValidationError[];
+}

package/build/Registry.js

@@ -0,0 +1,98 @@
+import * as semver from 'semver';
+import { PackageValidation, } from './types/Package.js';
+export default class Registry {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    packageAdd(slug) {
+        return (this.registry.packages[slug] = {
+            slug,
+            version: '',
+            versions: {},
+        });
+    }
+    packageVersionAdd(slug, version, pkgVersion) {
+        let pkg = this.package(slug);
+        if (!pkg) {
+            pkg = this.packageAdd(slug);
+        }
+        pkg.versions[version] = pkgVersion;
+        pkg.version = this.packageVersionLatest(pkg.versions);
+    }
+    package(slug) {
+        return this.registry.packages[slug];
+    }
+    packages() {
+        return this.registry.packages;
+    }
+    packageVersionLatest(versions) {
+        let latest = '0.0.0';
+        Object.keys(versions).forEach((version) => {
+            if (semver.gt(version, latest)) {
+                latest = version;
+            }
+        });
+        return latest;
+    }
+    get() {
+        return this.registry;
+    }
+    name() {
+        return this.registry.name;
+    }
+    url() {
+        return this.registry.url;
+    }
+    version() {
+        return this.registry.version;
+    }
+    packageRemove(slug) {
+        delete this.registry.packages[slug];
+    }
+    packageVersionRemove(slug, version) {
+        const pkg = this.package(slug);
+        if (pkg && pkg.versions[version]) {
+            delete pkg.versions[version];
+            pkg.version = this.packageVersionLatest(pkg.versions);
+        }
+        if (!Object.keys(pkg.versions).length) {
+            this.packageRemove(slug);
+        }
+    }
+    packageVersionValidate(pkgVersion) {
+        const fields = [
+            { name: 'author', type: 'string' },
+            { name: 'changes', type: 'string' },
+            { name: 'date', type: 'string' },
+            { name: 'description', type: 'string' },
+            { name: 'files', type: 'object' },
+            { name: 'license', type: 'string' },
+            { name: 'name', type: 'string' },
+            { name: 'tags', type: 'object' },
+            { name: 'type', type: 'string' },
+            { name: 'url', type: 'string' },
+        ];
+        const errors = [];
+        fields.forEach((field) => {
+            const versionField = pkgVersion[field.name];
+            if (!versionField) {
+                errors.push({
+                    field: field.name,
+                    error: PackageValidation.MISSING_FIELD,
+                    valueExpected: field.type,
+                    valueReceived: 'undefined',
+                });
+            }
+            else if (typeof versionField !== field.type) {
+                errors.push({
+                    field: field.name,
+                    error: PackageValidation.INVALID_TYPE,
+                    valueExpected: field.type,
+                    valueReceived: typeof versionField,
+                });
+            }
+        });
+        return errors;
+    }
+}

package/build/index-browser.d.ts

@@ -0,0 +1,21 @@
+export * from './Config.js';
+export * from './Registry.js';
+export * from './types/Architecture.js';
+export * from './types/Config.js';
+export * from './types/File.js';
+export * from './types/FileFormat.js';
+export * from './types/FileType.js';
+export * from './types/License.js';
+export * from './types/Package.js';
+export * from './types/Plugin.js';
+export * from './types/PluginFormat.js';
+export * from './types/PluginType.js';
+export * from './types/Preset.js';
+export * from './types/PresetFormat.js';
+export * from './types/PresetType.js';
+export * from './types/Project.js';
+export * from './types/ProjectFormat.js';
+export * from './types/ProjectType.js';
+export * from './types/Registry.js';
+export * from './types/System.js';
+export * from './types/SystemType.js';