notes/.obsidian/plugins/obsidian-latex-environments/main.js

/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
var __export = (target, all) => {
  __markAsModule(target);
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __reExport = (target, module2, desc) => {
  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
    for (let key of __getOwnPropNames(module2))
      if (!__hasOwnProp.call(target, key) && key !== "default")
        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
  }
  return target;
};
var __toModule = (module2) => {
  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
};
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/main.ts
__export(exports, {
  default: () => LatexEnvironments
});
var import_obsidian3 = __toModule(require("obsidian"));

// src/settings.ts
var LatexEnvironmentsSettings = class {
  constructor() {
    this.defaultEnvironment = "multline";
    this.customEnvironments = [];
  }
};
function ensureSettings(loaded) {
  var _a, _b;
  const settings = new LatexEnvironmentsSettings();
  settings.defaultEnvironment = (_a = loaded.defaultEnvironment) != null ? _a : settings.defaultEnvironment;
  settings.customEnvironments = (_b = loaded.customEnvironments) != null ? _b : settings.customEnvironments;
  return settings;
}

// src/search.ts
var SearchCursor = class {
  constructor(text, regex, _originalCaret) {
    this.text = text;
    this._originalCaret = _originalCaret;
    if (regex instanceof RegExp) {
      this.regex = regex;
    } else {
      this.regex = new RegExp(regex);
    }
    this.reset();
  }
  reset() {
    this._from = this._originalCaret;
    this._to = this._originalCaret;
    this._caret = this._originalCaret;
  }
  findNext() {
    const text = this.text.slice(this._caret);
    const match = text.match(this.regex);
    if ((match == null ? void 0 : match.index) == null) {
      return void 0;
    }
    this._from = this._caret + match.index;
    this._to = this._caret + match.index + match[0].length;
    this._caret = this._to;
    return match;
  }
  findPrevious() {
    const reverseRegex = new RegExp(`(?<full>${this.regex.source})(?!.*[\\r\\n]*.*\\k<full>)`, this.regex.flags);
    const text = this.text.slice(0, this._caret);
    const lastMatch = text.match(reverseRegex);
    if ((lastMatch == null ? void 0 : lastMatch.index) == null || (lastMatch == null ? void 0 : lastMatch.groups) == null) {
      return void 0;
    }
    this._from = lastMatch.index;
    this._to = lastMatch.index + lastMatch.groups.full.length;
    this._caret = this._from;
    return lastMatch;
  }
  to() {
    return this._to;
  }
  from() {
    return this._from;
  }
};

// src/mathblock.ts
var MathBlock = class {
  constructor(text, cursor) {
    this.text = text;
    const searchCursor = new SearchCursor(text, "\\$\\$", cursor);
    this.startPosition = searchCursor.findPrevious() != null ? searchCursor.to() : 0;
    searchCursor.reset();
    this.endPosition = searchCursor.findNext() != null ? searchCursor.from() : text.length;
  }
  getEnclosingEnvironment(cursor) {
    const beginEnds = new BeginEnds(this.text, this.startPosition, this.endPosition);
    const environments = Array.from(beginEnds);
    if (beginEnds.isOpen) {
      throw new Error("unclosed environments in block");
    }
    const start = environments.filter((env) => env.type === "begin" && env.from < cursor).pop();
    if (start === void 0) {
      return void 0;
    }
    const after = environments.filter((env) => env.from > start.to);
    let open = 1;
    let end;
    for (const env of after) {
      if (env.type === "begin") {
        open++;
      } else {
        open--;
        if (open === 0) {
          end = env;
          break;
        }
      }
    }
    if (end === void 0) {
      throw new Error("current environment is never closed");
    }
    if (end.to < cursor) {
      return void 0;
    }
    return {
      name: start.name,
      begin: start,
      end,
      contents: this.text.slice(start.to, end.from)
    };
  }
  static isMathMode(_cursor, _editor) {
    return true;
  }
};
var BeginEnds = class {
  constructor(text, start, end) {
    this.text = text;
    this.start = start;
    this.end = end;
    this.openEnvs = [];
    this.search = this.getEnvCursor(this.start);
  }
  reset() {
    this.search = this.getEnvCursor(this.start);
  }
  getEnvCursor(start) {
    return new SearchCursor(this.text, /\\(?<beginEnd>begin|end){\s*(?<name>[^}]+)\s*}/m, start);
  }
  get isOpen() {
    return this.openEnvs.length > 0;
  }
  [Symbol.iterator]() {
    this.reset();
    return this;
  }
  next() {
    const match = this.search.findNext();
    const to = this.search.to();
    if ((match == null ? void 0 : match.groups) == null || to > this.end) {
      return { done: true, value: null };
    }
    switch (match.groups.beginEnd) {
      case "begin": {
        const current = {
          name: match.groups.name,
          type: "begin",
          from: this.search.from(),
          to: this.search.to()
        };
        this.openEnvs.push(current);
        return {
          done: false,
          value: current
        };
      }
      case "end": {
        const current = this.openEnvs.pop();
        if (current === void 0) {
          throw new Error("closing environment which was never opened");
        }
        if (current.name !== match.groups.name) {
          throw new Error("environment not closed properly");
        }
        return {
          done: false,
          value: {
            name: match.groups.name,
            type: "end",
            from: this.search.from(),
            to: this.search.to()
          }
        };
      }
    }
    throw new Error(`regex returned unexpected result ${match[1]}`);
  }
};

// src/envmodal.ts
var import_obsidian = __toModule(require("obsidian"));

// src/environmentNames.ts
var DISPLAY_EQUATIONS = [
  "equation",
  "equation*",
  "gather",
  "gather*",
  "multline",
  "multline*",
  "split",
  "align",
  "align*",
  "flalign",
  "flalign*",
  "alignat",
  "alignat*"
];
var MATRICES = [
  "matrix",
  "pmatrix",
  "bmatrix",
  "Bmatrix",
  "vmatrix",
  "Vmatrix",
  "smallmatrix"
];
var SUB_ENVIRONMENTS = ["multlined", "gathered", "aligned", "cases"];
var DEFAULT_ENVIRONMENTS = [
  ...DISPLAY_EQUATIONS,
  ...MATRICES,
  ...SUB_ENVIRONMENTS
];

// src/envmodal.ts
var EnvModal = class extends import_obsidian.FuzzySuggestModal {
  constructor(app, settings, name, callback) {
    super(app);
    this.settings = settings;
    this.name = name;
    this.callback = callback;
    this.matched = false;
    this.setInstructions([
      { command: "\u2191\u2193", purpose: "to navigate" },
      { command: "\u21B5", purpose: "to select" },
      { command: "esc", purpose: "to dismiss" }
    ]);
    this.setPlaceholder("environment name");
  }
  getItems() {
    return Array.from(new Set([this.settings.defaultEnvironment].concat(this.settings.customEnvironments, DEFAULT_ENVIRONMENTS)));
  }
  getItemText(item) {
    this.matched = true;
    return item;
  }
  onNoSuggestion() {
    this.matched = false;
  }
  onChooseItem(item, _evt) {
    if (this.matched) {
      this.callback(item);
    } else {
      this.callback(this.inputEl.value);
    }
  }
  static callback(app, settings, defaultName, call) {
    new EnvModal(app, settings, defaultName, call).open();
  }
};

// src/latexEnvironmentsSettingsTab.ts
var import_obsidian2 = __toModule(require("obsidian"));
var LatexEnvironmentsSettingTab = class extends import_obsidian2.PluginSettingTab {
  constructor(app, plugin) {
    super(app, plugin);
    this.plugin = plugin;
  }
  display() {
    const { containerEl } = this;
    containerEl.empty();
    containerEl.createEl("h2", { text: "Settings for latex environments" });
    new import_obsidian2.Setting(containerEl).setName("Default environment").setDesc("The default environment to insert").addText((text) => text.setPlaceholder("environment").setValue(this.plugin.settings.defaultEnvironment).onChange((value) => __async(this, null, function* () {
      this.plugin.settings.defaultEnvironment = value;
      yield this.plugin.saveData(this.plugin.settings);
    })));
    new import_obsidian2.Setting(containerEl).setName("Extra environments").setDesc("Environment names to be suggested for completion (one per line)").addTextArea((area) => {
      area.setValue(this.plugin.settings.customEnvironments.join("\n")).onChange((value) => __async(this, null, function* () {
        this.plugin.settings.customEnvironments = value.split("\n").map((x) => x.trim()).filter((x) => x.length > 0);
        yield this.plugin.saveData(this.plugin.settings);
      }));
    });
  }
};

// src/actions/action.ts
var Action = class {
  constructor(doc) {
    this.doc = doc;
  }
  suggestName() {
    return void 0;
  }
  get needsName() {
    return true;
  }
};

// src/environment.ts
function newEnvironment(name, cursor, contents = "") {
  const pad = getPad(contents);
  return {
    replaceSelection: `\\begin{${name}}${pad}${contents}${pad}\\end{${name}}`,
    selection: {
      from: {
        ch: 0,
        line: cursor.line + 1
      }
    }
  };
}
function unwrapEnvironment(environment, doc) {
  return {
    changes: [
      {
        text: trim(environment.contents),
        from: doc.offsetToPos(environment.begin.from),
        to: doc.offsetToPos(environment.end.to)
      }
    ],
    selection: { from: doc.getCursor() }
  };
}
function changeEnvironment(environment, doc, name) {
  const change = {
    text: `\\begin{${name}}${environment.contents}\\end{${name}}`,
    from: doc.offsetToPos(environment.begin.from),
    to: doc.offsetToPos(environment.end.to)
  };
  return {
    changes: [change],
    selection: { from: doc.getCursor() }
  };
}
function getPad(text) {
  if (text.length > 0 && text.match(/^[ \t]*$/) != null) {
    return "";
  }
  return "\n";
}
function trim(text) {
  if (text.length === 0)
    return text;
  const start = text.startsWith("\n") ? 1 : 0;
  const end = text.endsWith("\n") ? text.length - 1 : text.length;
  return text.slice(start, end);
}

// src/actions/wrapAction.ts
var WrapAction = class extends Action {
  constructor(doc, addWhitespace = true) {
    super(doc);
    this.addWhitespace = addWhitespace;
  }
  prepare() {
    return this;
  }
  transaction(envName) {
    return newEnvironment(envName, this.doc.getCursor(), this.doc.getSelection());
  }
};

// src/actions/insertAction.ts
var InsertAction = class extends Action {
  prepare() {
    if (this.doc.somethingSelected()) {
      return new WrapAction(this.doc).prepare();
    }
    return this;
  }
  transaction(envName) {
    return newEnvironment(envName, this.doc.getCursor());
  }
};

// src/actions/changeAction.ts
var ChangeAction = class extends Action {
  suggestName() {
    return this.name;
  }
  prepare() {
    const cursor = this.doc.posToOffset(this.doc.getCursor());
    const block = new MathBlock(this.doc.getValue(), cursor);
    this.current = block.getEnclosingEnvironment(cursor);
    if (this.current === void 0) {
      return new WrapAction(this.doc, block.startPosition === block.endPosition);
    }
    this.name = this.current.name;
    return this;
  }
  transaction(envName) {
    if (this.current !== void 0) {
      return changeEnvironment(this.current, this.doc, envName);
    }
    return {};
  }
};

// src/actions/deleteAction.ts
var DeleteAction = class extends Action {
  get needsName() {
    return false;
  }
  prepare() {
    const cursor = this.doc.getCursor();
    const block = new MathBlock(this.doc.getValue(), this.doc.posToOffset(cursor));
    this.current = block.getEnclosingEnvironment(this.doc.posToOffset(cursor));
    return this;
  }
  transaction(_envName) {
    if (this.current !== void 0) {
      return unwrapEnvironment(this.current, this.doc);
    }
    return {};
  }
};

// src/main.ts
var LatexEnvironments = class extends import_obsidian3.Plugin {
  constructor() {
    super(...arguments);
    this.settings = new LatexEnvironmentsSettings();
  }
  onload() {
    return __async(this, null, function* () {
      const settings = yield this.loadData();
      if (settings !== null) {
        this.settings = ensureSettings(settings);
      }
      this.addCommand({
        id: "insert-latex-env",
        name: "Insert LaTeX environment",
        checkCallback: this.mathModeCallback(InsertAction)
      });
      this.addCommand({
        id: "change-latex-env",
        name: "Change LaTeX environment",
        checkCallback: this.mathModeCallback(ChangeAction)
      });
      this.addCommand({
        id: "delete-latex-env",
        name: "Delete LaTeX environment",
        checkCallback: this.mathModeCallback(DeleteAction)
      });
      this.addSettingTab(new LatexEnvironmentsSettingTab(this.app, this));
    });
  }
  mathModeCallback(ActionType) {
    return (checking) => {
      const leaf = this.app.workspace.activeLeaf;
      if (leaf.view instanceof import_obsidian3.MarkdownView) {
        const editor = leaf.view.editor;
        const cursor = editor.posToOffset(editor.getCursor());
        if (!MathBlock.isMathMode(cursor, editor)) {
          return false;
        }
        if (!checking) {
          try {
            const action = new ActionType(editor.getDoc()).prepare();
            this.withPromptName(editor, action);
          } catch (e) {
            new import_obsidian3.Notice(e.message);
          }
        }
        return true;
      }
      return false;
    };
  }
  withPromptName(editor, action) {
    const call = (envName) => {
      editor.transaction(action.transaction(envName));
      editor.focus();
    };
    if (action.needsName) {
      const suggested = action.suggestName();
      EnvModal.callback(this.app, this.settings, suggested !== void 0 ? suggested : this.settings.defaultEnvironment, call);
    } else {
      call("*");
    }
  }
};