document-model 1.0.0

package/dist/node/index-78a1221c.mjs

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