@textmode/document 0.0.0-stage → 1.1.0

package/dist/types/legacy.d.ts

@@ -0,0 +1,26 @@
+import type { LEGACY_TEXTMODE_ALL_VERSION, LEGACY_TEXTMODE_LAYER_FORMAT, LEGACY_TEXTMODE_SELECTED_VERSION } from '../constants.js';
+import type { TextmodeDocumentMetadata, TextmodeDocumentGrid } from './wire.js';
+import type { TextmodeV2DocumentLayer, TextmodeV2SelectedDocumentLayer } from './v2.js';
+export interface LegacyTextmodeSelectedDocumentJSON {
+    $schema?: string;
+    format: typeof LEGACY_TEXTMODE_LAYER_FORMAT;
+    formatVersion: typeof LEGACY_TEXTMODE_SELECTED_VERSION;
+    metadata?: TextmodeDocumentMetadata;
+    canvas: {
+        width: number;
+        height: number;
+    };
+    grid: TextmodeDocumentGrid;
+    layer: TextmodeV2SelectedDocumentLayer;
+}
+export interface LegacyTextmodeAllDocumentJSON {
+    $schema?: string;
+    format: typeof LEGACY_TEXTMODE_LAYER_FORMAT;
+    formatVersion: typeof LEGACY_TEXTMODE_ALL_VERSION;
+    metadata?: TextmodeDocumentMetadata;
+    canvas: {
+        width: number;
+        height: number;
+    };
+    layers: TextmodeV2DocumentLayer[];
+}

package/dist/types/legacy.js

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

package/dist/types/v2.d.ts

@@ -0,0 +1,34 @@
+import type { TextmodeDocumentFormat, TextmodeDocumentMetadata, TextmodeDocumentGrid, TextmodeDocumentCellCollection, TextmodeDocumentLayer } from './wire.js';
+export interface TextmodeV2SelectedDocumentLayer {
+    id: string;
+    cells: TextmodeDocumentCellCollection;
+}
+/** Layer fields required by the v2 wire format and validated during migration. */
+export interface TextmodeV2DocumentLayer extends TextmodeDocumentLayer {
+    offsetX: number;
+    offsetY: number;
+    rotationZ: number;
+}
+export interface TextmodeV2SelectedDocumentJSON {
+    format: TextmodeDocumentFormat;
+    formatVersion: '2.0.0';
+    target: 'selected';
+    metadata?: TextmodeDocumentMetadata;
+    canvas: {
+        width: number;
+        height: number;
+    };
+    grid: TextmodeDocumentGrid;
+    layer: TextmodeV2SelectedDocumentLayer;
+}
+export interface TextmodeV2AllDocumentJSON {
+    format: TextmodeDocumentFormat;
+    formatVersion: '2.0.0';
+    target: 'all';
+    metadata?: TextmodeDocumentMetadata;
+    canvas: {
+        width: number;
+        height: number;
+    };
+    layers: TextmodeV2DocumentLayer[];
+}

package/dist/types/v2.js

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

package/dist/types/wire.d.ts

@@ -0,0 +1,68 @@
+import type { TEXTMODE_DOCUMENT_FORMAT, TEXTMODE_DOCUMENT_FORMAT_VERSION, TEXTMODE_OBJECT_ROWS_ENCODING } from '../constants.js';
+/** Format discriminator encoded in a document. */
+export type TextmodeDocumentFormat = typeof TEXTMODE_DOCUMENT_FORMAT;
+/** Current on-disk format version, independent of the npm package version. */
+export type TextmodeDocumentVersion = typeof TEXTMODE_DOCUMENT_FORMAT_VERSION;
+/** RGBA color channels, each an integer from 0 through 255. */
+export interface TextmodeDocumentRGBAColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** On-disk color notation; decoded colors use RGBA channels. */
+export type TextmodeDocumentColor = string | TextmodeDocumentRGBAColor;
+/** Per-cell transform in degrees. */
+export interface TextmodeDocumentCellTransform {
+    invert: boolean;
+    flipX: boolean;
+    flipY: boolean;
+    rotation: number;
+}
+/** Cell at its redundant row-major x/y coordinates. */
+export interface TextmodeDocumentCell {
+    x: number;
+    y: number;
+    character: string;
+    foreground: TextmodeDocumentColor;
+    background: TextmodeDocumentColor;
+    transform: TextmodeDocumentCellTransform;
+}
+/** Dense row-major cell collection. */
+export interface TextmodeDocumentCellCollection {
+    encoding: typeof TEXTMODE_OBJECT_ROWS_ENCODING;
+    rows: TextmodeDocumentCell[][];
+}
+/** Logical grid dimensions and pixel extent of each cell. */
+export interface TextmodeDocumentGrid {
+    cols: number;
+    rows: number;
+    cellWidth: number;
+    cellHeight: number;
+}
+/** Optional producer information; it does not control decoding behavior. */
+export interface TextmodeDocumentMetadata {
+    createdAt: string;
+    generator: {
+        name: string;
+        version: string;
+    };
+}
+export interface TextmodeDocumentLayer {
+    id: string;
+    visible: boolean;
+    opacity: number;
+    blendMode: string;
+    offsetX: number;
+    offsetY: number;
+    rotationZ: number;
+    grid: TextmodeDocumentGrid;
+    cells: TextmodeDocumentCellCollection;
+}
+/** One portable document with one or more ordered layers, bottom first. */
+export interface TextmodeDocumentJSON {
+    format: TextmodeDocumentFormat;
+    formatVersion: TextmodeDocumentVersion;
+    metadata?: TextmodeDocumentMetadata;
+    layers: TextmodeDocumentLayer[];
+}

package/dist/types/wire.js

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

package/dist/validation.d.ts

@@ -0,0 +1,37 @@
+import type { TextmodeDocumentMetadata, TextmodeDocumentGrid, TextmodeDocumentRGBAColor, TextmodeDocumentDecodeResult, TextmodeDocumentError, TextmodeDocumentErrorCode, TextmodeDocumentLimits } from './types/index.js';
+export type UnknownRecord = Record<string, unknown>;
+export type ResolvedLimits = Required<TextmodeDocumentLimits>;
+export type DecodeContext = {
+    limits: ResolvedLimits;
+    remainingCells: number;
+};
+export declare class DocumentDecodeFailure extends Error {
+    readonly detail: TextmodeDocumentError;
+    constructor(detail: TextmodeDocumentError);
+}
+export declare function decodeColor(value: unknown, path: string): TextmodeDocumentRGBAColor;
+export declare function decodeCanvas(value: unknown, path: string): {
+    width: number;
+    height: number;
+};
+export declare function decodeGrid(value: unknown, path: string): TextmodeDocumentGrid;
+export declare function decodeMetadata(value: unknown, path: string, limits: ResolvedLimits): TextmodeDocumentMetadata;
+export declare function decodeLayerId(value: unknown, path: string, limits: ResolvedLimits): string;
+export declare function assertCanvasMatchesGrid(canvas: {
+    width: number;
+    height: number;
+}, grid: TextmodeDocumentGrid, path: string): void;
+export declare function resolveLimits(limits: TextmodeDocumentLimits | undefined): ResolvedLimits;
+export declare function checkedProduct(left: number, right: number, path: string): number;
+export declare function normalizeRotation(rotation: number): number;
+export declare function requireRecord(value: unknown, path: string): UnknownRecord;
+export declare function requireArray(value: unknown, path: string): unknown[];
+export declare function requireString(value: unknown, path: string): string;
+export declare function requireBoundedString(value: unknown, path: string, maxLength: number): string;
+export declare function requireCharacter(value: unknown, path: string, limits: ResolvedLimits): string;
+export declare function requireBoolean(value: unknown, path: string): boolean;
+export declare function requireFiniteNumber(value: unknown, path: string): number;
+export declare function requireNumberInRange(value: unknown, path: string, minimum: number, maximum: number): number;
+export declare function requireSafeInteger(value: unknown, path: string): number;
+export declare function failure(code: TextmodeDocumentErrorCode, message: string, path?: string): TextmodeDocumentDecodeResult;
+export declare function fail(code: TextmodeDocumentErrorCode, message: string, path?: string): never;

package/dist/validation.js

@@ -0,0 +1,205 @@
+import { DEFAULT_TEXTMODE_DOCUMENT_LIMITS } from './constants.js';
+export class DocumentDecodeFailure extends Error {
+    constructor(detail) {
+        super(detail.message);
+        this.detail = detail;
+    }
+}
+export function decodeColor(value, path) {
+    if (typeof value === 'string') {
+        const match = /^#([0-9a-f]{6}|[0-9a-f]{8})$/i.exec(value);
+        if (!match) {
+            fail('INVALID_DOCUMENT', 'Expected #RRGGBB or #RRGGBBAA color notation.', path);
+        }
+        const hex = match[1];
+        return {
+            r: Number.parseInt(hex.slice(0, 2), 16),
+            g: Number.parseInt(hex.slice(2, 4), 16),
+            b: Number.parseInt(hex.slice(4, 6), 16),
+            a: hex.length === 8 ? Number.parseInt(hex.slice(6, 8), 16) : 255,
+        };
+    }
+    const color = requireRecord(value, path);
+    return {
+        r: requireByte(color.r, `${path}.r`),
+        g: requireByte(color.g, `${path}.g`),
+        b: requireByte(color.b, `${path}.b`),
+        a: requireByte(color.a, `${path}.a`),
+    };
+}
+export function decodeCanvas(value, path) {
+    const canvas = requireRecord(value, path);
+    return {
+        width: requirePositiveSafeInteger(canvas.width, `${path}.width`),
+        height: requirePositiveSafeInteger(canvas.height, `${path}.height`),
+    };
+}
+export function decodeGrid(value, path) {
+    const grid = requireRecord(value, path);
+    return {
+        cols: requirePositiveSafeInteger(grid.cols, `${path}.cols`),
+        rows: requirePositiveSafeInteger(grid.rows, `${path}.rows`),
+        cellWidth: requirePositiveSafeInteger(grid.cellWidth, `${path}.cellWidth`),
+        cellHeight: requirePositiveSafeInteger(grid.cellHeight, `${path}.cellHeight`),
+    };
+}
+export function decodeMetadata(value, path, limits) {
+    const metadata = requireRecord(value, path);
+    const generator = requireRecord(metadata.generator, `${path}.generator`);
+    const generatorName = requireBoundedString(generator.name, `${path}.generator.name`, limits.maxMetadataStringLength);
+    const createdAt = requireBoundedString(metadata.createdAt, `${path}.createdAt`, limits.maxMetadataStringLength);
+    assertTimestamp(createdAt, `${path}.createdAt`);
+    return {
+        createdAt,
+        generator: {
+            name: generatorName,
+            version: requireBoundedString(generator.version, `${path}.generator.version`, limits.maxMetadataStringLength),
+        },
+    };
+}
+const TIMESTAMP_PATTERN = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\.[0-9]+)?(?:Z|[+-](?:[01][0-9]|2[0-3]):[0-5][0-9])$/;
+function assertTimestamp(value, path) {
+    const match = TIMESTAMP_PATTERN.exec(value);
+    if (!match)
+        fail('INVALID_DOCUMENT', 'Expected an uppercase RFC 3339 timestamp with seconds and a timezone.', path);
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    if (day > daysInMonth[month - 1])
+        fail('INVALID_DOCUMENT', 'Timestamp contains an invalid calendar date.', path);
+}
+export function decodeLayerId(value, path, limits) {
+    return requireBoundedString(value, path, limits.maxLayerIdLength);
+}
+export function assertCanvasMatchesGrid(canvas, grid, path) {
+    const expectedWidth = checkedProduct(grid.cols, grid.cellWidth, `${path}.width`);
+    const expectedHeight = checkedProduct(grid.rows, grid.cellHeight, `${path}.height`);
+    if (canvas.width !== expectedWidth || canvas.height !== expectedHeight) {
+        fail('INVALID_DOCUMENT', `Canvas must equal the grid pixel extent ${expectedWidth}x${expectedHeight}.`, path);
+    }
+}
+export function resolveLimits(limits) {
+    return {
+        maxCells: resolveLimit(limits?.maxCells, DEFAULT_TEXTMODE_DOCUMENT_LIMITS.maxCells, 'maxCells'),
+        maxLayers: resolveLimit(limits?.maxLayers, DEFAULT_TEXTMODE_DOCUMENT_LIMITS.maxLayers, 'maxLayers'),
+        maxLayerIdLength: resolveLimit(limits?.maxLayerIdLength, DEFAULT_TEXTMODE_DOCUMENT_LIMITS.maxLayerIdLength, 'maxLayerIdLength'),
+        maxCharacterLength: resolveLimit(limits?.maxCharacterLength, DEFAULT_TEXTMODE_DOCUMENT_LIMITS.maxCharacterLength, 'maxCharacterLength'),
+        maxMetadataStringLength: resolveLimit(limits?.maxMetadataStringLength, DEFAULT_TEXTMODE_DOCUMENT_LIMITS.maxMetadataStringLength, 'maxMetadataStringLength'),
+    };
+}
+function resolveLimit(value, fallback, name) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError(`${name} must be a positive safe integer.`);
+    }
+    return value;
+}
+export function checkedProduct(left, right, path) {
+    const product = left * right;
+    if (!Number.isSafeInteger(product)) {
+        fail('LIMIT_EXCEEDED', 'Numeric dimensions exceed the safe integer range.', path);
+    }
+    return product;
+}
+export function normalizeRotation(rotation) {
+    const normalized = ((rotation % 360) + 360) % 360;
+    return Object.is(normalized, -0) ? 0 : normalized;
+}
+export function requireRecord(value, path) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        fail('INVALID_DOCUMENT', 'Expected an object.', path);
+    }
+    return value;
+}
+export function requireArray(value, path) {
+    if (!Array.isArray(value))
+        fail('INVALID_DOCUMENT', 'Expected an array.', path);
+    return value;
+}
+export function requireString(value, path) {
+    if (typeof value !== 'string')
+        fail('INVALID_DOCUMENT', 'Expected a string.', path);
+    return value;
+}
+export function requireBoundedString(value, path, maxLength) {
+    const text = requireString(value, path);
+    if (text.length === 0)
+        fail('INVALID_DOCUMENT', 'Expected a non-empty string.', path);
+    if (text.length > maxLength) {
+        fail('LIMIT_EXCEEDED', `String length exceeds the configured limit ${maxLength}.`, path);
+    }
+    return text;
+}
+export function requireCharacter(value, path, limits) {
+    const character = requireString(value, path);
+    if (character.length === 0) {
+        fail('INVALID_DOCUMENT', 'Expected a non-empty glyph string.', path);
+    }
+    assertWellFormedUnicode(character, path);
+    if (Array.from(character).length > limits.maxCharacterLength) {
+        fail('LIMIT_EXCEEDED', `Glyph string scalar count exceeds the configured limit ${limits.maxCharacterLength}.`, path);
+    }
+    return character;
+}
+function assertWellFormedUnicode(value, path) {
+    for (let index = 0; index < value.length; index++) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!Number.isInteger(next) || next < 0xdc00 || next > 0xdfff) {
+                fail('INVALID_DOCUMENT', 'Glyph strings must not contain unpaired surrogates.', path);
+            }
+            index++;
+            continue;
+        }
+        if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            fail('INVALID_DOCUMENT', 'Glyph strings must not contain unpaired surrogates.', path);
+        }
+    }
+}
+export function requireBoolean(value, path) {
+    if (typeof value !== 'boolean')
+        fail('INVALID_DOCUMENT', 'Expected a boolean.', path);
+    return value;
+}
+export function requireFiniteNumber(value, path) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        fail('INVALID_DOCUMENT', 'Expected a finite number.', path);
+    }
+    return value;
+}
+export function requireNumberInRange(value, path, minimum, maximum) {
+    const number = requireFiniteNumber(value, path);
+    if (number < minimum || number > maximum) {
+        fail('INVALID_DOCUMENT', `Expected a number from ${minimum} through ${maximum}.`, path);
+    }
+    return number;
+}
+export function requireSafeInteger(value, path) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value)) {
+        fail('INVALID_DOCUMENT', 'Expected a safe integer.', path);
+    }
+    return value;
+}
+function requirePositiveSafeInteger(value, path) {
+    const integer = requireSafeInteger(value, path);
+    if (integer <= 0)
+        fail('INVALID_DOCUMENT', 'Expected a positive safe integer.', path);
+    return integer;
+}
+function requireByte(value, path) {
+    const integer = requireSafeInteger(value, path);
+    if (integer < 0 || integer > 255) {
+        fail('INVALID_DOCUMENT', 'Expected an integer from 0 through 255.', path);
+    }
+    return integer;
+}
+export function failure(code, message, path) {
+    return { ok: false, error: { code, message, ...(path ? { path } : {}) } };
+}
+export function fail(code, message, path) {
+    throw new DocumentDecodeFailure({ code, message, ...(path ? { path } : {}) });
+}

package/docs/consumer-guide.md

@@ -0,0 +1,230 @@
+# Consumer guide
+
+## Choose a decoder
+
+Use `parseTextmodeDocumentJSON(text, options)` when you know the file is a
+textmode document. If your app accepts several JSON formats, use `parseJSON(text)`
+first. Check the parsed object's `format`, then pass textmode documents to
+`decodeTextmodeDocument(value, options)`. A filename or MIME type alone cannot
+identify the format.
+
+```js
+import { parseJSON, decodeTextmodeDocument } from '@textmode/document';
+
+const parsed = parseJSON(jsonText);
+if (!parsed.ok) {
+	console.error(parsed.error);
+} else if (
+	parsed.value !== null &&
+	typeof parsed.value === 'object' &&
+	!Array.isArray(parsed.value) &&
+	['textmode.document', 'textmode.layer'].includes(parsed.value.format)
+) {
+	const result = decodeTextmodeDocument(parsed.value, {
+		acceptLegacy: true,
+		limits: { maxCells: 16384, maxLayers: 64 },
+	});
+	console.log(result);
+} else {
+	// Route other supported formats to the app's other decoders.
+}
+```
+
+`parseJSON` uses JavaScript's `JSON.parse`. If an object repeats a key, the last
+value wins. Producers should use unique keys. Valid JSON is not necessarily a
+valid textmode document.
+
+## Handle results and budgets
+
+Invalid input returns `{ ok: false, error }`. The error includes a `code`,
+`message`, and sometimes a JSON path, such as `$.layer.cells.rows[0][0].foreground`.
+
+| Code                   | Meaning                                                           |
+| ---------------------- | ----------------------------------------------------------------- |
+| `INVALID_JSON`         | The input is not valid JSON syntax.                               |
+| `INVALID_DOCUMENT`     | A value or cross-field invariant is invalid.                      |
+| `UNSUPPORTED_FORMAT`   | The discriminator is unsupported, or legacy decoding is disabled. |
+| `UNSUPPORTED_VERSION`  | The format version is not explicitly supported.                   |
+| `UNSUPPORTED_TARGET`   | The document shape is unsupported.                                |
+| `UNSUPPORTED_ENCODING` | The cell encoding is unsupported.                                 |
+| `LIMIT_EXCEEDED`       | A resource budget or safe numeric range is exceeded.              |
+
+Successful results contain a canonical v3 `document` and a `warnings` array.
+Migrated `textmode.layer` v1 files return `LEGACY_DOCUMENT_MIGRATED`. Set
+`acceptLegacy: false` to reject them; the default is `true`. Supported v2 files
+remain readable and return `DOCUMENT_VERSION_MIGRATED`.
+
+After decoding, your app must check its own requirements, such as available fonts
+and supported blend modes. The decoder normalizes known values and omits unknown
+properties, so decoding and serializing does not preserve extensions. The format
+does not store font identity or post-processing.
+
+Set limits to positive safe integers. Invalid limit configuration throws
+`TypeError`. See the [default limits](specification-3.0.md#validation-budgets-and-compatibility).
+
+Check file size before reading: decoder limits apply after JSON parsing and do not
+limit input bytes or parser memory. Choose budgets for your app and check for
+cancellation between reading, decoding, and importing. The library is synchronous;
+you can decode large files in a worker.
+
+## Use JSON Schema
+
+Node 24 can import the schema with an import attribute:
+
+```js
+import schema from '@textmode/document/schema/3.0' with { type: 'json' };
+```
+
+Bundlers may use different JSON import syntax. Tools that read files can resolve
+the same package subpath. All references within the schema are local.
+
+For example, with Ajv installed in the consumer:
+
+```js
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import schema from '@textmode/document/schema/3.0' with { type: 'json' };
+
+const ajv = new Ajv2020({ validateFormats: true });
+addFormats(ajv, { mode: 'full' });
+const validate = ajv.compile(schema);
+```
+
+Enable date-time format assertions to check timestamps. The schema checks
+structure and local constraints. The decoder also checks relationships such as
+row sizes and coordinates, plus Unicode and resource limits. A schema-valid file
+can still fail decoding. Changing a decoder limit does not change the published
+schema; for example, the schema's glyph `maxLength` remains 64.
+
+## Complete single-layer document
+
+A single-layer document uses the same structure as a layer stack. The receiving
+application chooses the font.
+
+```json
+{
+	"format": "textmode.document",
+	"formatVersion": "3.0.0",
+	"layers": [
+		{
+			"visible": true,
+			"opacity": 1,
+			"blendMode": "normal",
+			"offsetX": 0,
+			"offsetY": 0,
+			"rotationZ": 0,
+			"grid": {
+				"cols": 1,
+				"rows": 1,
+				"cellWidth": 8,
+				"cellHeight": 16
+			},
+			"id": "base",
+			"cells": {
+				"encoding": "object-rows-v1",
+				"rows": [
+					[
+						{
+							"x": 0,
+							"y": 0,
+							"character": "A",
+							"foreground": "#ffffffff",
+							"background": "#00000000",
+							"transform": {
+								"invert": false,
+								"flipX": false,
+								"flipY": false,
+								"rotation": 0
+							}
+						}
+					]
+				]
+			}
+		}
+	]
+}
+```
+
+## Complete layer stack
+
+Layers appear in stack order, with the bottom layer first. Each layer has its own
+grid and presentation values. The document has no root canvas or viewport.
+
+```json
+{
+	"format": "textmode.document",
+	"formatVersion": "3.0.0",
+	"layers": [
+		{
+			"id": "base",
+			"visible": true,
+			"opacity": 1,
+			"blendMode": "normal",
+			"offsetX": 0,
+			"offsetY": 0,
+			"rotationZ": 0,
+			"grid": {
+				"cols": 1,
+				"rows": 1,
+				"cellWidth": 8,
+				"cellHeight": 16
+			},
+			"cells": {
+				"encoding": "object-rows-v1",
+				"rows": [
+					[
+						{
+							"x": 0,
+							"y": 0,
+							"character": "A",
+							"foreground": "#ffffffff",
+							"background": "#000000ff",
+							"transform": {
+								"invert": false,
+								"flipX": false,
+								"flipY": false,
+								"rotation": 0
+							}
+						}
+					]
+				]
+			}
+		},
+		{
+			"id": "accent",
+			"visible": true,
+			"opacity": 0.5,
+			"blendMode": "screen",
+			"offsetX": 4,
+			"offsetY": 0,
+			"rotationZ": 15,
+			"grid": {
+				"cols": 1,
+				"rows": 1,
+				"cellWidth": 8,
+				"cellHeight": 16
+			},
+			"cells": {
+				"encoding": "object-rows-v1",
+				"rows": [
+					[
+						{
+							"x": 0,
+							"y": 0,
+							"character": "*",
+							"foreground": "#ff000080",
+							"background": "#00000000",
+							"transform": {
+								"invert": false,
+								"flipX": true,
+								"flipY": false,
+								"rotation": 90
+							}
+						}
+					]
+				]
+			}
+		}
+	]
+}
+```