@media-quest/builder 0.0.26 → 0.0.28

package/dist/public-api.js

@@ -0,0 +1,2740 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/public-api.ts
+var public_api_exports = {};
+__export(public_api_exports, {
+  BuilderCondition: () => BuilderCondition,
+  BuilderConditionGroup: () => BuilderConditionGroup,
+  BuilderMainText: () => BuilderMainText,
+  BuilderOperator: () => BuilderOperator,
+  BuilderOption: () => BuilderOption,
+  BuilderPage: () => BuilderPage,
+  BuilderQuestion: () => BuilderQuestion,
+  BuilderRule: () => BuilderRule,
+  BuilderSchema: () => BuilderSchema,
+  BuilderTag: () => BuilderTag,
+  BuilderText: () => BuilderText,
+  CodeBook: () => CodeBook,
+  ExcludeByPageIdSelectItem: () => ExcludeByPageIdSelectItem,
+  ExcludeByTagSelectItem: () => ExcludeByTagSelectItem,
+  JumpToActionManager: () => JumpToActionManager,
+  JumpToPageSelectItem: () => JumpToPageSelectItem,
+  MultiSelectItem: () => MultiSelectItem,
+  OperatorSelectItem: () => OperatorSelectItem,
+  OptionID: () => OptionID,
+  PageActionManager: () => PageActionManager,
+  PageID: () => PageID,
+  PagePrefix: () => PagePrefix,
+  QuestionID: () => QuestionID,
+  RuleCustomVariable: () => RuleCustomVariable,
+  RuleInput: () => RuleInput,
+  RuleOptionSelectItem: () => RuleOptionSelectItem,
+  RuleQuestionVariable: () => RuleQuestionVariable,
+  RuleVariableOption: () => RuleVariableOption,
+  RuleVariableSelectItem: () => RuleVariableSelectItem,
+  SchemaConfig: () => SchemaConfig,
+  SchemaID: () => SchemaID,
+  SchemaPrefix: () => SchemaPrefix,
+  SingleSelectItem: () => SingleSelectItem,
+  SumScore: () => SumScore,
+  SumScoreVariable: () => SumScoreVariable,
+  SumScoreVariableID: () => SumScoreVariableID,
+  TagActionManager: () => TagActionManager,
+  TagCollection: () => TagCollection,
+  TagID: () => TagID,
+  TextID: () => TextID,
+  VarID: () => VarID,
+  _CodeBook: () => _CodeBook,
+  createTypedIdSingleton: () => createTypedIdSingleton
+});
+module.exports = __toCommonJS(public_api_exports);
+
+// src/BuilderObject.ts
+var BuilderObject = class {
+  originalDto;
+  constructor(dto) {
+    this.originalDto = dto;
+  }
+};
+
+// src/primitives/ID.ts
+var ID_LENGTH = 32;
+var MIN_LENGTH = 10;
+var isID = (idName, id) => {
+  if (typeof id !== "string")
+    return false;
+  return id.length >= MIN_LENGTH;
+};
+var createIDByName = (idName) => {
+  const letters = "abcdefghijklmnopqrstuvyz";
+  const all = letters + letters.toUpperCase();
+  let result = "";
+  for (let i = 0; i < ID_LENGTH; i++) {
+    const char = all.charAt(Math.floor(Math.random() * all.length));
+    result += char;
+  }
+  return result;
+};
+var createDummyID = (idName, letter) => {
+  return letter.repeat(ID_LENGTH);
+};
+var createTypedIdSingleton = (idName) => {
+  const create = () => createIDByName(idName);
+  const is = (id) => isID(idName, id);
+  const validateOrThrow = (id) => {
+    if (!is(id)) {
+      throw new Error(`Invalid id: ${id}`);
+    }
+    return id;
+  };
+  const name = idName;
+  const validateOrCreate = (id) => {
+    return is(id) ? id : create();
+  };
+  const a = createDummyID(idName, "a");
+  const b = createDummyID(idName, "b");
+  const c = createDummyID(idName, "c");
+  const d = createDummyID(idName, "d");
+  const e = createDummyID(idName, "e");
+  const f = createDummyID(idName, "f");
+  const g = createDummyID(idName, "g");
+  const h = createDummyID(idName, "h");
+  const i = createDummyID(idName, "i");
+  const j = createDummyID(idName, "j");
+  const list = [a, b, c, d, e, f, g, h, i, j];
+  const dummy = {
+    a,
+    b,
+    c,
+    d,
+    e,
+    f,
+    g,
+    h,
+    i,
+    j,
+    list
+  };
+  return Object.freeze({ create, is, validateOrCreate, validateOrThrow, name, dummy });
+};
+var SchemaID = createTypedIdSingleton("SCHEMA");
+var PageID = createTypedIdSingleton("PAGE");
+var TagID = createTypedIdSingleton("TAG");
+var OptionID = createTypedIdSingleton("OPTION");
+var TextID = createTypedIdSingleton("TEXT");
+var QuestionID = createTypedIdSingleton("QUESTION");
+var SumScoreVariableID = createTypedIdSingleton("SUM_SCORE_VARIABLE");
+
+// src/Builder-option.ts
+var BuilderOption = class _BuilderOption extends BuilderObject {
+  objectType = "builder-question-option";
+  id;
+  value;
+  label = "";
+  _labelAudioFile = false;
+  get labelAudioFile() {
+    return this._labelAudioFile;
+  }
+  set labelAudioFile(audioFile) {
+    this._labelAudioFile = audioFile;
+  }
+  constructor(dto) {
+    super(dto);
+    this.id = dto.id;
+    this.value = dto.value;
+    this.label = dto.label;
+  }
+  static create(value, label) {
+    const id = OptionID.create();
+    const dto = {
+      id,
+      value,
+      label
+    };
+    const instance = new _BuilderOption(dto);
+    return instance;
+  }
+  static fromJson(dto) {
+    const instance = new _BuilderOption(dto);
+    return instance;
+  }
+  toJson() {
+    const dto = {
+      id: this.id,
+      value: this.value,
+      label: this.label
+    };
+    return dto;
+  }
+  clone() {
+    const dto = this.toJson();
+    const cloneDto = { ...dto, id: OptionID.create() };
+    return cloneDto;
+  }
+};
+
+// src/Builder-question.ts
+var BuilderQuestion = class _BuilderQuestion extends BuilderObject {
+  objectType = "builder-question";
+  id;
+  type;
+  questionText = "";
+  options = [];
+  prefix = "";
+  static create = (type) => {
+    const id = QuestionID.create();
+    return new _BuilderQuestion({
+      id,
+      _type: type,
+      text: "",
+      options: [],
+      prefix: ""
+    });
+  };
+  static fromJson(dto) {
+    const question = new _BuilderQuestion(dto);
+    return question;
+  }
+  constructor(dto) {
+    super(dto);
+    this.id = QuestionID.validateOrCreate(dto.id);
+    this.type = dto._type;
+    this.questionText = dto.text;
+    this.prefix = dto.prefix;
+    this.options = dto.options.map((o) => BuilderOption.fromJson(o));
+  }
+  addOption(label, value, atIndex = -1) {
+    const option = BuilderOption.create(value, label);
+    if (atIndex >= 0 && atIndex < this.options.length) {
+      this.options.splice(atIndex, 0, option);
+    } else {
+      this.options.push(option);
+    }
+    return option;
+  }
+  deleteOption(option) {
+    const filtered = this.options.filter((o) => o.id !== option.id);
+    const didDelete = filtered.length === this.options.length - 1;
+    this.options = filtered;
+    return didDelete;
+  }
+  toJson() {
+    const optionsJson = this.options.map((o) => o.toJson());
+    const dto = {
+      id: this.id,
+      prefix: this.prefix,
+      _type: this.type,
+      text: this.questionText,
+      options: optionsJson
+    };
+    return dto;
+  }
+  clone() {
+    const cloneId = QuestionID.create();
+    const dto = this.toJson();
+    const optionsClone = this.options.map((o) => o.clone());
+    const clonedDto = {
+      ...dto,
+      id: cloneId,
+      options: optionsClone
+    };
+    return clonedDto;
+  }
+};
+
+// src/BuilderMainText.ts
+var BuilderMainText = class _BuilderMainText extends BuilderObject {
+  objectType = "builder-main-text";
+  autoplay = false;
+  _audioFile = false;
+  autoplayDelay = 0;
+  text = "";
+  constructor(dto) {
+    super(dto);
+    this._audioFile = dto.audioFile ?? false;
+    this.autoplay = dto.autoplay ?? false;
+    this.autoplayDelay = dto.autoplayDelay ?? 0;
+    this.text = dto.text ?? "";
+  }
+  get autoplayDelayInSeconds() {
+    const delay = this.autoplayDelay;
+    const s = delay / 1e3;
+    const formatted = s.toFixed(1);
+    return formatted;
+  }
+  get durationTag() {
+    if (!this.audioFile)
+      return "";
+    const dur = this.audioFile.duration.toFixed(1);
+    return "dur " + dur + " s";
+  }
+  static fromJson(dto) {
+    const mainText = new _BuilderMainText(dto);
+    return mainText;
+  }
+  static create = () => {
+    const dto = {
+      autoplay: false,
+      autoplayDelay: 0,
+      audioFile: false,
+      text: ""
+    };
+    return new _BuilderMainText(dto);
+  };
+  clone() {
+    const dto = this.toJson();
+    const clone = JSON.parse(JSON.stringify(dto));
+    return clone;
+  }
+  toJson() {
+    const dto = {
+      text: this.text,
+      audioFile: this.audioFile,
+      autoplay: this.autoplay,
+      autoplayDelay: this.autoplayDelay
+    };
+    return dto;
+  }
+  get audioFile() {
+    return this._audioFile;
+  }
+  set audioFile(audioFile) {
+    if (audioFile === false) {
+      this.autoplayDelay = 0;
+      this.autoplay = false;
+    }
+    this._audioFile = audioFile;
+  }
+};
+
+// src/rulebuilder/condition/Builder-operator.ts
+var BuilderOperatorSymbols = {
+  equal: true,
+  notEqual: true,
+  lessThan: true,
+  lessThanOrEqual: true,
+  greaterThan: true,
+  greaterThanOrEqual: true,
+  between: true,
+  notBetween: true,
+  in: true,
+  notIn: true,
+  missing: true,
+  notMissing: true,
+  contains: true,
+  notContains: true,
+  empty: true,
+  notEmpty: true,
+  startsWith: true,
+  endsWith: true
+};
+var BuilderOperator;
+((BuilderOperator2) => {
+  BuilderOperator2.is = (symbol) => {
+    if (typeof symbol !== "string") {
+      return false;
+    }
+    return Object.keys(BuilderOperatorSymbols).includes(symbol);
+  };
+})(BuilderOperator || (BuilderOperator = {}));
+
+// src/rulebuilder/SingleSelectItem.ts
+var SingleSelectItem = class {
+  constructor(data) {
+    this.data = data;
+    this._selectLabel = this.getSelectLabel();
+    this._toolTip = this.getTooltip();
+    this._searchString = this.getSearchString();
+  }
+  _selectLabel;
+  _toolTip;
+  _searchString;
+  get selectLabel() {
+    return this._selectLabel;
+  }
+  get tooltip() {
+    return this._toolTip;
+  }
+  get searchString() {
+    return this._searchString;
+  }
+};
+var RuleVariableSelectItem = class _RuleVariableSelectItem extends SingleSelectItem {
+  constructor(data) {
+    super(data);
+    this.data = data;
+    this.options = data.options.map(RuleOptionSelectItem.create);
+  }
+  static create = (data) => {
+    return new _RuleVariableSelectItem(data);
+  };
+  options;
+  getSearchString() {
+    return this.data.varId + this.data.label;
+  }
+  getSelectLabel() {
+    return this.data.varId;
+  }
+  getTooltip() {
+    return this.data.label;
+  }
+};
+var RuleOptionSelectItem = class _RuleOptionSelectItem extends SingleSelectItem {
+  static create = (option) => {
+    return new _RuleOptionSelectItem(option);
+  };
+  constructor(option) {
+    super(option);
+  }
+  getSearchString() {
+    return "";
+  }
+  getSelectLabel() {
+    return this.data.label + "(" + this.data.value + ")";
+  }
+  getTooltip() {
+    return "";
+  }
+};
+var OperatorSelectItem = class _OperatorSelectItem extends SingleSelectItem {
+  static EQ = new _OperatorSelectItem("equal");
+  static NOT_EQ = new _OperatorSelectItem("notEqual");
+  static fromSymbol = (symbol) => {
+    if (symbol === "equal") {
+      return _OperatorSelectItem.EQ;
+    }
+    if (symbol === "notEqual") {
+      return _OperatorSelectItem.NOT_EQ;
+    }
+    return false;
+  };
+  constructor(operator) {
+    super(operator);
+  }
+  getSearchString() {
+    return "";
+  }
+  getSelectLabel() {
+    const operator = this.data;
+    if (operator === "equal") {
+      return "Equals";
+    }
+    if (operator === "notEqual") {
+      return "Not equals";
+    }
+    return "";
+  }
+  getTooltip() {
+    const operator = this.data;
+    if (operator === "equal") {
+      return "Equals";
+    }
+    if (operator === "notEqual") {
+      return "Not equals";
+    }
+    return "";
+  }
+};
+var JumpToPageSelectItem = class _JumpToPageSelectItem extends SingleSelectItem {
+  static create = (pageData) => new _JumpToPageSelectItem(pageData);
+  constructor(pageData) {
+    super(pageData);
+  }
+  getSearchString() {
+    return this.data.pagePrefix + this.data.mainText;
+  }
+  getSelectLabel() {
+    return this.data.pagePrefix + " (" + this.data.pageNumber + ")";
+  }
+  getTooltip() {
+    return this.data.mainText;
+  }
+};
+
+// src/rulebuilder/condition/Builder-condition.ts
+var BuilderCondition = class _BuilderCondition extends BuilderObject {
+  objectType = "builder-condition";
+  static NUMBER_OPERATORS = [
+    OperatorSelectItem.EQ,
+    OperatorSelectItem.NOT_EQ
+  ];
+  initialDto;
+  name = "";
+  static create = (variableList) => {
+    const condition = new _BuilderCondition(
+      {
+        kind: "condition",
+        name: "",
+        operator: "",
+        variableId: "",
+        value: ""
+      },
+      variableList
+    );
+    return condition;
+  };
+  static fromDto = (dto, variables) => {
+    const _dto = {
+      kind: "condition",
+      name: dto.name ?? "",
+      value: dto.value ?? "",
+      operator: dto.operator ?? "",
+      variableId: dto.variableId ?? ""
+    };
+    const instance = new _BuilderCondition(_dto, variables);
+    return instance;
+  };
+  _variable = false;
+  _operator = "";
+  _value = false;
+  _variableList = [];
+  /**
+   * Can only set variables that exist in variableList.
+   * @param variable
+   */
+  set variable(variable) {
+    if (variable === this._variable) {
+      return;
+    }
+    this._variable = variable;
+    this._operator = "";
+    this._value = false;
+  }
+  get variable() {
+    return this._variable;
+  }
+  set value(variableValue) {
+    this._value = variableValue;
+  }
+  get value() {
+    return this._value;
+  }
+  validate() {
+    if (this._variableList.length === 0) {
+      return {
+        isValid: false,
+        message: "Has no variableList to check dto against."
+      };
+    }
+    if (!this._variable) {
+      return {
+        isValid: false,
+        message: "Variable has not been initialized from variableList."
+      };
+    }
+    if (!this._operator) {
+      return { isValid: false, message: "Operator has not been initialized" };
+    }
+    if (!this._value) {
+      return {
+        isValid: false,
+        message: "Value (RuleVariableOption) is not initialized"
+      };
+    }
+    return { isValid: true };
+  }
+  toEngineCondition() {
+    const val = this.value;
+    const op = this._operator;
+    const v = this._variable;
+    if (!val)
+      return false;
+    if (!op)
+      return false;
+    if (!v)
+      return false;
+    if (op === "equal") {
+      const engineCondition = {
+        kind: "numeric-condition",
+        value: val.value,
+        valueLabel: val.label,
+        referenceId: v.varId,
+        referenceLabel: v.label,
+        operator: "eq"
+      };
+      return engineCondition;
+    }
+    return false;
+  }
+  findVariableInUniverse(variableId) {
+    const v = this._variableList.find((v2) => v2.varId === variableId);
+    return v ?? false;
+  }
+  set operator(operator) {
+    if (BuilderOperator.is(operator)) {
+      this._operator = operator;
+    } else {
+      this._operator = "";
+    }
+  }
+  get operator() {
+    return this._operator;
+  }
+  constructor(dto, variables) {
+    super(dto);
+    this.initialDto = dto;
+    this.name = dto.name;
+    this._setVariableList(variables);
+  }
+  get variableSelectItemsInUniverse() {
+    return this._variableList.map(RuleVariableSelectItem.create);
+  }
+  get operatorsSelectItems() {
+    return this._variable ? _BuilderCondition.NUMBER_OPERATORS : [];
+  }
+  get selectValueItems() {
+    if (!this._variable) {
+      return [];
+    }
+    const opt = this._variable.options.map(RuleOptionSelectItem.create);
+    return opt;
+  }
+  clone() {
+    return this.toJson();
+  }
+  _setVariableList(variables) {
+    this._variableList = variables;
+    const v = this._variableList.find((v2) => v2.varId === this.originalDto.variableId);
+    if (!v) {
+      this._variable = false;
+      this._operator = "";
+      this._value = false;
+      return false;
+    }
+    this._variable = v;
+    const op = this.originalDto.operator;
+    if (!BuilderOperator.is(op)) {
+      return false;
+    }
+    this._operator = op;
+    const maybeOption = v.options.find((op2) => op2.value === this.originalDto.value);
+    if (!maybeOption) {
+      return false;
+    }
+    this._value = maybeOption;
+    return true;
+  }
+  toJson() {
+    const name = this.name;
+    const variableId = this._variable ? this._variable.varId : "";
+    const operator = this._operator ? this._operator : "";
+    const value = this._value ? this._value.value : "";
+    return {
+      kind: "condition",
+      name,
+      operator,
+      variableId,
+      value
+    };
+  }
+};
+
+// src/rulebuilder/condition/Builder-condition-group.ts
+var ConditionGroupType = {
+  all: true,
+  any: true,
+  count: true
+};
+var BuilderConditionGroup = class _BuilderConditionGroup extends BuilderObject {
+  static isConditionGroupType = (value) => {
+    if (typeof value !== "string") {
+      return false;
+    }
+    const validValues = Object.keys(ConditionGroupType);
+    return validValues.includes(value);
+  };
+  objectType = "builder-condition-group";
+  _type;
+  name = "";
+  _conditions;
+  _variableList;
+  static fromDto = (dto, variableList) => {
+    return new _BuilderConditionGroup(dto, variableList);
+  };
+  constructor(dto, variableList) {
+    super(dto);
+    this.name = dto.name;
+    this._type = dto.type;
+    const conditionList = Array.isArray(dto.conditions) ? dto.conditions : [];
+    this._conditions = conditionList.map((dto2) => BuilderCondition.fromDto(dto2, variableList));
+    this._variableList = variableList;
+  }
+  get conditions() {
+    return this._conditions;
+  }
+  get conditionCount() {
+    return this._conditions.length;
+  }
+  addCondition() {
+    const newConditions = BuilderCondition.create(this._variableList);
+    this._conditions.push(newConditions);
+    return newConditions;
+  }
+  removeCondition(condition) {
+    const index = this._conditions.indexOf(condition);
+    if (index < 0) {
+      return false;
+    }
+    this._conditions.splice(index, 1);
+    return true;
+  }
+  clone() {
+    return this.toJson();
+  }
+  toJson() {
+    const conditions = [
+      ...this._conditions.map((c) => c.toJson())
+    ];
+    return {
+      name: this.name,
+      conditions,
+      type: this._type,
+      kind: "condition-group"
+    };
+  }
+  toEngineConditionComplex() {
+    const comp = {
+      kind: "complex-condition",
+      all: [],
+      some: [],
+      name: ""
+    };
+    const conditions = [];
+    this.conditions.forEach((c) => {
+      const maybeSimple = c.toEngineCondition();
+      if (maybeSimple) {
+        conditions.push(maybeSimple);
+      }
+    });
+    if (this._type === "all") {
+      return { ...comp, all: conditions };
+    }
+    if (this._type === "any") {
+      return { ...comp, some: conditions };
+    }
+    console.log("INVALID COMPLEX CONDITION. TODO IMPLEMENT range, and count.");
+    return false;
+  }
+  get type() {
+    return this._type;
+  }
+  set type(conditionGroupType) {
+    if (_BuilderConditionGroup.isConditionGroupType(conditionGroupType)) {
+      this._type = conditionGroupType;
+    }
+  }
+};
+
+// src/rulebuilder/multi-select-item.ts
+var MultiSelectItem = class {
+  constructor(data, isSelected) {
+    this.data = data;
+    this._isSelectedInitially = isSelected;
+    this.isSelected = isSelected;
+    this._searchString = this.getSearchString();
+    this._toolTip = this.getTooltip();
+    this._selectLabel = this.getSelectLabel();
+  }
+  _isSelectedInitially;
+  _selectLabel;
+  _toolTip;
+  _searchString;
+  isSelected;
+  get selectLabel() {
+    return this._selectLabel;
+  }
+  get tooltip() {
+    return this._toolTip;
+  }
+  get searchString() {
+    return this._searchString;
+  }
+};
+var ExcludeByTagSelectItem = class _ExcludeByTagSelectItem extends MultiSelectItem {
+  static create = (tagData, isSelected) => {
+    return new _ExcludeByTagSelectItem(tagData, isSelected);
+  };
+  constructor(data, isSelected) {
+    super(data, isSelected);
+  }
+  getSearchString() {
+    return this.data.tag;
+  }
+  getSelectLabel() {
+    return this.data.tag + " (" + this.data.pageCount + ")";
+  }
+  getTooltip() {
+    return this.data.tag + "  (used in " + this.data.pageCount + " pages)";
+  }
+};
+var ExcludeByPageIdSelectItem = class _ExcludeByPageIdSelectItem extends MultiSelectItem {
+  static create = (ruleActionPage, isSelected) => {
+    return new _ExcludeByPageIdSelectItem(ruleActionPage, isSelected);
+  };
+  constructor(data, isSelected) {
+    super(data, isSelected);
+  }
+  getSearchString() {
+    return this.data.pagePrefix + this.data.mainText;
+  }
+  getSelectLabel() {
+    return this.data.pagePrefix + " (" + this.data.pageNumber + ")";
+  }
+  getTooltip() {
+    return this.data.mainText;
+  }
+};
+
+// src/rulebuilder/tag-action-manager.ts
+var TagActionManager = class {
+  constructor(validOptions, initialSelection) {
+    this.validOptions = validOptions;
+    this.initialSelection = initialSelection;
+    this._initialSelection = /* @__PURE__ */ new Set([...initialSelection]);
+    this.selectItems = validOptions.map((opt) => {
+      const isSelected = this._initialSelection.has(opt.tag);
+      return ExcludeByTagSelectItem.create(opt, isSelected);
+    });
+  }
+  _initialSelection;
+  selectItems;
+  getCurrentSelection() {
+    const selected = this.selectItems.filter((item) => item.isSelected).map((itm) => itm.data.tag);
+    return selected;
+  }
+  getEngineActions() {
+    const selected = this.selectItems.filter((item) => item.isSelected);
+    const tagActions = selected.map((s) => s.data);
+    return [...tagActions];
+  }
+};
+
+// src/rulebuilder/page-action-manager.ts
+var PageActionManager = class {
+  constructor(validOptions, initialSelection) {
+    this.validOptions = validOptions;
+    this.initialSelection = initialSelection;
+    this._initialSelection = /* @__PURE__ */ new Set([...initialSelection]);
+    this.selectItems = validOptions.map((opt) => {
+      const isSelected = this._initialSelection.has(opt.pageId);
+      return ExcludeByPageIdSelectItem.create(opt, isSelected);
+    });
+  }
+  _initialSelection;
+  selectItems;
+  getCurrentSelection() {
+    const selected = this.selectItems.filter((item) => item.isSelected).map((itm) => itm.data.pageId);
+    return selected;
+  }
+  getEngineAction() {
+    const selectItems = this.selectItems.filter((item) => item.isSelected);
+    const actions = selectItems.map((item) => item.data);
+    return [...actions];
+  }
+};
+
+// src/rulebuilder/jump-to-action-manager.ts
+var JumpToActionManager = class {
+  constructor(validOptions, initialSelection) {
+    this.validOptions = validOptions;
+    this.initialSelection = initialSelection;
+    this.options = validOptions.map(JumpToPageSelectItem.create);
+    this._selected = this.findSelected(initialSelection);
+  }
+  options;
+  _selected;
+  get selected() {
+    return this._selected;
+  }
+  set selected(selected) {
+    this._selected = this.findSelected(selected);
+  }
+  getSelectedPageId() {
+    return this._selected ? this._selected.data.pageId : false;
+  }
+  findSelected(value) {
+    if (!value)
+      return false;
+    if (value instanceof JumpToPageSelectItem) {
+      return this.options.find((v) => v === value) || false;
+    }
+    if (typeof value === "string") {
+      return this.options.find((v) => v.data.pageId === value) || false;
+    }
+    return false;
+  }
+};
+
+// src/rulebuilder/Builder-rule.ts
+var BuilderRule = class _BuilderRule extends BuilderObject {
+  constructor(dto, _ruleInput) {
+    super(dto);
+    this.dto = dto;
+    this._ruleInput = _ruleInput;
+    const conditionInput = this._ruleInput.getConditionInput();
+    this.name = dto.name ?? "";
+    this._type = dto.type ?? "any";
+    this._conditions = dto.conditions.reduce(
+      (acc, curr) => {
+        if (curr.kind === "condition") {
+          const condition = BuilderCondition.fromDto(curr, conditionInput);
+          acc.push(condition);
+        }
+        if (curr.kind === "condition-group") {
+          const conditionGroup = BuilderConditionGroup.fromDto(curr, conditionInput);
+          acc.push(conditionGroup);
+        }
+        return acc;
+      },
+      []
+    );
+    this._pageActionManager = new PageActionManager(
+      _ruleInput.excludeByPageIdActions,
+      dto.excludePages
+    );
+    this._tagActionManager = new TagActionManager(_ruleInput.excludeByTagActions, dto.excludeTags);
+    this.jumpToActionManager = new JumpToActionManager(
+      _ruleInput.jumpToPageActions,
+      dto.jumpToPage
+    );
+  }
+  objectType = "builder-rule";
+  _type = "all";
+  name = "Rule name";
+  // public countNumber = 1;
+  _conditions = [];
+  _tagActionManager;
+  _pageActionManager;
+  jumpToActionManager;
+  static fromDto = (dto, input) => {
+    return new _BuilderRule(dto, input);
+  };
+  get conditions() {
+    return this._conditions;
+  }
+  getTagActions() {
+    return this._tagActionManager.selectItems;
+  }
+  getValidPageActions() {
+    return this._pageActionManager.selectItems;
+  }
+  get conditionCount() {
+    return this._conditions.length;
+  }
+  set type(type) {
+    if (BuilderConditionGroup.isConditionGroupType(type)) {
+      this._type = type;
+    }
+  }
+  get type() {
+    return this._type;
+  }
+  deleteCondition(condition) {
+    const index = this._conditions.indexOf(condition);
+    if (index < 0) {
+      return false;
+    }
+    this._conditions.splice(index, 1);
+    return true;
+  }
+  addCondition() {
+    const condition = BuilderCondition.create(this._ruleInput.getConditionInput());
+    this._conditions.push(condition);
+    return condition;
+  }
+  addConditionGroup() {
+    const dto = {
+      kind: "condition-group",
+      name: "",
+      type: "all",
+      conditions: []
+    };
+    const newGroup = BuilderConditionGroup.fromDto(dto, this._ruleInput.questionVars);
+    this._conditions.push(newGroup);
+    return newGroup;
+  }
+  clone() {
+    return this.toJson();
+  }
+  toJson() {
+    const conditions = this._conditions.map((c) => c.toJson());
+    const excludePages = this._pageActionManager.getCurrentSelection();
+    const excludeTags = this._tagActionManager.getCurrentSelection();
+    const jumpToPage = this.jumpToActionManager.getSelectedPageId();
+    const dto = {
+      type: this._type,
+      name: this.name,
+      conditions,
+      excludePages,
+      jumpToPage,
+      excludeTags
+    };
+    return dto;
+  }
+  toEngineRule() {
+    const conditions = [];
+    this._conditions.forEach((c) => {
+      if (c) {
+        if (c instanceof BuilderCondition) {
+          const simpleCondition = c.toEngineCondition();
+          if (simpleCondition) {
+            conditions.push(simpleCondition);
+          }
+        }
+        if (c instanceof BuilderConditionGroup) {
+          const complexCondition = c.toEngineConditionComplex();
+          if (complexCondition)
+            conditions.push(complexCondition);
+        }
+      }
+    });
+    let all = [];
+    let some = [];
+    if (this.type === "all") {
+      all = [...conditions];
+    }
+    const ruleActionList = [];
+    const maybeJumpToPage = this.jumpToActionManager.selected;
+    if (maybeJumpToPage) {
+      ruleActionList.push({ kind: "jumpToPage", pageId: maybeJumpToPage.data.pageId });
+    }
+    const excludePageByIdList = this._pageActionManager.getEngineAction().map((a) => a.pageId);
+    if (excludePageByIdList.length) {
+      ruleActionList.push({ kind: "excludeByPageId", pageIds: [...excludePageByIdList] });
+    }
+    const excludeTags = this._tagActionManager.getEngineActions().map((tagA) => tagA.tag);
+    if (excludeTags.length) {
+      ruleActionList.push({ kind: "excludeByTag", tagIds: [...excludeTags] });
+    }
+    const rule = {
+      description: this.name,
+      all,
+      some,
+      onFailure: [],
+      onSuccess: ruleActionList
+    };
+    return rule;
+  }
+};
+
+// src/rulebuilder/RuleInput.ts
+var RuleInput = class {
+  constructor(_questionVariables, _customVariables, _pageIdActions, _tagActions, _jumpActions) {
+    this._questionVariables = _questionVariables;
+    this._customVariables = _customVariables;
+    this._pageIdActions = _pageIdActions;
+    this._tagActions = _tagActions;
+    this._jumpActions = _jumpActions;
+  }
+  get questionVars() {
+    return this._questionVariables;
+  }
+  getConditionInput() {
+    return [...this.questionVars, ...this.customVars];
+  }
+  getJumpToPageOptions() {
+    return this._jumpActions.map(JumpToPageSelectItem.create);
+  }
+  get customVars() {
+    return this._customVariables;
+  }
+  get excludeByPageIdActions() {
+    return this._pageIdActions;
+  }
+  get excludeByTagActions() {
+    return this._tagActions;
+  }
+  get jumpToPageActions() {
+    return this._jumpActions;
+  }
+};
+
+// src/rulebuilder/RuleVariable.ts
+var RuleVariableOption = class {
+  constructor(label, value) {
+    this.label = label;
+    this.value = value;
+  }
+};
+var RuleQuestionVariable = class {
+  constructor(varId, label, options, pageNumber) {
+    this.varId = varId;
+    this.label = label;
+    this.options = options;
+    this.pageNumber = pageNumber;
+  }
+  kind = "question-variable";
+};
+var RuleCustomVariable = class {
+  constructor(varId, label, options) {
+    this.varId = varId;
+    this.label = label;
+    this.options = options;
+  }
+  kind = "configuration-variable";
+};
+
+// src/page/Builder-page.ts
+var import_engine = require("@media-quest/engine");
+
+// src/primitives/schema-prefix.ts
+var SchemaPrefix = class _SchemaPrefix {
+  constructor(_value) {
+    this._value = _value;
+  }
+  static MIN_LENGTH = 1;
+  static randomLen = 5;
+  static MAX_LENGTH = 16;
+  static fromValue = (value) => {
+    return new _SchemaPrefix(value);
+  };
+  static fromValueOrThrow = (value) => {
+    if (!_SchemaPrefix.isValid(value))
+      throw new Error("Invalid prefix");
+    return new _SchemaPrefix(value);
+  };
+  static fromString = (value) => {
+    if (!_SchemaPrefix.isValid(value))
+      return false;
+    return new _SchemaPrefix(value);
+  };
+  static castOrCreateRandom = (value) => {
+    const v = _SchemaPrefix.isValid(value) ? value : createRandomPrefix(_SchemaPrefix.randomLen);
+    return new _SchemaPrefix(v);
+  };
+  static isValid = (prefix) => {
+    if (typeof prefix !== "string")
+      return false;
+    if (prefix.length < _SchemaPrefix.MIN_LENGTH)
+      return false;
+    if (prefix.length > _SchemaPrefix.MAX_LENGTH)
+      return false;
+    return true;
+  };
+  get value() {
+    return this._value;
+  }
+  get isValid() {
+    return _SchemaPrefix.isValid(this._value);
+  }
+  set value(value) {
+    const casted = value;
+    if (typeof casted === "string") {
+      this._value = casted;
+    }
+  }
+};
+
+// src/primitives/page-prefix.ts
+var createRandomPrefix = (length) => {
+  const letters = "abcdefghijklmnopqrstuvyz";
+  const all = letters + letters.toUpperCase();
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    const char = all.charAt(Math.floor(Math.random() * all.length));
+    result += char;
+  }
+  return result;
+};
+var PagePrefix = class _PagePrefix {
+  constructor(_value) {
+    this._value = _value;
+  }
+  static MIN_LENGTH = 1;
+  static randomLen = 5;
+  static MAX_LENGTH = 16;
+  static create = () => {
+    const v = createRandomPrefix(_PagePrefix.randomLen);
+    return new _PagePrefix(v);
+  };
+  static fromString = (value) => {
+    if (!_PagePrefix.isValid(value))
+      return false;
+    return new _PagePrefix(value);
+  };
+  static fromStringOrThrow = (value) => {
+    if (!_PagePrefix.isValid(value))
+      throw new Error("Invalid prefix");
+    return value;
+  };
+  static castOrCreateRandom = (value) => {
+    const v = _PagePrefix.isValid(value) ? value : createRandomPrefix(_PagePrefix.randomLen);
+    return new _PagePrefix(v);
+  };
+  static isValid = (prefix) => {
+    if (typeof prefix !== "string")
+      return false;
+    if (prefix.length < SchemaPrefix.MIN_LENGTH)
+      return false;
+    return prefix.length <= SchemaPrefix.MAX_LENGTH;
+  };
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    if (!_PagePrefix.isValid(value)) {
+      console.log("INVALID PREFIX", value);
+    } else {
+      this._value = value;
+    }
+  }
+};
+
+// src/primitives/varID.ts
+var VarID = {
+  create: (schemaPrefix, pagePrefix) => {
+    const varId = schemaPrefix + "_" + pagePrefix;
+    return varId;
+  }
+};
+
+// src/page/Builder-page.ts
+var BuilderPage = class _BuilderPage extends BuilderObject {
+  objectType = "builder-page";
+  id;
+  _pageType;
+  _prefix;
+  _tags;
+  _backgroundColor = "#FFFFFF";
+  _includedInSumScores = /* @__PURE__ */ new Map();
+  mainMedia = false;
+  defaultQuestion;
+  mainText;
+  nextButton = BuilderOption.create(-1, "Neste");
+  static create(type, _prefix) {
+    const id = PageID.create();
+    const mainTextDto = {
+      text: "",
+      audioFile: false,
+      autoplay: false,
+      autoplayDelay: 0
+    };
+    const nextButtonDto = BuilderOption.create(-1, "page-next-button-text").toJson();
+    const defaultQuestionDto = BuilderQuestion.create("select-one").toJson();
+    const dto = {
+      _type: type,
+      autoplaySequence: [],
+      defaultQuestion: defaultQuestionDto,
+      id,
+      nextButton: nextButtonDto,
+      mainText: mainTextDto,
+      prefix: _prefix,
+      includedInSumScores: [],
+      tags: []
+    };
+    const page = new _BuilderPage(dto);
+    return page;
+  }
+  static fromJson(dto) {
+    const page = new _BuilderPage(dto);
+    return page;
+  }
+  constructor(dto) {
+    super(dto);
+    this.id = dto.id;
+    this._pageType = dto._type;
+    const prefixInstance = PagePrefix.castOrCreateRandom(dto.prefix);
+    this._prefix = prefixInstance;
+    this.mainText = BuilderMainText.fromJson(dto.mainText);
+    this.nextButton = BuilderOption.fromJson(dto.nextButton);
+    this.defaultQuestion = BuilderQuestion.fromJson(dto.defaultQuestion);
+    const tagList = Array.isArray(dto.tags) ? dto.tags : [];
+    const sumScores = Array.isArray(dto.includedInSumScores) ? dto.includedInSumScores : [];
+    sumScores.forEach((item) => {
+      this._includedInSumScores.set(item.sumScoreVariableId, {
+        sumScoreVariableId: item.sumScoreVariableId,
+        weight: item.weight,
+        name: "",
+        description: ""
+      });
+    });
+    this._tags = new Set(tagList);
+    if (dto.mainMedia) {
+      this.mainMedia = dto.mainMedia;
+    }
+  }
+  addTag(tag) {
+    this._tags.add(tag);
+  }
+  deleteTag(tag) {
+    this._tags.delete(tag);
+  }
+  set pageType(value) {
+    this._pageType = value;
+  }
+  get includedInSumScores() {
+    return [...this._includedInSumScores.values()];
+  }
+  getQuestionVariables(modulePrefix, pageNumber) {
+    const variables = [];
+    if (this._pageType === "question") {
+      const pagePrefix = this.prefix;
+      const varId = VarID.create(modulePrefix.value, pagePrefix);
+      const label = this.mainText.text;
+      const op = this.defaultQuestion.options.map((o) => {
+        const label2 = o.label;
+        const value = o.value;
+        return new RuleVariableOption(label2, value);
+      });
+      const singleVar = new RuleQuestionVariable(varId, label, op, pageNumber);
+      variables.push(singleVar);
+    }
+    return variables;
+  }
+  get tags() {
+    return [...this._tags];
+  }
+  get pageType() {
+    return this._pageType;
+  }
+  get prefix() {
+    return this._prefix.value;
+  }
+  set prefix(value) {
+    this._prefix.value = value;
+  }
+  /** @internal */
+  sumScoreVariableSet(sumScoreVariable, weight) {
+    const { id, name, description } = sumScoreVariable;
+    this._includedInSumScores.set(sumScoreVariable.id, {
+      sumScoreVariableId: id,
+      weight,
+      name,
+      description
+    });
+    return true;
+  }
+  /** @internal */
+  updateRelationShips(variables) {
+    variables.forEach((v) => {
+      const sumScoreEntry = this._includedInSumScores.get(v.id);
+      if (sumScoreEntry) {
+        this.sumScoreVariableSet(v, sumScoreEntry.weight);
+      }
+    });
+  }
+  toJson() {
+    const mainText = this.mainText.toJson();
+    const nextButton = this.nextButton.toJson();
+    const mainMedia = this.mainMedia;
+    const includedInSumScores = this.includedInSumScores.map(({ sumScoreVariableId, weight }) => ({
+      sumScoreVariableId,
+      weight
+    }));
+    const dto = {
+      _type: this.pageType,
+      mainText,
+      autoplaySequence: [],
+      nextButton,
+      id: this.id,
+      tags: [...this.tags],
+      includedInSumScores,
+      prefix: this._prefix.value,
+      defaultQuestion: this.defaultQuestion.toJson()
+    };
+    if (mainMedia) {
+      dto.mainMedia = mainMedia;
+    }
+    return dto;
+  }
+  clone() {
+    const dto = this.toJson();
+    const defaultQuestionClone = this.defaultQuestion.clone();
+    const mainTextClone = JSON.parse(JSON.stringify(this.mainText));
+    const newId = PageID.create();
+    const clone = {
+      ...dto,
+      id: newId,
+      defaultQuestion: defaultQuestionClone,
+      mainText: mainTextClone
+    };
+    return clone;
+  }
+  get backgroundColor() {
+    return this._backgroundColor;
+  }
+  set backgroundColor(color) {
+    if (typeof color === "string") {
+      this._backgroundColor = color;
+    }
+  }
+  /**
+   * @internal
+   */
+  _isIncludedInSumScore(sumScoreId) {
+    return this._includedInSumScores.has(sumScoreId);
+  }
+  /**
+   * @internal
+   */
+  sumScoreVariableDelete(sumScoreVariableID) {
+    this._includedInSumScores.delete(sumScoreVariableID);
+  }
+};
+
+// src/theme/AbstractThemeCompiler.ts
+var AbstractThemeCompiler = class {
+  constructor(theme) {
+    this.theme = theme;
+  }
+};
+
+// src/theme/theme-utils.ts
+var ThemeUtils;
+((ThemeUtils2) => {
+  ThemeUtils2.spaceEvenlyX = (items, options = {
+    startAt: 0,
+    endAt: 100,
+    defaultItemWidth: 5
+  }) => {
+    const startAt = options?.startAt ?? 0;
+    const endAt = options?.endAt ?? 100;
+    const range = Math.abs(endAt - startAt);
+    if (items.length === 0) {
+      return [];
+    }
+    const marginCount = items.length + 1;
+    const defaultWidth = options.defaultItemWidth ?? 150 / marginCount;
+    let totalWidthOfElements = items.reduce((prev, curr) => {
+      const w = curr.style.w ?? defaultWidth;
+      return prev + w;
+    }, 0);
+    let cursor = startAt;
+    const rest = Math.max(range - totalWidthOfElements, 0);
+    const margin = rest / marginCount;
+    items.forEach((item) => {
+      cursor = cursor + margin;
+      const w = item.style.w ?? defaultWidth;
+      const x = cursor;
+      cursor = cursor + w;
+      item.style.w = w;
+      item.style.x = x;
+    });
+    return items;
+  };
+  ThemeUtils2.centerY = () => ({
+    y: 50,
+    transform: "translate(0%, 50%)"
+  });
+  ThemeUtils2.centerX = () => ({
+    x: 50,
+    transform: "translate(-50%, 0%)"
+  });
+  ThemeUtils2.centerXY = () => ({
+    x: 50,
+    y: 50,
+    transform: "translate(-50%, 50%)"
+  });
+})(ThemeUtils || (ThemeUtils = {}));
+
+// src/theme/icon-urls.ts
+var IconUrls = {
+  ispeWhitePng: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fispe-hvit.png?alt=media&token=f6fe628b-2d99-472d-a2ea-e062873e2e22",
+  pauseSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fpause-24px.svg?alt=media&token=47337491-bb0d-4c56-9c89-a073ce19fad4",
+  pauseCircleOutlineSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fpause_circle_outline-24px.svg?alt=media&token=133aabc8-ab9a-4eaa-9914-4f0f82c22ee2",
+  pauseCircleFilledSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fpause_circle_filled-24px.svg?alt=media&token=af3f12c3-3199-4096-8ed2-76347b9a0a0a",
+  playCircleRegular: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fplay-circle-regular.svg?alt=media&token=0867b690-d7fd-475c-8e91-b2d7aeca54d1",
+  playArrowSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fplay_arrow-24px.svg?alt=media&token=2fa95e1f-61f7-4a18-afb3-210eabae8227",
+  playCircleOutline: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fplay_circle_outline-24px.svg?alt=media&token=3a9f62c5-dfa2-40ef-a50e-cf1bdd2d47f2",
+  stopCircleSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fstop_circle-24px.svg?alt=media&token=8fbc8b89-29bb-49ad-ae11-b8882ba3ca77",
+  stopSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fstop-24px.svg?alt=media&token=d2cd41f1-1331-4243-9b7a-dc0f0ccd255d",
+  replayCircleSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Freplay-24px.svg?alt=media&token=3c35ccf4-b467-4e81-85d6-b36ac64738ad",
+  volumeOffSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fvolume_off-24px.svg?alt=media&token=4e41cc10-9f4b-4967-b4df-ed0682e657a9",
+  volumeUpSvg: "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fvolume_up-24px.svg?alt=media&token=551bd0a6-a515-4f87-a245-da433f4833f9"
+};
+
+// src/theme/IDefaultTheme.ts
+var BuilderOptionTheme;
+((BuilderOptionTheme2) => {
+  const GREEN = "#70AD47";
+  const YELLOW = "#FFC000";
+  const ORANGE = "#F4902C";
+  const RED = "#FF0000";
+  const LIGHT_BLUE = "#42719C";
+  const WHITE = "#ffffff";
+  const BLUE = "#2F5597";
+  const BTN_WIDTH = 18.5;
+  const BTN_BORDER_WIDTH = 3;
+  const BTN_BORDER_RADIUS = 10;
+  const BTN_BORDER_STYLE = "solid";
+  const BTN_HEIGHT = 9.2;
+  const BTN_SHORT_WIDTH = 13.7;
+  const FONT_WEIGHT = 600;
+  const FONT_SIZE = 35;
+  BuilderOptionTheme2.blueButton = () => {
+    const optionTheme = {
+      name: "blue-button-theme",
+      normal: {
+        btn: {
+          css: {
+            backgroundColor: BLUE,
+            borderColor: BLUE,
+            textColor: WHITE,
+            fontSize: { _unit: "px", value: FONT_SIZE },
+            borderWidth: { _unit: "px", value: BTN_BORDER_WIDTH },
+            borderStyle: BTN_BORDER_STYLE,
+            borderRadius: { value: BTN_BORDER_RADIUS, _unit: "px" },
+            padding: { _unit: "px", value: 40 },
+            h: BTN_HEIGHT,
+            w: BTN_WIDTH,
+            x: 10,
+            y: 8,
+            textAlign: "center"
+          },
+          cssDisabled: { opacity: 0.3, cursor: "not-allowed" },
+          cssEnabled: { opacity: 1, cursor: "pointer" }
+        },
+        divider: {},
+        text1: {
+          y: 50,
+          transform: "translate(0%, 50%)",
+          textColor: WHITE,
+          fontSize: { _unit: "px", value: FONT_SIZE },
+          w: 84,
+          x: 8,
+          fontWeight: FONT_WEIGHT,
+          textAlign: "center"
+        },
+        text2: {}
+      },
+      dontKnow: {
+        btn: {
+          css: {
+            backgroundColor: WHITE,
+            borderColor: LIGHT_BLUE,
+            textColor: BLUE,
+            fontSize: { _unit: "px", value: FONT_SIZE },
+            borderWidth: { _unit: "px", value: BTN_BORDER_WIDTH },
+            borderStyle: BTN_BORDER_STYLE,
+            borderRadius: { value: BTN_BORDER_RADIUS, _unit: "px" },
+            padding: { _unit: "px", value: 40 },
+            h: BTN_HEIGHT,
+            w: BTN_SHORT_WIDTH,
+            x: 10,
+            y: 8,
+            textAlign: "center"
+          },
+          cssDisabled: { opacity: 0.3, cursor: "not-allowed" },
+          cssEnabled: { opacity: 1, cursor: "pointer" }
+        },
+        text1: {
+          y: 50,
+          transform: "translate(0%, 50%)",
+          textColor: BLUE,
+          fontSize: { _unit: "px", value: FONT_SIZE },
+          w: 84,
+          x: 8,
+          fontWeight: FONT_WEIGHT,
+          textAlign: "center"
+        },
+        text2: {},
+        divider: {}
+      }
+    };
+    return optionTheme;
+  };
+})(BuilderOptionTheme || (BuilderOptionTheme = {}));
+var DefaultTheme = {
+  name: "default-theme",
+  videoPlayer: {
+    playButton: {
+      iconUrl: IconUrls.playCircleRegular,
+      css: { w: 5, h: 5, y: 48, x: 4 },
+      cssDisabled: { opacity: 0.3, cursor: "not-allowed" },
+      cssEnabled: { opacity: 0.8, cursor: "pointer" }
+    },
+    pauseButton: {
+      iconUrl: IconUrls.pauseSvg,
+      css: { w: 5, h: 5, y: 48, x: 4 },
+      cssDisabled: { opacity: 0.3, cursor: "not-allowed" },
+      cssEnabled: { opacity: 0.8, cursor: "pointer" }
+    },
+    videoElement: { css: { w: 100, h: 45, y: 55, x: 0 } }
+  },
+  image: { style: { h: 50, w: 100, x: 0 } },
+  mainText: {
+    noMedia: {
+      text: {
+        css: {
+          w: 80,
+          y: 65,
+          x: 10,
+          textAlign: "center",
+          textColor: "black",
+          fontSize: { _unit: "px", value: 40 }
+        },
+        cssDisabled: {},
+        cssEnabled: {}
+      },
+      audio: {
+        css: {
+          h: 6,
+          w: 6,
+          x: 4,
+          y: 32,
+          cursor: "pointer",
+          opacity: 0.8,
+          visibility: "visible"
+        },
+        cssDisabled: { opacity: 0.3, cursor: "not-allowed" },
+        cssEnabled: { opacity: 0.8, cursor: "pointer" }
+      }
+    },
+    withMedia: {
+      text: {
+        css: {
+          w: 80,
+          y: 27,
+          x: 10,
+          textAlign: "center",
+          textColor: "black",
+          fontSize: { _unit: "px", value: 30 }
+        },
+        cssDisabled: {},
+        cssEnabled: {}
+      },
+      audio: {
+        css: {
+          h: 6,
+          w: 6,
+          x: 4,
+          y: 32,
+          cursor: "pointer",
+          opacity: 0.8,
+          visibility: "visible"
+        },
+        cssDisabled: { opacity: 0.3, cursor: "not-allowed" },
+        cssEnabled: { opacity: 0.8, cursor: "pointer" }
+      }
+    }
+  },
+  nextButtonTheme: BuilderOptionTheme.blueButton(),
+  responseButtons: BuilderOptionTheme.blueButton()
+};
+
+// src/theme/default-theme-compiler.ts
+var import_engine2 = require("@media-quest/engine");
+var DefaultThemeCompiler = class extends AbstractThemeCompiler {
+  name = "Ispe default theme.";
+  TAG = "[ DEFAULT_THEME_COMPILER ]: ";
+  constructor() {
+    super(DefaultTheme);
+  }
+  compileRules(source) {
+    const builderSchema = BuilderSchema.fromJson(source);
+    const ruleInput = builderSchema.getRuleInput();
+    const pageQueRules = [];
+    source.rules.forEach((rule) => {
+      const engineRule = BuilderRule.fromDto(rule, ruleInput).toEngineRule();
+      if (!import_engine2.Rule.isEmpty(engineRule)) {
+        pageQueRules.push(engineRule);
+      } else {
+        console.log(this.TAG, "Throws away empty rule. " + rule.type + " " + rule.name);
+      }
+    });
+    return pageQueRules;
+  }
+  compile(source) {
+    const pages = source.pages.map((p) => this.compilePage(p, source.prefix));
+    const rules = this.compileRules(source);
+    const dto = {
+      backgroundColor: source.backgroundColor,
+      baseHeight: source.baseHeight,
+      baseWidth: source.baseWidth,
+      id: source.id,
+      pageSequences: [],
+      pages,
+      predefinedFacts: [],
+      rules
+    };
+    return dto;
+  }
+  compilePage(page, modulePrefix) {
+    const tags = page.tags ?? [];
+    const { nextButton, mainText, id, mainMedia, _type, prefix } = page;
+    const staticElements = [];
+    let initialAudioTasks = [];
+    let initialVideoTaskList = [];
+    const newPage = {
+      background: "white",
+      components: [],
+      staticElements,
+      id,
+      prefix,
+      initialTasks: [],
+      tags: [...tags]
+    };
+    if (page.mainText.audioFile) {
+      const autoPlay = page.mainText.autoplay;
+      const autoPlayDelay = page.mainText.autoplayDelay;
+      const res = this.compileMainTextAudio(page.mainText.audioFile, autoPlay, autoPlayDelay);
+      initialAudioTasks = [...res.initialTasks];
+      newPage.components.push(...res.components);
+    }
+    if (_type === "question") {
+      const variableId = modulePrefix + "_" + page.prefix;
+      const { components, question } = this.compileQuestion(id, page, variableId);
+      newPage.components.push(...components);
+      newPage.staticElements.push(question);
+    }
+    if (_type === "info-page") {
+      const infoText = mainText.text;
+      const nextButtonComponent = this.compileButton(nextButton, {
+        kind: "next-button"
+      });
+      const textStyle = mainMedia ? DefaultTheme.mainText.withMedia.text.css : DefaultTheme.mainText.noMedia.text.css;
+      const infoTextElement = {
+        innerText: infoText,
+        _tag: "p",
+        style: textStyle
+      };
+      newPage.staticElements.push(infoTextElement);
+      newPage.components.push(nextButtonComponent);
+    }
+    if (mainMedia && mainMedia.kind === "main-image") {
+      const mainImageElement = this.compileImage(mainMedia);
+      newPage.staticElements.push(mainImageElement);
+    }
+    if (mainMedia && mainMedia.kind === "main-video") {
+      const videoOutput = this.compileVideo(mainMedia);
+      newPage.videoPlayer = videoOutput.videoPlayer;
+      newPage.components.push(...videoOutput.components);
+      initialVideoTaskList = [...videoOutput.autoPlayTasks];
+    }
+    newPage.initialTasks.push(...initialVideoTaskList);
+    newPage.initialTasks.push(...initialAudioTasks);
+    const clone = JSON.parse(JSON.stringify(newPage));
+    return clone;
+  }
+  compileImage(image) {
+    const img = {
+      _tag: "img",
+      style: this.theme.image.style,
+      url: image.file.downloadUrl
+    };
+    return img;
+  }
+  compileMainTextAudio(audioFile, autoPlay, autoPlayDelay) {
+    const t = this.theme.mainText;
+    const audioId = audioFile.id;
+    const iconUrl = "https://firebasestorage.googleapis.com/v0/b/ispe-backend-dev.appspot.com/o/public-assets%2Fvolume_up-24px.svg?alt=media&token=551bd0a6-a515-4f87-a245-da433f4833f9";
+    const playMainTextAudio = {
+      _tag: "img",
+      url: iconUrl,
+      style: { ...t.withMedia.audio.css }
+    };
+    const task = {
+      audioId,
+      blockAudio: false,
+      blockFormInput: false,
+      blockResponseButton: false,
+      blockVideo: false,
+      kind: "play-audio-task",
+      priority: "replace-all",
+      url: audioFile.downloadUrl
+    };
+    let initialAudioTasks = [];
+    if (autoPlay) {
+      const playAudioTask = { ...task, priority: "follow-queue" };
+      initialAudioTasks = [playAudioTask];
+      if (autoPlayDelay > 0) {
+        const delayTask = {
+          kind: "delay-task",
+          priority: "follow-queue",
+          duration: autoPlayDelay,
+          blockVideo: false,
+          blockAudio: false,
+          blockResponseButton: false,
+          blockFormInput: false
+        };
+        initialAudioTasks = [delayTask, playAudioTask];
+      }
+    }
+    const playBtn = {
+      el: playMainTextAudio,
+      onClick: { kind: "play-audio", task }
+    };
+    return { components: [playBtn], initialTasks: [...initialAudioTasks] };
+  }
+  compileVideo(video) {
+    const t = this.theme.videoPlayer;
+    const mode = video.mode;
+    const components = [];
+    let autoPlayTasks = [];
+    let autoplayVideoTask = false;
+    let autoplayDelayTask = false;
+    const playButtonTask = {
+      kind: "play-video-task",
+      url: video.file.downloadUrl,
+      videoId: video.file.id,
+      blockAudio: false,
+      blockFormInput: false,
+      blockResponseButton: false,
+      loop: mode === "gif-mode",
+      blockVideo: false,
+      priority: "replace-all"
+    };
+    if (video.mode === "autoplay" || video.mode === "gif-mode") {
+      autoplayVideoTask = { ...playButtonTask, priority: "follow-queue" };
+      autoPlayTasks = [autoplayVideoTask];
+      if (video.preDelay > 0) {
+        autoplayDelayTask = {
+          kind: "delay-task",
+          priority: "follow-queue",
+          duration: video.preDelay,
+          blockVideo: false,
+          blockAudio: false,
+          blockResponseButton: false,
+          blockFormInput: false
+        };
+        autoPlayTasks = [autoplayDelayTask, autoplayVideoTask];
+      }
+    }
+    const videoPlayer = {
+      playUrl: video.file.downloadUrl,
+      style: { h: 45, w: 100, x: 0, y: 55 }
+    };
+    const playButton = {
+      el: {
+        _tag: "img",
+        url: t.playButton.iconUrl,
+        style: { ...t.playButton.css, ...t.playButton.cssEnabled }
+      },
+      onClick: { kind: "play-video", task: playButtonTask },
+      whenVideoPlay: { visibility: "hidden" },
+      whenVideoPaused: { visibility: "visible" }
+    };
+    const pauseBtn = {
+      el: {
+        _tag: "img",
+        style: {
+          ...t.pauseButton.css,
+          visibility: "hidden",
+          ...t.pauseButton.cssEnabled
+        },
+        url: t.pauseButton.iconUrl
+      },
+      onClick: { kind: "pause-video" },
+      whenVideoPlay: { visibility: "visible" },
+      whenVideoPaused: { visibility: "hidden" }
+    };
+    if (mode !== "gif-mode") {
+      components.push(playButton);
+      components.push(pauseBtn);
+    }
+    return { videoPlayer, components, autoPlayTasks: [...autoPlayTasks] };
+  }
+  compileQuestion(pageId, page, variableId) {
+    const q = page.defaultQuestion;
+    const text = page.mainText.text;
+    const questionStyle = page.mainMedia ? DefaultTheme.mainText.withMedia.text.css : DefaultTheme.mainText.noMedia.text.css;
+    const question = {
+      _tag: "p",
+      innerText: text,
+      style: questionStyle
+    };
+    const buttons = q.options.map((o) => {
+      const btns = this.compileButton(o, {
+        kind: "response-button",
+        questionId: variableId,
+        questionText: text
+      });
+      return btns;
+    });
+    const rootElements = buttons.map((b) => b.el);
+    ThemeUtils.spaceEvenlyX(rootElements);
+    return { question, components: buttons };
+  }
+  compileButton(buttonDto, options) {
+    const { id, value, label } = buttonDto;
+    const onclickAction = options.kind === "response-button" ? {
+      kind: "submit-fact",
+      fact: {
+        kind: "numeric-fact",
+        label,
+        value,
+        referenceId: options.questionId,
+        referenceLabel: options.questionText
+      }
+    } : { kind: "next-page" };
+    const btnStyles = value === 9 ? DefaultTheme.responseButtons.dontKnow : DefaultTheme.responseButtons.normal;
+    const btn = {
+      _tag: "div",
+      children: [
+        {
+          _tag: "p",
+          innerText: label,
+          style: btnStyles.text1
+        }
+      ],
+      style: { ...btnStyles.btn.css, ...btnStyles.btn.cssEnabled }
+    };
+    if (options.kind === "next-button") {
+      btn.style.x = 50;
+      btn.style.y = 8;
+      btn.style.transform = "translate(-50%, 0%)";
+    }
+    const component = {
+      el: btn,
+      onClick: onclickAction
+    };
+    return component;
+  }
+};
+
+// src/Builder-schema.ts
+var import_engine5 = require("@media-quest/engine");
+
+// src/code-book/codebook.ts
+var fromPage = (page, sumScoreVariables, pagePosition, modulePrefix) => {
+  const variables = [];
+  if (page._type !== "question") {
+    return [];
+  }
+  const options = page.defaultQuestion.options.map((o) => {
+    return { value: o.value, label: o.label };
+  });
+  const varId = modulePrefix + "_" + page.prefix;
+  const includedInSumScores = page.includedInSumScores.filter((a) => true);
+  const variable = {
+    kind: "codebook-question-variable",
+    label: page.mainText.text,
+    pageId: page.id,
+    pagePrefix: page.prefix,
+    options,
+    modulePrefix,
+    pagePosition,
+    varId,
+    includedInSumScores: []
+  };
+  variables.push(variable);
+  return variables;
+};
+var getPageVariablesFromPages = (pages, sumScoreVariables, modulePrefix) => {
+  const variables = [];
+  pages.forEach((page, index) => {
+    const pageVariables = fromPage(page, sumScoreVariables, index, modulePrefix);
+    variables.push(...pageVariables);
+  });
+  return variables;
+};
+var fromSchema = (schema) => {
+  const modulePrefix = schema.prefix;
+  const sumScoreVariables = schema.sumScoreVariables ?? [];
+  const pageVariables = getPageVariablesFromPages(schema.pages, sumScoreVariables, modulePrefix);
+  const vs = schema.predefinedVariables;
+  const predefinedVariables = vs ? [...vs] : [];
+  return { pageVariables, predefinedVariables };
+};
+var _CodeBook = {
+  fromSchema
+};
+var CodeBook = Object.freeze(_CodeBook);
+
+// src/schema-config.ts
+var SchemaConfig = {
+  fromSchema: (schema) => {
+    const variables = schema.predefinedVariables ?? [];
+    return {
+      schemaId: schema.id,
+      schemaName: schema.name,
+      schemaPrefix: schema.prefix,
+      variables
+    };
+  }
+};
+
+// src/sum-score/sum-score-variable.ts
+var import_engine3 = require("@media-quest/engine");
+var SumScoreVariable = class _SumScoreVariable extends BuilderObject {
+  objectType = "builder-sum-score-variable";
+  id;
+  _useAvg = true;
+  _name = "";
+  _description = "";
+  _error = "";
+  _usedIn = [];
+  // private _basedOn = new Map<pageId: Page>()
+  get usedIn() {
+    return [...this._usedIn];
+  }
+  // private _basedOn: Array<{ varId: string }> = [];
+  static create = (data) => {
+    const id = SumScoreVariableID.create();
+    return new _SumScoreVariable({ id, ...data });
+  };
+  get hasErrors() {
+    return this._error.length !== 0;
+  }
+  static fromDto = (dto) => {
+    return new _SumScoreVariable(dto);
+  };
+  constructor(dto) {
+    super(dto);
+    this.id = dto.id;
+    this._name = dto.name;
+    this._useAvg = dto.useAvg;
+    this._description = dto.description;
+  }
+  toJson() {
+    const dto = {
+      description: this.description,
+      id: this.id,
+      name: this.name,
+      useAvg: this.useAvg
+    };
+    return dto;
+  }
+  clone() {
+    const id = SumScoreVariableID.create();
+    const dto = this.toJson();
+    return { ...dto, id };
+  }
+  /** @internal*/
+  _update(data) {
+    const d = data ?? {};
+    if (import_engine3.DUtil.isString(d.name)) {
+      this._name = d.name;
+    }
+    if (import_engine3.DUtil.isString(d.description)) {
+      this._description = d.description;
+    }
+    if (import_engine3.DUtil.isBool(d.useAvg)) {
+      this._useAvg = d.useAvg;
+    }
+  }
+  /**
+   * @internal - used by sum-score-variable-collection.
+   */
+  _setError(error) {
+    this._error = error;
+  }
+  /** @internal - used by sum-score-variable-collection */
+  _setUsedInPages(pages) {
+    this._usedIn = [...pages];
+  }
+  get name() {
+    return this._name;
+  }
+  get description() {
+    return this._description;
+  }
+  get useAvg() {
+    return this._useAvg;
+  }
+};
+
+// src/sum-score/sum-score-variable-collection.ts
+var SumScoreVariableCollection = class _SumScoreVariableCollection {
+  _all = [];
+  [Symbol.iterator]() {
+    const list = [...this._all];
+    return list[Symbol.iterator]();
+  }
+  asArray() {
+    return [...this._all];
+  }
+  static create = (variables) => {
+    return new _SumScoreVariableCollection(variables);
+  };
+  constructor(sumScoreVariables) {
+    const all = Array.isArray(sumScoreVariables) ? sumScoreVariables : [];
+    this._all = all.map((dto) => SumScoreVariable.fromDto(dto));
+    this.checkForErrors();
+  }
+  init(variables) {
+    this._all = variables.map((variable) => SumScoreVariable.fromDto(variable));
+    this.checkForErrors();
+  }
+  addNew(options) {
+    const newVariable = SumScoreVariable.create({ ...options });
+    this._all.push(newVariable);
+    this.checkForErrors();
+    return newVariable;
+  }
+  get size() {
+    return this._all.length;
+  }
+  get errorsCount() {
+    return this._all.filter((variable) => variable.hasErrors).length;
+  }
+  toJson() {
+    return this._all.map((item) => item.toJson());
+  }
+  /**
+   *
+   */
+  _deleteVariable(id) {
+    const initialSize = this._all.length;
+    this._all = this._all.filter((variable) => variable.id !== id);
+    this.checkForErrors();
+    return initialSize === this.size + 1;
+  }
+  /**
+   * @internal
+   */
+  _updateOne(id, updates) {
+    const variable = this._all.find((variable2) => variable2.id === id);
+    if (variable) {
+      variable._update(updates);
+      this.checkForErrors();
+      return true;
+    } else {
+      return false;
+    }
+  }
+  /** @internal */
+  _getVariableById(id) {
+    return this._all.find((variable) => variable.id === id);
+  }
+  checkForErrors() {
+    const nameMap = /* @__PURE__ */ new Map();
+    this._all.forEach((v) => {
+      const array = nameMap.get(v.name) ?? [];
+      array.push(v);
+      nameMap.set(v.name, array);
+    });
+    nameMap.forEach((sameNameArray) => {
+      sameNameArray.forEach((sameNameItem) => {
+        if (sameNameArray.length > 1) {
+          sameNameItem._setError("Duplicate name");
+        } else {
+          sameNameItem._setError("");
+        }
+      });
+    });
+  }
+};
+
+// src/tag/BuilderTag.ts
+var BuilderTag = class _BuilderTag extends BuilderObject {
+  objectType = "builder-tag";
+  id;
+  tagText = "";
+  tagDescription = "";
+  static MAX_LENGTH = 20;
+  static MIN_LENGTH = 1;
+  static create = (tag, description = "") => {
+    const id = TagID.create();
+    const dto = {
+      id,
+      tag,
+      description
+    };
+    return new _BuilderTag(dto);
+  };
+  static fromDto = (dto) => {
+    return new _BuilderTag(dto);
+  };
+  constructor(dto) {
+    const id = TagID.validateOrCreate(dto.id);
+    const withId = { ...dto, id };
+    super(withId);
+    this.id = id;
+    this.tagText = dto.tag ?? "";
+    this.tagDescription = dto.description ?? "";
+  }
+  clone() {
+    return this.toJson();
+  }
+  toJson() {
+    return { tag: this.tagText, description: this.tagDescription, id: this.id };
+  }
+};
+
+// src/tag/Tag-Collection.ts
+var TagCollection = class _TagCollection {
+  _tags = /* @__PURE__ */ new Set();
+  static create = () => {
+    return new _TagCollection([]);
+  };
+  [Symbol.iterator]() {
+    const list = [...this._tags];
+    return list[Symbol.iterator]();
+  }
+  constructor(initialTags) {
+    initialTags.forEach((tag) => {
+      this._tags.add(tag);
+    });
+  }
+  init(tags) {
+    const dtoList = Array.isArray(tags) ? tags : [];
+    const all = dtoList.map(BuilderTag.fromDto);
+    all.forEach((tag) => {
+      this._tags.add(tag);
+    });
+  }
+  add(tag) {
+    this._tags.add(tag);
+  }
+  /**
+   * Delete this tag from collection;
+   * @param tag
+   */
+  delete(tag) {
+    this._tags.delete(tag);
+  }
+  toJson() {
+    const list = [...this._tags];
+    const dtoList = list.map((t) => t.toJson());
+    return dtoList;
+  }
+  deleteAll(tags) {
+    const l = tags[Symbol.iterator]();
+    const asList = [...tags];
+    asList.forEach((t) => {
+      this.delete(t);
+    });
+  }
+};
+
+// src/page/Builder-page-collection.ts
+var import_engine4 = require("@media-quest/engine");
+var U = import_engine4.DUtil;
+var BuilderPageCollection = class _BuilderPageCollection {
+  _all = [];
+  static create(pages) {
+    const page = new _BuilderPageCollection(pages);
+    page._all = pages.map((p) => BuilderPage.fromJson(p));
+    return page;
+  }
+  constructor(initialPages) {
+  }
+  /** @internal - used by Schema*/
+  _init(pages) {
+    this._all = pages.map(BuilderPage.fromJson);
+  }
+  add(type, atIndex = -1) {
+    const pagePrefix = PagePrefix.create();
+    const newPage = BuilderPage.create(type, pagePrefix.value);
+    if (atIndex >= 0 && atIndex < this._all.length) {
+      this._all.splice(atIndex, 0, newPage);
+    } else {
+      this._all.push(newPage);
+    }
+    return newPage;
+  }
+  deleteById(id) {
+    const index = this._all.findIndex((p) => p.id === id);
+    if (index !== -1) {
+      this._all.splice(index, 1);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  getPageById(pageId) {
+    const maybePage = this._all.find((p) => p.id === pageId);
+    return maybePage ?? false;
+  }
+  get size() {
+    return this._all.length;
+  }
+  get pages() {
+    return [...this._all];
+  }
+  toJson() {
+    return this._all.map((p) => p.toJson());
+  }
+  [Symbol.iterator]() {
+    const list = [...this._all];
+    return list[Symbol.iterator]();
+  }
+  movePage(page, toIndex) {
+    const index = this._all.indexOf(page);
+    if (index < 0) {
+      return false;
+    }
+    const isValidIndex = U.isInRange(0, this._all.length - 1);
+    if (!isValidIndex(toIndex)) {
+      return false;
+    }
+    this._all.splice(index, 1);
+    this._all.splice(toIndex, 0, page);
+    return true;
+  }
+  insertPage(page, atIndex) {
+    const isValidIndex = U.isInRange(0, this._all.length - 1);
+    if (!isValidIndex(atIndex)) {
+      return false;
+    }
+    const exists = !!this._all.find((p) => p.id === page.id);
+    if (exists) {
+      return false;
+    }
+    this._all.splice(atIndex, 0, page);
+    return true;
+  }
+  addSumScoreVariable(sumScoreVariable, pageId, weight) {
+    const maybePage = this.getPageById(pageId);
+    if (!maybePage)
+      return false;
+    maybePage.sumScoreVariableSet(sumScoreVariable, weight);
+    return true;
+  }
+  updateRelationShips(context) {
+    const { sumScoreVariables } = context;
+    this._all.forEach((p) => {
+      p.updateRelationShips(context.sumScoreVariables);
+    });
+    sumScoreVariables.forEach((v) => {
+      const usedInPages = this._all.filter((p) => p._isIncludedInSumScore(v.id));
+      v._setUsedInPages(usedInPages);
+    });
+  }
+  sumScoreVariableDelete(sumScoreVariableID) {
+    this._all.forEach((p) => {
+      p.sumScoreVariableDelete(sumScoreVariableID);
+    });
+  }
+  sumScoreVariableDeleteFromPage(pageId, sumScoreVariableId) {
+    const maybePage = this.getPageById(pageId);
+    if (!maybePage)
+      return false;
+    maybePage.sumScoreVariableDelete(sumScoreVariableId);
+    return true;
+  }
+};
+
+// src/Builder-schema.ts
+var BuilderSchema = class _BuilderSchema {
+  constructor(id, name, prefix) {
+    this.id = id;
+    this.name = name;
+    this.prefix = prefix;
+    this._sumScoreCollection = SumScoreVariableCollection.create([]);
+    this._pageCollection = BuilderPageCollection.create([]);
+  }
+  prefix;
+  baseHeight = 1300;
+  baseWidth = 1024;
+  backgroundColor = "#000000";
+  _pageCollection;
+  mainImage = false;
+  predefinedVariables = [];
+  _rules = [];
+  _sumScoreCollection;
+  get rules() {
+    return [...this._rules];
+  }
+  get pages() {
+    return [...this._pageCollection];
+  }
+  get sumScoreVariables() {
+    return [...this._sumScoreCollection];
+  }
+  // get prefix(): SchemaPrefixValue {
+  //   return this._prefix.value;
+  // }
+  _tagCollection = TagCollection.create();
+  get tags() {
+    return [...this._tagCollection];
+  }
+  static create(id, name, prefix) {
+    const schemaPrefix = SchemaPrefix.castOrCreateRandom(prefix);
+    return new _BuilderSchema(id, name, schemaPrefix);
+  }
+  static fromJson(dto) {
+    const schemaPrefix = SchemaPrefix.castOrCreateRandom(dto.prefix);
+    const schema = new _BuilderSchema(dto.id, dto.name, schemaPrefix);
+    const sumScoreVariables = dto.sumScoreVariables ? [...dto.sumScoreVariables] : [];
+    const pagesDto = Array.isArray(dto.pages) ? dto.pages : [];
+    schema._tagCollection.init(dto.tags);
+    schema._sumScoreCollection.init(sumScoreVariables);
+    schema.backgroundColor = dto.backgroundColor;
+    schema.baseHeight = dto.baseHeight;
+    schema.baseWidth = dto.baseWidth;
+    schema._pageCollection._init(pagesDto);
+    schema.predefinedVariables = dto.predefinedVariables ?? [];
+    schema.backgroundColor = dto.backgroundColor;
+    schema.mainImage = dto.mainImage ?? false;
+    const rulesDto = dto.rules ?? [];
+    const ruleInput = schema.getRuleInput();
+    schema._rules = rulesDto.map((r) => BuilderRule.fromDto(r, ruleInput));
+    schema.updateSumScoreRelations();
+    return schema;
+  }
+  toJson() {
+    const pages = this._pageCollection.toJson();
+    const tags = this._tagCollection.toJson();
+    const rules = this._rules.map((rule) => rule.toJson());
+    const sumScoreVariables = this._sumScoreCollection.toJson();
+    const dto = {
+      backgroundColor: this.backgroundColor,
+      baseHeight: this.baseHeight,
+      baseWidth: this.baseWidth,
+      id: this.id,
+      name: this.name,
+      pages,
+      rules,
+      tags,
+      predefinedVariables: this.predefinedVariables,
+      sumScoreVariables,
+      mainImage: this.mainImage,
+      prefix: this.prefix.value
+    };
+    return dto;
+  }
+  addPage(type, atIndex = -1) {
+    return this._pageCollection.add(type, atIndex);
+  }
+  sumScoreVariableCreate(options) {
+    const variable = this._sumScoreCollection.addNew(options);
+    return variable;
+  }
+  sumScoreVariableAddToPage(sumScoreVariable, page, weight) {
+    const added = this._pageCollection.addSumScoreVariable(sumScoreVariable, page.id, weight);
+    this.updateSumScoreRelations();
+    return added;
+  }
+  updateSumScoreRelations() {
+    const sumScoreVariables = this._sumScoreCollection.asArray();
+    this._pageCollection.updateRelationShips({ sumScoreVariables });
+  }
+  sumScoreVariableUpdate(id, data) {
+    const didUpdate = this._sumScoreCollection._updateOne(id, data);
+    this.updateSumScoreRelations();
+    return didUpdate;
+  }
+  sumScoreVariableDeleteFromPage(pageId, sumScoreVariableId) {
+    this._pageCollection.sumScoreVariableDeleteFromPage(pageId, sumScoreVariableId);
+    this.updateSumScoreRelations();
+  }
+  insertPage(page, atIndex) {
+    return this.insertPageAtIndex(page, atIndex);
+  }
+  insertPageAtIndex(page, atIndex) {
+    return this._pageCollection.insertPage(page, atIndex);
+  }
+  addRule() {
+    const input = this.getRuleInput();
+    const count = this._rules.length + 1;
+    const name = "Rule-number: " + count;
+    const rule = BuilderRule.fromDto(
+      {
+        conditions: [],
+        type: "all",
+        name,
+        excludeTags: [],
+        jumpToPage: false,
+        excludePages: []
+      },
+      input
+    );
+    this._rules.push(rule);
+    return rule;
+  }
+  deleteRule(rule) {
+    this._rules = this._rules.filter((r) => r !== rule);
+  }
+  movePage(page, toIndex) {
+    return this._pageCollection.movePage(page, toIndex);
+  }
+  deletePage(page) {
+    return this._pageCollection.deleteById(page.id);
+  }
+  reevaluateRules() {
+    console.log("Reevaluationg rulesInput");
+    const input = this.getRuleInput();
+    const rulesDto = this._rules.map((r) => r.toJson());
+    this._rules = rulesDto.map((dto) => BuilderRule.fromDto(dto, input));
+  }
+  getRuleInput() {
+    const qVars = [];
+    const cVars = [];
+    const pageIdActions = [];
+    const tagActions = this.tags.map((t) => {
+      const tag = t.tagText;
+      const pageCount = this._pageCollection.pages.reduce((count, curr) => {
+        return curr.tags.includes(tag) ? count + 1 : count;
+      }, 0);
+      const excludeByTagDto = {
+        kind: "exclude-by-tag",
+        pageCount,
+        tag,
+        description: t.tagDescription
+      };
+      return excludeByTagDto;
+    });
+    const jumpActions = [];
+    this._pageCollection.pages.forEach((page, index) => {
+      const pageVariables = page.getQuestionVariables(this.prefix, index);
+      qVars.push(...pageVariables);
+      const mainText = page.mainText.text;
+      const pagePrefix = page.prefix;
+      const jumpAction = {
+        kind: "jump-to-page",
+        pageId: page.id,
+        pagePrefix,
+        pageNumber: index,
+        mainText: page.mainText.text
+      };
+      const excludePageAction = {
+        kind: "exclude-by-pageId",
+        pageId: page.id,
+        pagePrefix,
+        pageNumber: index,
+        mainText
+      };
+      jumpActions.push(jumpAction);
+      pageIdActions.push(excludePageAction);
+    });
+    const ruleInput = new RuleInput(qVars, cVars, pageIdActions, tagActions, jumpActions);
+    return ruleInput;
+  }
+  deleteTags(tags) {
+    this._tagCollection.deleteAll(tags);
+  }
+  addTag(builderTag) {
+    this._tagCollection.add(builderTag);
+  }
+  compile(options = { blockAutoplayQuestion: false, blockAutoplayVideo: false }) {
+    const builderSchema = _BuilderSchema.fromJson(this.toJson());
+    builderSchema._pageCollection.pages.forEach((p) => {
+      if (options.blockAutoplayQuestion) {
+        p.mainText.autoplay = false;
+      }
+      if (options.blockAutoplayVideo && p.mainMedia) {
+        if (p.mainMedia.kind === "main-video") {
+          p.mainMedia.mode = "optional";
+        }
+      }
+    });
+    const moduleDto = builderSchema.toJson();
+    const imp = new DefaultThemeCompiler();
+    const codebook = CodeBook.fromSchema(moduleDto);
+    const schema = imp.compile(moduleDto);
+    const schemaConfig = SchemaConfig.fromSchema(moduleDto);
+    const output = { codebook, schema, schemaConfig };
+    return output;
+  }
+  sumScoreVariableDelete(id) {
+    const didDelete = this._sumScoreCollection._deleteVariable(id);
+    const sumScoreVariables = [...this._sumScoreCollection];
+    this._pageCollection.updateRelationShips({ sumScoreVariables });
+    this._pageCollection.sumScoreVariableDelete(id);
+    return didDelete;
+  }
+};
+
+// src/Builder-text.ts
+var BuilderText = class _BuilderText extends BuilderObject {
+  objectType = "builder-text";
+  id;
+  text = "";
+  name = "";
+  translateRequired = false;
+  // audio: {id: B}
+  constructor(dto) {
+    super(dto);
+    this.id = dto.id;
+    this.translateRequired = dto.translationRequired;
+    this.name = dto.name;
+    this.text = dto.text;
+  }
+  static create(name) {
+    const id = TextID.create();
+    const dto = {
+      id,
+      name,
+      text: "",
+      translationRequired: false
+    };
+    const instance = new _BuilderText(dto);
+    return instance;
+  }
+  static fromJson(dto) {
+    const instance = new _BuilderText(dto);
+    return instance;
+  }
+  clone() {
+    const dto = this.toJson();
+    const withNewId = { ...dto, id: TextID.create() };
+    return withNewId;
+  }
+  toJson() {
+    const dto = {
+      id: this.id,
+      name: this.name,
+      text: this.text,
+      translationRequired: this.translateRequired
+    };
+    return dto;
+  }
+};
+
+// src/sum-score/sum-score.ts
+var ALLOWED_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+var isAllowedValue = (num) => {
+  const notNegative = num >= 0;
+  const lessThanNine = num < 9;
+  return notNegative && lessThanNine;
+};
+var calculateAll = (schemaDto, answers) => {
+  const vs = schemaDto.sumScoreVariables ?? [];
+  const basedOnMap = /* @__PURE__ */ new Map();
+  const codeBook = CodeBook.fromSchema(schemaDto);
+  const pages = schemaDto.pages;
+  pages.forEach((page) => {
+    page.includedInSumScores.forEach((includedInScores) => {
+      const variableId = includedInScores.sumScoreVariableId;
+      const weight = includedInScores.weight;
+      const p = codeBook.pageVariables.find((v) => v.pageId === page.id);
+      if (p) {
+        const currentBasedOnArray = basedOnMap.get(variableId) ?? [];
+        currentBasedOnArray.push({ varId: p.varId, weight });
+        basedOnMap.set(variableId, currentBasedOnArray);
+      } else {
+        console.error("INVALID DATA in calculate all sum-scores.");
+      }
+    });
+  });
+  const results = vs.map((v) => {
+    const basedOn = basedOnMap.get(v.id) ?? [];
+    return calculate(v, basedOn, answers);
+  });
+  return results;
+};
+var calculate = (sumScoreVariable, basedOnVariables, answers) => {
+  const legalValues = [...ALLOWED_VALUES];
+  let includedAnswerCount = 0;
+  let skippedBy9Count = 0;
+  let missingAnswerCount = 0;
+  let sumScore = 0;
+  const errorMessages = [];
+  const basedOn = [];
+  const useAvg = sumScoreVariable.useAvg;
+  const basedOnEntries = basedOnVariables.map((scv) => {
+    const maybeAnswer = answers.find((v) => v.varId === scv.varId);
+    let result2 = { kind: "missing", varId: scv.varId };
+    if (!maybeAnswer) {
+      return result2;
+    }
+    const value = maybeAnswer.value;
+    const varLabel = maybeAnswer.varLabel;
+    const weight = scv.weight ?? 1;
+    const varId = maybeAnswer.varId;
+    result2 = {
+      kind: "has-value",
+      varId,
+      weight,
+      value,
+      varLabel
+    };
+    return result2;
+  });
+  basedOnEntries.forEach((entry) => {
+    if (entry.kind === "missing") {
+      missingAnswerCount++;
+    }
+    if (entry.kind === "has-value") {
+      const { varId, varLabel, weight, value } = { ...entry };
+      const isAllowed = isAllowedValue(value);
+      if (isAllowed) {
+        basedOn.push({ varId, weight, value, varLabel });
+        sumScore += entry.value * entry.weight;
+        includedAnswerCount++;
+      }
+      if (value === 9) {
+        skippedBy9Count++;
+        basedOn.push({ varId, weight, value, varLabel });
+      }
+    }
+    if (entry.kind === "invalid-variable") {
+      errorMessages.push(entry.message);
+    }
+  });
+  const avg = sumScore / includedAnswerCount;
+  const result = {
+    avg,
+    useAvg,
+    includedAnswerCount,
+    skippedBy9Count,
+    sumScore,
+    basedOn,
+    missingAnswerCount,
+    errorMessages
+  };
+  return result;
+};
+var createVariable = () => {
+  const id = SumScoreVariableID.create();
+  return {
+    id,
+    name: "",
+    useAvg: true,
+    description: ""
+    // basedOn: [],
+  };
+};
+var SumScore = {
+  ALLOWED_VALUES,
+  calculate,
+  calculateAll,
+  isAllowedValue,
+  createVariable
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuilderCondition,
+  BuilderConditionGroup,
+  BuilderMainText,
+  BuilderOperator,
+  BuilderOption,
+  BuilderPage,
+  BuilderQuestion,
+  BuilderRule,
+  BuilderSchema,
+  BuilderTag,
+  BuilderText,
+  CodeBook,
+  ExcludeByPageIdSelectItem,
+  ExcludeByTagSelectItem,
+  JumpToActionManager,
+  JumpToPageSelectItem,
+  MultiSelectItem,
+  OperatorSelectItem,
+  OptionID,
+  PageActionManager,
+  PageID,
+  PagePrefix,
+  QuestionID,
+  RuleCustomVariable,
+  RuleInput,
+  RuleOptionSelectItem,
+  RuleQuestionVariable,
+  RuleVariableOption,
+  RuleVariableSelectItem,
+  SchemaConfig,
+  SchemaID,
+  SchemaPrefix,
+  SingleSelectItem,
+  SumScore,
+  SumScoreVariable,
+  SumScoreVariableID,
+  TagActionManager,
+  TagCollection,
+  TagID,
+  TextID,
+  VarID,
+  _CodeBook,
+  createTypedIdSingleton
+});
+//# sourceMappingURL=public-api.js.map