gmljs 2.0.5 → 3.0.0-beta-20260118

package/.claude/settings.local.json

@@ -0,0 +1,18 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm test:*)",
+      "Bash(grep:*)",
+      "Bash(npm run build:*)",
+      "Bash(node --import tsx --test 'src/__test__/preview.test.ts')",
+      "Bash(node --import tsx -e:*)",
+      "Bash(npm ls:*)",
+      "Bash(node --import tsx --test --test-update-snapshots 'src/__test__/preview.test.ts')",
+      "Bash(git checkout:*)",
+      "Bash(xxd:*)",
+      "Bash(node --version)",
+      "Bash(node --test:*)",
+      "Bash(node --import tsx --test --test-update-snapshots 'src/**/*.test.ts')"
+    ]
+  }
+}

package/dist/gml/index.d.ts

@@ -0,0 +1,34 @@
+import { GMLAttributeDefinition, GMLChildNodeDefinition, GMLNodeAttribute, GMLNodeAttributes, GMLNodeAttributeValue, GMLNodeChildPath, GMLNodeChildren, GMLNodeDefinition, GMLNodeInterface, GMLNodeName, GMLNodeValue, GMLObjectRepresentation, GMLParsedNode } from "./types";
+export declare abstract class GMLNode implements GMLNodeInterface {
+    definition: GMLNodeDefinition;
+    attributes: GMLNodeAttributes;
+    children: GMLNodeChildren;
+    value: GMLNodeValue;
+    constructor(definition: GMLNodeDefinition, data?: GMLParsedNode);
+    init(data?: GMLParsedNode): void;
+    verifyAttributes(): void;
+    verifyChildren(): void;
+    setAttribute(key: GMLNodeAttribute, value: GMLNodeAttributeValue): void;
+    getAttribute(key: GMLNodeAttribute): GMLNodeAttributeValue | undefined;
+    addChild(name: GMLNodeName, child: GMLNode): void;
+    removeChild(name: GMLNodeName, index?: number): void;
+    hasChild(name: GMLNodeName): boolean;
+    hasChildren(): boolean;
+    getChild<T extends GMLNodeInterface>(child: GMLNodeChildPath): T | undefined;
+    getChildren<T extends GMLNodeInterface>(name: GMLNodeName): T[] | undefined;
+    getChildPath<T extends GMLNodeInterface>(path: GMLNodeChildPath[]): T | undefined;
+    getChildValue(path: GMLNodeChildPath[]): GMLNodeValue | undefined;
+    getChildValueString(path: GMLNodeChildPath[]): string;
+    getValue(): GMLNodeValue;
+    setValue(value: GMLNodeValue): void;
+    parseValue(data: GMLParsedNode): void;
+    parseAttributes(data: GMLParsedNode): void;
+    parseChildNodes(data: GMLParsedNode): void;
+    getChildNodeDefinition(name: GMLNodeName): GMLChildNodeDefinition | undefined;
+    getAttributeDefinition(name: GMLNodeAttribute): GMLAttributeDefinition | undefined;
+    getTagStart(): string;
+    getTagEnd(): string;
+    getTagContent(): string;
+    toString(): string;
+    toObject(): GMLObjectRepresentation;
+}

package/dist/gml/index.js

@@ -0,0 +1,190 @@
+import { formatXmlTagStart, formatXmlTagEnd } from "../util/xml";
+import { getGMLNodeDefinition } from "./map";
+import { createGMLChildNodeDefinition, createGmlNode, isGMLChildNodeDefinition, isGMLNodeAttribute, isGMLNodeName, } from "./util";
+export class GMLNode {
+    definition;
+    attributes = {};
+    children = {};
+    value = "";
+    constructor(definition, data) {
+        this.definition = definition;
+        this.init(data);
+        this.verifyAttributes();
+        this.verifyChildren();
+    }
+    init(data) {
+        // Apply attribute defaults first
+        this.definition.attributes.forEach((item) => {
+            if (item.defaultValue !== undefined) {
+                this.setAttribute(item.name, item.defaultValue);
+            }
+        });
+        if (data) {
+            this.parseValue(data);
+            this.parseAttributes(data);
+            this.parseChildNodes(data);
+        }
+        else {
+            this.definition.children.forEach((item) => {
+                if (typeof item === "object" && item.initDefault) {
+                    this.addChild(item.name, createGmlNode(getGMLNodeDefinition(item.name)));
+                }
+            });
+        }
+    }
+    verifyAttributes() {
+        // Check for required attributes
+        this.definition.attributes.forEach(({ name, required }) => {
+            if (required && this.getAttribute(name) === undefined) {
+                throw new Error(`Invalid GML: A "${this.definition.name}" node requires a "${name}" attribute.`);
+            }
+        });
+    }
+    verifyChildren() {
+        // Check for required children
+        this.definition.children
+            .filter(isGMLChildNodeDefinition)
+            .forEach(({ name, required }) => {
+            if (required && !this.hasChild(name)) {
+                throw new Error(`Invalid GML: A "${this.definition.name}" node requires a "${name}" child node.`);
+            }
+        });
+    }
+    setAttribute(key, value) {
+        this.attributes[key] = value;
+    }
+    getAttribute(key) {
+        return this.attributes[key];
+    }
+    addChild(name, child) {
+        if (!Array.isArray(this.children[name])) {
+            this.children[name] = [];
+        }
+        this.children[name]?.push(child);
+    }
+    removeChild(name, index) {
+        if (index) {
+            this.children[name]?.splice(index, 1);
+            if (!this.children[name]?.length) {
+                delete this.children[name];
+            }
+        }
+        else {
+            delete this.children[name];
+        }
+    }
+    hasChild(name) {
+        return Array.isArray(this.children[name]) && this.children[name].length > 0;
+    }
+    hasChildren() {
+        return Object.keys(this.children).length > 0;
+    }
+    getChild(child) {
+        let name;
+        let index = 0;
+        if (Array.isArray(child)) {
+            [name, index] = child;
+        }
+        else if (typeof child === "string") {
+            name = child;
+        }
+        else {
+            return undefined;
+        }
+        return this.getChildren(name)?.[index];
+    }
+    getChildren(name) {
+        return this.children[name];
+    }
+    getChildPath(path) {
+        if (!Array.isArray(path) || !path.length) {
+            return undefined;
+        }
+        const node = this.getChild(path[0]);
+        return path.length > 1 ? node?.getChildPath(path.slice(1)) : node;
+    }
+    getChildValue(path) {
+        const node = this.getChildPath(path);
+        return node?.value;
+    }
+    getChildValueString(path) {
+        const node = this.getChildPath(path);
+        return String(node?.value ?? "");
+    }
+    getValue() {
+        return this.value;
+    }
+    setValue(value) {
+        this.value = value;
+    }
+    parseValue(data) {
+        const value = data.textContent ?? "";
+        this.value =
+            (typeof value === "string" ? value : "").split("\n").shift() ?? "";
+    }
+    parseAttributes(data) {
+        if (!Array.isArray(this.definition.attributes)) {
+            return;
+        }
+        if ("attributes" in data && data.attributes.length) {
+            for (let i = 0; i < data.attributes.length; ++i) {
+                const attr = data.attributes.item(i);
+                const name = attr?.nodeName.toLowerCase();
+                if (attr && isGMLNodeAttribute(name)) {
+                    const value = attr.value;
+                    const attributeDefinition = this.getAttributeDefinition(name);
+                    if (attributeDefinition) {
+                        const attributeValue = typeof attributeDefinition.parse === "function"
+                            ? attributeDefinition.parse(value)
+                            : value;
+                        this.setAttribute(name, attributeValue);
+                    }
+                }
+            }
+        }
+    }
+    parseChildNodes(data) {
+        if (data.childNodes?.length) {
+            for (let i = 0; i < data.childNodes.length; ++i) {
+                const child = data.childNodes[i];
+                const name = child.nodeName.toLowerCase();
+                if (isGMLNodeName(name)) {
+                    const childNode = this.getChildNodeDefinition(name);
+                    if (childNode) {
+                        const definition = getGMLNodeDefinition(name);
+                        this.addChild(name, createGmlNode(definition, child));
+                    }
+                }
+            }
+        }
+    }
+    getChildNodeDefinition(name) {
+        return this.definition.children
+            .map((item) => typeof item === "string" ? createGMLChildNodeDefinition(item) : item)
+            .find((item) => item.name === name);
+    }
+    getAttributeDefinition(name) {
+        return this.definition.attributes?.find((item) => item.name === name);
+    }
+    getTagStart() {
+        return formatXmlTagStart(this.definition.name, this.attributes);
+    }
+    getTagEnd() {
+        return formatXmlTagEnd(this.definition.name);
+    }
+    getTagContent() {
+        return Object.keys(this.children)
+            .map((child) => this.children[child]?.map((item) => item.toString()).join(""))
+            .join("");
+    }
+    toString() {
+        return `${this.getTagStart()}${this.getTagContent()}${this.getTagEnd()}`;
+    }
+    toObject() {
+        const obj = (Object.keys(this.children)).reduce((result, tag) => ({
+            ...result,
+            [tag]: this.children[tag].map((item) => item.toObject()),
+        }), {});
+        return obj;
+    }
+}

package/dist/gml/map.d.ts

@@ -0,0 +1,4 @@
+import { GMLNodeDefinition, GMLNodeName } from "./types";
+declare const gmlNodeClassMap: Record<GMLNodeName, GMLNodeDefinition>;
+export declare const getGMLNodeDefinition: (nodeName: GMLNodeName) => GMLNodeDefinition;
+export default gmlNodeClassMap;

package/dist/gml/map.js

@@ -0,0 +1,79 @@
+import { GMLNodeName } from "./types";
+import GMLBrush from "./nodes/brush";
+import GMLClient from "./nodes/client";
+import { GMLBrushModeDefinition as GMLBrushMode, GMLBrushSpecDefinition as GMLBrushSpec, GMLBrushWidthDefinition as GMLBrushWidth, GMLBrushSpeedToWidthRatioDefinition as GMLBrushSpeedToWidthRatio, GMLBrushUniqueStyleIdDefinition as GMLBrushUniqueStyleId, GMLBrushLayerAbsoluteDefinition as GMLBrushLayerAbsolute, GMLBrushLayerRelativeDefinition as GMLBrushLayerRelative, GMLBrushDripAmountDefinition as GMLBrushDripAmount, GMLBrushDripSpeedDefinition as GMLBrushDripSpeed, GMLBrushDripVecRelativeToUpDefinition as GMLBrushDripVecRelativeToUp, } from "./nodes/brush/settings";
+import { GMLClientIpDefinition as GMLClientIp, GMLClientKeywordsDefinition as GMLClientKeywords, GMLClientNameDefinition as GMLClientName, GMLClientPermalinkDefinition as GMLClientPermalink, GMLClientUniqueKeyDefinition as GMLClientUniqueKey, GMLClientUsernameDefinition as GMLClientUsername, GMLClientVersionDefinition as GMLClientVersion, GMLLocationDefinition as GMLLocation, GMLLocationLatitudeDefinition as GMLLocationLatitude, GMLLocationLongitudeDefinition as GMLLocationLongitude, GMLTimeDefinition as GMLTime, } from "./nodes/client/settings";
+import GMLDocument from "./nodes/document";
+import GMLDrawing from "./nodes/drawing";
+import GMLEnvironment from "./nodes/environment";
+import { GMLEnvOffsetDefinition as GMLEnvOffset, GMLEnvRotationDefinition as GMLEnvRotation, GMLEnvOriginDefinition as GMLEnvOrigin, GMLEnvRealScareDefinition as GMLEnvRealScare, GMLEnvAudioDefinition as GMLEnvAudio, GMLEnvBackgroundDefinition as GMLEnvBackground, GMLEnvUpDefinition as GMLEnvUp, GMLEnvScreenBoundsDefinition as GMLEnvScreenBounds, } from "./nodes/environment/settings";
+import GMLPoint from "./nodes/point";
+import GMLColor, { GMLColorRDefinition as GMLColorR, GMLColorGDefinition as GMLColorG, GMLColorBDefinition as GMLColorB, GMLColorADefinition as GMLColorA, } from "./nodes/point/color";
+import GMLDirection from "./nodes/point/direction";
+import { GMLPointXDefinition as GMLPointX, GMLPointYDefinition as GMLPointY, GMLPointZDefinition as GMLPointZ, GMLPointTDefinition as GMLPointT, 
+// GMLPointTimeDefinition as GMLPointTime,
+GMLPointPressureDefinition as GMLPointPressure, GMLPointRotationDefinition as GMLPointRotation, GMLPointUnitDefinition as GMLPointUnit, } from "./nodes/point/points";
+import GMLRoot from "./nodes/root";
+import GMLStroke from "./nodes/stroke";
+import GMLStrokeInfo from "./nodes/stroke/info";
+import GMLStrokeInfoCurved from "./nodes/stroke/curved";
+import GMLTag from "./nodes/tag";
+import GMLHeader from "./nodes/header";
+const gmlNodeClassMap = {
+    [GMLNodeName.BRUSH]: GMLBrush,
+    [GMLNodeName.BRUSH_MODE]: GMLBrushMode,
+    [GMLNodeName.BRUSH_SPEC]: GMLBrushSpec,
+    [GMLNodeName.BRUSH_WIDTH]: GMLBrushWidth,
+    [GMLNodeName.BRUSH_SPEED_TO_WIDTH_RATIO]: GMLBrushSpeedToWidthRatio,
+    [GMLNodeName.BRUSH_DRIP_AMOUNT]: GMLBrushDripAmount,
+    [GMLNodeName.BRUSH_DRIP_SPEED]: GMLBrushDripSpeed,
+    [GMLNodeName.BRUSH_DRIP_VEC_RELATIVE_TO_UP]: GMLBrushDripVecRelativeToUp,
+    [GMLNodeName.BRUSH_LAYER_ABSOLUTE]: GMLBrushLayerAbsolute,
+    [GMLNodeName.BRUSH_LAYER_RELATIVE]: GMLBrushLayerRelative,
+    [GMLNodeName.BRUSH_UNIQUE_STYLE_ID]: GMLBrushUniqueStyleId,
+    [GMLNodeName.CLIENT]: GMLClient,
+    [GMLNodeName.CLIENT_IP]: GMLClientIp,
+    [GMLNodeName.CLIENT_NAME]: GMLClientName,
+    [GMLNodeName.CLIENT_KEYWORDS]: GMLClientKeywords,
+    [GMLNodeName.CLIENT_PERMALINK]: GMLClientPermalink,
+    [GMLNodeName.CLIENT_UNIQUEKEY]: GMLClientUniqueKey,
+    [GMLNodeName.CLIENT_USERNAME]: GMLClientUsername,
+    [GMLNodeName.CLIENT_VERSION]: GMLClientVersion,
+    [GMLNodeName.CLIENT_LOCATION]: GMLLocation,
+    [GMLNodeName.CLIENT_LOCATION_LAT]: GMLLocationLatitude,
+    [GMLNodeName.CLIENT_LOCATION_LON]: GMLLocationLongitude,
+    [GMLNodeName.CLIENT_TIME]: GMLTime,
+    [GMLNodeName.COLOR]: GMLColor,
+    [GMLNodeName.COLOR_R]: GMLColorR,
+    [GMLNodeName.COLOR_G]: GMLColorG,
+    [GMLNodeName.COLOR_B]: GMLColorB,
+    [GMLNodeName.COLOR_A]: GMLColorA,
+    [GMLNodeName.DIRECTION]: GMLDirection,
+    [GMLNodeName.DOCUMENT]: GMLDocument,
+    [GMLNodeName.DRAWING]: GMLDrawing,
+    [GMLNodeName.ENVIRONMENT]: GMLEnvironment,
+    [GMLNodeName.ENVIRONMENT_OFFSET]: GMLEnvOffset,
+    [GMLNodeName.ENVIRONMENT_ROTATION]: GMLEnvRotation,
+    [GMLNodeName.ENVIRONMENT_UP]: GMLEnvUp,
+    [GMLNodeName.ENVIRONMENT_SCREEN_BOUNDS]: GMLEnvScreenBounds,
+    [GMLNodeName.ENVIRONMENT_ORIGIN]: GMLEnvOrigin,
+    [GMLNodeName.ENVIRONMENT_REAL_SCALE]: GMLEnvRealScare,
+    [GMLNodeName.ENVIRONMENT_AUDIO]: GMLEnvAudio,
+    [GMLNodeName.ENVIRONMENT_BACKGROUND]: GMLEnvBackground,
+    [GMLNodeName.HEADER]: GMLHeader,
+    [GMLNodeName.POINT]: GMLPoint,
+    [GMLNodeName.POINT_T]: GMLPointT,
+    [GMLNodeName.POINT_X]: GMLPointX,
+    [GMLNodeName.POINT_Y]: GMLPointY,
+    [GMLNodeName.POINT_Z]: GMLPointZ,
+    [GMLNodeName.PRESSURE]: GMLPointPressure,
+    [GMLNodeName.ROOT]: GMLRoot,
+    [GMLNodeName.ROTATION]: GMLPointRotation,
+    [GMLNodeName.STROKE]: GMLStroke,
+    [GMLNodeName.STROKE_INFO]: GMLStrokeInfo,
+    [GMLNodeName.STROKE_INFO_CURVED]: GMLStrokeInfoCurved,
+    [GMLNodeName.TAG]: GMLTag,
+    [GMLNodeName.UNIT]: GMLPointUnit,
+};
+export const getGMLNodeDefinition = (nodeName) => gmlNodeClassMap[nodeName];
+export default gmlNodeClassMap;

package/dist/gml/nodes/brush/index.d.ts

@@ -0,0 +1,6 @@
+import { GMLNode } from "../..";
+import { GMLNodeDefinition } from "../../types";
+export declare class GMLBrush extends GMLNode {
+}
+export declare const GMLBrushDefinition: GMLNodeDefinition;
+export default GMLBrushDefinition;

package/dist/gml/nodes/brush/index.js

@@ -0,0 +1,23 @@
+import { GMLNode } from "../..";
+import { GMLNodeName } from "../../types";
+export class GMLBrush extends GMLNode {
+}
+export const GMLBrushDefinition = {
+    name: GMLNodeName.BRUSH,
+    model: GMLBrush,
+    attributes: [],
+    children: [
+        GMLNodeName.COLOR,
+        GMLNodeName.BRUSH_MODE,
+        GMLNodeName.BRUSH_SPEC,
+        GMLNodeName.BRUSH_WIDTH,
+        GMLNodeName.BRUSH_SPEED_TO_WIDTH_RATIO,
+        GMLNodeName.BRUSH_DRIP_AMOUNT,
+        GMLNodeName.BRUSH_DRIP_SPEED,
+        GMLNodeName.BRUSH_DRIP_VEC_RELATIVE_TO_UP,
+        GMLNodeName.BRUSH_LAYER_ABSOLUTE,
+        GMLNodeName.BRUSH_LAYER_RELATIVE,
+        GMLNodeName.BRUSH_UNIQUE_STYLE_ID,
+    ],
+};
+export default GMLBrushDefinition;

package/dist/gml/nodes/brush/settings.d.ts

@@ -0,0 +1,35 @@
+import { GMLNodeDefinition } from "../../types";
+import { GMLLeafNode } from "../leaf";
+import { GMLFloatNode } from "../leaf/float";
+import { GMLIntegerNode } from "../leaf/integer";
+import { GMLLeafNodeParent } from "../leaf/parent";
+export declare class GMLBrushMode extends GMLLeafNode {
+}
+export declare const GMLBrushModeDefinition: GMLNodeDefinition;
+export declare class GMLBrushSpec extends GMLLeafNode {
+}
+export declare const GMLBrushSpecDefinition: GMLNodeDefinition;
+export declare class GMLBrushWidth extends GMLFloatNode {
+}
+export declare const GMLBrushWidthDefinition: GMLNodeDefinition;
+export declare class GMLBrushSpeedToWidthRatio extends GMLFloatNode {
+}
+export declare const GMLBrushSpeedToWidthRatioDefinition: GMLNodeDefinition;
+export declare class GMLBrushUniqueStyleId extends GMLLeafNode {
+}
+export declare const GMLBrushUniqueStyleIdDefinition: GMLNodeDefinition;
+export declare class GMLBrushLayerAbsolute extends GMLIntegerNode {
+}
+export declare const GMLBrushLayerAbsoluteDefinition: GMLNodeDefinition;
+export declare class GMLBrushLayerRelative extends GMLIntegerNode {
+}
+export declare const GMLBrushLayerRelativeDefinition: GMLNodeDefinition;
+export declare class GMLBrushDripAmount extends GMLFloatNode {
+}
+export declare const GMLBrushDripAmountDefinition: GMLNodeDefinition;
+export declare class GMLBrushDripSpeed extends GMLFloatNode {
+}
+export declare const GMLBrushDripSpeedDefinition: GMLNodeDefinition;
+export declare class GMLBrushDripVecRelativeToUp extends GMLLeafNodeParent {
+}
+export declare const GMLBrushDripVecRelativeToUpDefinition: GMLNodeDefinition;

package/dist/gml/nodes/brush/settings.js

@@ -0,0 +1,45 @@
+import { GMLNodeName } from "../../types";
+import { createDefinition } from "../../util/definition";
+import { GMLLeafNode } from "../leaf";
+import { GMLFloatNode } from "../leaf/float";
+import { GMLIntegerNode } from "../leaf/integer";
+import { GMLLeafNodeParent } from "../leaf/parent";
+export class GMLBrushMode extends GMLLeafNode {
+}
+export const GMLBrushModeDefinition = createDefinition(GMLNodeName.BRUSH_MODE, GMLBrushMode);
+export class GMLBrushSpec extends GMLLeafNode {
+}
+export const GMLBrushSpecDefinition = createDefinition(GMLNodeName.BRUSH_SPEC, GMLBrushSpec);
+export class GMLBrushWidth extends GMLFloatNode {
+}
+export const GMLBrushWidthDefinition = createDefinition(GMLNodeName.BRUSH_WIDTH, GMLBrushWidth);
+export class GMLBrushSpeedToWidthRatio extends GMLFloatNode {
+}
+export const GMLBrushSpeedToWidthRatioDefinition = createDefinition(GMLNodeName.BRUSH_SPEED_TO_WIDTH_RATIO, GMLBrushSpeedToWidthRatio);
+export class GMLBrushUniqueStyleId extends GMLLeafNode {
+}
+export const GMLBrushUniqueStyleIdDefinition = createDefinition(GMLNodeName.BRUSH_UNIQUE_STYLE_ID, GMLBrushUniqueStyleId);
+export class GMLBrushLayerAbsolute extends GMLIntegerNode {
+}
+export const GMLBrushLayerAbsoluteDefinition = createDefinition(GMLNodeName.BRUSH_LAYER_ABSOLUTE, GMLBrushLayerAbsolute);
+export class GMLBrushLayerRelative extends GMLIntegerNode {
+}
+export const GMLBrushLayerRelativeDefinition = createDefinition(GMLNodeName.BRUSH_LAYER_RELATIVE, GMLBrushLayerRelative);
+export class GMLBrushDripAmount extends GMLFloatNode {
+}
+export const GMLBrushDripAmountDefinition = createDefinition(GMLNodeName.BRUSH_DRIP_AMOUNT, GMLBrushDripAmount);
+export class GMLBrushDripSpeed extends GMLFloatNode {
+}
+export const GMLBrushDripSpeedDefinition = createDefinition(GMLNodeName.BRUSH_DRIP_SPEED, GMLBrushDripSpeed);
+export class GMLBrushDripVecRelativeToUp extends GMLLeafNodeParent {
+}
+export const GMLBrushDripVecRelativeToUpDefinition = {
+    name: GMLNodeName.BRUSH_DRIP_VEC_RELATIVE_TO_UP,
+    model: GMLBrushDripVecRelativeToUp,
+    attributes: [],
+    children: [
+        { name: GMLNodeName.POINT_X, required: true },
+        { name: GMLNodeName.POINT_Y, required: true },
+        GMLNodeName.POINT_Z,
+    ],
+};

package/dist/gml/nodes/client/index.d.ts

@@ -0,0 +1,7 @@
+import { GMLNode } from "../..";
+import { GMLNodeDefinition, GMLParsedNode } from "../../types";
+export declare class GMLClient extends GMLNode {
+    init(data?: GMLParsedNode): void;
+}
+export declare const definition: GMLNodeDefinition;
+export default definition;

package/dist/gml/nodes/client/index.js

@@ -0,0 +1,25 @@
+import { GMLNode } from "../..";
+import { GMLNodeName } from "../../types";
+export class GMLClient extends GMLNode {
+    init(data) {
+        super.init(data);
+        // TODO: Add <version> if default <name> was created
+    }
+}
+export const definition = {
+    name: GMLNodeName.CLIENT,
+    model: GMLClient,
+    attributes: [],
+    children: [
+        { name: GMLNodeName.CLIENT_NAME, initDefault: true },
+        { name: GMLNodeName.CLIENT_VERSION, initDefault: true },
+        { name: GMLNodeName.CLIENT_TIME, initDefault: true },
+        GMLNodeName.CLIENT_USERNAME,
+        GMLNodeName.CLIENT_PERMALINK,
+        GMLNodeName.CLIENT_KEYWORDS,
+        GMLNodeName.CLIENT_UNIQUEKEY,
+        GMLNodeName.CLIENT_IP,
+        GMLNodeName.CLIENT_LOCATION,
+    ],
+};
+export default definition;

package/dist/gml/nodes/client/settings.d.ts

@@ -0,0 +1,48 @@
+import { GMLNodeDefinition, GMLParsedNode } from "../../types";
+import { GMLLeafNode } from "../leaf";
+import { GMLLeafNodeParent } from "../leaf/parent";
+export declare class GMLClientUsername extends GMLLeafNode {
+}
+export declare const GMLClientUsernameDefinition: GMLNodeDefinition;
+export declare class GMLClientPermalink extends GMLLeafNode {
+}
+export declare const GMLClientPermalinkDefinition: GMLNodeDefinition;
+export declare class GMLClientKeywords extends GMLLeafNode {
+}
+export declare const GMLClientKeywordsDefinition: GMLNodeDefinition;
+export declare class GMLClientUniqueKey extends GMLLeafNode {
+}
+export declare const GMLClientUniqueKeyDefinition: GMLNodeDefinition;
+export declare class GMLClientIp extends GMLLeafNode {
+}
+export declare const GMLClientIpDefinition: GMLNodeDefinition;
+export declare class GMLClientName extends GMLLeafNode {
+    init(data?: GMLParsedNode): void;
+}
+export declare const GMLClientNameDefinition: GMLNodeDefinition;
+export declare class GMLTime extends GMLLeafNode {
+    /**
+     * `declare` tells TypeScript the property exists but does not emit
+     * any initialization code. This allows the value set in init() to
+     * persist.
+     */
+    private stringValue;
+    constructor(definition: GMLNodeDefinition, data?: GMLParsedNode);
+    init(data?: GMLParsedNode): void;
+    parseValue(data: GMLParsedNode): void;
+    get floatValue(): number | undefined;
+}
+export declare const GMLTimeDefinition: GMLNodeDefinition;
+export declare class GMLClientVersion extends GMLLeafNode {
+    init(data?: GMLParsedNode): void;
+}
+export declare const GMLClientVersionDefinition: GMLNodeDefinition;
+export declare class GMLLocation extends GMLLeafNodeParent {
+}
+export declare const GMLLocationDefinition: GMLNodeDefinition;
+export declare class GMLLocationLongitude extends GMLLeafNode {
+}
+export declare const GMLLocationLongitudeDefinition: GMLNodeDefinition;
+export declare class GMLLocationLatitude extends GMLLeafNode {
+}
+export declare const GMLLocationLatitudeDefinition: GMLNodeDefinition;

package/dist/gml/nodes/client/settings.js

@@ -0,0 +1,74 @@
+import { GMLNodeName, } from "../../types";
+import { GMLLeafNode } from "../leaf";
+import { createDefinition } from "../../util/definition";
+import { GMLLeafNodeParent } from "../leaf/parent";
+import config from "../../../../package.json";
+export class GMLClientUsername extends GMLLeafNode {
+}
+export const GMLClientUsernameDefinition = createDefinition(GMLNodeName.CLIENT_USERNAME, GMLClientUsername);
+export class GMLClientPermalink extends GMLLeafNode {
+}
+export const GMLClientPermalinkDefinition = createDefinition(GMLNodeName.CLIENT_PERMALINK, GMLClientPermalink);
+export class GMLClientKeywords extends GMLLeafNode {
+}
+export const GMLClientKeywordsDefinition = createDefinition(GMLNodeName.CLIENT_KEYWORDS, GMLClientKeywords);
+export class GMLClientUniqueKey extends GMLLeafNode {
+}
+export const GMLClientUniqueKeyDefinition = createDefinition(GMLNodeName.CLIENT_UNIQUEKEY, GMLClientUniqueKey);
+export class GMLClientIp extends GMLLeafNode {
+}
+export const GMLClientIpDefinition = createDefinition(GMLNodeName.CLIENT_IP, GMLClientIp);
+export class GMLClientName extends GMLLeafNode {
+    init(data) {
+        this.setValue("gmljs");
+        super.init(data);
+    }
+}
+export const GMLClientNameDefinition = createDefinition(GMLNodeName.CLIENT_NAME, GMLClientName);
+export class GMLTime extends GMLLeafNode {
+    constructor(definition, data) {
+        super(definition, data);
+        this.stringValue = data?.textContent ?? "";
+    }
+    init(data) {
+        this.setValue(Math.floor(Date.now() * 0.001));
+        super.init(data);
+    }
+    parseValue(data) {
+        const value = data.textContent ?? "";
+        const intValue = parseInt(value, 10);
+        if (!Number.isFinite(intValue)) {
+            throw new Error(`Unable to parse value "${value}" as integer.`);
+        }
+        this.value = intValue;
+        this.stringValue = value;
+    }
+    get floatValue() {
+        return this.stringValue ? parseFloat(this.stringValue) : undefined;
+    }
+}
+export const GMLTimeDefinition = createDefinition(GMLNodeName.CLIENT_TIME, GMLTime);
+export class GMLClientVersion extends GMLLeafNode {
+    init(data) {
+        this.setValue(config.version ?? "unknown");
+        super.init(data);
+    }
+}
+export const GMLClientVersionDefinition = createDefinition(GMLNodeName.CLIENT_VERSION, GMLClientVersion);
+export class GMLLocation extends GMLLeafNodeParent {
+}
+export const GMLLocationDefinition = {
+    name: GMLNodeName.CLIENT_LOCATION,
+    model: GMLLocation,
+    attributes: [],
+    children: [
+        { name: GMLNodeName.CLIENT_LOCATION_LAT, required: true },
+        { name: GMLNodeName.CLIENT_LOCATION_LON, required: true },
+    ],
+};
+export class GMLLocationLongitude extends GMLLeafNode {
+}
+export const GMLLocationLongitudeDefinition = createDefinition(GMLNodeName.CLIENT_LOCATION_LON, GMLLocationLongitude);
+export class GMLLocationLatitude extends GMLLeafNode {
+}
+export const GMLLocationLatitudeDefinition = createDefinition(GMLNodeName.CLIENT_LOCATION_LAT, GMLLocationLatitude);

package/dist/gml/nodes/document/index.d.ts

@@ -0,0 +1,7 @@
+import { GMLNode } from "../..";
+import { GMLNodeDefinition } from "../../types";
+export declare class GMLDocument extends GMLNode {
+    toString(): string;
+}
+export declare const GMLDocumentDefinition: GMLNodeDefinition;
+export default GMLDocumentDefinition;

package/dist/gml/nodes/document/index.js

@@ -0,0 +1,14 @@
+import { GMLNode } from "../..";
+import { GMLNodeName } from "../../types";
+export class GMLDocument extends GMLNode {
+    toString() {
+        return this.getChild(GMLNodeName.ROOT)?.toString() ?? "";
+    }
+}
+export const GMLDocumentDefinition = {
+    name: GMLNodeName.DOCUMENT,
+    model: GMLDocument,
+    attributes: [],
+    children: [{ name: GMLNodeName.ROOT, initDefault: true }],
+};
+export default GMLDocumentDefinition;

package/dist/gml/nodes/drawing/index.d.ts

@@ -0,0 +1,9 @@
+import { GMLNode } from "../..";
+import { GMLNodeDefinition } from "../../types";
+import { GMLStroke } from "../stroke";
+export declare class GMLDrawing extends GMLNode {
+    getStroke(index: number): GMLStroke | undefined;
+    getStrokes(): GMLStroke[];
+}
+export declare const GMLDrawingDefinition: GMLNodeDefinition;
+export default GMLDrawingDefinition;

package/dist/gml/nodes/drawing/index.js

@@ -0,0 +1,17 @@
+import { GMLNode } from "../..";
+import { GMLNodeName } from "../../types";
+export class GMLDrawing extends GMLNode {
+    getStroke(index) {
+        return this.getChildPath([[GMLNodeName.STROKE, index]]);
+    }
+    getStrokes() {
+        return this.getChildren(GMLNodeName.STROKE) ?? [];
+    }
+}
+export const GMLDrawingDefinition = {
+    name: GMLNodeName.DRAWING,
+    model: GMLDrawing,
+    attributes: [],
+    children: [GMLNodeName.STROKE],
+};
+export default GMLDrawingDefinition;

package/dist/gml/nodes/environment/index.d.ts

@@ -0,0 +1,10 @@
+import { GMLNode } from "../..";
+import { GMLNodeDefinition } from "../../types";
+export declare class GMLEnvironment extends GMLNode {
+    getUp(): number[] | undefined;
+    getScreenBounds(): number[] | undefined;
+    getOffset(): number[] | undefined;
+    getRotation(): number[] | undefined;
+}
+export declare const GMLEnvironmentDefinition: GMLNodeDefinition;
+export default GMLEnvironmentDefinition;