@ibodr/schema 0.0.0

package/dist/index.mjs

@@ -0,0 +1,4084 @@
+import { structuredClone, sortByIndex, objectMapFromEntries, getIndices, objectMapEntries, registerDrawLibraryVersion, mapObjectMapValues, uniqueId, safeParseUrl, assert, filterEntries, objectMapValues, annotateError } from '@ibodr/utils';
+import { T } from '@ibodr/validate';
+import { createMigrationIds, createRecordMigrationSequence, createMigrationSequence, createRecordType, StoreSchema, RecordType } from '@ibodr/store';
+import { computed } from '@ibodr/state';
+
+// src/index.ts
+function idValidator(prefix) {
+  return T.string.refine((id) => {
+    if (!id.startsWith(`${prefix}:`)) {
+      throw new Error(`${prefix} ID must start with "${prefix}:"`);
+    }
+    return id;
+  });
+}
+
+// src/assets/DrBaseAsset.ts
+var assetIdValidator = idValidator("asset");
+function createAssetValidator(type, props, meta) {
+  const propsValidator = props instanceof T.Validator ? props : props ? T.object(props) : T.jsonValue;
+  return T.object({
+    id: assetIdValidator,
+    typeName: T.literal("asset"),
+    type: T.literal(type),
+    props: propsValidator,
+    meta: meta ? T.object(meta) : T.jsonValue
+  });
+}
+var bookmarkAssetProps = {
+  title: T.string,
+  description: T.string,
+  image: T.string,
+  favicon: T.string,
+  src: T.srcUrl.nullable()
+};
+createAssetValidator(
+  "bookmark",
+  T.object(bookmarkAssetProps)
+);
+var Versions = createMigrationIds("com.draw.asset.bookmark", {
+  MakeUrlsValid: 1,
+  AddFavicon: 2
+});
+var bookmarkAssetMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.asset.bookmark",
+  recordType: "asset",
+  filter: (asset) => asset.type === "bookmark",
+  sequence: [
+    {
+      id: Versions.MakeUrlsValid,
+      up: (asset) => {
+        if (!T.srcUrl.isValid(asset.props.src)) {
+          asset.props.src = "";
+        }
+      },
+      down: (_asset) => {
+      }
+    },
+    {
+      id: Versions.AddFavicon,
+      up: (asset) => {
+        if (!T.srcUrl.isValid(asset.props.favicon)) {
+          asset.props.favicon = "";
+        }
+      },
+      down: (asset) => {
+        delete asset.props.favicon;
+      }
+    }
+  ]
+});
+var imageAssetProps = {
+  w: T.number,
+  h: T.number,
+  name: T.string,
+  isAnimated: T.boolean,
+  mimeType: T.string.nullable(),
+  src: T.srcUrl.nullable(),
+  fileSize: T.nonZeroNumber.optional(),
+  pixelRatio: T.positiveNumber.optional()
+};
+createAssetValidator(
+  "image",
+  T.object(imageAssetProps)
+);
+var Versions2 = createMigrationIds("com.draw.asset.image", {
+  AddIsAnimated: 1,
+  RenameWidthHeight: 2,
+  MakeUrlsValid: 3,
+  AddFileSize: 4,
+  MakeFileSizeOptional: 5,
+  AddPixelRatio: 6
+});
+var imageAssetMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.asset.image",
+  recordType: "asset",
+  filter: (asset) => asset.type === "image",
+  sequence: [
+    {
+      id: Versions2.AddIsAnimated,
+      up: (asset) => {
+        asset.props.isAnimated = false;
+      },
+      down: (asset) => {
+        delete asset.props.isAnimated;
+      }
+    },
+    {
+      id: Versions2.RenameWidthHeight,
+      up: (asset) => {
+        asset.props.w = asset.props.width;
+        asset.props.h = asset.props.height;
+        delete asset.props.width;
+        delete asset.props.height;
+      },
+      down: (asset) => {
+        asset.props.width = asset.props.w;
+        asset.props.height = asset.props.h;
+        delete asset.props.w;
+        delete asset.props.h;
+      }
+    },
+    {
+      id: Versions2.MakeUrlsValid,
+      up: (asset) => {
+        if (!T.srcUrl.isValid(asset.props.src)) {
+          asset.props.src = "";
+        }
+      },
+      down: (_asset) => {
+      }
+    },
+    {
+      id: Versions2.AddFileSize,
+      up: (asset) => {
+        asset.props.fileSize = -1;
+      },
+      down: (asset) => {
+        delete asset.props.fileSize;
+      }
+    },
+    {
+      id: Versions2.MakeFileSizeOptional,
+      up: (asset) => {
+        if (asset.props.fileSize === -1) {
+          asset.props.fileSize = void 0;
+        }
+      },
+      down: (asset) => {
+        if (asset.props.fileSize === void 0) {
+          asset.props.fileSize = -1;
+        }
+      }
+    },
+    {
+      id: Versions2.AddPixelRatio,
+      up: (_asset) => {
+      },
+      down: (asset) => {
+        delete asset.props.pixelRatio;
+      }
+    }
+  ]
+});
+var videoAssetProps = {
+  w: T.number,
+  h: T.number,
+  name: T.string,
+  isAnimated: T.boolean,
+  mimeType: T.string.nullable(),
+  src: T.srcUrl.nullable(),
+  fileSize: T.number.optional()
+};
+createAssetValidator(
+  "video",
+  T.object(videoAssetProps)
+);
+var Versions3 = createMigrationIds("com.draw.asset.video", {
+  AddIsAnimated: 1,
+  RenameWidthHeight: 2,
+  MakeUrlsValid: 3,
+  AddFileSize: 4,
+  MakeFileSizeOptional: 5
+});
+var videoAssetMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.asset.video",
+  recordType: "asset",
+  filter: (asset) => asset.type === "video",
+  sequence: [
+    {
+      id: Versions3.AddIsAnimated,
+      up: (asset) => {
+        asset.props.isAnimated = false;
+      },
+      down: (asset) => {
+        delete asset.props.isAnimated;
+      }
+    },
+    {
+      id: Versions3.RenameWidthHeight,
+      up: (asset) => {
+        asset.props.w = asset.props.width;
+        asset.props.h = asset.props.height;
+        delete asset.props.width;
+        delete asset.props.height;
+      },
+      down: (asset) => {
+        asset.props.width = asset.props.w;
+        asset.props.height = asset.props.h;
+        delete asset.props.w;
+        delete asset.props.h;
+      }
+    },
+    {
+      id: Versions3.MakeUrlsValid,
+      up: (asset) => {
+        if (!T.srcUrl.isValid(asset.props.src)) {
+          asset.props.src = "";
+        }
+      },
+      down: (_asset) => {
+      }
+    },
+    {
+      id: Versions3.AddFileSize,
+      up: (asset) => {
+        asset.props.fileSize = -1;
+      },
+      down: (asset) => {
+        delete asset.props.fileSize;
+      }
+    },
+    {
+      id: Versions3.MakeFileSizeOptional,
+      up: (asset) => {
+        if (asset.props.fileSize === -1) {
+          asset.props.fileSize = void 0;
+        }
+      },
+      down: (asset) => {
+        if (asset.props.fileSize === void 0) {
+          asset.props.fileSize = -1;
+        }
+      }
+    }
+  ]
+});
+var vecModelValidator = T.object({
+  x: T.number,
+  y: T.number,
+  z: T.number.optional()
+});
+var boxModelValidator = T.object({
+  x: T.number,
+  y: T.number,
+  w: T.number,
+  h: T.number
+});
+var opacityValidator = T.unitInterval;
+
+// src/shapes/DrBaseShape.ts
+var parentIdValidator = T.string.refine((id) => {
+  if (!id.startsWith("page:") && !id.startsWith("shape:")) {
+    throw new Error('Parent ID must start with "page:" or "shape:"');
+  }
+  return id;
+});
+var shapeIdValidator = idValidator("shape");
+function createShapeValidator(type, props, meta) {
+  return T.object({
+    id: shapeIdValidator,
+    typeName: T.literal("shape"),
+    x: T.number,
+    y: T.number,
+    rotation: T.number,
+    index: T.indexKey,
+    parentId: parentIdValidator,
+    type: T.literal(type),
+    isLocked: T.boolean,
+    opacity: opacityValidator,
+    props: props ? T.object(props) : T.jsonValue,
+    meta: meta ? T.object(meta) : T.jsonValue
+  });
+}
+
+// src/bindings/DrBaseBinding.ts
+var bindingIdValidator = idValidator("binding");
+function createBindingValidator(type, props, meta) {
+  return T.object({
+    id: bindingIdValidator,
+    typeName: T.literal("binding"),
+    type: T.literal(type),
+    fromId: shapeIdValidator,
+    toId: shapeIdValidator,
+    props: props ? T.object(props) : T.jsonValue,
+    meta: meta ? T.object(meta) : T.jsonValue
+  });
+}
+
+// src/records/DrBinding.ts
+createMigrationIds("com.draw.binding", {});
+var rootBindingMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.binding",
+  recordType: "binding",
+  sequence: []
+});
+function isBinding(record) {
+  if (!record) return false;
+  return record.typeName === "binding";
+}
+function isBindingId(id) {
+  if (!id) return false;
+  return id.startsWith("binding:");
+}
+function createBindingId(id) {
+  return `binding:${id ?? uniqueId()}`;
+}
+function createBindingPropsMigrationSequence(migrations) {
+  return migrations;
+}
+function createBindingPropsMigrationIds(bindingType, ids) {
+  return mapObjectMapValues(ids, (_k, v) => `com.draw.binding.${bindingType}/${v}`);
+}
+function createBindingRecordType(bindings) {
+  return createRecordType("binding", {
+    scope: "document",
+    validator: T.model(
+      "binding",
+      T.union(
+        "type",
+        mapObjectMapValues(
+          bindings,
+          (type, { props, meta }) => createBindingValidator(type, props, meta)
+        )
+      )
+    )
+  }).withDefaultProperties(() => ({
+    meta: {}
+  }));
+}
+var richTextValidator = T.object({
+  type: T.string,
+  content: T.arrayOf(T.unknown),
+  attrs: T.any.optional()
+});
+function toRichText(text) {
+  const lines = text.split("\n");
+  const content = lines.map((text2) => {
+    if (!text2) {
+      return {
+        type: "paragraph"
+      };
+    }
+    return {
+      type: "paragraph",
+      content: [{ type: "text", text: text2 }]
+    };
+  });
+  return {
+    type: "doc",
+    content
+  };
+}
+var StyleProp = class _StyleProp {
+  /** @internal */
+  constructor(id, defaultValue, type) {
+    this.id = id;
+    this.defaultValue = defaultValue;
+    this.type = type;
+  }
+  id;
+  defaultValue;
+  type;
+  /**
+   * Define a new {@link StyleProp}.
+   *
+   * @param uniqueId - Each StyleProp must have a unique ID. We recommend you prefix this with
+   * your app/library name.
+   * @param options -
+   * - `defaultValue`: The default value for this style prop.
+   *
+   * - `type`: Optionally, describe what type of data you expect for this style prop.
+   *
+   * @example
+   * ```ts
+   * import {T} from '@ibodr/validate'
+   * import {StyleProp} from '@ibodr/schema'
+   *
+   * const MyLineWidthProp = StyleProp.define('myApp:lineWidth', {
+   *   defaultValue: 1,
+   *   type: T.number,
+   * })
+   * ```
+   * @public
+   */
+  static define(uniqueId4, options) {
+    const { defaultValue, type = T.any } = options;
+    return new _StyleProp(uniqueId4, defaultValue, type);
+  }
+  /**
+   * Define a new {@link StyleProp} as a list of possible values.
+   *
+   * @param uniqueId - Each StyleProp must have a unique ID. We recommend you prefix this with
+   * your app/library name.
+   * @param options -
+   * - `defaultValue`: The default value for this style prop.
+   *
+   * - `values`: An array of possible values of this style prop.
+   *
+   * @example
+   * ```ts
+   * import {StyleProp} from '@ibodr/schema'
+   *
+   * const MySizeProp = StyleProp.defineEnum('myApp:size', {
+   *   defaultValue: 'medium',
+   *   values: ['small', 'medium', 'large'],
+   * })
+   * ```
+   */
+  static defineEnum(uniqueId4, options) {
+    const { defaultValue, values } = options;
+    return new EnumStyleProp(uniqueId4, defaultValue, values);
+  }
+  setDefaultValue(value) {
+    this.defaultValue = value;
+  }
+  validate(value) {
+    return this.type.validate(value);
+  }
+  validateUsingKnownGoodVersion(prevValue, newValue) {
+    if (this.type.validateUsingKnownGoodVersion) {
+      return this.type.validateUsingKnownGoodVersion(prevValue, newValue);
+    } else {
+      return this.validate(newValue);
+    }
+  }
+};
+var EnumStyleProp = class extends StyleProp {
+  /** @internal */
+  constructor(id, defaultValue, values) {
+    super(id, defaultValue, T.literalEnum(...values));
+    this.values = [...values];
+  }
+  values;
+  /**
+   * Add new values to this enum style prop at runtime. This is useful for extending
+   * the built-in styles with custom values (e.g. adding custom colors). Be sure to
+   * also modify the associated types.
+   *
+   * @param newValues - The new values to add.
+   *
+   * @public
+   */
+  addValues(...newValues) {
+    for (const v of newValues) {
+      if (!this.values.includes(v)) {
+        this.values.push(v);
+      }
+    }
+    this.type = T.literalEnum(...this.values);
+  }
+  /**
+   * Remove values from this enum style prop at runtime. This is useful for narrowing
+   * the built-in styles with custom values (e.g. adding custom colors). Be sure to
+   * also modify the associated types.
+   *
+   * @param valuesToRemove - The values to remove.
+   *
+   * @public
+   */
+  removeValues(...valuesToRemove) {
+    for (const v of valuesToRemove) {
+      if (this.values.includes(v)) {
+        this.values.splice(this.values.indexOf(v), 1);
+      }
+    }
+    this.type = T.literalEnum(...this.values);
+  }
+};
+
+// src/records/DrShape.ts
+var rootShapeVersions = createMigrationIds("com.draw.shape", {
+  AddIsLocked: 1,
+  HoistOpacity: 2,
+  AddMeta: 3,
+  AddWhite: 4
+});
+var rootShapeMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.shape",
+  recordType: "shape",
+  sequence: [
+    {
+      id: rootShapeVersions.AddIsLocked,
+      up: (record) => {
+        record.isLocked = false;
+      },
+      down: (record) => {
+        delete record.isLocked;
+      }
+    },
+    {
+      id: rootShapeVersions.HoistOpacity,
+      up: (record) => {
+        record.opacity = Number(record.props.opacity ?? "1");
+        delete record.props.opacity;
+      },
+      down: (record) => {
+        const opacity = record.opacity;
+        delete record.opacity;
+        record.props.opacity = opacity < 0.175 ? "0.1" : opacity < 0.375 ? "0.25" : opacity < 0.625 ? "0.5" : opacity < 0.875 ? "0.75" : "1";
+      }
+    },
+    {
+      id: rootShapeVersions.AddMeta,
+      up: (record) => {
+        record.meta = {};
+      }
+    },
+    {
+      id: rootShapeVersions.AddWhite,
+      up: (_record) => {
+      },
+      down: (record) => {
+        if (record.props.color === "white") {
+          record.props.color = "black";
+        }
+      }
+    }
+  ]
+});
+function isShape(record) {
+  if (!record) return false;
+  return record.typeName === "shape";
+}
+function isShapeId(id) {
+  if (!id) return false;
+  return id.startsWith("shape:");
+}
+function createShapeId(id) {
+  return `shape:${id ?? uniqueId()}`;
+}
+function getShapePropKeysByStyle(props) {
+  const propKeysByStyle = /* @__PURE__ */ new Map();
+  for (const [key, prop] of Object.entries(props)) {
+    if (prop instanceof StyleProp) {
+      if (propKeysByStyle.has(prop)) {
+        throw new Error(
+          `Duplicate style prop ${prop.id}. Each style prop can only be used once within a shape.`
+        );
+      }
+      propKeysByStyle.set(prop, key);
+    }
+  }
+  return propKeysByStyle;
+}
+function createShapePropsMigrationSequence(migrations) {
+  return migrations;
+}
+function createShapePropsMigrationIds(shapeType, ids) {
+  return mapObjectMapValues(ids, (_k, v) => `com.draw.shape.${shapeType}/${v}`);
+}
+function createShapeRecordType(shapes) {
+  return createRecordType("shape", {
+    scope: "document",
+    validator: T.model(
+      "shape",
+      T.union(
+        "type",
+        mapObjectMapValues(
+          shapes,
+          (type, { props, meta }) => createShapeValidator(type, props, meta)
+        )
+      )
+    )
+  }).withDefaultProperties(() => ({
+    x: 0,
+    y: 0,
+    rotation: 0,
+    isLocked: false,
+    opacity: 1,
+    meta: {}
+  }));
+}
+function processPropsMigrations(typeName, records) {
+  const result = [];
+  for (const [subType, { migrations }] of Object.entries(records)) {
+    const sequenceId = `com.draw.${typeName}.${subType}`;
+    if (!migrations) {
+      result.push(
+        createMigrationSequence({
+          sequenceId,
+          retroactive: true,
+          sequence: []
+        })
+      );
+    } else if ("sequenceId" in migrations) {
+      assert(
+        sequenceId === migrations.sequenceId,
+        `sequenceId mismatch for ${subType} ${RecordType} migrations. Expected '${sequenceId}', got '${migrations.sequenceId}'`
+      );
+      result.push(migrations);
+    } else if ("sequence" in migrations) {
+      result.push(
+        createMigrationSequence({
+          sequenceId,
+          retroactive: true,
+          sequence: migrations.sequence.map(
+            (m) => "id" in m ? createPropsMigration(typeName, subType, m) : m
+          )
+        })
+      );
+    } else {
+      result.push(
+        createMigrationSequence({
+          sequenceId,
+          retroactive: true,
+          sequence: Object.keys(migrations.migrators).map((k) => Number(k)).sort((a, b) => a - b).map(
+            (version) => ({
+              id: `${sequenceId}/${version}`,
+              scope: "record",
+              filter: (r) => r.typeName === typeName && r.type === subType,
+              up: (record) => {
+                const result2 = migrations.migrators[version].up(record);
+                if (result2) {
+                  return result2;
+                }
+              },
+              down: (record) => {
+                const result2 = migrations.migrators[version].down(record);
+                if (result2) {
+                  return result2;
+                }
+              }
+            })
+          )
+        })
+      );
+    }
+  }
+  return result;
+}
+function createPropsMigration(typeName, subType, m) {
+  return {
+    id: m.id,
+    dependsOn: m.dependsOn,
+    scope: "record",
+    filter: (r) => r.typeName === typeName && r.type === subType,
+    up: (record) => {
+      const result = m.up(record.props);
+      if (result) {
+        record.props = result;
+      }
+    },
+    down: typeof m.down === "function" ? (record) => {
+      const result = m.down(record.props);
+      if (result) {
+        record.props = result;
+      }
+    } : void 0
+  };
+}
+
+// src/styles/DrColorStyle.ts
+var defaultColorNames = [
+  "black",
+  "grey",
+  "light-violet",
+  "violet",
+  "blue",
+  "light-blue",
+  "yellow",
+  "orange",
+  "green",
+  "light-green",
+  "light-red",
+  "red",
+  "white"
+];
+var DefaultColorStyle = StyleProp.defineEnum("draw:color", {
+  defaultValue: "black",
+  values: defaultColorNames
+});
+var DefaultLabelColorStyle = StyleProp.defineEnum("draw:labelColor", {
+  defaultValue: "black",
+  values: defaultColorNames
+});
+function registerColorsFromThemes(definitions) {
+  const colorNames = /* @__PURE__ */ new Set();
+  for (const def of Object.values(definitions)) {
+    for (const colorPalette of [def.colors.light, def.colors.dark]) {
+      for (const [key, value] of Object.entries(colorPalette)) {
+        if (typeof value === "object" && value !== null) {
+          colorNames.add(key);
+        }
+      }
+    }
+  }
+  if (colorNames.size > 0) {
+    DefaultColorStyle.addValues(...colorNames);
+    DefaultLabelColorStyle.addValues(...colorNames);
+  }
+  const toRemove = DefaultColorStyle.values.filter((v) => !colorNames.has(v));
+  if (toRemove.length > 0) {
+    DefaultColorStyle.removeValues(...toRemove);
+    DefaultLabelColorStyle.removeValues(...toRemove);
+  }
+  {
+    for (const def of Object.values(definitions)) {
+      for (const color of colorNames) {
+        if (!(color in def.colors.light)) {
+          console.warn(
+            `Theme '${def.id}' light palette is missing color '${color}'. Shapes using this color won't render correctly.`
+          );
+        }
+        if (!(color in def.colors.dark)) {
+          console.warn(
+            `Theme '${def.id}' dark palette is missing color '${color}'. Shapes using this color won't render correctly.`
+          );
+        }
+      }
+    }
+  }
+}
+
+// src/styles/DrDashStyle.ts
+var DefaultDashStyle = StyleProp.defineEnum("draw:dash", {
+  defaultValue: "draw",
+  values: ["draw", "solid", "dashed", "dotted", "none"]
+});
+
+// src/styles/DrFillStyle.ts
+var DefaultFillStyle = StyleProp.defineEnum("draw:fill", {
+  defaultValue: "none",
+  values: ["none", "semi", "solid", "pattern", "fill", "lined-fill"]
+});
+
+// src/styles/DrFontStyle.ts
+var DefaultFontStyle = StyleProp.defineEnum("draw:font", {
+  defaultValue: "draw",
+  values: ["draw", "sans", "serif", "mono"]
+});
+var DefaultFontFamilies = {
+  draw: "'draw_draw', sans-serif",
+  sans: "'draw_sans', sans-serif",
+  serif: "'draw_serif', serif",
+  mono: "'draw_mono', monospace"
+};
+function isFontEntry(value) {
+  return typeof value === "object" && value !== null && "fontFamily" in value;
+}
+function registerFontsFromThemes(definitions) {
+  const fontNames = /* @__PURE__ */ new Set();
+  for (const def of Object.values(definitions)) {
+    if (!def.fonts) continue;
+    for (const [key, value] of Object.entries(def.fonts)) {
+      if (isFontEntry(value)) {
+        fontNames.add(key);
+      }
+    }
+  }
+  const toAdd = [...fontNames].filter((v) => !DefaultFontStyle.values.includes(v));
+  if (toAdd.length > 0) {
+    DefaultFontStyle.addValues(...toAdd);
+  }
+  const toRemove = DefaultFontStyle.values.filter((v) => !fontNames.has(v));
+  if (toRemove.length > 0) {
+    DefaultFontStyle.removeValues(...toRemove);
+  }
+  {
+    for (const def of Object.values(definitions)) {
+      for (const font of fontNames) {
+        if (!def.fonts || !(font in def.fonts)) {
+          console.warn(
+            `Theme '${def.id}' is missing font '${font}'. Shapes using this font won't render correctly in this theme.`
+          );
+        }
+      }
+    }
+  }
+}
+
+// src/styles/DrSizeStyle.ts
+var DefaultSizeStyle = StyleProp.defineEnum("draw:size", {
+  defaultValue: "m",
+  values: ["s", "m", "l", "xl"]
+});
+
+// src/shapes/DrArrowShape.ts
+var arrowKinds = ["arc", "elbow"];
+var ArrowShapeKindStyle = StyleProp.defineEnum("draw:arrowKind", {
+  defaultValue: "arc",
+  values: arrowKinds
+});
+var arrowheadTypes = [
+  "arrow",
+  "triangle",
+  "square",
+  "dot",
+  "pipe",
+  "diamond",
+  "inverted",
+  "bar",
+  "none"
+];
+var ArrowShapeArrowheadStartStyle = StyleProp.defineEnum("draw:arrowheadStart", {
+  defaultValue: "none",
+  values: arrowheadTypes
+});
+var ArrowShapeArrowheadEndStyle = StyleProp.defineEnum("draw:arrowheadEnd", {
+  defaultValue: "arrow",
+  values: arrowheadTypes
+});
+var arrowShapeProps = {
+  kind: ArrowShapeKindStyle,
+  labelColor: DefaultLabelColorStyle,
+  color: DefaultColorStyle,
+  fill: DefaultFillStyle,
+  dash: DefaultDashStyle,
+  size: DefaultSizeStyle,
+  arrowheadStart: ArrowShapeArrowheadStartStyle,
+  arrowheadEnd: ArrowShapeArrowheadEndStyle,
+  font: DefaultFontStyle,
+  start: vecModelValidator,
+  end: vecModelValidator,
+  bend: T.number,
+  richText: richTextValidator,
+  labelPosition: T.number,
+  scale: T.nonZeroNumber,
+  elbowMidPoint: T.number
+};
+var arrowShapeVersions = createShapePropsMigrationIds("arrow", {
+  AddLabelColor: 1,
+  AddIsPrecise: 2,
+  AddLabelPosition: 3,
+  ExtractBindings: 4,
+  AddScale: 5,
+  AddElbow: 6,
+  AddRichText: 7,
+  AddRichTextAttrs: 8
+});
+function propsMigration(migration) {
+  return createPropsMigration("shape", "arrow", migration);
+}
+var arrowShapeMigrations = createMigrationSequence({
+  sequenceId: "com.draw.shape.arrow",
+  retroactive: false,
+  sequence: [
+    propsMigration({
+      id: arrowShapeVersions.AddLabelColor,
+      up: (props) => {
+        props.labelColor = "black";
+      },
+      down: "retired"
+    }),
+    propsMigration({
+      id: arrowShapeVersions.AddIsPrecise,
+      up: ({ start, end }) => {
+        if (start.type === "binding") {
+          start.isPrecise = !(start.normalizedAnchor.x === 0.5 && start.normalizedAnchor.y === 0.5);
+        }
+        if (end.type === "binding") {
+          end.isPrecise = !(end.normalizedAnchor.x === 0.5 && end.normalizedAnchor.y === 0.5);
+        }
+      },
+      down: ({ start, end }) => {
+        if (start.type === "binding") {
+          if (!start.isPrecise) {
+            start.normalizedAnchor = { x: 0.5, y: 0.5 };
+          }
+          delete start.isPrecise;
+        }
+        if (end.type === "binding") {
+          if (!end.isPrecise) {
+            end.normalizedAnchor = { x: 0.5, y: 0.5 };
+          }
+          delete end.isPrecise;
+        }
+      }
+    }),
+    propsMigration({
+      id: arrowShapeVersions.AddLabelPosition,
+      up: (props) => {
+        props.labelPosition = 0.5;
+      },
+      down: (props) => {
+        delete props.labelPosition;
+      }
+    }),
+    {
+      id: arrowShapeVersions.ExtractBindings,
+      scope: "storage",
+      up: (storage) => {
+        const updates = [];
+        for (const record of storage.values()) {
+          if (record.typeName !== "shape" || record.type !== "arrow") continue;
+          const arrow = record;
+          const newArrow = structuredClone(arrow);
+          const { start, end } = arrow.props;
+          if (start.type === "binding") {
+            const id = createBindingId();
+            const binding = {
+              typeName: "binding",
+              id,
+              type: "arrow",
+              fromId: arrow.id,
+              toId: start.boundShapeId,
+              meta: {},
+              props: {
+                terminal: "start",
+                normalizedAnchor: start.normalizedAnchor,
+                isExact: start.isExact,
+                isPrecise: start.isPrecise
+              }
+            };
+            updates.push([id, binding]);
+            newArrow.props.start = { x: 0, y: 0 };
+          } else {
+            delete newArrow.props.start.type;
+          }
+          if (end.type === "binding") {
+            const id = createBindingId();
+            const binding = {
+              typeName: "binding",
+              id,
+              type: "arrow",
+              fromId: arrow.id,
+              toId: end.boundShapeId,
+              meta: {},
+              props: {
+                terminal: "end",
+                normalizedAnchor: end.normalizedAnchor,
+                isExact: end.isExact,
+                isPrecise: end.isPrecise
+              }
+            };
+            updates.push([id, binding]);
+            newArrow.props.end = { x: 0, y: 0 };
+          } else {
+            delete newArrow.props.end.type;
+          }
+          updates.push([arrow.id, newArrow]);
+        }
+        for (const [id, record] of updates) {
+          storage.set(id, record);
+        }
+      }
+    },
+    propsMigration({
+      id: arrowShapeVersions.AddScale,
+      up: (props) => {
+        props.scale = 1;
+      },
+      down: (props) => {
+        delete props.scale;
+      }
+    }),
+    propsMigration({
+      id: arrowShapeVersions.AddElbow,
+      up: (props) => {
+        props.kind = "arc";
+        props.elbowMidPoint = 0.5;
+      },
+      down: (props) => {
+        delete props.kind;
+        delete props.elbowMidPoint;
+      }
+    }),
+    propsMigration({
+      id: arrowShapeVersions.AddRichText,
+      up: (props) => {
+        props.richText = toRichText(props.text);
+        delete props.text;
+      }
+      // N.B. Explicitly no down state so that we force clients to update.
+      // down: (props) => {
+      // 	delete props.richText
+      // },
+    }),
+    propsMigration({
+      id: arrowShapeVersions.AddRichTextAttrs,
+      up: (_props) => {
+      },
+      down: (props) => {
+        if (props.richText && "attrs" in props.richText) {
+          delete props.richText.attrs;
+        }
+      }
+    })
+  ]
+});
+
+// src/bindings/DrArrowBinding.ts
+var ElbowArrowSnap = T.literalEnum("center", "edge-point", "edge", "none");
+var arrowBindingProps = {
+  terminal: T.literalEnum("start", "end"),
+  normalizedAnchor: vecModelValidator,
+  isExact: T.boolean,
+  isPrecise: T.boolean,
+  snap: ElbowArrowSnap
+};
+var arrowBindingVersions = createBindingPropsMigrationIds("arrow", {
+  AddSnap: 1
+});
+var arrowBindingMigrations = createBindingPropsMigrationSequence({
+  sequence: [
+    { dependsOn: [arrowShapeVersions.ExtractBindings] },
+    {
+      id: arrowBindingVersions.AddSnap,
+      up: (props) => {
+        props.snap = "none";
+      },
+      down: (props) => {
+        delete props.snap;
+      }
+    }
+  ]
+});
+var cameraValidator = T.model(
+  "camera",
+  T.object({
+    typeName: T.literal("camera"),
+    id: idValidator("camera"),
+    x: T.number,
+    y: T.number,
+    z: T.number,
+    meta: T.jsonValue
+  })
+);
+var cameraVersions = createMigrationIds("com.draw.camera", {
+  AddMeta: 1
+});
+var cameraMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.camera",
+  recordType: "camera",
+  sequence: [
+    {
+      id: cameraVersions.AddMeta,
+      up: (record) => {
+        record.meta = {};
+      }
+    }
+  ]
+});
+var CameraRecordType = createRecordType("camera", {
+  validator: cameraValidator,
+  scope: "session"
+}).withDefaultProperties(
+  () => ({
+    x: 0,
+    y: 0,
+    z: 1,
+    meta: {}
+  })
+);
+var TL_CURSOR_TYPES = /* @__PURE__ */ new Set([
+  "none",
+  "default",
+  "pointer",
+  "cross",
+  "grab",
+  "rotate",
+  "grabbing",
+  "resize-edge",
+  "resize-corner",
+  "text",
+  "move",
+  "ew-resize",
+  "ns-resize",
+  "nesw-resize",
+  "nwse-resize",
+  "nesw-rotate",
+  "nwse-rotate",
+  "swne-rotate",
+  "senw-rotate",
+  "zoom-in",
+  "zoom-out"
+]);
+var cursorTypeValidator = T.setEnum(TL_CURSOR_TYPES);
+var cursorValidator = T.object({
+  type: cursorTypeValidator,
+  rotation: T.number
+});
+var TL_CANVAS_UI_COLOR_TYPES = /* @__PURE__ */ new Set([
+  "accent",
+  "white",
+  "black",
+  "selection-stroke",
+  "selection-fill",
+  "laser",
+  "muted-1"
+]);
+var canvasUiColorTypeValidator = T.setEnum(TL_CANVAS_UI_COLOR_TYPES);
+
+// src/misc/DrScribble.ts
+var TL_SCRIBBLE_STATES = /* @__PURE__ */ new Set([
+  "starting",
+  "paused",
+  "active",
+  "complete",
+  "stopping"
+]);
+var scribbleValidator = T.object({
+  id: T.string,
+  points: T.arrayOf(vecModelValidator),
+  size: T.positiveNumber,
+  color: canvasUiColorTypeValidator,
+  opacity: T.number,
+  state: T.setEnum(TL_SCRIBBLE_STATES),
+  delay: T.number,
+  shrink: T.number,
+  taper: T.boolean
+});
+var pageIdValidator = idValidator("page");
+var pageValidator = T.model(
+  "page",
+  T.object({
+    typeName: T.literal("page"),
+    id: pageIdValidator,
+    name: T.string,
+    index: T.indexKey,
+    meta: T.jsonValue
+  })
+);
+var pageVersions = createMigrationIds("com.draw.page", {
+  AddMeta: 1
+});
+var pageMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.page",
+  recordType: "page",
+  sequence: [
+    {
+      id: pageVersions.AddMeta,
+      up: (record) => {
+        record.meta = {};
+      }
+    }
+  ]
+});
+var PageRecordType = createRecordType("page", {
+  validator: pageValidator,
+  scope: "document"
+}).withDefaultProperties(() => ({
+  meta: {}
+}));
+function isPageId(id) {
+  return PageRecordType.isId(id);
+}
+
+// src/records/DrInstance.ts
+var shouldKeyBePreservedBetweenSessions = {
+  // This object defines keys that should be preserved across calls to loadSnapshot()
+  id: false,
+  // meta
+  typeName: false,
+  // meta
+  currentPageId: false,
+  // does not preserve because who knows if the page still exists
+  opacityForNextShape: false,
+  // does not preserve because it's a temporary state
+  stylesForNextShape: false,
+  // does not preserve because it's a temporary state
+  followingUserId: false,
+  // does not preserve because it's a temporary state
+  highlightedUserIds: false,
+  // does not preserve because it's a temporary state
+  brush: false,
+  // does not preserve because it's a temporary state
+  cursor: false,
+  // does not preserve because it's a temporary state
+  scribbles: false,
+  // does not preserve because it's a temporary state
+  isFocusMode: true,
+  // preserves because it's a user preference
+  isDebugMode: true,
+  // preserves because it's a user preference
+  isToolLocked: true,
+  // preserves because it's a user preference
+  exportBackground: true,
+  // preserves because it's a user preference
+  screenBounds: true,
+  // preserves because it's capturing the user's screen state
+  insets: true,
+  // preserves because it's capturing the user's screen state
+  zoomBrush: false,
+  // does not preserve because it's a temporary state
+  chatMessage: false,
+  // does not preserve because it's a temporary state
+  isChatting: false,
+  // does not preserve because it's a temporary state
+  isPenMode: false,
+  // does not preserve because it's a temporary state
+  isGridMode: true,
+  // preserves because it's a user preference
+  isFocused: true,
+  // preserves because obviously
+  devicePixelRatio: true,
+  // preserves because it captures the user's screen state
+  isCoarsePointer: true,
+  // preserves because it captures the user's screen state
+  isHoveringCanvas: false,
+  // does not preserve because it's a temporary state
+  openMenus: false,
+  // does not preserve because it's a temporary state
+  isChangingStyle: false,
+  // does not preserve because it's a temporary state
+  isReadonly: true,
+  // preserves because it's a config option
+  meta: false,
+  // does not preserve because who knows what's in there, leave it up to sdk users to save and reinstate
+  duplicateProps: false,
+  //
+  cameraState: false
+  // does not preserve because it's a temporary state
+};
+function pluckPreservingValues(val) {
+  return val ? filterEntries(val, (key) => {
+    return shouldKeyBePreservedBetweenSessions[key];
+  }) : null;
+}
+idValidator("instance");
+function createInstanceRecordType(stylesById) {
+  const stylesForNextShapeValidators = {};
+  for (const [id, style] of stylesById) {
+    stylesForNextShapeValidators[id] = T.optional(style);
+  }
+  const instanceTypeValidator = T.model(
+    "instance",
+    T.object({
+      typeName: T.literal("instance"),
+      id: idValidator("instance"),
+      currentPageId: pageIdValidator,
+      followingUserId: T.string.nullable(),
+      brush: boxModelValidator.nullable(),
+      opacityForNextShape: opacityValidator,
+      stylesForNextShape: T.object(stylesForNextShapeValidators),
+      cursor: cursorValidator,
+      scribbles: T.arrayOf(scribbleValidator),
+      isFocusMode: T.boolean,
+      isDebugMode: T.boolean,
+      isToolLocked: T.boolean,
+      exportBackground: T.boolean,
+      screenBounds: boxModelValidator,
+      insets: T.arrayOf(T.boolean),
+      zoomBrush: boxModelValidator.nullable(),
+      isPenMode: T.boolean,
+      isGridMode: T.boolean,
+      chatMessage: T.string,
+      isChatting: T.boolean,
+      highlightedUserIds: T.arrayOf(T.string),
+      isFocused: T.boolean,
+      devicePixelRatio: T.number,
+      isCoarsePointer: T.boolean,
+      isHoveringCanvas: T.boolean.nullable(),
+      openMenus: T.arrayOf(T.string),
+      isChangingStyle: T.boolean,
+      isReadonly: T.boolean,
+      meta: T.jsonValue,
+      duplicateProps: T.object({
+        shapeIds: T.arrayOf(idValidator("shape")),
+        offset: T.object({
+          x: T.number,
+          y: T.number
+        })
+      }).nullable(),
+      cameraState: T.literalEnum("idle", "moving")
+    })
+  );
+  return createRecordType("instance", {
+    validator: instanceTypeValidator,
+    scope: "session",
+    ephemeralKeys: {
+      currentPageId: false,
+      meta: false,
+      followingUserId: true,
+      opacityForNextShape: true,
+      stylesForNextShape: true,
+      brush: true,
+      cursor: true,
+      scribbles: true,
+      isFocusMode: true,
+      isDebugMode: true,
+      isToolLocked: true,
+      exportBackground: true,
+      screenBounds: true,
+      insets: true,
+      zoomBrush: true,
+      isPenMode: true,
+      isGridMode: true,
+      chatMessage: true,
+      isChatting: true,
+      highlightedUserIds: true,
+      isFocused: true,
+      devicePixelRatio: true,
+      isCoarsePointer: true,
+      isHoveringCanvas: true,
+      openMenus: true,
+      isChangingStyle: true,
+      isReadonly: true,
+      duplicateProps: true,
+      cameraState: true
+    }
+  }).withDefaultProperties(
+    () => ({
+      followingUserId: null,
+      opacityForNextShape: 1,
+      stylesForNextShape: {},
+      brush: null,
+      scribbles: [],
+      cursor: {
+        type: "default",
+        rotation: 0
+      },
+      isFocusMode: false,
+      exportBackground: false,
+      isDebugMode: false,
+      isToolLocked: false,
+      screenBounds: { x: 0, y: 0, w: 1080, h: 720 },
+      insets: [false, false, false, false],
+      zoomBrush: null,
+      isGridMode: false,
+      isPenMode: false,
+      chatMessage: "",
+      isChatting: false,
+      highlightedUserIds: [],
+      isFocused: false,
+      devicePixelRatio: typeof window === "undefined" ? 1 : window.devicePixelRatio,
+      isCoarsePointer: false,
+      isHoveringCanvas: null,
+      openMenus: [],
+      isChangingStyle: false,
+      isReadonly: false,
+      meta: {},
+      duplicateProps: null,
+      cameraState: "idle"
+    })
+  );
+}
+var instanceVersions = createMigrationIds("com.draw.instance", {
+  AddTransparentExportBgs: 1,
+  RemoveDialog: 2,
+  AddToolLockMode: 3,
+  RemoveExtraPropsForNextShape: 4,
+  AddLabelColor: 5,
+  AddFollowingUserId: 6,
+  RemoveAlignJustify: 7,
+  AddZoom: 8,
+  AddVerticalAlign: 9,
+  AddScribbleDelay: 10,
+  RemoveUserId: 11,
+  AddIsPenModeAndIsGridMode: 12,
+  HoistOpacity: 13,
+  AddChat: 14,
+  AddHighlightedUserIds: 15,
+  ReplacePropsForNextShapeWithStylesForNextShape: 16,
+  AddMeta: 17,
+  RemoveCursorColor: 18,
+  AddLonelyProperties: 19,
+  ReadOnlyReadonly: 20,
+  AddHoveringCanvas: 21,
+  AddScribbles: 22,
+  AddInset: 23,
+  AddDuplicateProps: 24,
+  RemoveCanMoveCamera: 25,
+  AddCameraState: 26
+});
+var instanceMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.instance",
+  recordType: "instance",
+  sequence: [
+    {
+      id: instanceVersions.AddTransparentExportBgs,
+      up: (instance) => {
+        return { ...instance, exportBackground: true };
+      }
+    },
+    {
+      id: instanceVersions.RemoveDialog,
+      up: ({ dialog: _, ...instance }) => {
+        return instance;
+      }
+    },
+    {
+      id: instanceVersions.AddToolLockMode,
+      up: (instance) => {
+        return { ...instance, isToolLocked: false };
+      }
+    },
+    {
+      id: instanceVersions.RemoveExtraPropsForNextShape,
+      up: ({ propsForNextShape, ...instance }) => {
+        return {
+          ...instance,
+          propsForNextShape: Object.fromEntries(
+            Object.entries(propsForNextShape).filter(
+              ([key]) => [
+                "color",
+                "labelColor",
+                "dash",
+                "fill",
+                "size",
+                "font",
+                "align",
+                "verticalAlign",
+                "icon",
+                "geo",
+                "arrowheadStart",
+                "arrowheadEnd",
+                "spline"
+              ].includes(key)
+            )
+          )
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddLabelColor,
+      up: ({ propsForNextShape, ...instance }) => {
+        return {
+          ...instance,
+          propsForNextShape: {
+            ...propsForNextShape,
+            labelColor: "black"
+          }
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddFollowingUserId,
+      up: (instance) => {
+        return { ...instance, followingUserId: null };
+      }
+    },
+    {
+      id: instanceVersions.RemoveAlignJustify,
+      up: (instance) => {
+        let newAlign = instance.propsForNextShape.align;
+        if (newAlign === "justify") {
+          newAlign = "start";
+        }
+        return {
+          ...instance,
+          propsForNextShape: {
+            ...instance.propsForNextShape,
+            align: newAlign
+          }
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddZoom,
+      up: (instance) => {
+        return { ...instance, zoomBrush: null };
+      }
+    },
+    {
+      id: instanceVersions.AddVerticalAlign,
+      up: (instance) => {
+        return {
+          ...instance,
+          propsForNextShape: {
+            ...instance.propsForNextShape,
+            verticalAlign: "middle"
+          }
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddScribbleDelay,
+      up: (instance) => {
+        if (instance.scribble !== null) {
+          return { ...instance, scribble: { ...instance.scribble, delay: 0 } };
+        }
+        return { ...instance };
+      }
+    },
+    {
+      id: instanceVersions.RemoveUserId,
+      up: ({ userId: _, ...instance }) => {
+        return instance;
+      }
+    },
+    {
+      id: instanceVersions.AddIsPenModeAndIsGridMode,
+      up: (instance) => {
+        return { ...instance, isPenMode: false, isGridMode: false };
+      }
+    },
+    {
+      id: instanceVersions.HoistOpacity,
+      up: ({ propsForNextShape: { opacity, ...propsForNextShape }, ...instance }) => {
+        return { ...instance, opacityForNextShape: Number(opacity ?? "1"), propsForNextShape };
+      }
+    },
+    {
+      id: instanceVersions.AddChat,
+      up: (instance) => {
+        return { ...instance, chatMessage: "", isChatting: false };
+      }
+    },
+    {
+      id: instanceVersions.AddHighlightedUserIds,
+      up: (instance) => {
+        return { ...instance, highlightedUserIds: [] };
+      }
+    },
+    {
+      id: instanceVersions.ReplacePropsForNextShapeWithStylesForNextShape,
+      up: ({ propsForNextShape: _, ...instance }) => {
+        return { ...instance, stylesForNextShape: {} };
+      }
+    },
+    {
+      id: instanceVersions.AddMeta,
+      up: (record) => {
+        return {
+          ...record,
+          meta: {}
+        };
+      }
+    },
+    {
+      id: instanceVersions.RemoveCursorColor,
+      up: (record) => {
+        const { color: _, ...cursor } = record.cursor;
+        return {
+          ...record,
+          cursor
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddLonelyProperties,
+      up: (record) => {
+        return {
+          ...record,
+          canMoveCamera: true,
+          isFocused: false,
+          devicePixelRatio: 1,
+          isCoarsePointer: false,
+          openMenus: [],
+          isChangingStyle: false,
+          isReadOnly: false
+        };
+      }
+    },
+    {
+      id: instanceVersions.ReadOnlyReadonly,
+      up: ({ isReadOnly: _isReadOnly, ...record }) => {
+        return {
+          ...record,
+          isReadonly: _isReadOnly
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddHoveringCanvas,
+      up: (record) => {
+        return {
+          ...record,
+          isHoveringCanvas: null
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddScribbles,
+      up: ({ scribble: _, ...record }) => {
+        return {
+          ...record,
+          scribbles: []
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddInset,
+      up: (record) => {
+        return {
+          ...record,
+          insets: [false, false, false, false]
+        };
+      },
+      down: ({ insets: _, ...record }) => {
+        return {
+          ...record
+        };
+      }
+    },
+    {
+      id: instanceVersions.AddDuplicateProps,
+      up: (record) => {
+        return {
+          ...record,
+          duplicateProps: null
+        };
+      },
+      down: ({ duplicateProps: _, ...record }) => {
+        return {
+          ...record
+        };
+      }
+    },
+    {
+      id: instanceVersions.RemoveCanMoveCamera,
+      up: ({ canMoveCamera: _, ...record }) => {
+        return {
+          ...record
+        };
+      },
+      down: (instance) => {
+        return { ...instance, canMoveCamera: true };
+      }
+    },
+    {
+      id: instanceVersions.AddCameraState,
+      up: (record) => {
+        return { ...record, cameraState: "idle" };
+      },
+      down: ({ cameraState: _, ...record }) => {
+        return record;
+      }
+    }
+  ]
+});
+var DrINSTANCE_ID = "instance:instance";
+var instancePageStateValidator = T.model(
+  "instance_page_state",
+  T.object({
+    typeName: T.literal("instance_page_state"),
+    id: idValidator("instance_page_state"),
+    pageId: pageIdValidator,
+    selectedShapeIds: T.arrayOf(shapeIdValidator),
+    hintingShapeIds: T.arrayOf(shapeIdValidator),
+    erasingShapeIds: T.arrayOf(shapeIdValidator),
+    hoveredShapeId: shapeIdValidator.nullable(),
+    editingShapeId: shapeIdValidator.nullable(),
+    croppingShapeId: shapeIdValidator.nullable(),
+    focusedGroupId: shapeIdValidator.nullable(),
+    meta: T.jsonValue
+  })
+);
+var instancePageStateVersions = createMigrationIds("com.draw.instance_page_state", {
+  AddCroppingId: 1,
+  RemoveInstanceIdAndCameraId: 2,
+  AddMeta: 3,
+  RenameProperties: 4,
+  RenamePropertiesAgain: 5
+});
+var instancePageStateMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.instance_page_state",
+  recordType: "instance_page_state",
+  sequence: [
+    {
+      id: instancePageStateVersions.AddCroppingId,
+      up(instance) {
+        instance.croppingShapeId = null;
+      }
+    },
+    {
+      id: instancePageStateVersions.RemoveInstanceIdAndCameraId,
+      up(instance) {
+        delete instance.instanceId;
+        delete instance.cameraId;
+      }
+    },
+    {
+      id: instancePageStateVersions.AddMeta,
+      up: (record) => {
+        record.meta = {};
+      }
+    },
+    {
+      id: instancePageStateVersions.RenameProperties,
+      // this migration is cursed: it was written wrong and doesn't do anything.
+      // rather than replace it, I've added another migration below that fixes it.
+      up: (_record) => {
+      },
+      down: (_record) => {
+      }
+    },
+    {
+      id: instancePageStateVersions.RenamePropertiesAgain,
+      up: (record) => {
+        record.selectedShapeIds = record.selectedIds;
+        delete record.selectedIds;
+        record.hintingShapeIds = record.hintingIds;
+        delete record.hintingIds;
+        record.erasingShapeIds = record.erasingIds;
+        delete record.erasingIds;
+        record.hoveredShapeId = record.hoveredId;
+        delete record.hoveredId;
+        record.editingShapeId = record.editingId;
+        delete record.editingId;
+        record.croppingShapeId = record.croppingShapeId ?? record.croppingId ?? null;
+        delete record.croppingId;
+        record.focusedGroupId = record.focusLayerId;
+        delete record.focusLayerId;
+      },
+      down: (record) => {
+        record.selectedIds = record.selectedShapeIds;
+        delete record.selectedShapeIds;
+        record.hintingIds = record.hintingShapeIds;
+        delete record.hintingShapeIds;
+        record.erasingIds = record.erasingShapeIds;
+        delete record.erasingShapeIds;
+        record.hoveredId = record.hoveredShapeId;
+        delete record.hoveredShapeId;
+        record.editingId = record.editingShapeId;
+        delete record.editingShapeId;
+        record.croppingId = record.croppingShapeId;
+        delete record.croppingShapeId;
+        record.focusLayerId = record.focusedGroupId;
+        delete record.focusedGroupId;
+      }
+    }
+  ]
+});
+var InstancePageStateRecordType = createRecordType(
+  "instance_page_state",
+  {
+    validator: instancePageStateValidator,
+    scope: "session",
+    ephemeralKeys: {
+      pageId: false,
+      selectedShapeIds: false,
+      editingShapeId: false,
+      croppingShapeId: false,
+      meta: false,
+      hintingShapeIds: true,
+      erasingShapeIds: true,
+      hoveredShapeId: true,
+      focusedGroupId: true
+    }
+  }
+).withDefaultProperties(
+  () => ({
+    editingShapeId: null,
+    croppingShapeId: null,
+    selectedShapeIds: [],
+    hoveredShapeId: null,
+    erasingShapeIds: [],
+    hintingShapeIds: [],
+    focusedGroupId: null,
+    meta: {}
+  })
+);
+var pointerValidator = T.model(
+  "pointer",
+  T.object({
+    typeName: T.literal("pointer"),
+    id: idValidator("pointer"),
+    x: T.number,
+    y: T.number,
+    lastActivityTimestamp: T.number,
+    meta: T.jsonValue
+  })
+);
+var pointerVersions = createMigrationIds("com.draw.pointer", {
+  AddMeta: 1
+});
+var pointerMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.pointer",
+  recordType: "pointer",
+  sequence: [
+    {
+      id: pointerVersions.AddMeta,
+      up: (record) => {
+        record.meta = {};
+      }
+    }
+  ]
+});
+var PointerRecordType = createRecordType("pointer", {
+  validator: pointerValidator,
+  scope: "session"
+}).withDefaultProperties(
+  () => ({
+    x: 0,
+    y: 0,
+    lastActivityTimestamp: 0,
+    meta: {}
+  })
+);
+var DrPOINTER_ID = PointerRecordType.createId("pointer");
+var instancePresenceValidator = T.model(
+  "instance_presence",
+  T.object({
+    typeName: T.literal("instance_presence"),
+    id: idValidator("instance_presence"),
+    userId: T.string,
+    userName: T.string,
+    lastActivityTimestamp: T.number.nullable(),
+    followingUserId: T.string.nullable(),
+    cursor: T.object({
+      x: T.number,
+      y: T.number,
+      type: cursorTypeValidator,
+      rotation: T.number
+    }).nullable(),
+    color: T.string,
+    camera: T.object({
+      x: T.number,
+      y: T.number,
+      z: T.number
+    }).nullable(),
+    screenBounds: boxModelValidator.nullable(),
+    selectedShapeIds: T.arrayOf(idValidator("shape")),
+    currentPageId: idValidator("page"),
+    brush: boxModelValidator.nullable(),
+    scribbles: T.arrayOf(scribbleValidator),
+    chatMessage: T.string,
+    meta: T.jsonValue
+  })
+);
+var instancePresenceVersions = createMigrationIds("com.draw.instance_presence", {
+  AddScribbleDelay: 1,
+  RemoveInstanceId: 2,
+  AddChatMessage: 3,
+  AddMeta: 4,
+  RenameSelectedShapeIds: 5,
+  NullableCameraCursor: 6
+});
+var instancePresenceMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.instance_presence",
+  recordType: "instance_presence",
+  sequence: [
+    {
+      id: instancePresenceVersions.AddScribbleDelay,
+      up: (instance) => {
+        if (instance.scribble !== null) {
+          instance.scribble.delay = 0;
+        }
+      }
+    },
+    {
+      id: instancePresenceVersions.RemoveInstanceId,
+      up: (instance) => {
+        delete instance.instanceId;
+      }
+    },
+    {
+      id: instancePresenceVersions.AddChatMessage,
+      up: (instance) => {
+        instance.chatMessage = "";
+      }
+    },
+    {
+      id: instancePresenceVersions.AddMeta,
+      up: (record) => {
+        record.meta = {};
+      }
+    },
+    {
+      id: instancePresenceVersions.RenameSelectedShapeIds,
+      up: (_record) => {
+      }
+    },
+    {
+      id: instancePresenceVersions.NullableCameraCursor,
+      up: (_record) => {
+      },
+      down: (record) => {
+        if (record.camera === null) {
+          record.camera = { x: 0, y: 0, z: 1 };
+        }
+        if (record.lastActivityTimestamp === null) {
+          record.lastActivityTimestamp = 0;
+        }
+        if (record.cursor === null) {
+          record.cursor = { type: "default", x: 0, y: 0, rotation: 0 };
+        }
+        if (record.screenBounds === null) {
+          record.screenBounds = { x: 0, y: 0, w: 1, h: 1 };
+        }
+      }
+    }
+  ]
+});
+var InstancePresenceRecordType = createRecordType(
+  "instance_presence",
+  {
+    validator: instancePresenceValidator,
+    scope: "presence"
+  }
+).withDefaultProperties(() => ({
+  lastActivityTimestamp: null,
+  followingUserId: null,
+  color: "#FF0000",
+  camera: null,
+  cursor: null,
+  screenBounds: null,
+  selectedShapeIds: [],
+  brush: null,
+  scribbles: [],
+  chatMessage: "",
+  meta: {}
+}));
+
+// src/createPresenceStateDerivation.ts
+function createPresenceStateDerivation($user, opts) {
+  const { instanceId, getUserPresence: _getUserPresence } = opts ?? {};
+  const getUserPresence = _getUserPresence ?? getDefaultUserPresence;
+  return (store) => {
+    return computed("instancePresence", () => {
+      const user = $user.get();
+      if (!user) return null;
+      const state = getUserPresence(store, user);
+      if (!state) return null;
+      return InstancePresenceRecordType.create({
+        ...state,
+        id: instanceId ?? InstancePresenceRecordType.createId(store.id)
+      });
+    });
+  };
+}
+function getDefaultUserPresence(store, user) {
+  const instance = store.get(DrINSTANCE_ID);
+  const pageState = store.get(InstancePageStateRecordType.createId(instance?.currentPageId));
+  const camera = store.get(CameraRecordType.createId(instance?.currentPageId));
+  const pointer = store.get(DrPOINTER_ID);
+  if (!pageState || !instance || !camera || !pointer) {
+    return null;
+  }
+  return {
+    selectedShapeIds: pageState.selectedShapeIds,
+    brush: instance.brush,
+    scribbles: instance.scribbles,
+    userId: user.id,
+    userName: user.name,
+    followingUserId: instance.followingUserId,
+    camera: {
+      x: camera.x,
+      y: camera.y,
+      z: camera.z
+    },
+    color: user.color || "#FF0000",
+    currentPageId: instance.currentPageId,
+    cursor: {
+      x: pointer.x,
+      y: pointer.y,
+      rotation: instance.cursor.rotation,
+      type: instance.cursor.type
+    },
+    lastActivityTimestamp: pointer.lastActivityTimestamp,
+    screenBounds: instance.screenBounds,
+    chatMessage: instance.chatMessage,
+    meta: {}
+  };
+}
+var assetVersions = createMigrationIds("com.draw.asset", {
+  AddMeta: 1
+});
+var assetMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.asset",
+  recordType: "asset",
+  sequence: [
+    {
+      id: assetVersions.AddMeta,
+      up: (record) => {
+        record.meta = {};
+      }
+    }
+  ]
+});
+function createAssetRecordType(assets) {
+  return createRecordType("asset", {
+    scope: "document",
+    validator: T.model(
+      "asset",
+      T.union(
+        "type",
+        mapObjectMapValues(
+          assets,
+          (type, { props, meta }) => createAssetValidator(type, props, meta)
+        )
+      )
+    )
+  }).withDefaultProperties(() => ({
+    meta: {}
+  }));
+}
+var AssetRecordType = createRecordType("asset", {
+  scope: "document"
+}).withDefaultProperties(() => ({
+  meta: {}
+}));
+function createAssetPropsMigrationSequence(migrations) {
+  return migrations;
+}
+function createAssetPropsMigrationIds(assetType, ids) {
+  return mapObjectMapValues(ids, (_k, v) => `com.draw.asset.${assetType}/${v}`);
+}
+function createCustomRecordType(typeName, config) {
+  return createRecordType(typeName, {
+    scope: config.scope,
+    validator: config.validator
+  }).withDefaultProperties(config.createDefaultProperties ?? (() => ({})));
+}
+function processCustomRecordMigrations(records) {
+  const result = [];
+  for (const [typeName, config] of Object.entries(records)) {
+    const sequenceId = `com.draw.${typeName}`;
+    const { migrations } = config;
+    if (!migrations) {
+      result.push(
+        createMigrationSequence({
+          sequenceId,
+          retroactive: true,
+          sequence: []
+        })
+      );
+    } else if ("sequenceId" in migrations) {
+      assert(
+        sequenceId === migrations.sequenceId,
+        `sequenceId mismatch for ${typeName} custom record migrations. Expected '${sequenceId}', got '${migrations.sequenceId}'`
+      );
+      result.push(migrations);
+    } else if ("sequence" in migrations) {
+      result.push(
+        createMigrationSequence({
+          sequenceId,
+          retroactive: true,
+          sequence: migrations.sequence.map((m) => {
+            if (!("id" in m)) return m;
+            return {
+              id: m.id,
+              dependsOn: m.dependsOn,
+              scope: "record",
+              filter: (r) => r.typeName === typeName,
+              up: (record) => {
+                const result2 = m.up(record);
+                if (result2) return result2;
+              },
+              down: typeof m.down === "function" ? (record) => {
+                const result2 = m.down(record);
+                if (result2) return result2;
+              } : void 0
+            };
+          })
+        })
+      );
+    }
+  }
+  return result;
+}
+function createCustomRecordMigrationIds(recordType, ids) {
+  return mapObjectMapValues(ids, (_k, v) => `com.draw.${recordType}/${v}`);
+}
+function createCustomRecordMigrationSequence(migrations) {
+  return migrations;
+}
+function createCustomRecordId(typeName, id) {
+  return `${typeName}:${id ?? uniqueId()}`;
+}
+function isCustomRecordId(typeName, id) {
+  if (!id) return false;
+  return id.startsWith(`${typeName}:`);
+}
+function isCustomRecord(typeName, record) {
+  if (!record) return false;
+  return record.typeName === typeName;
+}
+var documentValidator = T.model(
+  "document",
+  T.object({
+    typeName: T.literal("document"),
+    id: T.literal("document:document"),
+    gridSize: T.number,
+    name: T.string,
+    meta: T.jsonValue
+  })
+);
+function isDocument(record) {
+  if (!record) return false;
+  return record.typeName === "document";
+}
+var documentVersions = createMigrationIds("com.draw.document", {
+  AddName: 1,
+  AddMeta: 2
+});
+var documentMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.document",
+  recordType: "document",
+  sequence: [
+    {
+      id: documentVersions.AddName,
+      up: (document) => {
+        document.name = "";
+      },
+      down: (document) => {
+        delete document.name;
+      }
+    },
+    {
+      id: documentVersions.AddMeta,
+      up: (record) => {
+        record.meta = {};
+      }
+    }
+  ]
+});
+var DocumentRecordType = createRecordType("document", {
+  validator: documentValidator,
+  scope: "document"
+}).withDefaultProperties(
+  () => ({
+    gridSize: 10,
+    name: "",
+    meta: {}
+  })
+);
+var DrDOCUMENT_ID = DocumentRecordType.createId("document");
+var userIdValidator = idValidator("user");
+var userVersions = createMigrationIds("com.draw.user", {
+  Initial: 1
+});
+var userMigrations = createRecordMigrationSequence({
+  sequenceId: "com.draw.user",
+  recordType: "user",
+  sequence: [
+    {
+      id: userVersions.Initial,
+      up: (_record) => {
+      }
+    }
+  ]
+});
+function createUserRecordType(config) {
+  const metaConfig = config?.meta;
+  const metaValidator = metaConfig ? T.object(
+    Object.fromEntries(
+      Object.entries(metaConfig).map(([key, v]) => [
+        key,
+        new T.Validator((value) => {
+          if (value === void 0) return void 0;
+          return v.validate(value);
+        })
+      ])
+    )
+  ).allowUnknownProperties() : T.jsonValue;
+  const validator = T.model(
+    "user",
+    T.object({
+      typeName: T.literal("user"),
+      id: userIdValidator,
+      name: T.string,
+      color: T.string,
+      imageUrl: T.string,
+      meta: metaValidator
+    })
+  );
+  return createRecordType("user", {
+    validator,
+    scope: "document"
+  }).withDefaultProperties(() => ({
+    name: "",
+    color: "",
+    imageUrl: "",
+    meta: {}
+  }));
+}
+T.model(
+  "user",
+  T.object({
+    typeName: T.literal("user"),
+    id: userIdValidator,
+    name: T.string,
+    color: T.string,
+    imageUrl: T.string,
+    meta: T.jsonValue
+  })
+);
+var UserRecordType = createUserRecordType();
+function isUserId(id) {
+  return UserRecordType.isId(id);
+}
+function createUserId(id) {
+  return UserRecordType.createId(id);
+}
+var bookmarkShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  assetId: assetIdValidator.nullable(),
+  url: T.linkUrl
+};
+var Versions4 = createShapePropsMigrationIds("bookmark", {
+  NullAssetId: 1,
+  MakeUrlsValid: 2
+});
+var bookmarkShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions4.NullAssetId,
+      up: (props) => {
+        if (props.assetId === void 0) {
+          props.assetId = null;
+        }
+      },
+      down: "retired"
+    },
+    {
+      id: Versions4.MakeUrlsValid,
+      up: (props) => {
+        if (!T.linkUrl.isValid(props.url)) {
+          props.url = "";
+        }
+      },
+      down: (_props) => {
+      }
+    }
+  ]
+});
+var FIRST_POINT_B64_LENGTH = 16;
+var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var B64_LOOKUP = new Uint8Array(128);
+for (let i = 0; i < 64; i++) {
+  B64_LOOKUP[BASE64_CHARS.charCodeAt(i)] = i;
+}
+var POW2 = new Float64Array(31);
+for (let i = 0; i < 31; i++) {
+  POW2[i] = Math.pow(2, i - 15);
+}
+var POW2_SUBNORMAL = Math.pow(2, -14) / 1024;
+var MANTISSA = new Float64Array(1024);
+for (let i = 0; i < 1024; i++) {
+  MANTISSA[i] = 1 + i / 1024;
+}
+function nativeGetFloat16(dataView, offset) {
+  return dataView.getFloat16(offset, true);
+}
+function fallbackGetFloat16(dataView, offset) {
+  return float16BitsToNumber(dataView.getUint16(offset, true));
+}
+var getFloat16 = typeof DataView.prototype.getFloat16 === "function" ? nativeGetFloat16 : fallbackGetFloat16;
+function nativeSetFloat16(dataView, offset, value) {
+  dataView.setFloat16(offset, value, true);
+}
+function fallbackSetFloat16(dataView, offset, value) {
+  dataView.setUint16(offset, numberToFloat16Bits(value), true);
+}
+var setFloat16 = typeof DataView.prototype.setFloat16 === "function" ? nativeSetFloat16 : fallbackSetFloat16;
+function nativeBase64ToUint8Array(base64) {
+  return Uint8Array.fromBase64(base64);
+}
+function fallbackBase64ToUint8Array(base64) {
+  const numBytes = Math.floor(base64.length * 3 / 4);
+  const bytes = new Uint8Array(numBytes);
+  let byteIndex = 0;
+  for (let i = 0; i < base64.length; i += 4) {
+    const c0 = B64_LOOKUP[base64.charCodeAt(i)];
+    const c1 = B64_LOOKUP[base64.charCodeAt(i + 1)];
+    const c2 = B64_LOOKUP[base64.charCodeAt(i + 2)];
+    const c3 = B64_LOOKUP[base64.charCodeAt(i + 3)];
+    const bitmap = c0 << 18 | c1 << 12 | c2 << 6 | c3;
+    bytes[byteIndex++] = bitmap >> 16 & 255;
+    bytes[byteIndex++] = bitmap >> 8 & 255;
+    bytes[byteIndex++] = bitmap & 255;
+  }
+  return bytes;
+}
+function nativeUint8ArrayToBase64(uint8Array) {
+  return uint8Array.toBase64();
+}
+function fallbackUint8ArrayToBase64(uint8Array) {
+  assert(uint8Array.length % 3 === 0, "Uint8Array length must be a multiple of 3");
+  let result = "";
+  for (let i = 0; i < uint8Array.length; i += 3) {
+    const byte1 = uint8Array[i];
+    const byte2 = uint8Array[i + 1];
+    const byte3 = uint8Array[i + 2];
+    const bitmap = byte1 << 16 | byte2 << 8 | byte3;
+    result += BASE64_CHARS[bitmap >> 18 & 63] + BASE64_CHARS[bitmap >> 12 & 63] + BASE64_CHARS[bitmap >> 6 & 63] + BASE64_CHARS[bitmap & 63];
+  }
+  return result;
+}
+var uint8ArrayToBase64 = typeof Uint8Array.prototype.toBase64 === "function" ? nativeUint8ArrayToBase64 : fallbackUint8ArrayToBase64;
+var base64ToUint8Array = typeof Uint8Array.fromBase64 === "function" ? nativeBase64ToUint8Array : fallbackBase64ToUint8Array;
+function float16BitsToNumber(bits) {
+  const sign = bits >> 15;
+  const exp = bits >> 10 & 31;
+  const frac = bits & 1023;
+  if (exp === 0) {
+    return sign ? -frac * POW2_SUBNORMAL : frac * POW2_SUBNORMAL;
+  }
+  if (exp === 31) {
+    return frac ? NaN : sign ? -Infinity : Infinity;
+  }
+  const magnitude = POW2[exp] * MANTISSA[frac];
+  return sign ? -magnitude : magnitude;
+}
+function numberToFloat16Bits(value) {
+  if (value === 0) return Object.is(value, -0) ? 32768 : 0;
+  if (!Number.isFinite(value)) {
+    if (Number.isNaN(value)) return 32256;
+    return value > 0 ? 31744 : 64512;
+  }
+  const sign = value < 0 ? 1 : 0;
+  value = Math.abs(value);
+  const exp = Math.floor(Math.log2(value));
+  let expBiased = exp + 15;
+  if (expBiased >= 31) {
+    return sign << 15 | 31744;
+  }
+  if (expBiased <= 0) {
+    const frac2 = Math.round(value * Math.pow(2, 14) * 1024);
+    return sign << 15 | frac2 & 1023;
+  }
+  const mantissa = value / Math.pow(2, exp) - 1;
+  let frac = Math.round(mantissa * 1024);
+  if (frac >= 1024) {
+    frac = 0;
+    expBiased++;
+    if (expBiased >= 31) {
+      return sign << 15 | 31744;
+    }
+  }
+  return sign << 15 | expBiased << 10 | frac;
+}
+var b64Vecs = class {
+  /**
+   * Encode a single point (x, y, z) to 8 base64 characters using legacy Float16 encoding.
+   * Each coordinate is encoded as a Float16 value, resulting in 6 bytes total.
+   *
+   * @param x - The x coordinate
+   * @param y - The y coordinate
+   * @param z - The z coordinate
+   * @returns An 8-character base64 string representing the point
+   * @internal
+   */
+  static _legacyEncodePoint(x, y, z) {
+    const buffer = new Uint8Array(6);
+    const dataView = new DataView(buffer.buffer);
+    setFloat16(dataView, 0, x);
+    setFloat16(dataView, 2, y);
+    setFloat16(dataView, 4, z);
+    return uint8ArrayToBase64(buffer);
+  }
+  /**
+   * Convert an array of VecModels to a base64 string using legacy Float16 encoding.
+   * Uses Float16 encoding for each coordinate (x, y, z). If a point's z value is
+   * undefined, it defaults to 0.5.
+   *
+   * @param points - An array of VecModel objects to encode
+   * @returns A base64-encoded string containing all points
+   * @internal Used only for migrations from legacy format
+   */
+  static _legacyEncodePoints(points) {
+    if (points.length === 0) return "";
+    const buffer = new Uint8Array(points.length * 6);
+    const dataView = new DataView(buffer.buffer);
+    for (let i = 0; i < points.length; i++) {
+      const p = points[i];
+      const offset = i * 6;
+      setFloat16(dataView, offset, p.x);
+      setFloat16(dataView, offset + 2, p.y);
+      setFloat16(dataView, offset + 4, p.z ?? 0.5);
+    }
+    return uint8ArrayToBase64(buffer);
+  }
+  /**
+   * Convert a legacy base64 string back to an array of VecModels.
+   * Decodes Float16-encoded coordinates (x, y, z) from the base64 string.
+   *
+   * @param base64 - The base64-encoded string containing point data
+   * @returns An array of VecModel objects decoded from the string
+   * @internal Used only for migrations from legacy format
+   */
+  static _legacyDecodePoints(base64) {
+    const bytes = base64ToUint8Array(base64);
+    const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const result = [];
+    for (let offset = 0; offset < bytes.length; offset += 6) {
+      result.push({
+        x: getFloat16(dataView, offset),
+        y: getFloat16(dataView, offset + 2),
+        z: getFloat16(dataView, offset + 4)
+      });
+    }
+    return result;
+  }
+  /**
+   * Encode an array of VecModels using delta encoding for improved precision.
+   * The first point is stored as Float32 (high precision for absolute position),
+   * subsequent points are stored as Float16 deltas from the previous point.
+   * This provides full precision for the starting position and excellent precision
+   * for deltas between consecutive points (which are typically small values).
+   *
+   * Format:
+   * - First point: 3 Float32 values = 12 bytes = 16 base64 chars
+   * - Delta points: 3 Float16 values each = 6 bytes = 8 base64 chars each
+   *
+   * @param points - An array of VecModel objects to encode
+   * @returns A base64-encoded string containing delta-encoded points
+   * @public
+   */
+  static encodePoints(points) {
+    if (points.length === 0) return "";
+    const firstPointBytes = 12;
+    const deltaBytes = (points.length - 1) * 6;
+    const totalBytes = firstPointBytes + deltaBytes;
+    const buffer = new Uint8Array(totalBytes);
+    const dataView = new DataView(buffer.buffer);
+    const first = points[0];
+    dataView.setFloat32(0, first.x, true);
+    dataView.setFloat32(4, first.y, true);
+    dataView.setFloat32(8, first.z ?? 0.5, true);
+    let prevX = first.x;
+    let prevY = first.y;
+    let prevZ = first.z ?? 0.5;
+    for (let i = 1; i < points.length; i++) {
+      const p = points[i];
+      const z = p.z ?? 0.5;
+      const offset = firstPointBytes + (i - 1) * 6;
+      setFloat16(dataView, offset, p.x - prevX);
+      setFloat16(dataView, offset + 2, p.y - prevY);
+      setFloat16(dataView, offset + 4, z - prevZ);
+      prevX = p.x;
+      prevY = p.y;
+      prevZ = z;
+    }
+    return uint8ArrayToBase64(buffer);
+  }
+  /**
+   * Decode a delta-encoded base64 string back to an array of absolute VecModels.
+   * The first point is stored as Float32 (high precision), subsequent points are
+   * Float16 deltas that are accumulated to reconstruct absolute positions.
+   *
+   * @param base64 - The base64-encoded string containing delta-encoded point data
+   * @returns An array of VecModel objects with absolute coordinates
+   * @public
+   */
+  static decodePoints(base64) {
+    if (base64.length === 0) return [];
+    const bytes = base64ToUint8Array(base64);
+    const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const result = [];
+    let x = dataView.getFloat32(0, true);
+    let y = dataView.getFloat32(4, true);
+    let z = dataView.getFloat32(8, true);
+    result.push({ x, y, z });
+    const firstPointBytes = 12;
+    for (let offset = firstPointBytes; offset < bytes.length; offset += 6) {
+      x += getFloat16(dataView, offset);
+      y += getFloat16(dataView, offset + 2);
+      z += getFloat16(dataView, offset + 4);
+      result.push({ x, y, z });
+    }
+    return result;
+  }
+  /**
+   * Get the first point from a delta-encoded base64 string.
+   * The first point is stored as Float32 for full precision.
+   *
+   * @param b64Points - The delta-encoded base64 string
+   * @returns The first point as a VecModel, or null if the string is too short
+   * @public
+   */
+  static decodeFirstPoint(b64Points) {
+    if (b64Points.length < FIRST_POINT_B64_LENGTH) return null;
+    const bytes = base64ToUint8Array(b64Points.slice(0, FIRST_POINT_B64_LENGTH));
+    const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return {
+      x: dataView.getFloat32(0, true),
+      y: dataView.getFloat32(4, true),
+      z: dataView.getFloat32(8, true)
+    };
+  }
+  /**
+   * Get the last point from a delta-encoded base64 string.
+   * Requires decoding all points to accumulate deltas.
+   *
+   * @param b64Points - The delta-encoded base64 string
+   * @returns The last point as a VecModel, or null if the string is too short
+   * @public
+   */
+  static decodeLastPoint(b64Points) {
+    if (b64Points.length < FIRST_POINT_B64_LENGTH) return null;
+    const bytes = base64ToUint8Array(b64Points);
+    const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let x = dataView.getFloat32(0, true);
+    let y = dataView.getFloat32(4, true);
+    let z = dataView.getFloat32(8, true);
+    const firstPointBytes = 12;
+    for (let offset = firstPointBytes; offset < bytes.length; offset += 6) {
+      x += getFloat16(dataView, offset);
+      y += getFloat16(dataView, offset + 2);
+      z += getFloat16(dataView, offset + 4);
+    }
+    return { x, y, z };
+  }
+};
+
+// src/shapes/DrDrawShape.ts
+var DrawShapeSegment = T.object({
+  type: T.literalEnum("free", "straight"),
+  path: T.string
+});
+var drawShapeProps = {
+  color: DefaultColorStyle,
+  fill: DefaultFillStyle,
+  dash: DefaultDashStyle,
+  size: DefaultSizeStyle,
+  segments: T.arrayOf(DrawShapeSegment),
+  isComplete: T.boolean,
+  isClosed: T.boolean,
+  isPen: T.boolean,
+  scale: T.nonZeroNumber,
+  scaleX: T.nonZeroFiniteNumber,
+  scaleY: T.nonZeroFiniteNumber
+};
+var Versions5 = createShapePropsMigrationIds("draw", {
+  AddInPen: 1,
+  AddScale: 2,
+  Base64: 3,
+  LegacyPointsConversion: 4
+});
+var drawShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions5.AddInPen,
+      up: (props) => {
+        const { points } = props.segments[0];
+        if (points.length === 0) {
+          props.isPen = false;
+          return;
+        }
+        let isPen = !(points[0].z === 0 || points[0].z === 0.5);
+        if (points[1]) {
+          isPen = isPen && !(points[1].z === 0 || points[1].z === 0.5);
+        }
+        props.isPen = isPen;
+      },
+      down: "retired"
+    },
+    {
+      id: Versions5.AddScale,
+      up: (props) => {
+        props.scale = 1;
+      },
+      down: (props) => {
+        delete props.scale;
+      }
+    },
+    {
+      id: Versions5.Base64,
+      up: (props) => {
+        props.segments = props.segments.map((segment) => {
+          if (segment.path !== void 0) return segment;
+          const { points, ...rest } = segment;
+          const vecModels = Array.isArray(points) ? points : b64Vecs._legacyDecodePoints(points);
+          return {
+            ...rest,
+            path: b64Vecs.encodePoints(vecModels)
+          };
+        });
+        props.scaleX = props.scaleX ?? 1;
+        props.scaleY = props.scaleY ?? 1;
+      },
+      down: (props) => {
+        props.segments = props.segments.map((segment) => {
+          const { path, ...rest } = segment;
+          return {
+            ...rest,
+            points: b64Vecs.decodePoints(path)
+          };
+        });
+        delete props.scaleX;
+        delete props.scaleY;
+      }
+    },
+    {
+      id: Versions5.LegacyPointsConversion,
+      up: (props) => {
+        props.segments = props.segments.map((segment) => {
+          if (segment.path !== void 0) return segment;
+          const { points, ...rest } = segment;
+          const vecModels = Array.isArray(points) ? points : b64Vecs._legacyDecodePoints(points);
+          return {
+            ...rest,
+            path: b64Vecs.encodePoints(vecModels)
+          };
+        });
+      },
+      down: (_props) => {
+      }
+    }
+  ]
+});
+function compressLegacySegments(segments) {
+  return segments.map((segment) => ({
+    type: segment.type,
+    path: b64Vecs.encodePoints(segment.points)
+  }));
+}
+var DRAW_APP_RE = /(^\/r\/[^/]+\/?$)/;
+var EMBED_DEFINITIONS = [
+  {
+    hostnames: ["beta.draw.com", "tldraw.com", "localhost:3000"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.pathname.match(DRAW_APP_RE)) {
+        return url;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["figma.com"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.pathname.match(/^\/embed\/?$/)) {
+        const outUrl = urlObj.searchParams.get("url");
+        if (outUrl) {
+          return outUrl;
+        }
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["google.*"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (!urlObj) return;
+      const matches = urlObj.pathname.match(/^\/maps\/embed\/v1\/view\/?$/);
+      if (matches && urlObj.searchParams.has("center") && urlObj.searchParams.get("zoom")) {
+        const zoom = urlObj.searchParams.get("zoom");
+        const [lat, lon] = urlObj.searchParams.get("center").split(",");
+        return `https://www.google.com/maps/@${lat},${lon},${zoom}z`;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["val.town"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      const matches = urlObj && urlObj.pathname.match(/\/embed\/(.+)\/?/);
+      if (matches) {
+        return `https://www.val.town/v/${matches[1]}`;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["codesandbox.io"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      const matches = urlObj && urlObj.pathname.match(/\/embed\/([^/]+)\/?/);
+      if (matches) {
+        return `https://codesandbox.io/s/${matches[1]}`;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["codepen.io"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const CODEPEN_EMBED_REGEXP = /https:\/\/codepen.io\/([^/]+)\/embed\/([^/]+)/;
+      const matches = url.match(CODEPEN_EMBED_REGEXP);
+      if (matches) {
+        const [_, user, id] = matches;
+        return `https://codepen.io/${user}/pen/${id}`;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["scratch.mit.edu"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const SCRATCH_EMBED_REGEXP = /https:\/\/scratch.mit.edu\/projects\/embed\/([^/]+)/;
+      const matches = url.match(SCRATCH_EMBED_REGEXP);
+      if (matches) {
+        const [_, id] = matches;
+        return `https://scratch.mit.edu/projects/${id}`;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["*.youtube.com", "youtube.com", "youtu.be"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (!urlObj) return;
+      const hostname = urlObj.hostname.replace(/^www./, "");
+      if (hostname === "youtube.com") {
+        const matches = urlObj.pathname.match(/^\/embed\/([^/]+)\/?/);
+        if (matches) {
+          return `https://www.youtube.com/watch?v=${matches[1]}`;
+        }
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["calendar.google.*"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      const srcQs = urlObj?.searchParams.get("src");
+      if (urlObj?.pathname.match(/\/calendar\/embed/) && srcQs) {
+        urlObj.pathname = "/calendar/u/0";
+        const keys = Array.from(urlObj.searchParams.keys());
+        for (const key of keys) {
+          urlObj.searchParams.delete(key);
+        }
+        urlObj.searchParams.set("cid", srcQs);
+        return urlObj.href;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["docs.google.*"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj?.pathname.match(/^\/presentation/) && urlObj?.pathname.match(/\/embed\/?$/)) {
+        urlObj.pathname = urlObj.pathname.replace(/\/embed$/, "/pub");
+        const keys = Array.from(urlObj.searchParams.keys());
+        for (const key of keys) {
+          urlObj.searchParams.delete(key);
+        }
+        return urlObj.href;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["gist.github.com"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.pathname.match(/\/([^/]+)\/([^/]+)/)) {
+        if (!url.split("/").pop()) return;
+        return url;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["replit.com"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.pathname.match(/\/@([^/]+)\/([^/]+)/) && urlObj.searchParams.has("embed")) {
+        urlObj.searchParams.delete("embed");
+        return urlObj.href;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["felt.com"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.pathname.match(/^\/embed\/map\//)) {
+        urlObj.pathname = urlObj.pathname.replace(/^\/embed/, "");
+        return urlObj.href;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["open.spotify.com"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.pathname.match(/^\/embed\/(artist|album)\//)) {
+        return urlObj.origin + urlObj.pathname.replace(/^\/embed/, "");
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["vimeo.com", "player.vimeo.com"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.hostname === "player.vimeo.com") {
+        const matches = urlObj.pathname.match(/^\/video\/([^/]+)\/?$/);
+        if (matches) {
+          return "https://vimeo.com/" + matches[1];
+        }
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["observablehq.com"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.pathname.match(/^\/embed\/@([^/]+)\/([^/]+)\/?$/)) {
+        return `${urlObj.origin}${urlObj.pathname.replace("/embed", "")}#cell-*`;
+      }
+      if (urlObj && urlObj.pathname.match(/^\/embed\/([^/]+)\/?$/)) {
+        return `${urlObj.origin}${urlObj.pathname.replace("/embed", "/d")}#cell-*`;
+      }
+      return;
+    }
+  },
+  {
+    hostnames: ["desmos.com"],
+    canEditWhileLocked: true,
+    fromEmbedUrl: (url) => {
+      const urlObj = safeParseUrl(url);
+      if (urlObj && urlObj.hostname === "www.desmos.com" && urlObj.pathname.match(/^\/calculator\/([^/]+)\/?$/) && urlObj.search === "?embed" && urlObj.hash === "") {
+        return url.replace("?embed", "");
+      }
+      return;
+    }
+  }
+];
+var embedShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  url: T.string
+};
+var Versions6 = createShapePropsMigrationIds("embed", {
+  GenOriginalUrlInEmbed: 1,
+  RemoveDoesResize: 2,
+  RemoveTmpOldUrl: 3,
+  RemovePermissionOverrides: 4
+});
+var embedShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions6.GenOriginalUrlInEmbed,
+      // add tmpOldUrl property
+      up: (props) => {
+        try {
+          const url = props.url;
+          const host = new URL(url).host.replace("www.", "");
+          let originalUrl;
+          for (const localEmbedDef of EMBED_DEFINITIONS) {
+            if (localEmbedDef.hostnames.includes(host)) {
+              try {
+                originalUrl = localEmbedDef.fromEmbedUrl(url);
+              } catch (err) {
+                console.warn(err);
+              }
+            }
+          }
+          props.tmpOldUrl = props.url;
+          props.url = originalUrl ?? "";
+        } catch {
+          props.url = "";
+          props.tmpOldUrl = props.url;
+        }
+      },
+      down: "retired"
+    },
+    {
+      id: Versions6.RemoveDoesResize,
+      up: (props) => {
+        delete props.doesResize;
+      },
+      down: "retired"
+    },
+    {
+      id: Versions6.RemoveTmpOldUrl,
+      up: (props) => {
+        delete props.tmpOldUrl;
+      },
+      down: "retired"
+    },
+    {
+      id: Versions6.RemovePermissionOverrides,
+      up: (props) => {
+        delete props.overridePermissions;
+      },
+      down: "retired"
+    }
+  ]
+});
+var frameShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  name: T.string,
+  // because shape colors are an option, we don't want them to be picked up by the editor as a
+  // style prop by default, so instead of a proper style we just supply an equivalent validator.
+  // Check `FrameShapeUtil.configure` for how we replace this with the original
+  // `DefaultColorStyle` style when the option is turned on.
+  // We delegate to DefaultColorStyle.validate so custom colors from themes are
+  // picked up automatically.
+  color: { validate: (v) => DefaultColorStyle.validate(v) }
+};
+var Versions7 = createShapePropsMigrationIds("frame", {
+  AddColorProp: 1
+});
+var frameShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions7.AddColorProp,
+      up: (props) => {
+        props.color = "black";
+      },
+      down: (props) => {
+        delete props.color;
+      }
+    }
+  ]
+});
+
+// src/styles/DrHorizontalAlignStyle.ts
+var DefaultHorizontalAlignStyle = StyleProp.defineEnum("draw:horizontalAlign", {
+  defaultValue: "middle",
+  values: ["start", "middle", "end", "start-legacy", "end-legacy", "middle-legacy"]
+});
+
+// src/styles/DrVerticalAlignStyle.ts
+var DefaultVerticalAlignStyle = StyleProp.defineEnum("draw:verticalAlign", {
+  defaultValue: "middle",
+  values: ["start", "middle", "end"]
+});
+
+// src/shapes/DrGeoShape.ts
+var GeoShapeGeoStyle = StyleProp.defineEnum("draw:geo", {
+  defaultValue: "rectangle",
+  values: [
+    "cloud",
+    "rectangle",
+    "ellipse",
+    "triangle",
+    "diamond",
+    "pentagon",
+    "hexagon",
+    "octagon",
+    "star",
+    "rhombus",
+    "rhombus-2",
+    "oval",
+    "trapezoid",
+    "arrow-right",
+    "arrow-left",
+    "arrow-up",
+    "arrow-down",
+    "x-box",
+    "check-box",
+    "heart"
+  ]
+});
+var geoShapeProps = {
+  geo: GeoShapeGeoStyle,
+  dash: DefaultDashStyle,
+  url: T.linkUrl,
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  growY: T.positiveNumber,
+  scale: T.nonZeroNumber,
+  // Text properties
+  labelColor: DefaultLabelColorStyle,
+  color: DefaultColorStyle,
+  fill: DefaultFillStyle,
+  size: DefaultSizeStyle,
+  font: DefaultFontStyle,
+  align: DefaultHorizontalAlignStyle,
+  verticalAlign: DefaultVerticalAlignStyle,
+  richText: richTextValidator
+};
+var geoShapeVersions = createShapePropsMigrationIds("geo", {
+  AddUrlProp: 1,
+  AddLabelColor: 2,
+  RemoveJustify: 3,
+  AddCheckBox: 4,
+  AddVerticalAlign: 5,
+  MigrateLegacyAlign: 6,
+  AddCloud: 7,
+  MakeUrlsValid: 8,
+  AddScale: 9,
+  AddRichText: 10,
+  AddRichTextAttrs: 11
+});
+var geoShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: geoShapeVersions.AddUrlProp,
+      up: (props) => {
+        props.url = "";
+      },
+      down: "retired"
+    },
+    {
+      id: geoShapeVersions.AddLabelColor,
+      up: (props) => {
+        props.labelColor = "black";
+      },
+      down: "retired"
+    },
+    {
+      id: geoShapeVersions.RemoveJustify,
+      up: (props) => {
+        if (props.align === "justify") {
+          props.align = "start";
+        }
+      },
+      down: "retired"
+    },
+    {
+      id: geoShapeVersions.AddCheckBox,
+      up: (_props) => {
+      },
+      down: "retired"
+    },
+    {
+      id: geoShapeVersions.AddVerticalAlign,
+      up: (props) => {
+        props.verticalAlign = "middle";
+      },
+      down: "retired"
+    },
+    {
+      id: geoShapeVersions.MigrateLegacyAlign,
+      up: (props) => {
+        let newAlign;
+        switch (props.align) {
+          case "start":
+            newAlign = "start-legacy";
+            break;
+          case "end":
+            newAlign = "end-legacy";
+            break;
+          default:
+            newAlign = "middle-legacy";
+            break;
+        }
+        props.align = newAlign;
+      },
+      down: "retired"
+    },
+    {
+      id: geoShapeVersions.AddCloud,
+      up: (_props) => {
+      },
+      down: "retired"
+    },
+    {
+      id: geoShapeVersions.MakeUrlsValid,
+      up: (props) => {
+        if (!T.linkUrl.isValid(props.url)) {
+          props.url = "";
+        }
+      },
+      down: (_props) => {
+      }
+    },
+    {
+      id: geoShapeVersions.AddScale,
+      up: (props) => {
+        props.scale = 1;
+      },
+      down: (props) => {
+        delete props.scale;
+      }
+    },
+    {
+      id: geoShapeVersions.AddRichText,
+      up: (props) => {
+        props.richText = toRichText(props.text);
+        delete props.text;
+      }
+      // N.B. Explicitly no down state so that we force clients to update.
+      // down: (props) => {
+      // 	delete props.richText
+      // },
+    },
+    {
+      id: geoShapeVersions.AddRichTextAttrs,
+      up: (_props) => {
+      },
+      down: (props) => {
+        if (props.richText && "attrs" in props.richText) {
+          delete props.richText.attrs;
+        }
+      }
+    }
+  ]
+});
+
+// src/shapes/DrGroupShape.ts
+var groupShapeProps = {};
+var groupShapeMigrations = createShapePropsMigrationSequence({ sequence: [] });
+var highlightShapeProps = {
+  color: DefaultColorStyle,
+  size: DefaultSizeStyle,
+  segments: T.arrayOf(DrawShapeSegment),
+  isComplete: T.boolean,
+  isPen: T.boolean,
+  scale: T.nonZeroNumber,
+  scaleX: T.nonZeroFiniteNumber,
+  scaleY: T.nonZeroFiniteNumber
+};
+var Versions8 = createShapePropsMigrationIds("highlight", {
+  AddScale: 1,
+  Base64: 2,
+  LegacyPointsConversion: 3
+});
+var highlightShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions8.AddScale,
+      up: (props) => {
+        props.scale = 1;
+      },
+      down: (props) => {
+        delete props.scale;
+      }
+    },
+    {
+      id: Versions8.Base64,
+      up: (props) => {
+        props.segments = props.segments.map((segment) => {
+          if (segment.path !== void 0) return segment;
+          const { points, ...rest } = segment;
+          const vecModels = Array.isArray(points) ? points : b64Vecs._legacyDecodePoints(points);
+          return {
+            ...rest,
+            path: b64Vecs.encodePoints(vecModels)
+          };
+        });
+        props.scaleX = props.scaleX ?? 1;
+        props.scaleY = props.scaleY ?? 1;
+      },
+      down: (props) => {
+        props.segments = props.segments.map((segment) => {
+          const { path, ...rest } = segment;
+          return {
+            ...rest,
+            points: b64Vecs.decodePoints(path)
+          };
+        });
+        delete props.scaleX;
+        delete props.scaleY;
+      }
+    },
+    {
+      id: Versions8.LegacyPointsConversion,
+      up: (props) => {
+        props.segments = props.segments.map((segment) => {
+          if (segment.path !== void 0) return segment;
+          const { points, ...rest } = segment;
+          const vecModels = Array.isArray(points) ? points : b64Vecs._legacyDecodePoints(points);
+          return {
+            ...rest,
+            path: b64Vecs.encodePoints(vecModels)
+          };
+        });
+      },
+      down: (_props) => {
+      }
+    }
+  ]
+});
+var ImageShapeCrop = T.object({
+  topLeft: vecModelValidator,
+  bottomRight: vecModelValidator,
+  isCircle: T.boolean.optional()
+});
+var imageShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  playing: T.boolean,
+  url: T.linkUrl,
+  assetId: assetIdValidator.nullable(),
+  crop: ImageShapeCrop.nullable(),
+  flipX: T.boolean,
+  flipY: T.boolean,
+  altText: T.string
+};
+var Versions9 = createShapePropsMigrationIds("image", {
+  AddUrlProp: 1,
+  AddCropProp: 2,
+  MakeUrlsValid: 3,
+  AddFlipProps: 4,
+  AddAltText: 5
+});
+var imageShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions9.AddUrlProp,
+      up: (props) => {
+        props.url = "";
+      },
+      down: "retired"
+    },
+    {
+      id: Versions9.AddCropProp,
+      up: (props) => {
+        props.crop = null;
+      },
+      down: (props) => {
+        delete props.crop;
+      }
+    },
+    {
+      id: Versions9.MakeUrlsValid,
+      up: (props) => {
+        if (!T.linkUrl.isValid(props.url)) {
+          props.url = "";
+        }
+      },
+      down: (_props) => {
+      }
+    },
+    {
+      id: Versions9.AddFlipProps,
+      up: (props) => {
+        props.flipX = false;
+        props.flipY = false;
+      },
+      down: (props) => {
+        delete props.flipX;
+        delete props.flipY;
+      }
+    },
+    {
+      id: Versions9.AddAltText,
+      up: (props) => {
+        props.altText = "";
+      },
+      down: (props) => {
+        delete props.altText;
+      }
+    }
+  ]
+});
+var LineShapeSplineStyle = StyleProp.defineEnum("draw:spline", {
+  defaultValue: "line",
+  values: ["cubic", "line"]
+});
+var lineShapePointValidator = T.object({
+  id: T.string,
+  index: T.indexKey,
+  x: T.number,
+  y: T.number
+});
+var lineShapeProps = {
+  color: DefaultColorStyle,
+  dash: DefaultDashStyle,
+  size: DefaultSizeStyle,
+  spline: LineShapeSplineStyle,
+  points: T.dict(T.string, lineShapePointValidator),
+  scale: T.nonZeroNumber
+};
+var lineShapeVersions = createShapePropsMigrationIds("line", {
+  AddSnapHandles: 1,
+  RemoveExtraHandleProps: 2,
+  HandlesToPoints: 3,
+  PointIndexIds: 4,
+  AddScale: 5
+});
+var lineShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: lineShapeVersions.AddSnapHandles,
+      up: (props) => {
+        for (const handle of Object.values(props.handles)) {
+          handle.canSnap = true;
+        }
+      },
+      down: "retired"
+    },
+    {
+      id: lineShapeVersions.RemoveExtraHandleProps,
+      up: (props) => {
+        props.handles = objectMapFromEntries(
+          Object.values(props.handles).map((handle) => [
+            handle.index,
+            {
+              x: handle.x,
+              y: handle.y
+            }
+          ])
+        );
+      },
+      down: (props) => {
+        const handles = Object.entries(props.handles).map(([index, handle]) => ({ index, ...handle })).sort(sortByIndex);
+        props.handles = Object.fromEntries(
+          handles.map((handle, i) => {
+            const id = i === 0 ? "start" : i === handles.length - 1 ? "end" : `handle:${handle.index}`;
+            return [
+              id,
+              {
+                id,
+                type: "vertex",
+                canBind: false,
+                canSnap: true,
+                index: handle.index,
+                x: handle.x,
+                y: handle.y
+              }
+            ];
+          })
+        );
+      }
+    },
+    {
+      id: lineShapeVersions.HandlesToPoints,
+      up: (props) => {
+        const sortedHandles = Object.entries(props.handles).map(([index, { x, y }]) => ({ x, y, index })).sort(sortByIndex);
+        props.points = sortedHandles.map(({ x, y }) => ({ x, y }));
+        delete props.handles;
+      },
+      down: (props) => {
+        const indices = getIndices(props.points.length);
+        props.handles = Object.fromEntries(
+          props.points.map((handle, i) => {
+            const index = indices[i];
+            return [
+              index,
+              {
+                x: handle.x,
+                y: handle.y
+              }
+            ];
+          })
+        );
+        delete props.points;
+      }
+    },
+    {
+      id: lineShapeVersions.PointIndexIds,
+      up: (props) => {
+        const indices = getIndices(props.points.length);
+        props.points = Object.fromEntries(
+          props.points.map((point, i) => {
+            const id = indices[i];
+            return [
+              id,
+              {
+                id,
+                index: id,
+                x: point.x,
+                y: point.y
+              }
+            ];
+          })
+        );
+      },
+      down: (props) => {
+        const sortedHandles = Object.values(props.points).sort(sortByIndex);
+        props.points = sortedHandles.map(({ x, y }) => ({ x, y }));
+      }
+    },
+    {
+      id: lineShapeVersions.AddScale,
+      up: (props) => {
+        props.scale = 1;
+      },
+      down: (props) => {
+        delete props.scale;
+      }
+    }
+  ]
+});
+var noteShapeProps = {
+  color: DefaultColorStyle,
+  labelColor: DefaultLabelColorStyle,
+  size: DefaultSizeStyle,
+  font: DefaultFontStyle,
+  fontSizeAdjustment: T.positiveNumber.nullable(),
+  align: DefaultHorizontalAlignStyle,
+  verticalAlign: DefaultVerticalAlignStyle,
+  growY: T.positiveNumber,
+  url: T.linkUrl,
+  richText: richTextValidator,
+  scale: T.nonZeroNumber,
+  textFirstEditedBy: T.string.nullable()
+};
+var Versions10 = createShapePropsMigrationIds("note", {
+  AddUrlProp: 1,
+  RemoveJustify: 2,
+  MigrateLegacyAlign: 3,
+  AddVerticalAlign: 4,
+  MakeUrlsValid: 5,
+  AddFontSizeAdjustment: 6,
+  AddScale: 7,
+  AddLabelColor: 8,
+  AddRichText: 9,
+  AddRichTextAttrs: 10,
+  AddFirstEditedBy: 11,
+  MakeFontSizeAdjustmentRatio: 12
+});
+var noteShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions10.AddUrlProp,
+      up: (props) => {
+        props.url = "";
+      },
+      down: "retired"
+    },
+    {
+      id: Versions10.RemoveJustify,
+      up: (props) => {
+        if (props.align === "justify") {
+          props.align = "start";
+        }
+      },
+      down: "retired"
+    },
+    {
+      id: Versions10.MigrateLegacyAlign,
+      up: (props) => {
+        switch (props.align) {
+          case "start":
+            props.align = "start-legacy";
+            return;
+          case "end":
+            props.align = "end-legacy";
+            return;
+          default:
+            props.align = "middle-legacy";
+            return;
+        }
+      },
+      down: "retired"
+    },
+    {
+      id: Versions10.AddVerticalAlign,
+      up: (props) => {
+        props.verticalAlign = "middle";
+      },
+      down: "retired"
+    },
+    {
+      id: Versions10.MakeUrlsValid,
+      up: (props) => {
+        if (!T.linkUrl.isValid(props.url)) {
+          props.url = "";
+        }
+      },
+      down: (_props) => {
+      }
+    },
+    {
+      id: Versions10.AddFontSizeAdjustment,
+      up: (props) => {
+        props.fontSizeAdjustment = 0;
+      },
+      down: (props) => {
+        delete props.fontSizeAdjustment;
+      }
+    },
+    {
+      id: Versions10.AddScale,
+      up: (props) => {
+        props.scale = 1;
+      },
+      down: (props) => {
+        delete props.scale;
+      }
+    },
+    {
+      id: Versions10.AddLabelColor,
+      up: (props) => {
+        props.labelColor = "black";
+      },
+      down: (props) => {
+        delete props.labelColor;
+      }
+    },
+    {
+      id: Versions10.AddRichText,
+      up: (props) => {
+        props.richText = toRichText(props.text);
+        delete props.text;
+      }
+      // N.B. Explicitly no down state so that we force clients to update.
+      // down: (props) => {
+      // 	delete props.richText
+      // },
+    },
+    {
+      id: Versions10.AddRichTextAttrs,
+      up: (_props) => {
+      },
+      down: (props) => {
+        if (props.richText && "attrs" in props.richText) {
+          delete props.richText.attrs;
+        }
+      }
+    },
+    {
+      id: Versions10.AddFirstEditedBy,
+      up: (props) => {
+        props.textFirstEditedBy = null;
+      },
+      down: (props) => {
+        delete props.textFirstEditedBy;
+      }
+    },
+    {
+      id: Versions10.MakeFontSizeAdjustmentRatio,
+      up: (props) => {
+        props.fontSizeAdjustment = props.fontSizeAdjustment === 0 ? 1 : null;
+      },
+      down: (props) => {
+        props.fontSizeAdjustment = 0;
+      }
+    }
+  ]
+});
+
+// src/styles/DrTextAlignStyle.ts
+var DefaultTextAlignStyle = StyleProp.defineEnum("draw:textAlign", {
+  defaultValue: "start",
+  values: ["start", "middle", "end"]
+});
+
+// src/shapes/DrTextShape.ts
+var textShapeProps = {
+  color: DefaultColorStyle,
+  size: DefaultSizeStyle,
+  font: DefaultFontStyle,
+  textAlign: DefaultTextAlignStyle,
+  w: T.nonZeroNumber,
+  richText: richTextValidator,
+  scale: T.nonZeroNumber,
+  autoSize: T.boolean
+};
+var Versions11 = createShapePropsMigrationIds("text", {
+  RemoveJustify: 1,
+  AddTextAlign: 2,
+  AddRichText: 3,
+  AddRichTextAttrs: 4
+});
+var textShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions11.RemoveJustify,
+      up: (props) => {
+        if (props.align === "justify") {
+          props.align = "start";
+        }
+      },
+      down: "retired"
+    },
+    {
+      id: Versions11.AddTextAlign,
+      up: (props) => {
+        props.textAlign = props.align;
+        delete props.align;
+      },
+      down: (props) => {
+        props.align = props.textAlign;
+        delete props.textAlign;
+      }
+    },
+    {
+      id: Versions11.AddRichText,
+      up: (props) => {
+        props.richText = toRichText(props.text);
+        delete props.text;
+      }
+      // N.B. Explicitly no down state so that we force clients to update.
+      // down: (props) => {
+      // 	delete props.richText
+      // },
+    },
+    {
+      id: Versions11.AddRichTextAttrs,
+      up: (_props) => {
+      },
+      down: (props) => {
+        if (props.richText && "attrs" in props.richText) {
+          delete props.richText.attrs;
+        }
+      }
+    }
+  ]
+});
+var videoShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  time: T.number,
+  playing: T.boolean,
+  autoplay: T.boolean,
+  url: T.linkUrl,
+  assetId: assetIdValidator.nullable(),
+  altText: T.string
+};
+var Versions12 = createShapePropsMigrationIds("video", {
+  AddUrlProp: 1,
+  MakeUrlsValid: 2,
+  AddAltText: 3,
+  AddAutoplay: 4
+});
+var videoShapeMigrations = createShapePropsMigrationSequence({
+  sequence: [
+    {
+      id: Versions12.AddUrlProp,
+      up: (props) => {
+        props.url = "";
+      },
+      down: "retired"
+    },
+    {
+      id: Versions12.MakeUrlsValid,
+      up: (props) => {
+        if (!T.linkUrl.isValid(props.url)) {
+          props.url = "";
+        }
+      },
+      down: (_props) => {
+      }
+    },
+    {
+      id: Versions12.AddAltText,
+      up: (props) => {
+        props.altText = "";
+      },
+      down: (props) => {
+        delete props.altText;
+      }
+    },
+    {
+      id: Versions12.AddAutoplay,
+      up: (props) => {
+        props.autoplay = true;
+      },
+      down: (props) => {
+        delete props.autoplay;
+      }
+    }
+  ]
+});
+var Versions13 = createMigrationIds("com.draw.store", {
+  RemoveCodeAndIconShapeTypes: 1,
+  AddInstancePresenceType: 2,
+  RemoveTLUserAndPresenceAndAddPointer: 3,
+  RemoveUserDocument: 4,
+  FixIndexKeys: 5
+});
+var storeMigrations = createMigrationSequence({
+  sequenceId: "com.draw.store",
+  retroactive: false,
+  sequence: [
+    {
+      id: Versions13.RemoveCodeAndIconShapeTypes,
+      scope: "storage",
+      up: (storage) => {
+        for (const [id, record] of storage.entries()) {
+          if (record.typeName === "shape" && "type" in record && (record.type === "icon" || record.type === "code")) {
+            storage.delete(id);
+          }
+        }
+      }
+    },
+    {
+      id: Versions13.AddInstancePresenceType,
+      scope: "storage",
+      up(_storage) {
+      }
+    },
+    {
+      // remove user and presence records and add pointer records
+      id: Versions13.RemoveTLUserAndPresenceAndAddPointer,
+      scope: "storage",
+      up: (storage) => {
+        for (const [id, record] of storage.entries()) {
+          if (record.typeName.match(/^(user|user_presence)$/)) {
+            storage.delete(id);
+          }
+        }
+      }
+    },
+    {
+      // remove user document records
+      id: Versions13.RemoveUserDocument,
+      scope: "storage",
+      up: (storage) => {
+        for (const [id, record] of storage.entries()) {
+          if (record.typeName.match("user_document")) {
+            storage.delete(id);
+          }
+        }
+      }
+    },
+    {
+      id: Versions13.FixIndexKeys,
+      scope: "record",
+      up: (record) => {
+        if (["shape", "page"].includes(record.typeName) && "index" in record) {
+          const recordWithIndex = record;
+          if (recordWithIndex.index.endsWith("0") && recordWithIndex.index !== "a0") {
+            recordWithIndex.index = recordWithIndex.index.slice(0, -1) + getNRandomBase62Digits(3);
+          }
+          if (record.typeName === "shape" && recordWithIndex.type === "line") {
+            const lineShape = recordWithIndex;
+            for (const [_, point] of objectMapEntries(lineShape.props.points)) {
+              if (point.index.endsWith("0") && point.index !== "a0") {
+                point.index = point.index.slice(0, -1) + getNRandomBase62Digits(3);
+              }
+            }
+          }
+        }
+      },
+      down: () => {
+      }
+    }
+  ]
+});
+var BASE_62_DIGITS_WITHOUT_ZERO = "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var getRandomBase62Digit = () => {
+  return BASE_62_DIGITS_WITHOUT_ZERO.charAt(
+    Math.floor(Math.random() * BASE_62_DIGITS_WITHOUT_ZERO.length)
+  );
+};
+var getNRandomBase62Digits = (n) => {
+  return Array.from({ length: n }, getRandomBase62Digit).join("");
+};
+function redactRecordForErrorReporting(record) {
+  if (record.typeName === "asset") {
+    if ("src" in record) {
+      record.src = "<redacted>";
+    }
+    if ("src" in record.props) {
+      record.props.src = "<redacted>";
+    }
+  }
+}
+function createCachedUserResolve(resolveFn) {
+  const cache = /* @__PURE__ */ new Map();
+  return (userId) => {
+    let signal = cache.get(userId);
+    if (!signal) {
+      signal = computed("resolve-user-" + userId, () => resolveFn(userId));
+      cache.set(userId, signal);
+    }
+    return signal;
+  };
+}
+function onValidationFailure({
+  error,
+  phase,
+  record,
+  recordBefore
+}) {
+  const isExistingValidationIssue = (
+    // if we're initializing the store for the first time, we should
+    // allow invalid records so people can load old buggy data:
+    phase === "initialize"
+  );
+  annotateError(error, {
+    tags: {
+      origin: "store.validateRecord",
+      storePhase: phase,
+      isExistingValidationIssue
+    },
+    extras: {
+      recordBefore: recordBefore ? redactRecordForErrorReporting(structuredClone(recordBefore)) : void 0,
+      recordAfter: redactRecordForErrorReporting(structuredClone(record))
+    }
+  });
+  throw error;
+}
+function getDefaultPages() {
+  return [
+    PageRecordType.create({
+      id: "page:page",
+      name: "Page 1",
+      index: "a1",
+      meta: {}
+    })
+  ];
+}
+function createIntegrityChecker(store) {
+  const $pageIds = store.query.ids("page");
+  const $pageStates = store.query.records("instance_page_state");
+  const ensureStoreIsUsable = () => {
+    if (!store.has(DrDOCUMENT_ID)) {
+      store.put([DocumentRecordType.create({ id: DrDOCUMENT_ID, name: store.props.defaultName })]);
+      return ensureStoreIsUsable();
+    }
+    if (!store.has(DrPOINTER_ID)) {
+      store.put([PointerRecordType.create({ id: DrPOINTER_ID })]);
+      return ensureStoreIsUsable();
+    }
+    const pageIds = $pageIds.get();
+    if (pageIds.size === 0) {
+      store.put(getDefaultPages());
+      return ensureStoreIsUsable();
+    }
+    const getFirstPageId = () => [...pageIds].map((id) => store.get(id)).sort(sortByIndex)[0].id;
+    const instanceState = store.get(DrINSTANCE_ID);
+    if (!instanceState) {
+      store.put([
+        store.schema.types.instance.create({
+          id: DrINSTANCE_ID,
+          currentPageId: getFirstPageId(),
+          exportBackground: true
+        })
+      ]);
+      return ensureStoreIsUsable();
+    } else if (!pageIds.has(instanceState.currentPageId)) {
+      store.put([{ ...instanceState, currentPageId: getFirstPageId() }]);
+      return ensureStoreIsUsable();
+    }
+    const missingPageStateIds = /* @__PURE__ */ new Set();
+    const missingCameraIds = /* @__PURE__ */ new Set();
+    for (const id of pageIds) {
+      const pageStateId = InstancePageStateRecordType.createId(id);
+      const pageState = store.get(pageStateId);
+      if (!pageState) {
+        missingPageStateIds.add(pageStateId);
+      }
+      const cameraId = CameraRecordType.createId(id);
+      if (!store.has(cameraId)) {
+        missingCameraIds.add(cameraId);
+      }
+    }
+    if (missingPageStateIds.size > 0) {
+      store.put(
+        [...missingPageStateIds].map(
+          (id) => InstancePageStateRecordType.create({
+            id,
+            pageId: InstancePageStateRecordType.parseId(id)
+          })
+        )
+      );
+    }
+    if (missingCameraIds.size > 0) {
+      store.put([...missingCameraIds].map((id) => CameraRecordType.create({ id })));
+    }
+    const pageStates = $pageStates.get();
+    for (const pageState of pageStates) {
+      if (!pageIds.has(pageState.pageId)) {
+        store.remove([pageState.id]);
+        continue;
+      }
+      if (pageState.croppingShapeId && !store.has(pageState.croppingShapeId)) {
+        store.put([{ ...pageState, croppingShapeId: null }]);
+        return ensureStoreIsUsable();
+      }
+      if (pageState.focusedGroupId && !store.has(pageState.focusedGroupId)) {
+        store.put([{ ...pageState, focusedGroupId: null }]);
+        return ensureStoreIsUsable();
+      }
+      if (pageState.hoveredShapeId && !store.has(pageState.hoveredShapeId)) {
+        store.put([{ ...pageState, hoveredShapeId: null }]);
+        return ensureStoreIsUsable();
+      }
+      const filteredSelectedIds = pageState.selectedShapeIds.filter((id) => store.has(id));
+      if (filteredSelectedIds.length !== pageState.selectedShapeIds.length) {
+        store.put([{ ...pageState, selectedShapeIds: filteredSelectedIds }]);
+        return ensureStoreIsUsable();
+      }
+      const filteredHintingIds = pageState.hintingShapeIds.filter((id) => store.has(id));
+      if (filteredHintingIds.length !== pageState.hintingShapeIds.length) {
+        store.put([{ ...pageState, hintingShapeIds: filteredHintingIds }]);
+        return ensureStoreIsUsable();
+      }
+      const filteredErasingIds = pageState.erasingShapeIds.filter((id) => store.has(id));
+      if (filteredErasingIds.length !== pageState.erasingShapeIds.length) {
+        store.put([{ ...pageState, erasingShapeIds: filteredErasingIds }]);
+        return ensureStoreIsUsable();
+      }
+    }
+  };
+  return ensureStoreIsUsable;
+}
+
+// src/createDrSchema.ts
+var defaultShapeSchemas = {
+  arrow: { migrations: arrowShapeMigrations, props: arrowShapeProps },
+  bookmark: { migrations: bookmarkShapeMigrations, props: bookmarkShapeProps },
+  draw: { migrations: drawShapeMigrations, props: drawShapeProps },
+  embed: { migrations: embedShapeMigrations, props: embedShapeProps },
+  frame: { migrations: frameShapeMigrations, props: frameShapeProps },
+  geo: { migrations: geoShapeMigrations, props: geoShapeProps },
+  group: { migrations: groupShapeMigrations, props: groupShapeProps },
+  highlight: { migrations: highlightShapeMigrations, props: highlightShapeProps },
+  image: { migrations: imageShapeMigrations, props: imageShapeProps },
+  line: { migrations: lineShapeMigrations, props: lineShapeProps },
+  note: { migrations: noteShapeMigrations, props: noteShapeProps },
+  text: { migrations: textShapeMigrations, props: textShapeProps },
+  video: { migrations: videoShapeMigrations, props: videoShapeProps }
+};
+var defaultBindingSchemas = {
+  arrow: { migrations: arrowBindingMigrations, props: arrowBindingProps }
+};
+var defaultAssetSchemas = {
+  image: { migrations: imageAssetMigrations, props: imageAssetProps },
+  video: { migrations: videoAssetMigrations, props: videoAssetProps },
+  bookmark: { migrations: bookmarkAssetMigrations, props: bookmarkAssetProps }
+};
+function createDrSchema({
+  shapes = defaultShapeSchemas,
+  bindings = defaultBindingSchemas,
+  assets = defaultAssetSchemas,
+  user,
+  records = {},
+  migrations
+} = {}) {
+  const stylesById = /* @__PURE__ */ new Map();
+  for (const shape of objectMapValues(shapes)) {
+    for (const style of getShapePropKeysByStyle(shape.props ?? {}).keys()) {
+      if (stylesById.has(style.id) && stylesById.get(style.id) !== style) {
+        throw new Error(`Multiple StyleProp instances with the same id: ${style.id}`);
+      }
+      stylesById.set(style.id, style);
+    }
+  }
+  const ShapeRecordType = createShapeRecordType(shapes);
+  const BindingRecordType = createBindingRecordType(bindings);
+  const _AssetRecordType = createAssetRecordType(assets);
+  const InstanceRecordType = createInstanceRecordType(stylesById);
+  const CustomUserRecordType = user ? createUserRecordType(user) : UserRecordType;
+  const builtInTypeNames = /* @__PURE__ */ new Set([
+    "asset",
+    "binding",
+    "camera",
+    "document",
+    "instance",
+    "instance_page_state",
+    "page",
+    "instance_presence",
+    "pointer",
+    "shape",
+    "store",
+    "user"
+  ]);
+  const customRecordTypes = {};
+  for (const [typeName, config] of Object.entries(records)) {
+    if (builtInTypeNames.has(typeName)) {
+      throw new Error(
+        `Custom record type name '${typeName}' conflicts with tldraw's built-in record type of that name. Choose a different name instead.`
+      );
+    }
+    customRecordTypes[typeName] = createCustomRecordType(typeName, config);
+  }
+  return StoreSchema.create(
+    {
+      asset: _AssetRecordType,
+      binding: BindingRecordType,
+      camera: CameraRecordType,
+      document: DocumentRecordType,
+      instance: InstanceRecordType,
+      instance_page_state: InstancePageStateRecordType,
+      page: PageRecordType,
+      instance_presence: InstancePresenceRecordType,
+      pointer: PointerRecordType,
+      shape: ShapeRecordType,
+      user: CustomUserRecordType,
+      ...customRecordTypes
+    },
+    {
+      migrations: [
+        storeMigrations,
+        assetMigrations,
+        cameraMigrations,
+        documentMigrations,
+        instanceMigrations,
+        instancePageStateMigrations,
+        pageMigrations,
+        instancePresenceMigrations,
+        pointerMigrations,
+        rootShapeMigrations,
+        userMigrations,
+        ...processPropsMigrations("asset", assets),
+        ...processPropsMigrations("shape", shapes),
+        ...processPropsMigrations("binding", bindings),
+        ...processCustomRecordMigrations(records),
+        ...user?.migrations ?? [],
+        ...migrations ?? []
+      ],
+      onValidationFailure,
+      createIntegrityChecker
+    }
+  );
+}
+
+// src/misc/DrHandle.ts
+var TL_HANDLE_TYPES = /* @__PURE__ */ new Set(["vertex", "virtual", "create", "clone"]);
+
+// src/translations/languages.ts
+var LANGUAGES = [
+  { locale: "id", label: "Bahasa Indonesia" },
+  { locale: "ms", label: "Bahasa Melayu" },
+  { locale: "ca", label: "Catal\xE0" },
+  { locale: "cs", label: "\u010Ce\u0161tina" },
+  { locale: "da", label: "Danish" },
+  { locale: "de", label: "Deutsch" },
+  { locale: "en", label: "English" },
+  { locale: "es", label: "Espa\xF1ol" },
+  { locale: "tl", label: "Filipino" },
+  { locale: "fr", label: "Fran\xE7ais" },
+  { locale: "gl", label: "Galego" },
+  { locale: "hr", label: "Hrvatski" },
+  { locale: "it", label: "Italiano" },
+  { locale: "hu", label: "Magyar" },
+  { locale: "nl", label: "Nederlands" },
+  { locale: "no", label: "Norwegian" },
+  { locale: "pl", label: "Polski" },
+  { locale: "pt-br", label: "Portugu\xEAs - Brasil" },
+  { locale: "pt-pt", label: "Portugu\xEAs - Europeu" },
+  { locale: "ro", label: "Rom\xE2n\u0103" },
+  { locale: "sl", label: "Sloven\u0161\u010Dina" },
+  { locale: "so", label: "Somali" },
+  { locale: "fi", label: "Suomi" },
+  { locale: "sv", label: "Svenska" },
+  { locale: "vi", label: "Ti\u1EBFng Vi\u1EC7t" },
+  { locale: "tr", label: "T\xFCrk\xE7e" },
+  { locale: "el", label: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC" },
+  { locale: "ru", label: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
+  { locale: "uk", label: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430" },
+  { locale: "he", label: "\u05E2\u05D1\u05E8\u05D9\u05EA" },
+  { locale: "ur", label: "\u0627\u0631\u062F\u0648" },
+  { locale: "ar", label: "\u0639\u0631\u0628\u064A" },
+  { locale: "fa", label: "\u0641\u0627\u0631\u0633\u06CC" },
+  { locale: "ne", label: "\u0928\u0947\u092A\u093E\u0932\u0940" },
+  { locale: "mr", label: "\u092E\u0930\u093E\u0920\u0940" },
+  { locale: "hi-in", label: "\u0939\u093F\u0928\u094D\u0926\u0940" },
+  { locale: "bn", label: "\u09AC\u09BE\u0982\u09B2\u09BE" },
+  { locale: "pa", label: "\u0A2A\u0A70\u0A1C\u0A3E\u0A2C\u0A40" },
+  { locale: "gu-in", label: "\u0A97\u0AC1\u0A9C\u0AB0\u0ABE\u0AA4\u0AC0" },
+  { locale: "ta", label: "\u0BA4\u0BAE\u0BBF\u0BB4\u0BCD" },
+  { locale: "te", label: "\u0C24\u0C46\u0C32\u0C41\u0C17\u0C41" },
+  { locale: "kn", label: "\u0C95\u0CA8\u0CCD\u0CA8\u0CA1" },
+  { locale: "ml", label: "\u0D2E\u0D32\u0D2F\u0D3E\u0D33\u0D02" },
+  { locale: "th", label: "\u0E20\u0E32\u0E29\u0E32\u0E44\u0E17\u0E22" },
+  { locale: "km-kh", label: "\u1797\u17B6\u179F\u17B6\u1781\u17D2\u1798\u17C2\u179A" },
+  { locale: "ko-kr", label: "\uD55C\uAD6D\uC5B4" },
+  { locale: "ja", label: "\u65E5\u672C\u8A9E" },
+  { locale: "zh-cn", label: "\u7B80\u4F53\u4E2D\u6587" },
+  { locale: "zh-tw", label: "\u7E41\u9AD4\u4E2D\u6587 (\u53F0\u7063)" }
+];
+
+// src/translations/translations.ts
+function getDefaultTranslationLocale() {
+  const locales = typeof window !== "undefined" && window.navigator ? window.navigator.languages ?? ["en"] : ["en"];
+  return _getDefaultTranslationLocale(locales);
+}
+function _getDefaultTranslationLocale(locales) {
+  for (const locale of locales) {
+    const supportedLocale = getSupportedLocale(locale);
+    if (supportedLocale) {
+      return supportedLocale;
+    }
+  }
+  return "en";
+}
+var DEFAULT_LOCALE_REGIONS = {
+  zh: "zh-cn",
+  pt: "pt-br",
+  ko: "ko-kr",
+  hi: "hi-in"
+};
+function getSupportedLocale(locale) {
+  const exactMatch = LANGUAGES.find((t) => t.locale === locale.toLowerCase());
+  if (exactMatch) {
+    return exactMatch.locale;
+  }
+  const [language, region] = locale.split(/[-_]/).map((s) => s.toLowerCase());
+  if (region) {
+    const languageMatch = LANGUAGES.find((t) => t.locale === language);
+    if (languageMatch) {
+      return languageMatch.locale;
+    }
+  }
+  if (language in DEFAULT_LOCALE_REGIONS) {
+    return DEFAULT_LOCALE_REGIONS[language];
+  }
+  return null;
+}
+
+// src/index.ts
+registerDrawLibraryVersion(
+  "@ibodr/schema",
+  "0.0.0",
+  "esm"
+);
+
+export { ArrowShapeArrowheadEndStyle, ArrowShapeArrowheadStartStyle, ArrowShapeKindStyle, AssetRecordType, CameraRecordType, DefaultColorStyle, DefaultDashStyle, DefaultFillStyle, DefaultFontFamilies, DefaultFontStyle, DefaultHorizontalAlignStyle, DefaultSizeStyle, DefaultTextAlignStyle, DefaultVerticalAlignStyle, DocumentRecordType, DrDOCUMENT_ID, DrINSTANCE_ID, DrPOINTER_ID, ElbowArrowSnap, EnumStyleProp, GeoShapeGeoStyle, ImageShapeCrop, InstancePageStateRecordType, InstancePresenceRecordType, LANGUAGES, LineShapeSplineStyle, PageRecordType, PointerRecordType, StyleProp, TL_CANVAS_UI_COLOR_TYPES, TL_CURSOR_TYPES, TL_HANDLE_TYPES, TL_SCRIBBLE_STATES, UserRecordType, arrowBindingMigrations, arrowBindingProps, arrowBindingVersions, arrowShapeMigrations, arrowShapeProps, arrowShapeVersions, assetIdValidator, assetMigrations, b64Vecs, bindingIdValidator, bookmarkAssetMigrations, bookmarkAssetProps, bookmarkShapeMigrations, bookmarkShapeProps, boxModelValidator, canvasUiColorTypeValidator, compressLegacySegments, createAssetPropsMigrationIds, createAssetPropsMigrationSequence, createAssetRecordType, createAssetValidator, createBindingId, createBindingPropsMigrationIds, createBindingPropsMigrationSequence, createBindingValidator, createCachedUserResolve, createCustomRecordId, createCustomRecordMigrationIds, createCustomRecordMigrationSequence, createDrSchema, createPresenceStateDerivation, createShapeId, createShapePropsMigrationIds, createShapePropsMigrationSequence, createShapeValidator, createUserId, createUserRecordType, defaultAssetSchemas, defaultBindingSchemas, defaultShapeSchemas, drawShapeMigrations, drawShapeProps, embedShapeMigrations, embedShapeProps, frameShapeMigrations, frameShapeProps, geoShapeMigrations, geoShapeProps, getDefaultTranslationLocale, getDefaultUserPresence, getShapePropKeysByStyle, groupShapeMigrations, groupShapeProps, highlightShapeMigrations, highlightShapeProps, idValidator, imageAssetMigrations, imageAssetProps, imageShapeMigrations, imageShapeProps, isBinding, isBindingId, isCustomRecord, isCustomRecordId, isDocument, isFontEntry, isPageId, isShape, isShapeId, isUserId, lineShapeMigrations, lineShapeProps, noteShapeMigrations, noteShapeProps, opacityValidator, pageIdValidator, parentIdValidator, pluckPreservingValues, registerColorsFromThemes, registerFontsFromThemes, richTextValidator, rootBindingMigrations, rootShapeMigrations, scribbleValidator, shapeIdValidator, textShapeMigrations, textShapeProps, toRichText, userIdValidator, vecModelValidator, videoAssetMigrations, videoAssetProps, videoShapeMigrations, videoShapeProps };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map