document-model 1.0.21 → 1.0.23

package/dist/browser/internal/index-8aac3662.js

@@ -0,0 +1,1928 @@
+var ut = Object.defineProperty;
+var mt = (t, e, r) => e in t ? ut(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var ce = (t, e, r) => (mt(t, typeof e != "symbol" ? e + "" : e, r), r);
+import { c as Et, i as ht, a as Ot, b as gt, s as St, d as bt, l as ft, e as _t, f as s, B as l, g as It, h as Tt } from "./object-67d1240b.js";
+import "json-stringify-deterministic";
+import "immer";
+import "jszip";
+import { z as o } from "zod";
+const Rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" })), de = {
+  id: "powerhouse/document-model",
+  name: "DocumentModel",
+  extension: "phdm",
+  description: "The Powerhouse Document Model describes the state and operations of a document type.",
+  author: {
+    name: "Powerhouse",
+    website: "https://www.powerhouse.inc/"
+  },
+  specifications: [
+    {
+      version: 1,
+      changeLog: [],
+      modules: [
+        {
+          name: "header",
+          operations: [
+            {
+              name: "SetModelName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModelId",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModelExtension",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModelDescription",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetAuthorName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetAuthorWebsite",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "versioning",
+          operations: [
+            {
+              name: "AddChangeLogItem",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "UpdateChangeLogItem",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteChangeLogItem",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderChangeLogItems",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReleaseNewVersion",
+              schema: null,
+              id: "",
+              description: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "module",
+          operations: [
+            {
+              name: "AddModule",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModuleName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModuleDescription",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteModule",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderModules",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "operation-error",
+          operations: [
+            {
+              name: "AddOperationError",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationErrorCode",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationErrorName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationErrorDescription",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationErrorTemplate",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteOperationError",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderOperationErrors",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "operation-example",
+          operations: [
+            {
+              name: "AddOperationExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "UpdateOperationExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteOperationExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderOperationExamples",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "operation",
+          operations: [
+            {
+              name: "AddOperation",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationSchema",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationDescription",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationTemplate",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationReducer",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "MoveOperation",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteOperation",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderModuleOperations",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "state",
+          operations: [
+            {
+              name: "SetStateSchema",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetInitialState",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "AddStateExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "UpdateStateExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteStateExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderStateExamples",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        }
+      ],
+      state: {
+        global: {
+          schema: "",
+          initialValue: `{
+    "id": "",
+    "name": "",
+    "extension": "",
+    "description": "",
+    "author": {
+        "name": "",
+        "website": ""
+    },
+    "specifications": [
+        {
+            "version": 1,
+            "changeLog": [],
+            "state": {
+                "schema": "",
+                "initialValue": "",
+                "examples": []
+            },
+            "modules": []
+        }
+    ]
+}`,
+          examples: []
+        },
+        local: {
+          schema: "",
+          initialValue: "{}",
+          examples: []
+        }
+      }
+    }
+  ]
+}, ue = (t) => t != null, At = o.any().refine((t) => ue(t));
+function _() {
+  return o.object({
+    __typename: o.literal("AddChangeLogItemInput").optional(),
+    content: o.string(),
+    id: o.string(),
+    insertBefore: o.string().nullable()
+  });
+}
+function I() {
+  return o.object({
+    description: o.string().nullish(),
+    id: o.string(),
+    name: o.string()
+  });
+}
+function T() {
+  return o.object({
+    errorCode: o.string().nullish(),
+    errorDescription: o.string().nullish(),
+    errorName: o.string().nullish(),
+    errorTemplate: o.string().nullish(),
+    id: o.string(),
+    operationId: o.string()
+  });
+}
+function R() {
+  return o.object({
+    example: o.string(),
+    id: o.string(),
+    operationId: o.string()
+  });
+}
+function A() {
+  return o.object({
+    description: o.string().nullish(),
+    id: o.string(),
+    moduleId: o.string(),
+    name: o.string(),
+    reducer: o.string().nullish(),
+    schema: o.string().nullish(),
+    template: o.string().nullish(),
+    scope: b().nullish()
+  });
+}
+function x() {
+  return o.object({
+    scope: o.string(),
+    example: o.string(),
+    id: o.string(),
+    insertBefore: o.string().nullish()
+  });
+}
+function me() {
+  return o.object({
+    __typename: o.literal("Author").optional(),
+    name: o.string(),
+    website: o.string().nullable()
+  });
+}
+function D() {
+  return o.object({
+    __typename: o.literal("CodeExample").optional(),
+    id: o.string(),
+    value: o.string()
+  });
+}
+function M() {
+  return o.object({
+    __typename: o.literal("DeleteChangeLogItemInput").optional(),
+    id: o.string()
+  });
+}
+function N() {
+  return o.object({
+    id: o.string()
+  });
+}
+function L() {
+  return o.object({
+    id: o.string()
+  });
+}
+function P() {
+  return o.object({
+    id: o.string()
+  });
+}
+function j() {
+  return o.object({
+    id: o.string()
+  });
+}
+function C() {
+  return o.object({
+    scope: o.string(),
+    id: o.string()
+  });
+}
+function b() {
+  return o.literal("global").or(o.literal("local"));
+}
+function xt() {
+  return o.union([
+    _(),
+    I(),
+    T(),
+    R(),
+    A(),
+    x(),
+    M(),
+    N(),
+    L(),
+    P(),
+    j(),
+    C(),
+    k(),
+    y(),
+    w(),
+    v(),
+    U(),
+    V(),
+    F(),
+    H(),
+    X(),
+    G(),
+    $(),
+    W(),
+    z(),
+    B(),
+    q(),
+    J(),
+    K(),
+    Q(),
+    Y(),
+    Z(),
+    ee(),
+    te(),
+    re(),
+    oe(),
+    ne(),
+    ie(),
+    se(),
+    ae(),
+    pe()
+  ]);
+}
+function Dt() {
+  return o.object({
+    __typename: o.literal("DocumentModelState").optional(),
+    author: me(),
+    description: o.string(),
+    extension: o.string(),
+    id: o.string(),
+    name: o.string(),
+    specifications: o.array(Ee())
+  });
+}
+function Ee() {
+  return o.object({
+    __typename: o.literal("DocumentSpecification").optional(),
+    changeLog: o.array(o.string()),
+    modules: o.array(he()),
+    state: be(),
+    version: o.number()
+  });
+}
+function he() {
+  return o.object({
+    __typename: o.literal("Module").optional(),
+    description: o.string().nullable(),
+    id: o.string(),
+    name: o.string(),
+    operations: o.array(Oe())
+  });
+}
+function k() {
+  return o.object({
+    newModuleId: o.string(),
+    operationId: o.string()
+  });
+}
+function Oe() {
+  return o.object({
+    __typename: o.literal("Operation").optional(),
+    description: o.string().nullable(),
+    errors: o.array(ge()),
+    examples: o.array(D()),
+    id: o.string(),
+    name: o.string().nullable(),
+    reducer: o.string().nullable(),
+    schema: o.string().nullable(),
+    template: o.string().nullable(),
+    scope: b()
+  });
+}
+function ge() {
+  return o.object({
+    __typename: o.literal("OperationError").optional(),
+    code: o.string().nullable(),
+    description: o.string().nullable(),
+    id: o.string(),
+    name: o.string().nullable(),
+    template: o.string().nullable()
+  });
+}
+function y() {
+  return o.object({
+    __typename: o.literal("ReorderChangeLogItemsInput").optional(),
+    order: o.array(o.string())
+  });
+}
+function w() {
+  return o.object({
+    moduleId: o.string(),
+    order: o.array(o.string())
+  });
+}
+function v() {
+  return o.object({
+    order: o.array(o.string())
+  });
+}
+function U() {
+  return o.object({
+    operationId: o.string(),
+    order: o.array(o.string())
+  });
+}
+function V() {
+  return o.object({
+    operationId: o.string(),
+    order: o.array(o.string())
+  });
+}
+function F() {
+  return o.object({
+    scope: o.string(),
+    order: o.array(o.string())
+  });
+}
+function H() {
+  return o.object({
+    authorName: o.string()
+  });
+}
+function X() {
+  return o.object({
+    authorWebsite: o.string()
+  });
+}
+function G() {
+  return o.object({
+    scope: o.string(),
+    initialValue: o.string()
+  });
+}
+function $() {
+  return o.object({
+    description: o.string()
+  });
+}
+function W() {
+  return o.object({
+    extension: o.string()
+  });
+}
+function z() {
+  return o.object({
+    id: o.string()
+  });
+}
+function B() {
+  return o.object({
+    name: o.string()
+  });
+}
+function q() {
+  return o.object({
+    description: o.string().nullish(),
+    id: o.string()
+  });
+}
+function J() {
+  return o.object({
+    id: o.string(),
+    name: o.string().nullish()
+  });
+}
+function K() {
+  return o.object({
+    description: o.string().nullish(),
+    id: o.string()
+  });
+}
+function Q() {
+  return o.object({
+    errorCode: o.string().nullish(),
+    id: o.string()
+  });
+}
+function Y() {
+  return o.object({
+    errorDescription: o.string().nullish(),
+    id: o.string()
+  });
+}
+function Z() {
+  return o.object({
+    errorName: o.string().nullish(),
+    id: o.string()
+  });
+}
+function ee() {
+  return o.object({
+    errorTemplate: o.string().nullish(),
+    id: o.string()
+  });
+}
+function te() {
+  return o.object({
+    id: o.string(),
+    name: o.string().nullish()
+  });
+}
+function Se() {
+  return o.object({
+    id: o.string(),
+    scope: b()
+  });
+}
+function re() {
+  return o.object({
+    id: o.string(),
+    reducer: o.string().nullish()
+  });
+}
+function oe() {
+  return o.object({
+    id: o.string(),
+    schema: o.string().nullish()
+  });
+}
+function ne() {
+  return o.object({
+    id: o.string(),
+    template: o.string().nullish()
+  });
+}
+function ie() {
+  return o.object({
+    scope: o.string(),
+    schema: o.string()
+  });
+}
+function f() {
+  return o.object({
+    __typename: o.literal("State").optional(),
+    examples: o.array(D()),
+    initialValue: o.string(),
+    schema: o.string()
+  });
+}
+function be() {
+  return o.object({
+    global: f(),
+    local: f()
+  });
+}
+function se() {
+  return o.object({
+    __typename: o.literal("UpdateChangeLogItemInput").optional(),
+    id: o.string(),
+    newContent: o.string()
+  });
+}
+function ae() {
+  return o.object({
+    example: o.string(),
+    id: o.string()
+  });
+}
+function pe() {
+  return o.object({
+    scope: o.string(),
+    id: o.string(),
+    newExample: o.string()
+  });
+}
+const Mt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AddChangeLogItemInputSchema: _,
+  AddModuleInputSchema: I,
+  AddOperationErrorInputSchema: T,
+  AddOperationExampleInputSchema: R,
+  AddOperationInputSchema: A,
+  AddStateExampleInputSchema: x,
+  AuthorSchema: me,
+  CodeExampleSchema: D,
+  DeleteChangeLogItemInputSchema: M,
+  DeleteModuleInputSchema: N,
+  DeleteOperationErrorInputSchema: L,
+  DeleteOperationExampleInputSchema: P,
+  DeleteOperationInputSchema: j,
+  DeleteStateExampleInputSchema: C,
+  DocumentModelInputSchema: xt,
+  DocumentModelStateSchema: Dt,
+  DocumentSpecificationSchema: Ee,
+  ModuleSchema: he,
+  MoveOperationInputSchema: k,
+  OperationErrorSchema: ge,
+  OperationSchema: Oe,
+  OperationScopeSchema: b,
+  ReorderChangeLogItemsInputSchema: y,
+  ReorderModuleOperationsInputSchema: w,
+  ReorderModulesInputSchema: v,
+  ReorderOperationErrorsInputSchema: U,
+  ReorderOperationExamplesInputSchema: V,
+  ReorderStateExamplesInputSchema: F,
+  ScopeStateSchema: be,
+  SetAuthorNameInputSchema: H,
+  SetAuthorWebsiteInputSchema: X,
+  SetInitialStateInputSchema: G,
+  SetModelDescriptionInputSchema: $,
+  SetModelExtensionInputSchema: W,
+  SetModelIdInputSchema: z,
+  SetModelNameInputSchema: B,
+  SetModuleDescriptionInputSchema: q,
+  SetModuleNameInputSchema: J,
+  SetOperationDescriptionInputSchema: K,
+  SetOperationErrorCodeInputSchema: Q,
+  SetOperationErrorDescriptionInputSchema: Y,
+  SetOperationErrorNameInputSchema: Z,
+  SetOperationErrorTemplateInputSchema: ee,
+  SetOperationNameInputSchema: te,
+  SetOperationReducerInputSchema: re,
+  SetOperationSchemaInputSchema: oe,
+  SetOperationScopeInputSchema: Se,
+  SetOperationTemplateInputSchema: ne,
+  SetStateSchemaInputSchema: ie,
+  StateSchema: f,
+  UpdateChangeLogItemInputSchema: se,
+  UpdateOperationExampleInputSchema: ae,
+  UpdateStateExampleInputSchema: pe,
+  definedNonNullAnySchema: At,
+  isDefinedNonNullAny: ue
+}, Symbol.toStringTag, { value: "Module" })), d = {
+  setModelNameOperation(t, e) {
+    t.name = e.input.name;
+  },
+  setModelIdOperation(t, e) {
+    t.id = e.input.id;
+  },
+  setModelExtensionOperation(t, e) {
+    t.extension = e.input.extension;
+  },
+  setModelDescriptionOperation(t, e) {
+    t.description = e.input.description;
+  },
+  setAuthorNameOperation(t, e) {
+    t.author = t.author || { name: "", website: null }, t.author.name = e.input.authorName;
+  },
+  setAuthorWebsiteOperation(t, e) {
+    t.author = t.author || { name: "", website: null }, t.author.website = e.input.authorWebsite;
+  }
+}, E = {
+  addChangeLogItemOperation(t, e) {
+    throw new Error('Reducer "addChangeLogItemOperation" not yet implemented');
+  },
+  updateChangeLogItemOperation(t, e) {
+    throw new Error('Reducer "updateChangeLogItemOperation" not yet implemented');
+  },
+  deleteChangeLogItemOperation(t, e) {
+    throw new Error('Reducer "deleteChangeLogItemOperation" not yet implemented');
+  },
+  reorderChangeLogItemsOperation(t, e) {
+    throw new Error('Reducer "reorderChangeLogItemsOperation" not yet implemented');
+  },
+  releaseNewVersionOperation(t, e) {
+    throw new Error('Reducer "releaseNewVersionOperation" not yet implemented');
+  }
+}, Nt = (t) => {
+  const e = {};
+  return t.forEach((r, n) => e[r] = n), (r, n) => (e[n.id] || 999999) - (e[r.id] || 999999);
+}, h = {
+  addModuleOperation(t, e) {
+    t.specifications[t.specifications.length - 1].modules.push({
+      id: e.input.id,
+      name: e.input.name,
+      description: e.input.description || "",
+      operations: []
+    });
+  },
+  setModuleNameOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      r.modules[n].id === e.input.id && (r.modules[n].name = e.input.name || "");
+  },
+  setModuleDescriptionOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      r.modules[n].id === e.input.id && (r.modules[n].description = e.input.description || "");
+  },
+  deleteModuleOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    r.modules = r.modules.filter(
+      (n) => n.id != e.input.id
+    );
+  },
+  reorderModulesOperation(t, e) {
+    t.specifications[t.specifications.length - 1].modules.sort(Nt(e.input.order));
+  }
+}, Lt = (t) => {
+  const e = {};
+  return t.forEach((r, n) => e[r] = n), (r, n) => (e[n.id] || 999999) - (e[r.id] || 999999);
+}, c = {
+  addOperationErrorOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.operationId && r.modules[n].operations[i].errors.push({
+          id: e.input.id,
+          name: e.input.errorName || "",
+          code: e.input.errorCode || "",
+          description: e.input.errorDescription || "",
+          template: e.input.errorTemplate || ""
+        });
+  },
+  setOperationErrorCodeOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        for (let a = 0; a < r.modules[n].operations[i].errors.length; a++)
+          r.modules[n].operations[i].errors[a].id == e.input.id && (r.modules[n].operations[i].errors[a].code = e.input.errorCode || "");
+  },
+  setOperationErrorNameOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        for (let a = 0; a < r.modules[n].operations[i].errors.length; a++)
+          r.modules[n].operations[i].errors[a].id == e.input.id && (r.modules[n].operations[i].errors[a].name = e.input.errorName || "");
+  },
+  setOperationErrorDescriptionOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        for (let a = 0; a < r.modules[n].operations[i].errors.length; a++)
+          r.modules[n].operations[i].errors[a].id == e.input.id && (r.modules[n].operations[i].errors[a].description = e.input.errorDescription || "");
+  },
+  setOperationErrorTemplateOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        for (let a = 0; a < r.modules[n].operations[i].errors.length; a++)
+          r.modules[n].operations[i].errors[a].id == e.input.id && (r.modules[n].operations[i].errors[a].template = e.input.errorTemplate || "");
+  },
+  deleteOperationErrorOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].errors = r.modules[n].operations[i].errors.filter((a) => a.id != e.input.id);
+  },
+  reorderOperationErrorsOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.operationId && r.modules[n].operations[i].errors.sort(
+          Lt(e.input.order)
+        );
+  }
+}, Pt = (t) => {
+  const e = {};
+  return t.forEach((r, n) => e[r] = n), (r, n) => (e[n.id] || 999999) - (e[r.id] || 999999);
+}, S = {
+  addOperationExampleOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.operationId && r.modules[n].operations[i].examples.push({
+          id: e.input.id,
+          value: e.input.example
+        });
+  },
+  updateOperationExampleOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        for (let a = 0; a < r.modules[n].operations[i].examples.length; a++)
+          r.modules[n].operations[i].examples[a].id == e.input.id && (r.modules[n].operations[i].examples[a].value = e.input.example);
+  },
+  deleteOperationExampleOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].examples = r.modules[n].operations[i].examples.filter(
+          (a) => a.id != e.input.id
+        );
+  },
+  reorderOperationExamplesOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.operationId && r.modules[n].operations[i].examples.sort(
+          Pt(e.input.order)
+        );
+  }
+}, jt = (t) => {
+  const e = {};
+  return t.forEach((r, n) => e[r] = n), (r, n) => (e[n.id] || 999999) - (e[r.id] || 999999);
+}, p = {
+  addOperationOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      r.modules[n].id == e.input.moduleId && r.modules[n].operations.push({
+        id: e.input.id,
+        name: e.input.name,
+        description: e.input.description || "",
+        schema: e.input.schema || "",
+        template: e.input.template || e.input.description || "",
+        reducer: e.input.reducer || "",
+        errors: [],
+        examples: [],
+        scope: e.input.scope || "global"
+      });
+  },
+  setOperationNameOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.id && (r.modules[n].operations[i].name = e.input.name || "");
+  },
+  setOperationScopeOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.id && (r.modules[n].operations[i].scope = e.input.scope || "global");
+  },
+  setOperationSchemaOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.id && (r.modules[n].operations[i].schema = e.input.schema || "");
+  },
+  setOperationDescriptionOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.id && (r.modules[n].operations[i].description = e.input.description || "");
+  },
+  setOperationTemplateOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.id && (r.modules[n].operations[i].template = e.input.template || "");
+  },
+  setOperationReducerOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      for (let i = 0; i < r.modules[n].operations.length; i++)
+        r.modules[n].operations[i].id == e.input.id && (r.modules[n].operations[i].reducer = e.input.reducer || "");
+  },
+  moveOperationOperation(t, e) {
+    const r = [], n = t.specifications[t.specifications.length - 1];
+    for (let i = 0; i < n.modules.length; i++)
+      n.modules[i].operations = n.modules[i].operations.filter((a) => a.id == e.input.operationId ? (r.push(a), !1) : !0);
+    for (let i = 0; i < n.modules.length; i++)
+      n.modules[i].id == e.input.newModuleId && n.modules[i].operations.push(...r);
+  },
+  deleteOperationOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      r.modules[n].operations = r.modules[n].operations.filter((i) => i.id != e.input.id);
+  },
+  reorderModuleOperationsOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    for (let n = 0; n < r.modules.length; n++)
+      r.modules[n].id == e.input.moduleId && r.modules[n].operations.sort(
+        jt(e.input.order)
+      );
+  }
+}, Ct = (t) => {
+  const e = {};
+  return t.forEach((r, n) => e[r] = n), (r, n) => (e[n.id] || 999999) - (e[r.id] || 999999);
+}, u = {
+  setStateSchemaOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    if (Object.keys(r.state).includes(e.input.scope))
+      r.state[e.input.scope].schema = e.input.schema;
+    else
+      throw new Error(`Invalid scope: ${e.input.scope}`);
+  },
+  setInitialStateOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    if (Object.keys(r.state).includes(e.input.scope))
+      r.state[e.input.scope].initialValue = e.input.initialValue;
+    else
+      throw new Error(`Invalid scope: ${e.input.scope}`);
+  },
+  addStateExampleOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    if (Object.keys(r.state).includes(e.input.scope))
+      r.state[e.input.scope].examples.push({
+        id: e.input.id,
+        value: e.input.example
+      });
+    else
+      throw new Error(`Invalid scope: ${e.input.scope}`);
+  },
+  updateStateExampleOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    if (!Object.keys(r.state).includes(e.input.scope))
+      throw new Error(`Invalid scope: ${e.input.scope}`);
+    const n = r.state[e.input.scope].examples;
+    for (let i = 0; i < n.length; i++)
+      n[i].id == e.input.id && (n[i].value = e.input.newExample);
+  },
+  deleteStateExampleOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    if (Object.keys(r.state).includes(e.input.scope))
+      r.state[e.input.scope].examples = r.state[e.input.scope].examples.filter((n) => n.id != e.input.id);
+    else
+      throw new Error(`Invalid scope: ${e.input.scope}`);
+  },
+  reorderStateExamplesOperation(t, e) {
+    const r = t.specifications[t.specifications.length - 1];
+    if (Object.keys(r.state).includes(e.input.scope))
+      r.state[e.input.scope].examples.sort(Ct(e.input.order));
+    else
+      throw new Error(`Invalid scope: ${e.input.scope}`);
+  }
+}, kt = (t, e) => {
+  if (ht(e))
+    return t;
+  switch (e.type) {
+    case "SET_MODEL_NAME":
+      B().parse(e.input), d.setModelNameOperation(t.global, e);
+      break;
+    case "SET_MODEL_ID":
+      z().parse(e.input), d.setModelIdOperation(t.global, e);
+      break;
+    case "SET_MODEL_EXTENSION":
+      W().parse(e.input), d.setModelExtensionOperation(t.global, e);
+      break;
+    case "SET_MODEL_DESCRIPTION":
+      $().parse(e.input), d.setModelDescriptionOperation(t.global, e);
+      break;
+    case "SET_AUTHOR_NAME":
+      H().parse(e.input), d.setAuthorNameOperation(t.global, e);
+      break;
+    case "SET_AUTHOR_WEBSITE":
+      X().parse(e.input), d.setAuthorWebsiteOperation(t.global, e);
+      break;
+    case "ADD_CHANGE_LOG_ITEM":
+      _().parse(e.input), E.addChangeLogItemOperation(t.global, e);
+      break;
+    case "UPDATE_CHANGE_LOG_ITEM":
+      se().parse(e.input), E.updateChangeLogItemOperation(
+        t.global,
+        e
+      );
+      break;
+    case "DELETE_CHANGE_LOG_ITEM":
+      M().parse(e.input), E.deleteChangeLogItemOperation(
+        t.global,
+        e
+      );
+      break;
+    case "REORDER_CHANGE_LOG_ITEMS":
+      y().parse(e.input), E.reorderChangeLogItemsOperation(
+        t.global,
+        e
+      );
+      break;
+    case "RELEASE_NEW_VERSION":
+      if (Object.keys(e.input).length > 0)
+        throw new Error(
+          "Expected empty input for action RELEASE_NEW_VERSION"
+        );
+      E.releaseNewVersionOperation(t.global, e);
+      break;
+    case "ADD_MODULE":
+      I().parse(e.input), h.addModuleOperation(t.global, e);
+      break;
+    case "SET_MODULE_NAME":
+      J().parse(e.input), h.setModuleNameOperation(t.global, e);
+      break;
+    case "SET_MODULE_DESCRIPTION":
+      q().parse(e.input), h.setModuleDescriptionOperation(t.global, e);
+      break;
+    case "DELETE_MODULE":
+      N().parse(e.input), h.deleteModuleOperation(t.global, e);
+      break;
+    case "REORDER_MODULES":
+      v().parse(e.input), h.reorderModulesOperation(t.global, e);
+      break;
+    case "ADD_OPERATION_ERROR":
+      T().parse(e.input), c.addOperationErrorOperation(
+        t.global,
+        e
+      );
+      break;
+    case "SET_OPERATION_ERROR_CODE":
+      Q().parse(e.input), c.setOperationErrorCodeOperation(
+        t.global,
+        e
+      );
+      break;
+    case "SET_OPERATION_ERROR_NAME":
+      Z().parse(e.input), c.setOperationErrorNameOperation(
+        t.global,
+        e
+      );
+      break;
+    case "SET_OPERATION_ERROR_DESCRIPTION":
+      Y().parse(e.input), c.setOperationErrorDescriptionOperation(
+        t.global,
+        e
+      );
+      break;
+    case "SET_OPERATION_ERROR_TEMPLATE":
+      ee().parse(e.input), c.setOperationErrorTemplateOperation(
+        t.global,
+        e
+      );
+      break;
+    case "DELETE_OPERATION_ERROR":
+      L().parse(e.input), c.deleteOperationErrorOperation(
+        t.global,
+        e
+      );
+      break;
+    case "REORDER_OPERATION_ERRORS":
+      U().parse(e.input), c.reorderOperationErrorsOperation(
+        t.global,
+        e
+      );
+      break;
+    case "ADD_OPERATION_EXAMPLE":
+      R().parse(e.input), S.addOperationExampleOperation(
+        t.global,
+        e
+      );
+      break;
+    case "UPDATE_OPERATION_EXAMPLE":
+      ae().parse(e.input), S.updateOperationExampleOperation(
+        t.global,
+        e
+      );
+      break;
+    case "DELETE_OPERATION_EXAMPLE":
+      P().parse(e.input), S.deleteOperationExampleOperation(
+        t.global,
+        e
+      );
+      break;
+    case "REORDER_OPERATION_EXAMPLES":
+      V().parse(e.input), S.reorderOperationExamplesOperation(
+        t.global,
+        e
+      );
+      break;
+    case "ADD_OPERATION":
+      A().parse(e.input), p.addOperationOperation(t.global, e);
+      break;
+    case "SET_OPERATION_NAME":
+      te().parse(e.input), p.setOperationNameOperation(t.global, e);
+      break;
+    case "SET_OPERATION_SCOPE":
+      Se().parse(e.input), p.setOperationScopeOperation(t.global, e);
+      break;
+    case "SET_OPERATION_SCHEMA":
+      oe().parse(e.input), p.setOperationSchemaOperation(t.global, e);
+      break;
+    case "SET_OPERATION_DESCRIPTION":
+      K().parse(e.input), p.setOperationDescriptionOperation(
+        t.global,
+        e
+      );
+      break;
+    case "SET_OPERATION_TEMPLATE":
+      ne().parse(e.input), p.setOperationTemplateOperation(
+        t.global,
+        e
+      );
+      break;
+    case "SET_OPERATION_REDUCER":
+      re().parse(e.input), p.setOperationReducerOperation(t.global, e);
+      break;
+    case "MOVE_OPERATION":
+      k().parse(e.input), p.moveOperationOperation(t.global, e);
+      break;
+    case "DELETE_OPERATION":
+      j().parse(e.input), p.deleteOperationOperation(t.global, e);
+      break;
+    case "REORDER_MODULE_OPERATIONS":
+      w().parse(e.input), p.reorderModuleOperationsOperation(
+        t.global,
+        e
+      );
+      break;
+    case "SET_STATE_SCHEMA":
+      ie().parse(e.input), u.setStateSchemaOperation(t.global, e);
+      break;
+    case "SET_INITIAL_STATE":
+      G().parse(e.input), u.setInitialStateOperation(t.global, e);
+      break;
+    case "ADD_STATE_EXAMPLE":
+      x().parse(e.input), u.addStateExampleOperation(t.global, e);
+      break;
+    case "UPDATE_STATE_EXAMPLE":
+      pe().parse(e.input), u.updateStateExampleOperation(t.global, e);
+      break;
+    case "DELETE_STATE_EXAMPLE":
+      C().parse(e.input), u.deleteStateExampleOperation(t.global, e);
+      break;
+    case "REORDER_STATE_EXAMPLES":
+      F().parse(e.input), u.reorderStateExamplesOperation(t.global, e);
+      break;
+    default:
+      return t;
+  }
+}, g = Et(kt), yt = {
+  id: "",
+  name: "",
+  extension: "",
+  description: "",
+  author: {
+    name: "",
+    website: ""
+  },
+  specifications: [
+    {
+      version: 1,
+      changeLog: [],
+      state: {
+        global: {
+          schema: "",
+          initialValue: "",
+          examples: []
+        },
+        local: {
+          schema: "",
+          initialValue: "",
+          examples: []
+        }
+      },
+      modules: []
+    }
+  ]
+}, wt = {}, O = {
+  fileExtension: "phdm",
+  createState(t) {
+    return {
+      global: { ...yt, ...t == null ? void 0 : t.global },
+      local: { ...wt, ...t == null ? void 0 : t.local }
+    };
+  },
+  createExtendedState(t) {
+    return Ot(
+      { ...t, documentType: "powerhouse/document-model" },
+      O.createState
+    );
+  },
+  createDocument(t) {
+    return gt(
+      O.createExtendedState(t),
+      O.createState
+    );
+  },
+  saveToFile(t, e, r) {
+    return St(t, e, "phdm", r);
+  },
+  saveToFileHandle(t, e) {
+    return bt(t, e);
+  },
+  loadFromFile(t) {
+    return ft(t, g);
+  },
+  loadFromInput(t) {
+    return _t(t, g);
+  }
+}, fe = (t) => s(
+  "SET_MODEL_NAME",
+  { ...t }
+), _e = (t) => s(
+  "SET_MODEL_ID",
+  { ...t }
+), Ie = (t) => s(
+  "SET_MODEL_EXTENSION",
+  { ...t }
+), Te = (t) => s(
+  "SET_MODEL_DESCRIPTION",
+  { ...t }
+), Re = (t) => s(
+  "SET_AUTHOR_NAME",
+  { ...t }
+), Ae = (t) => s(
+  "SET_AUTHOR_WEBSITE",
+  { ...t }
+);
+class vt extends l {
+  setModelName(e, r) {
+    return this.dispatch(fe(e), r);
+  }
+  setModelId(e, r) {
+    return this.dispatch(_e(e), r);
+  }
+  setModelExtension(e, r) {
+    return this.dispatch(Ie(e), r);
+  }
+  setModelDescription(e, r) {
+    return this.dispatch(Te(e), r);
+  }
+  setAuthorName(e, r) {
+    return this.dispatch(Re(e), r);
+  }
+  setAuthorWebsite(e, r) {
+    return this.dispatch(Ae(e), r);
+  }
+}
+const xe = (t) => s(
+  "ADD_CHANGE_LOG_ITEM",
+  { ...t }
+), De = (t) => s(
+  "UPDATE_CHANGE_LOG_ITEM",
+  { ...t }
+), Me = (t) => s(
+  "DELETE_CHANGE_LOG_ITEM",
+  { ...t }
+), Ne = (t) => s(
+  "REORDER_CHANGE_LOG_ITEMS",
+  { ...t }
+), Le = () => s(
+  "RELEASE_NEW_VERSION"
+);
+class Ut extends l {
+  addChangeLogItem(e, r) {
+    return this.dispatch(xe(e), r);
+  }
+  updateChangeLogItem(e, r) {
+    return this.dispatch(De(e), r);
+  }
+  deleteChangeLogItem(e, r) {
+    return this.dispatch(Me(e), r);
+  }
+  reorderChangeLogItems(e, r) {
+    return this.dispatch(Ne(e), r);
+  }
+  releaseNewVersion(e) {
+    return this.dispatch(Le(), e);
+  }
+}
+const Pe = (t) => s(
+  "ADD_MODULE",
+  { ...t }
+), je = (t) => s(
+  "SET_MODULE_NAME",
+  { ...t }
+), Ce = (t) => s(
+  "SET_MODULE_DESCRIPTION",
+  { ...t }
+), ke = (t) => s(
+  "DELETE_MODULE",
+  { ...t }
+), ye = (t) => s(
+  "REORDER_MODULES",
+  { ...t }
+);
+class Vt extends l {
+  addModule(e, r) {
+    return this.dispatch(Pe(e), r);
+  }
+  setModuleName(e, r) {
+    return this.dispatch(je(e), r);
+  }
+  setModuleDescription(e, r) {
+    return this.dispatch(Ce(e), r);
+  }
+  deleteModule(e, r) {
+    return this.dispatch(ke(e), r);
+  }
+  reorderModules(e, r) {
+    return this.dispatch(ye(e), r);
+  }
+}
+const we = (t) => s(
+  "ADD_OPERATION_ERROR",
+  { ...t }
+), ve = (t) => s(
+  "SET_OPERATION_ERROR_CODE",
+  { ...t }
+), Ue = (t) => s(
+  "SET_OPERATION_ERROR_NAME",
+  { ...t }
+), Ve = (t) => s(
+  "SET_OPERATION_ERROR_DESCRIPTION",
+  { ...t }
+), Fe = (t) => s(
+  "SET_OPERATION_ERROR_TEMPLATE",
+  { ...t }
+), He = (t) => s(
+  "DELETE_OPERATION_ERROR",
+  { ...t }
+), Xe = (t) => s(
+  "REORDER_OPERATION_ERRORS",
+  { ...t }
+);
+class Ft extends l {
+  addOperationError(e, r) {
+    return this.dispatch(we(e), r);
+  }
+  setOperationErrorCode(e, r) {
+    return this.dispatch(ve(e), r);
+  }
+  setOperationErrorName(e, r) {
+    return this.dispatch(Ue(e), r);
+  }
+  setOperationErrorDescription(e, r) {
+    return this.dispatch(Ve(e), r);
+  }
+  setOperationErrorTemplate(e, r) {
+    return this.dispatch(Fe(e), r);
+  }
+  deleteOperationError(e, r) {
+    return this.dispatch(He(e), r);
+  }
+  reorderOperationErrors(e, r) {
+    return this.dispatch(Xe(e), r);
+  }
+}
+const Ge = (t) => s(
+  "ADD_OPERATION_EXAMPLE",
+  { ...t }
+), $e = (t) => s(
+  "UPDATE_OPERATION_EXAMPLE",
+  { ...t }
+), We = (t) => s(
+  "DELETE_OPERATION_EXAMPLE",
+  { ...t }
+), ze = (t) => s(
+  "REORDER_OPERATION_EXAMPLES",
+  { ...t }
+);
+class Ht extends l {
+  addOperationExample(e, r) {
+    return this.dispatch(Ge(e), r);
+  }
+  updateOperationExample(e, r) {
+    return this.dispatch($e(e), r);
+  }
+  deleteOperationExample(e, r) {
+    return this.dispatch(We(e), r);
+  }
+  reorderOperationExamples(e, r) {
+    return this.dispatch(ze(e), r);
+  }
+}
+const Be = (t) => s(
+  "ADD_OPERATION",
+  { ...t }
+), qe = (t) => s(
+  "SET_OPERATION_NAME",
+  { ...t }
+), Je = (t) => s(
+  "SET_OPERATION_SCOPE",
+  { ...t }
+), Ke = (t) => s(
+  "SET_OPERATION_SCHEMA",
+  { ...t }
+), Qe = (t) => s(
+  "SET_OPERATION_DESCRIPTION",
+  { ...t }
+), Ye = (t) => s(
+  "SET_OPERATION_TEMPLATE",
+  { ...t }
+), Ze = (t) => s(
+  "SET_OPERATION_REDUCER",
+  { ...t }
+), et = (t) => s(
+  "MOVE_OPERATION",
+  { ...t }
+), tt = (t) => s(
+  "DELETE_OPERATION",
+  { ...t }
+), rt = (t) => s(
+  "REORDER_MODULE_OPERATIONS",
+  { ...t }
+);
+class Xt extends l {
+  addOperation(e, r) {
+    return this.dispatch(Be(e), r);
+  }
+  setOperationName(e, r) {
+    return this.dispatch(qe(e), r);
+  }
+  setOperationScope(e, r) {
+    return this.dispatch(Je(e), r);
+  }
+  setOperationSchema(e, r) {
+    return this.dispatch(Ke(e), r);
+  }
+  setOperationDescription(e, r) {
+    return this.dispatch(Qe(e), r);
+  }
+  setOperationTemplate(e, r) {
+    return this.dispatch(Ye(e), r);
+  }
+  setOperationReducer(e, r) {
+    return this.dispatch(Ze(e), r);
+  }
+  moveOperation(e, r) {
+    return this.dispatch(et(e), r);
+  }
+  deleteOperation(e, r) {
+    return this.dispatch(tt(e), r);
+  }
+  reorderModuleOperations(e, r) {
+    return this.dispatch(rt(e), r);
+  }
+}
+const ot = (t) => s(
+  "SET_STATE_SCHEMA",
+  { ...t }
+), nt = (t) => s(
+  "SET_INITIAL_STATE",
+  { ...t }
+), it = (t) => s(
+  "ADD_STATE_EXAMPLE",
+  { ...t }
+), st = (t) => s(
+  "UPDATE_STATE_EXAMPLE",
+  { ...t }
+), at = (t) => s(
+  "DELETE_STATE_EXAMPLE",
+  { ...t }
+), pt = (t) => s(
+  "REORDER_STATE_EXAMPLES",
+  { ...t }
+);
+class Gt extends l {
+  setStateSchema(e, r) {
+    return this.dispatch(ot(e), r);
+  }
+  setInitialState(e, r) {
+    return this.dispatch(nt(e), r);
+  }
+  addStateExample(e, r) {
+    return this.dispatch(it(e), r);
+  }
+  updateStateExample(e, r) {
+    return this.dispatch(st(e), r);
+  }
+  deleteStateExample(e, r) {
+    return this.dispatch(at(e), r);
+  }
+  reorderStateExamples(e, r) {
+    return this.dispatch(pt(e), r);
+  }
+}
+var m;
+let le = (m = class extends l {
+  constructor(e, r) {
+    super(g, O.createDocument(e), r);
+  }
+  saveToFile(e, r) {
+    return super.saveToFile(e, m.fileExtension, r);
+  }
+  loadFromFile(e) {
+    return super.loadFromFile(e);
+  }
+  static async fromFile(e) {
+    const r = new this();
+    return await r.loadFromFile(e), r;
+  }
+}, ce(m, "fileExtension", "phdm"), m);
+It(le, [
+  vt,
+  Ut,
+  Vt,
+  Ft,
+  Ht,
+  Xt,
+  Gt
+]);
+const $t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addChangeLogItem: xe,
+  addModule: Pe,
+  addOperation: Be,
+  addOperationError: we,
+  addOperationExample: Ge,
+  addStateExample: it,
+  deleteChangeLogItem: Me,
+  deleteModule: ke,
+  deleteOperation: tt,
+  deleteOperationError: He,
+  deleteOperationExample: We,
+  deleteStateExample: at,
+  moveOperation: et,
+  releaseNewVersion: Le,
+  reorderChangeLogItems: Ne,
+  reorderModuleOperations: rt,
+  reorderModules: ye,
+  reorderOperationErrors: Xe,
+  reorderOperationExamples: ze,
+  reorderStateExamples: pt,
+  setAuthorName: Re,
+  setAuthorWebsite: Ae,
+  setInitialState: nt,
+  setModelDescription: Te,
+  setModelExtension: Ie,
+  setModelId: _e,
+  setModelName: fe,
+  setModuleDescription: Ce,
+  setModuleName: je,
+  setOperationDescription: Qe,
+  setOperationErrorCode: ve,
+  setOperationErrorDescription: Ve,
+  setOperationErrorName: Ue,
+  setOperationErrorTemplate: Fe,
+  setOperationName: qe,
+  setOperationReducer: Ze,
+  setOperationSchema: Ke,
+  setOperationScope: Je,
+  setOperationTemplate: Ye,
+  setStateSchema: ot,
+  updateChangeLogItem: De,
+  updateOperationExample: $e,
+  updateStateExample: st
+}, Symbol.toStringTag, { value: "Module" })), lt = le, ct = { ...O, ...Rt }, dt = { ...Tt, ...$t }, Wt = {
+  Document: lt,
+  reducer: g,
+  actions: dt,
+  utils: ct,
+  documentModel: de
+}, Yt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Document: lt,
+  DocumentModel: le,
+  actions: dt,
+  documentModel: de,
+  module: Wt,
+  reducer: g,
+  utils: ct,
+  z: Mt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Yt as D,
+  le as a,
+  lt as b,
+  dt as c,
+  de as d,
+  Wt as m,
+  g as r,
+  ct as u,
+  Mt as z
+};