@openfairygui/functions 0.2.0-alpha.1 → 0.2.0-alpha.12

package/README.md

@@ -11,16 +11,45 @@ npm install --save @openfairygui/core @openfairygui/functions
 ## Usage
 
 ```ts
-import { NodeIO } from '@openfairygui/core';
-import { inspect, publish } from '@openfairygui/functions';
+import { NodeIO } from '@openfairygui/core/node';
+import { inspect } from '@openfairygui/functions';
+import { publishNode } from '@openfairygui/functions/node';
 
 const io = new NodeIO();
 const doc = await io.readProject('./MyProject/MyProject.fairy');
 
 const report = inspect(doc);
-await doc.transform(publish({ output: './release' }));
+await publishNode({ document: doc, output: './release' });
 ```
 
+`publishNode` owns the standard Node filesystem, Sharp raster backend, and project plugin discovery. The root `publish()` export remains the lower-level capability-injected core for custom hosts.
+
+## Browser LayaBox publish
+
+Use `@openfairygui/core/web` to read the raw project, then publish through the browser-only entry. Both filesystems are caller-owned, so they can be File System Access, OPFS, IndexedDB, ZIP, or memory adapters.
+
+```ts
+import { WebIO } from '@openfairygui/core/web';
+import { publishBrowser } from '@openfairygui/functions/web';
+
+const document = await new WebIO(sourceFileSystem).readProject('Project.fairy');
+const result = await publishBrowser({
+	document,
+	sourceFileSystem,
+	outputFileSystem,
+	projectType: 'layabox',
+	output: '.fairygui-runtime',
+});
+
+if (!result.success) console.error(result.diagnostics);
+```
+
+The browser entry uses native Canvas APIs for atlas PNGs, writes only through `outputFileSystem`, supplies no Node plugin capability, and disables non-runtime code generation.
+
+Publish plugins are documented in the repository guide:
+
+- https://github.com/OpenFairyGUI/OpenFairyGUI/blob/main/docs/publish-plugins.md
+
 ## Phase A UAM authoring seam
 
 `@openfairygui/functions` also exposes a thin stateless wrapper over the Phase A UAM

package/dist/atlas-CDn6TirX.d.ts

@@ -0,0 +1,193 @@
+import { FileSystem, Transform } from "@openfairygui/core";
+
+//#region src/publish/contracts.d.ts
+/**
+ * Source files required by a publish adapter.
+ *
+ * The host owns this filesystem: Node adapters use native paths while web
+ * adapters can use File System Access, OPFS, IndexedDB, ZIP, or memory.
+ */
+type PublishSourceFileSystem = Pick<FileSystem, 'readFileRaw' | 'join'>;
+/**
+ * Output files required by a publish adapter.
+ */
+type PublishOutputFileSystem = Pick<FileSystem, 'writeFileRaw' | 'mkdir' | 'join'>;
+/**
+ * Full filesystem contract consumed by the capability-injected publish core.
+ *
+ * Read, enumeration, and delete operations are optional because individual
+ * publish lanes only request them when needed.
+ */
+type PublishFileSystem = PublishOutputFileSystem & {
+  deleteFile?: (path: string) => Promise<void>;
+  exists?: FileSystem['exists'];
+  readdir?: FileSystem['readdir'];
+  readFileRaw?: FileSystem['readFileRaw'];
+};
+interface AtlasRasterMetadata {
+  width?: number;
+  height?: number;
+  channels?: number;
+  hasAlpha?: boolean;
+  trimOffsetLeft?: number;
+  trimOffsetTop?: number;
+}
+interface AtlasRasterResolvedBuffer {
+  data: Uint8Array;
+  info: Required<Pick<AtlasRasterMetadata, 'width' | 'height' | 'channels'>> & AtlasRasterMetadata;
+}
+interface AtlasRasterCompositeInput {
+  input: Uint8Array;
+  left: number;
+  top: number;
+}
+type AtlasRasterInput = string | Uint8Array | {
+  create: {
+    width: number;
+    height: number;
+    channels: 4;
+    background: {
+      r: number;
+      g: number;
+      b: number;
+      alpha: number;
+    };
+  };
+};
+/**
+ * Host-provided raster pipeline used by atlas packing.
+ *
+ * Sharp and the browser Canvas adapter both satisfy this contract.
+ */
+interface AtlasRasterPipeline {
+  ensureAlpha(): AtlasRasterPipeline;
+  resize(options: {
+    width: number;
+    height: number;
+    fit?: 'fill';
+  }): AtlasRasterPipeline;
+  raw(): AtlasRasterPipeline;
+  extract(options: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+  }): AtlasRasterPipeline;
+  png(): AtlasRasterPipeline;
+  rotate(angle: number): AtlasRasterPipeline;
+  composite(inputs: AtlasRasterCompositeInput[]): AtlasRasterPipeline;
+  metadata(): Promise<AtlasRasterMetadata>;
+  toBuffer(options: {
+    resolveWithObject: true;
+  }): Promise<AtlasRasterResolvedBuffer>;
+  toBuffer(options?: {
+    resolveWithObject?: false;
+  }): Promise<Uint8Array>;
+  toFile(path: string): Promise<unknown>;
+}
+type AtlasRasterBackend = (input: AtlasRasterInput) => AtlasRasterPipeline;
+//#endregion
+//#region src/atlas.d.ts
+interface AtlasOptions {
+  /**
+   * Limit atlas generation to specific package names.
+   * When omitted, all packages are processed.
+   */
+  packages?: string[];
+  /**
+   * Raster backend, injected by the host adapter.
+   * Required for actual image compositing and trimImage.
+   *
+   * ```ts
+   * import sharp from 'sharp';
+   * await doc.transform(atlas({ encoder: sharp }));
+   * ```
+   */
+  encoder?: AtlasRasterBackend;
+  /** Maximum atlas texture size (width and height). Default: 2048. */
+  maxSize?: number;
+  /** Whether to use the fast editor-compatible packing heuristics. Default: true. */
+  fast?: boolean;
+  /** Allow rotating sprites 90° for better packing. Default: true. */
+  allowRotation?: boolean;
+  /** Pixel padding between sprites. Default: 1. */
+  padding?: number;
+  /** Constrain atlas dimensions to powers of two. Default: false. */
+  powerOfTwo?: boolean;
+  /** Force square atlas (width === height). Default: false. */
+  square?: boolean;
+  /** Allow spilling into multiple atlas pages. Default: true. */
+  multiPage?: boolean;
+  /**
+   * Trim transparent pixels from image edges before packing.
+   * Requires a raster backend. Stores offset/originalSize in Sprite nodes.
+   * Default: false.
+   */
+  trimImage?: boolean;
+  /**
+   * Base path for reading source images. If not set, images must have
+   * their pixel data stored in extras._imageData as Uint8Array.
+   */
+  basePath?: string;
+  /**
+   * Output directory for generated atlas PNGs.
+   * Required when encoder is provided.
+   */
+  outputPath?: string;
+  /**
+   * Optional mkdir function to ensure output directory exists.
+   * If not provided, the outputPath directory must already exist.
+   */
+  mkdir?: (path: string) => Promise<void>;
+  /**
+   * Optional raw file reader for reading .jta MovieClip files.
+   * Required for MovieClip frame atlas packing.
+   */
+  readFileRaw?: (path: string) => Promise<Uint8Array>;
+  /**
+   * Keep original input order when MaxRects tie-break scores are equal.
+   * This is an internal publish detail used to mirror editor/CLI behavior.
+   */
+  preserveInputOrderOnTie?: boolean;
+  /**
+   * Internal publish detail used by Unity binary output:
+   * allow single untrimmed PNG image packages to bypass the packer and
+   * write atlas0 directly, matching the reference CLI behavior.
+   */
+  directSingleImageOutput?: boolean;
+  /**
+   * Internal publish detail used by the direct-image-output path.
+   * When extractAlpha is enabled, the direct output shortcut must be disabled.
+   */
+  extractAlpha?: boolean;
+  /**
+   * When branchProcessing keeps branch resources, publish branch images into
+   * separate atlas pages/files per branch instead of mixing them with main.
+   */
+  separatedAtlasForBranch?: boolean;
+}
+/**
+ * Packs image resources into texture atlases.
+ *
+ * This transform performs MaxRects bin-packing on all ImageResource items
+ * within each package, creating Atlas and Sprite property nodes. When an
+ * a raster backend is provided, it also composites the actual PNG files.
+ *
+ * When `trimImage` is enabled and encoder is available, transparent pixels
+ * at image edges are trimmed before packing. The trimmed offset and original
+ * dimensions are stored in the Sprite nodes for runtime reconstruction.
+ *
+ * ```ts
+ * import sharp from 'sharp';
+ * await doc.transform(atlas({
+ *   encoder: sharp,
+ *   maxSize: 2048,
+ *   trimImage: true,
+ *   basePath: './assets/',
+ *   outputPath: './dist/',
+ * }));
+ * ```
+ */
+declare function atlas(_options?: AtlasOptions): Transform;
+//#endregion
+export { AtlasRasterInput as a, AtlasRasterResolvedBuffer as c, PublishSourceFileSystem as d, AtlasRasterCompositeInput as i, PublishFileSystem as l, atlas as n, AtlasRasterMetadata as o, AtlasRasterBackend as r, AtlasRasterPipeline as s, AtlasOptions as t, PublishOutputFileSystem as u };

package/dist/atlas-CHsu2Y8i.d.cts

@@ -0,0 +1,193 @@
+import { FileSystem, Transform } from "@openfairygui/core";
+
+//#region src/publish/contracts.d.ts
+/**
+ * Source files required by a publish adapter.
+ *
+ * The host owns this filesystem: Node adapters use native paths while web
+ * adapters can use File System Access, OPFS, IndexedDB, ZIP, or memory.
+ */
+type PublishSourceFileSystem = Pick<FileSystem, 'readFileRaw' | 'join'>;
+/**
+ * Output files required by a publish adapter.
+ */
+type PublishOutputFileSystem = Pick<FileSystem, 'writeFileRaw' | 'mkdir' | 'join'>;
+/**
+ * Full filesystem contract consumed by the capability-injected publish core.
+ *
+ * Read, enumeration, and delete operations are optional because individual
+ * publish lanes only request them when needed.
+ */
+type PublishFileSystem = PublishOutputFileSystem & {
+  deleteFile?: (path: string) => Promise<void>;
+  exists?: FileSystem['exists'];
+  readdir?: FileSystem['readdir'];
+  readFileRaw?: FileSystem['readFileRaw'];
+};
+interface AtlasRasterMetadata {
+  width?: number;
+  height?: number;
+  channels?: number;
+  hasAlpha?: boolean;
+  trimOffsetLeft?: number;
+  trimOffsetTop?: number;
+}
+interface AtlasRasterResolvedBuffer {
+  data: Uint8Array;
+  info: Required<Pick<AtlasRasterMetadata, 'width' | 'height' | 'channels'>> & AtlasRasterMetadata;
+}
+interface AtlasRasterCompositeInput {
+  input: Uint8Array;
+  left: number;
+  top: number;
+}
+type AtlasRasterInput = string | Uint8Array | {
+  create: {
+    width: number;
+    height: number;
+    channels: 4;
+    background: {
+      r: number;
+      g: number;
+      b: number;
+      alpha: number;
+    };
+  };
+};
+/**
+ * Host-provided raster pipeline used by atlas packing.
+ *
+ * Sharp and the browser Canvas adapter both satisfy this contract.
+ */
+interface AtlasRasterPipeline {
+  ensureAlpha(): AtlasRasterPipeline;
+  resize(options: {
+    width: number;
+    height: number;
+    fit?: 'fill';
+  }): AtlasRasterPipeline;
+  raw(): AtlasRasterPipeline;
+  extract(options: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+  }): AtlasRasterPipeline;
+  png(): AtlasRasterPipeline;
+  rotate(angle: number): AtlasRasterPipeline;
+  composite(inputs: AtlasRasterCompositeInput[]): AtlasRasterPipeline;
+  metadata(): Promise<AtlasRasterMetadata>;
+  toBuffer(options: {
+    resolveWithObject: true;
+  }): Promise<AtlasRasterResolvedBuffer>;
+  toBuffer(options?: {
+    resolveWithObject?: false;
+  }): Promise<Uint8Array>;
+  toFile(path: string): Promise<unknown>;
+}
+type AtlasRasterBackend = (input: AtlasRasterInput) => AtlasRasterPipeline;
+//#endregion
+//#region src/atlas.d.ts
+interface AtlasOptions {
+  /**
+   * Limit atlas generation to specific package names.
+   * When omitted, all packages are processed.
+   */
+  packages?: string[];
+  /**
+   * Raster backend, injected by the host adapter.
+   * Required for actual image compositing and trimImage.
+   *
+   * ```ts
+   * import sharp from 'sharp';
+   * await doc.transform(atlas({ encoder: sharp }));
+   * ```
+   */
+  encoder?: AtlasRasterBackend;
+  /** Maximum atlas texture size (width and height). Default: 2048. */
+  maxSize?: number;
+  /** Whether to use the fast editor-compatible packing heuristics. Default: true. */
+  fast?: boolean;
+  /** Allow rotating sprites 90° for better packing. Default: true. */
+  allowRotation?: boolean;
+  /** Pixel padding between sprites. Default: 1. */
+  padding?: number;
+  /** Constrain atlas dimensions to powers of two. Default: false. */
+  powerOfTwo?: boolean;
+  /** Force square atlas (width === height). Default: false. */
+  square?: boolean;
+  /** Allow spilling into multiple atlas pages. Default: true. */
+  multiPage?: boolean;
+  /**
+   * Trim transparent pixels from image edges before packing.
+   * Requires a raster backend. Stores offset/originalSize in Sprite nodes.
+   * Default: false.
+   */
+  trimImage?: boolean;
+  /**
+   * Base path for reading source images. If not set, images must have
+   * their pixel data stored in extras._imageData as Uint8Array.
+   */
+  basePath?: string;
+  /**
+   * Output directory for generated atlas PNGs.
+   * Required when encoder is provided.
+   */
+  outputPath?: string;
+  /**
+   * Optional mkdir function to ensure output directory exists.
+   * If not provided, the outputPath directory must already exist.
+   */
+  mkdir?: (path: string) => Promise<void>;
+  /**
+   * Optional raw file reader for reading .jta MovieClip files.
+   * Required for MovieClip frame atlas packing.
+   */
+  readFileRaw?: (path: string) => Promise<Uint8Array>;
+  /**
+   * Keep original input order when MaxRects tie-break scores are equal.
+   * This is an internal publish detail used to mirror editor/CLI behavior.
+   */
+  preserveInputOrderOnTie?: boolean;
+  /**
+   * Internal publish detail used by Unity binary output:
+   * allow single untrimmed PNG image packages to bypass the packer and
+   * write atlas0 directly, matching the reference CLI behavior.
+   */
+  directSingleImageOutput?: boolean;
+  /**
+   * Internal publish detail used by the direct-image-output path.
+   * When extractAlpha is enabled, the direct output shortcut must be disabled.
+   */
+  extractAlpha?: boolean;
+  /**
+   * When branchProcessing keeps branch resources, publish branch images into
+   * separate atlas pages/files per branch instead of mixing them with main.
+   */
+  separatedAtlasForBranch?: boolean;
+}
+/**
+ * Packs image resources into texture atlases.
+ *
+ * This transform performs MaxRects bin-packing on all ImageResource items
+ * within each package, creating Atlas and Sprite property nodes. When an
+ * a raster backend is provided, it also composites the actual PNG files.
+ *
+ * When `trimImage` is enabled and encoder is available, transparent pixels
+ * at image edges are trimmed before packing. The trimmed offset and original
+ * dimensions are stored in the Sprite nodes for runtime reconstruction.
+ *
+ * ```ts
+ * import sharp from 'sharp';
+ * await doc.transform(atlas({
+ *   encoder: sharp,
+ *   maxSize: 2048,
+ *   trimImage: true,
+ *   basePath: './assets/',
+ *   outputPath: './dist/',
+ * }));
+ * ```
+ */
+declare function atlas(_options?: AtlasOptions): Transform;
+//#endregion
+export { AtlasRasterInput as a, AtlasRasterResolvedBuffer as c, PublishSourceFileSystem as d, AtlasRasterCompositeInput as i, PublishFileSystem as l, atlas as n, AtlasRasterMetadata as o, AtlasRasterBackend as r, AtlasRasterPipeline as s, AtlasOptions as t, PublishOutputFileSystem as u };

package/dist/codegen-C7PPZrB3.d.cts

@@ -0,0 +1,241 @@
+import { l as PublishFileSystem, r as AtlasRasterBackend, t as AtlasOptions } from "./atlas-CHsu2Y8i.cjs";
+import { Component, Document, Package, ProjectSettings, PublishSettings, Transform } from "@openfairygui/core";
+
+//#region src/publish.d.ts
+interface PublishOptions {
+  /**
+   * Output directory override for published files (.fui + atlas PNGs).
+   * When omitted, publish uses package-level or project-level publish paths.
+   */
+  output?: string;
+  /**
+   * Compress the binary data with zlib raw deflate. Default: false.
+   */
+  compressed?: boolean;
+  /**
+   * File extension for the binary output. Default: 'fui'.
+   * Unity projects typically use 'bytes'.
+   */
+  fileExtension?: string;
+  /**
+   * Raster backend for atlas image compositing.
+   * If not provided, atlas packing only computes layout (no PNGs generated).
+   */
+  encoder?: AtlasRasterBackend;
+  /**
+   * Base path for reading source images (project assets root).
+   * Required when encoder is provided.
+   */
+  basePath?: string;
+  /**
+   * Atlas packing options.
+   */
+  atlas?: Omit<AtlasOptions, 'encoder' | 'basePath' | 'outputPath'>;
+  /**
+   * Filter which packages to publish by name. If not set, all packages are published.
+   */
+  packages?: string[];
+  /**
+   * FileSystem abstraction for writing output files.
+   * Required for actual file output. Without it, only the Document model
+   * is updated (atlas layout computed, sprite nodes created).
+   */
+  fs?: PublishFileSystem;
+  /**
+   * Active branch name used when branchProcessing is "主干合并活跃分支".
+   * Empty or omitted means publishing the main branch.
+   */
+  branch?: string;
+  /**
+   * Publish hooks supplied by the host adapter.
+   *
+   * Node adapters load project plugins. Browser adapters pass an empty list.
+   */
+  plugins?: LoadedPlugin[];
+  /**
+   * Run generic code generation after runtime artifacts. Default: true.
+   */
+  codeGeneration?: boolean;
+}
+interface ResolvedPublishAtlasOptions extends Pick<AtlasOptions, 'maxSize' | 'fast' | 'allowRotation' | 'padding' | 'powerOfTwo' | 'square' | 'multiPage' | 'trimImage' | 'extractAlpha'> {}
+interface ResolvePublishOptionsOverrides {
+  compressed?: boolean;
+  fileExtension?: string;
+  packages?: string[];
+  atlas?: Partial<ResolvedPublishAtlasOptions>;
+}
+interface ResolvedPublishOptions {
+  compressed: boolean;
+  fileExtension: string;
+  packages?: string[];
+  atlas: ResolvedPublishAtlasOptions;
+}
+/**
+ * Resolve publish defaults from the document's project settings.
+ *
+ * This keeps the editor-aligned publish rules reusable across environments,
+ * while callers still provide environment-specific concerns such as fs/encoder/basePath.
+ */
+declare function resolvePublishOptions(doc: Document, overrides?: ResolvePublishOptionsOverrides): ResolvedPublishOptions;
+/**
+ * Publishes a FairyGUI project.
+ *
+ * Orchestrates:
+ * 1. Atlas packing (MaxRects layout + optional raster compositing)
+ * 2. Per-package .fui binary serialization
+ * 3. File writing to the output directory
+ *
+ * This is the capability-injected core. Standard hosts should use
+ * `publishNode()` or `publishBrowser()` through their dedicated entries.
+ *
+ * ```ts
+ * import sharp from 'sharp';
+ * const io = new NodeIO();
+ * const doc = await io.readProject('./project.fairy');
+ *
+ * await doc.transform(publish({
+ *   output: './release/',
+ *   compressed: true,
+ *   encoder: sharp,
+ *   basePath: './assets/',
+ *   fileExtension: 'bytes',
+ *   fs: io.createFileSystem(),
+ * }));
+ * ```
+ */
+declare function publish(options: PublishOptions): Transform;
+//#endregion
+//#region src/shared-types.d.ts
+type ExtrasMap = Record<string, unknown>;
+interface CliCodeGenerationSettings extends NonNullable<PublishSettings['codeGeneration']> {
+  allowGenCode?: boolean;
+  classNamePrefix?: string;
+  codePath?: string;
+  codeType?: string;
+  getMemberByName?: boolean;
+  ignoreNoname?: boolean;
+  memberNamePrefix?: string;
+  packageName?: string;
+}
+interface CliAtlasSettings extends NonNullable<PublishSettings['atlasSetting']> {
+  maxSize?: number;
+  paging?: boolean;
+  sizeOption?: string;
+  forceSquare?: boolean;
+  fast?: boolean;
+  allowRotation?: boolean;
+  padding?: number;
+  trimImage?: boolean;
+  extractAlpha?: boolean;
+}
+interface CliPublishSettings extends PublishSettings {
+  atlasSetting?: CliAtlasSettings;
+  codeGeneration?: CliCodeGenerationSettings;
+}
+type RootProjectSettings = ProjectSettings & {
+  publish?: CliPublishSettings;
+};
+interface PublishDependency {
+  id: string;
+  name: string;
+}
+interface HasOptionalFont {
+  getFont?(): string | string[] | null | undefined;
+}
+interface HasOptionalSrc {
+  getSrc?(): string | undefined;
+}
+interface HasOptionalUrl {
+  getUrl?(): string | undefined;
+}
+//#endregion
+//#region src/plugins/types.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface PluginManifest {
+  name: string;
+  displayName?: string;
+  description?: string;
+  version?: string;
+  author?: {
+    name?: string;
+  };
+  icon?: string;
+  main: string;
+}
+interface ICodeWriterConfig {
+  blockStart?: string;
+  blockEnd?: string;
+  blockFromNewLine?: boolean;
+  usingTabs?: boolean;
+  endOfLine?: string;
+  fileMark?: string;
+}
+interface CodeWriter {
+  writeMark(): void;
+  writeln(fmt?: string, ...args: any[]): CodeWriter;
+  startBlock(): CodeWriter;
+  endBlock(): CodeWriter;
+  incIndent(): CodeWriter;
+  decIndent(): CodeWriter;
+  reset(): void;
+  toString(): string;
+  save(filePath: string): void;
+}
+interface Plugin {
+  genCode?: (doc: Document, settings: Required<CliCodeGenerationSettings>, options: PublishCodeGenerationOptions) => MaybePromise<void>;
+  onPublishStart?: (doc: Document, options: PublishOptions) => MaybePromise<void>;
+  onPublishEnd?: (doc: Document, options: PublishOptions) => MaybePromise<void>;
+}
+interface LoadedPlugin {
+  name: string;
+  plugin: Plugin;
+}
+type PluginModule = Plugin & {
+  default?: Plugin;
+};
+//#endregion
+//#region src/codegen.d.ts
+declare const AUTO_GENERATED_CODE_MARK = "/** This is an automatically generated class by FairyGUI. Please do not modify it. **/";
+interface PublishCodeGenerationOptions {
+  basePath?: string;
+  fs: PublishFileSystem;
+  packages: Package[];
+  plugins?: LoadedPlugin[];
+}
+interface ResolvedPackageCodegenPlan {
+  outputDir: string;
+  packageFolderName: string;
+  packageNamespace: string;
+  binderClassName: string;
+  settings: CliCodeGenerationSettings;
+}
+interface CodegenMember {
+  index: number;
+  kind: 'child' | 'controller' | 'transition';
+  name: string;
+  originalName: string;
+  type: string;
+  ignored: boolean;
+  referencedComponent?: CodegenReferencedComponent;
+}
+interface CodegenReferencedComponent {
+  component: Component;
+  package: Package;
+}
+interface CodegenClass {
+  classId: string;
+  className: string;
+  encodedClassName: string;
+  componentType: string;
+  componentName: string;
+  packageName: string;
+  url: string;
+  members: CodegenMember[];
+}
+declare function publishCodeGeneration(doc: Document, options: PublishCodeGenerationOptions): Promise<void>;
+declare function resolvePackageCodegenPlan(pkg: Package, settings: CliCodeGenerationSettings, options: PublishCodeGenerationOptions): ResolvedPackageCodegenPlan | null;
+declare function buildCodegenClasses(doc: Document, pkg: Package, plan: ResolvedPackageCodegenPlan): CodegenClass[];
+declare function encodeText(value: string): Uint8Array;
+declare function decodeText(value: Uint8Array): string;
+//#endregion
+export { ResolvedPublishAtlasOptions as A, HasOptionalFont as C, RootProjectSettings as D, PublishDependency as E, publish as M, resolvePublishOptions as N, PublishOptions as O, ExtrasMap as S, HasOptionalUrl as T, PluginManifest as _, PublishCodeGenerationOptions as a, CliCodeGenerationSettings as b, decodeText as c, resolvePackageCodegenPlan as d, CodeWriter as f, Plugin as g, MaybePromise as h, CodegenReferencedComponent as i, ResolvedPublishOptions as j, ResolvePublishOptionsOverrides as k, encodeText as l, LoadedPlugin as m, CodegenClass as n, ResolvedPackageCodegenPlan as o, ICodeWriterConfig as p, CodegenMember as r, buildCodegenClasses as s, AUTO_GENERATED_CODE_MARK as t, publishCodeGeneration as u, PluginModule as v, HasOptionalSrc as w, CliPublishSettings as x, CliAtlasSettings as y };