service-flow-designer 0.0.1-beta.1 → 0.0.1-beta.2

package/dist/lib/node_modules/.pnpm/quill@2.0.2/node_modules/quill/core/quill.js

@@ -0,0 +1,600 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const parchment = require("../../../../parchment@3.0.0/node_modules/parchment/dist/parchment.js");
+const Delta = require("../../../../quill-delta@5.1.0/node_modules/quill-delta/dist/Delta.js");
+const editor = require("./editor.js");
+const emitter = require("./emitter.js");
+const instances = require("./instances.js");
+const logger = require("./logger.js");
+const module$1 = require("./module.js");
+const selection = require("./selection.js");
+const composition = require("./composition.js");
+const theme = require("./theme.js");
+const scrollRectIntoView = require("./utils/scrollRectIntoView.js");
+const createRegistryWithFormats = require("./utils/createRegistryWithFormats.js");
+const merge = require("../../../../lodash-es@4.17.21/node_modules/lodash-es/merge.js");
+const debug = logger("quill");
+const globalRegistry = new parchment.Registry();
+parchment.ParentBlot.uiClass = "ql-ui";
+const _Quill = class _Quill {
+  static debug(limit) {
+    if (limit === true) {
+      limit = "log";
+    }
+    logger.level(limit);
+  }
+  static find(node) {
+    let bubble = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    return instances.get(node) || globalRegistry.find(node, bubble);
+  }
+  static import(name) {
+    if (this.imports[name] == null) {
+      debug.error(`Cannot import ${name}. Are you sure it was registered?`);
+    }
+    return this.imports[name];
+  }
+  static register() {
+    if (typeof (arguments.length <= 0 ? void 0 : arguments[0]) !== "string") {
+      const target = arguments.length <= 0 ? void 0 : arguments[0];
+      const overwrite = !!(arguments.length <= 1 ? void 0 : arguments[1]);
+      const name = "attrName" in target ? target.attrName : target.blotName;
+      if (typeof name === "string") {
+        this.register(`formats/${name}`, target, overwrite);
+      } else {
+        Object.keys(target).forEach((key) => {
+          this.register(key, target[key], overwrite);
+        });
+      }
+    } else {
+      const path = arguments.length <= 0 ? void 0 : arguments[0];
+      const target = arguments.length <= 1 ? void 0 : arguments[1];
+      const overwrite = !!(arguments.length <= 2 ? void 0 : arguments[2]);
+      if (this.imports[path] != null && !overwrite) {
+        debug.warn(`Overwriting ${path} with`, target);
+      }
+      this.imports[path] = target;
+      if ((path.startsWith("blots/") || path.startsWith("formats/")) && target && typeof target !== "boolean" && target.blotName !== "abstract") {
+        globalRegistry.register(target);
+      }
+      if (typeof target.register === "function") {
+        target.register(globalRegistry);
+      }
+    }
+  }
+  constructor(container) {
+    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    this.options = expandConfig(container, options);
+    this.container = this.options.container;
+    if (this.container == null) {
+      debug.error("Invalid Quill container", container);
+      return;
+    }
+    if (this.options.debug) {
+      _Quill.debug(this.options.debug);
+    }
+    const html = this.container.innerHTML.trim();
+    this.container.classList.add("ql-container");
+    this.container.innerHTML = "";
+    instances.set(this.container, this);
+    this.root = this.addContainer("ql-editor");
+    this.root.classList.add("ql-blank");
+    this.emitter = new emitter();
+    const scrollBlotName = parchment.ScrollBlot.blotName;
+    const ScrollBlot = this.options.registry.query(scrollBlotName);
+    if (!ScrollBlot || !("blotName" in ScrollBlot)) {
+      throw new Error(`Cannot initialize Quill without "${scrollBlotName}" blot`);
+    }
+    this.scroll = new ScrollBlot(this.options.registry, this.root, {
+      emitter: this.emitter
+    });
+    this.editor = new editor(this.scroll);
+    this.selection = new selection.default(this.scroll, this.emitter);
+    this.composition = new composition(this.scroll, this.emitter);
+    this.theme = new this.options.theme(this, this.options);
+    this.keyboard = this.theme.addModule("keyboard");
+    this.clipboard = this.theme.addModule("clipboard");
+    this.history = this.theme.addModule("history");
+    this.uploader = this.theme.addModule("uploader");
+    this.theme.addModule("input");
+    this.theme.addModule("uiNode");
+    this.theme.init();
+    this.emitter.on(emitter.events.EDITOR_CHANGE, (type) => {
+      if (type === emitter.events.TEXT_CHANGE) {
+        this.root.classList.toggle("ql-blank", this.editor.isBlank());
+      }
+    });
+    this.emitter.on(emitter.events.SCROLL_UPDATE, (source, mutations) => {
+      const oldRange = this.selection.lastRange;
+      const [newRange] = this.selection.getRange();
+      const selectionInfo = oldRange && newRange ? {
+        oldRange,
+        newRange
+      } : void 0;
+      modify.call(this, () => this.editor.update(null, mutations, selectionInfo), source);
+    });
+    this.emitter.on(emitter.events.SCROLL_EMBED_UPDATE, (blot, delta) => {
+      const oldRange = this.selection.lastRange;
+      const [newRange] = this.selection.getRange();
+      const selectionInfo = oldRange && newRange ? {
+        oldRange,
+        newRange
+      } : void 0;
+      modify.call(this, () => {
+        const change = new Delta.default().retain(blot.offset(this)).retain({
+          [blot.statics.blotName]: delta
+        });
+        return this.editor.update(change, [], selectionInfo);
+      }, _Quill.sources.USER);
+    });
+    if (html) {
+      const contents = this.clipboard.convert({
+        html: `${html}<p><br></p>`,
+        text: "\n"
+      });
+      this.setContents(contents);
+    }
+    this.history.clear();
+    if (this.options.placeholder) {
+      this.root.setAttribute("data-placeholder", this.options.placeholder);
+    }
+    if (this.options.readOnly) {
+      this.disable();
+    }
+    this.allowReadOnlyEdits = false;
+  }
+  addContainer(container) {
+    let refNode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+    if (typeof container === "string") {
+      const className = container;
+      container = document.createElement("div");
+      container.classList.add(className);
+    }
+    this.container.insertBefore(container, refNode);
+    return container;
+  }
+  blur() {
+    this.selection.setRange(null);
+  }
+  deleteText(index, length, source) {
+    [index, length, , source] = overload(index, length, source);
+    return modify.call(this, () => {
+      return this.editor.deleteText(index, length);
+    }, source, index, -1 * length);
+  }
+  disable() {
+    this.enable(false);
+  }
+  editReadOnly(modifier) {
+    this.allowReadOnlyEdits = true;
+    const value = modifier();
+    this.allowReadOnlyEdits = false;
+    return value;
+  }
+  enable() {
+    let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+    this.scroll.enable(enabled);
+    this.container.classList.toggle("ql-disabled", !enabled);
+  }
+  focus() {
+    let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    this.selection.focus();
+    if (!options.preventScroll) {
+      this.scrollSelectionIntoView();
+    }
+  }
+  format(name, value) {
+    let source = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : emitter.sources.API;
+    return modify.call(this, () => {
+      const range = this.getSelection(true);
+      let change = new Delta.default();
+      if (range == null) return change;
+      if (this.scroll.query(name, parchment.Scope.BLOCK)) {
+        change = this.editor.formatLine(range.index, range.length, {
+          [name]: value
+        });
+      } else if (range.length === 0) {
+        this.selection.format(name, value);
+        return change;
+      } else {
+        change = this.editor.formatText(range.index, range.length, {
+          [name]: value
+        });
+      }
+      this.setSelection(range, emitter.sources.SILENT);
+      return change;
+    }, source);
+  }
+  formatLine(index, length, name, value, source) {
+    let formats;
+    [index, length, formats, source] = overload(
+      index,
+      length,
+      // @ts-expect-error
+      name,
+      value,
+      source
+    );
+    return modify.call(this, () => {
+      return this.editor.formatLine(index, length, formats);
+    }, source, index, 0);
+  }
+  formatText(index, length, name, value, source) {
+    let formats;
+    [index, length, formats, source] = overload(
+      // @ts-expect-error
+      index,
+      length,
+      name,
+      value,
+      source
+    );
+    return modify.call(this, () => {
+      return this.editor.formatText(index, length, formats);
+    }, source, index, 0);
+  }
+  getBounds(index) {
+    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+    let bounds = null;
+    if (typeof index === "number") {
+      bounds = this.selection.getBounds(index, length);
+    } else {
+      bounds = this.selection.getBounds(index.index, index.length);
+    }
+    if (!bounds) return null;
+    const containerBounds = this.container.getBoundingClientRect();
+    return {
+      bottom: bounds.bottom - containerBounds.top,
+      height: bounds.height,
+      left: bounds.left - containerBounds.left,
+      right: bounds.right - containerBounds.left,
+      top: bounds.top - containerBounds.top,
+      width: bounds.width
+    };
+  }
+  getContents() {
+    let index = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.getLength() - index;
+    [index, length] = overload(index, length);
+    return this.editor.getContents(index, length);
+  }
+  getFormat() {
+    let index = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.getSelection(true);
+    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+    if (typeof index === "number") {
+      return this.editor.getFormat(index, length);
+    }
+    return this.editor.getFormat(index.index, index.length);
+  }
+  getIndex(blot) {
+    return blot.offset(this.scroll);
+  }
+  getLength() {
+    return this.scroll.length();
+  }
+  getLeaf(index) {
+    return this.scroll.leaf(index);
+  }
+  getLine(index) {
+    return this.scroll.line(index);
+  }
+  getLines() {
+    let index = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Number.MAX_VALUE;
+    if (typeof index !== "number") {
+      return this.scroll.lines(index.index, index.length);
+    }
+    return this.scroll.lines(index, length);
+  }
+  getModule(name) {
+    return this.theme.modules[name];
+  }
+  getSelection() {
+    let focus = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+    if (focus) this.focus();
+    this.update();
+    return this.selection.getRange()[0];
+  }
+  getSemanticHTML() {
+    let index = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+    let length = arguments.length > 1 ? arguments[1] : void 0;
+    if (typeof index === "number") {
+      length = length ?? this.getLength() - index;
+    }
+    [index, length] = overload(index, length);
+    return this.editor.getHTML(index, length);
+  }
+  getText() {
+    let index = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+    let length = arguments.length > 1 ? arguments[1] : void 0;
+    if (typeof index === "number") {
+      length = length ?? this.getLength() - index;
+    }
+    [index, length] = overload(index, length);
+    return this.editor.getText(index, length);
+  }
+  hasFocus() {
+    return this.selection.hasFocus();
+  }
+  insertEmbed(index, embed, value) {
+    let source = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : _Quill.sources.API;
+    return modify.call(this, () => {
+      return this.editor.insertEmbed(index, embed, value);
+    }, source, index);
+  }
+  insertText(index, text, name, value, source) {
+    let formats;
+    [index, , formats, source] = overload(index, 0, name, value, source);
+    return modify.call(this, () => {
+      return this.editor.insertText(index, text, formats);
+    }, source, index, text.length);
+  }
+  isEnabled() {
+    return this.scroll.isEnabled();
+  }
+  off() {
+    return this.emitter.off(...arguments);
+  }
+  on() {
+    return this.emitter.on(...arguments);
+  }
+  once() {
+    return this.emitter.once(...arguments);
+  }
+  removeFormat(index, length, source) {
+    [index, length, , source] = overload(index, length, source);
+    return modify.call(this, () => {
+      return this.editor.removeFormat(index, length);
+    }, source, index);
+  }
+  scrollRectIntoView(rect) {
+    scrollRectIntoView(this.root, rect);
+  }
+  /**
+   * @deprecated Use Quill#scrollSelectionIntoView() instead.
+   */
+  scrollIntoView() {
+    console.warn("Quill#scrollIntoView() has been deprecated and will be removed in the near future. Please use Quill#scrollSelectionIntoView() instead.");
+    this.scrollSelectionIntoView();
+  }
+  /**
+   * Scroll the current selection into the visible area.
+   * If the selection is already visible, no scrolling will occur.
+   */
+  scrollSelectionIntoView() {
+    const range = this.selection.lastRange;
+    const bounds = range && this.selection.getBounds(range.index, range.length);
+    if (bounds) {
+      this.scrollRectIntoView(bounds);
+    }
+  }
+  setContents(delta) {
+    let source = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : emitter.sources.API;
+    return modify.call(this, () => {
+      delta = new Delta.default(delta);
+      const length = this.getLength();
+      const delete1 = this.editor.deleteText(0, length);
+      const applied = this.editor.insertContents(0, delta);
+      const delete2 = this.editor.deleteText(this.getLength() - 1, 1);
+      return delete1.compose(applied).compose(delete2);
+    }, source);
+  }
+  setSelection(index, length, source) {
+    if (index == null) {
+      this.selection.setRange(null, length || _Quill.sources.API);
+    } else {
+      [index, length, , source] = overload(index, length, source);
+      this.selection.setRange(new selection.Range(Math.max(0, index), length), source);
+      if (source !== emitter.sources.SILENT) {
+        this.scrollSelectionIntoView();
+      }
+    }
+  }
+  setText(text) {
+    let source = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : emitter.sources.API;
+    const delta = new Delta.default().insert(text);
+    return this.setContents(delta, source);
+  }
+  update() {
+    let source = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : emitter.sources.USER;
+    const change = this.scroll.update(source);
+    this.selection.update(source);
+    return change;
+  }
+  updateContents(delta) {
+    let source = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : emitter.sources.API;
+    return modify.call(this, () => {
+      delta = new Delta.default(delta);
+      return this.editor.applyDelta(delta);
+    }, source, true);
+  }
+};
+__publicField(_Quill, "DEFAULTS", {
+  bounds: null,
+  modules: {
+    clipboard: true,
+    keyboard: true,
+    history: true,
+    uploader: true
+  },
+  placeholder: "",
+  readOnly: false,
+  registry: globalRegistry,
+  theme: "default"
+});
+__publicField(_Quill, "events", emitter.events);
+__publicField(_Quill, "sources", emitter.sources);
+__publicField(_Quill, "version", "2.0.2");
+__publicField(_Quill, "imports", {
+  delta: Delta.default,
+  parchment,
+  "core/module": module$1,
+  "core/theme": theme
+});
+let Quill = _Quill;
+function resolveSelector(selector) {
+  return typeof selector === "string" ? document.querySelector(selector) : selector;
+}
+function expandModuleConfig(config) {
+  return Object.entries(config ?? {}).reduce((expanded, _ref) => {
+    let [key, value] = _ref;
+    return {
+      ...expanded,
+      [key]: value === true ? {} : value
+    };
+  }, {});
+}
+function omitUndefinedValuesFromOptions(obj) {
+  return Object.fromEntries(Object.entries(obj).filter((entry) => entry[1] !== void 0));
+}
+function expandConfig(containerOrSelector, options) {
+  const container = resolveSelector(containerOrSelector);
+  if (!container) {
+    throw new Error("Invalid Quill container");
+  }
+  const shouldUseDefaultTheme = !options.theme || options.theme === Quill.DEFAULTS.theme;
+  const theme$1 = shouldUseDefaultTheme ? theme : Quill.import(`themes/${options.theme}`);
+  if (!theme$1) {
+    throw new Error(`Invalid theme ${options.theme}. Did you register it?`);
+  }
+  const {
+    modules: quillModuleDefaults,
+    ...quillDefaults
+  } = Quill.DEFAULTS;
+  const {
+    modules: themeModuleDefaults,
+    ...themeDefaults
+  } = theme$1.DEFAULTS;
+  let userModuleOptions = expandModuleConfig(options.modules);
+  if (userModuleOptions != null && userModuleOptions.toolbar && userModuleOptions.toolbar.constructor !== Object) {
+    userModuleOptions = {
+      ...userModuleOptions,
+      toolbar: {
+        container: userModuleOptions.toolbar
+      }
+    };
+  }
+  const modules = merge({}, expandModuleConfig(quillModuleDefaults), expandModuleConfig(themeModuleDefaults), userModuleOptions);
+  const config = {
+    ...quillDefaults,
+    ...omitUndefinedValuesFromOptions(themeDefaults),
+    ...omitUndefinedValuesFromOptions(options)
+  };
+  let registry = options.registry;
+  if (registry) {
+    if (options.formats) {
+      debug.warn('Ignoring "formats" option because "registry" is specified');
+    }
+  } else {
+    registry = options.formats ? createRegistryWithFormats(options.formats, config.registry, debug) : config.registry;
+  }
+  return {
+    ...config,
+    registry,
+    container,
+    theme: theme$1,
+    modules: Object.entries(modules).reduce((modulesWithDefaults, _ref2) => {
+      let [name, value] = _ref2;
+      if (!value) return modulesWithDefaults;
+      const moduleClass = Quill.import(`modules/${name}`);
+      if (moduleClass == null) {
+        debug.error(`Cannot load ${name} module. Are you sure you registered it?`);
+        return modulesWithDefaults;
+      }
+      return {
+        ...modulesWithDefaults,
+        // @ts-expect-error
+        [name]: merge({}, moduleClass.DEFAULTS || {}, value)
+      };
+    }, {}),
+    bounds: resolveSelector(config.bounds)
+  };
+}
+function modify(modifier, source, index, shift) {
+  if (!this.isEnabled() && source === emitter.sources.USER && !this.allowReadOnlyEdits) {
+    return new Delta.default();
+  }
+  let range = index == null ? null : this.getSelection();
+  const oldDelta = this.editor.delta;
+  const change = modifier();
+  if (range != null) {
+    if (index === true) {
+      index = range.index;
+    }
+    if (shift == null) {
+      range = shiftRange(range, change, source);
+    } else if (shift !== 0) {
+      range = shiftRange(range, index, shift, source);
+    }
+    this.setSelection(range, emitter.sources.SILENT);
+  }
+  if (change.length() > 0) {
+    const args = [emitter.events.TEXT_CHANGE, change, oldDelta, source];
+    this.emitter.emit(emitter.events.EDITOR_CHANGE, ...args);
+    if (source !== emitter.sources.SILENT) {
+      this.emitter.emit(...args);
+    }
+  }
+  return change;
+}
+function overload(index, length, name, value, source) {
+  let formats = {};
+  if (typeof index.index === "number" && typeof index.length === "number") {
+    if (typeof length !== "number") {
+      source = value;
+      value = name;
+      name = length;
+      length = index.length;
+      index = index.index;
+    } else {
+      length = index.length;
+      index = index.index;
+    }
+  } else if (typeof length !== "number") {
+    source = value;
+    value = name;
+    name = length;
+    length = 0;
+  }
+  if (typeof name === "object") {
+    formats = name;
+    source = value;
+  } else if (typeof name === "string") {
+    if (value != null) {
+      formats[name] = value;
+    } else {
+      source = name;
+    }
+  }
+  source = source || emitter.sources.API;
+  return [index, length, formats, source];
+}
+function shiftRange(range, index, lengthOrSource, source) {
+  const length = typeof lengthOrSource === "number" ? lengthOrSource : 0;
+  if (range == null) return null;
+  let start;
+  let end;
+  if (index && typeof index.transformPosition === "function") {
+    [start, end] = [range.index, range.index + range.length].map((pos) => (
+      // @ts-expect-error -- TODO: add a better type guard around `index`
+      index.transformPosition(pos, source !== emitter.sources.USER)
+    ));
+  } else {
+    [start, end] = [range.index, range.index + range.length].map((pos) => {
+      if (pos < index || pos === index && source === emitter.sources.USER) return pos;
+      if (length >= 0) {
+        return pos + length;
+      }
+      return Math.max(index, pos + length);
+    });
+  }
+  return new selection.Range(start, end - start);
+}
+exports.Parchment = parchment;
+exports.Range = selection.Range;
+exports.default = Quill;
+exports.expandConfig = expandConfig;
+exports.globalRegistry = globalRegistry;
+exports.overload = overload;