prosekit 0.0.0-next-20230627094841

package/dist/chunk-HSPTUO6P.js

@@ -0,0 +1,53 @@
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+export {
+  __esm,
+  __commonJS,
+  __export,
+  __reExport,
+  __toESM,
+  __toCommonJS,
+  __decorateClass
+};

package/dist/chunk-JMNJUDT7.js

@@ -0,0 +1,165 @@
+import {
+  Plugin
+} from "./chunk-UTNVEPBA.js";
+import {
+  canJoin,
+  findWrapping
+} from "./chunk-ERNIDFFW.js";
+
+// ../../node_modules/.pnpm/prosemirror-inputrules@1.2.1/node_modules/prosemirror-inputrules/dist/index.js
+var InputRule = class {
+  // :: (RegExp, union<string, (state: EditorState, match: [string], start: number, end: number) → ?Transaction>)
+  /**
+  Create an input rule. The rule applies when the user typed
+  something and the text directly in front of the cursor matches
+  `match`, which should end with `$`.
+  
+  The `handler` can be a string, in which case the matched text, or
+  the first matched group in the regexp, is replaced by that
+  string.
+  
+  Or a it can be a function, which will be called with the match
+  array produced by
+  [`RegExp.exec`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec),
+  as well as the start and end of the matched range, and which can
+  return a [transaction](https://prosemirror.net/docs/ref/#state.Transaction) that describes the
+  rule's effect, or null to indicate the input was not handled.
+  */
+  constructor(match, handler) {
+    this.match = match;
+    this.match = match;
+    this.handler = typeof handler == "string" ? stringHandler(handler) : handler;
+  }
+};
+function stringHandler(string) {
+  return function(state, match, start, end) {
+    let insert = string;
+    if (match[1]) {
+      let offset = match[0].lastIndexOf(match[1]);
+      insert += match[0].slice(offset + match[1].length);
+      start += offset;
+      let cutOff = start - end;
+      if (cutOff > 0) {
+        insert = match[0].slice(offset - cutOff, offset) + insert;
+        start = end;
+      }
+    }
+    return state.tr.insertText(insert, start, end);
+  };
+}
+var MAX_MATCH = 500;
+function inputRules({ rules }) {
+  let plugin = new Plugin({
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr, prev) {
+        let stored = tr.getMeta(this);
+        if (stored)
+          return stored;
+        return tr.selectionSet || tr.docChanged ? null : prev;
+      }
+    },
+    props: {
+      handleTextInput(view, from, to, text) {
+        return run(view, from, to, text, rules, plugin);
+      },
+      handleDOMEvents: {
+        compositionend: (view) => {
+          setTimeout(() => {
+            let { $cursor } = view.state.selection;
+            if ($cursor)
+              run(view, $cursor.pos, $cursor.pos, "", rules, plugin);
+          });
+        }
+      }
+    },
+    isInputRules: true
+  });
+  return plugin;
+}
+function run(view, from, to, text, rules, plugin) {
+  if (view.composing)
+    return false;
+  let state = view.state, $from = state.doc.resolve(from);
+  if ($from.parent.type.spec.code)
+    return false;
+  let textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, null, "\uFFFC") + text;
+  for (let i = 0; i < rules.length; i++) {
+    let match = rules[i].match.exec(textBefore);
+    let tr = match && rules[i].handler(state, match, from - (match[0].length - text.length), to);
+    if (!tr)
+      continue;
+    view.dispatch(tr.setMeta(plugin, { transform: tr, from, to, text }));
+    return true;
+  }
+  return false;
+}
+var undoInputRule = (state, dispatch) => {
+  let plugins = state.plugins;
+  for (let i = 0; i < plugins.length; i++) {
+    let plugin = plugins[i], undoable;
+    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+      if (dispatch) {
+        let tr = state.tr, toUndo = undoable.transform;
+        for (let j = toUndo.steps.length - 1; j >= 0; j--)
+          tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+        if (undoable.text) {
+          let marks = tr.doc.resolve(undoable.from).marks();
+          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
+        } else {
+          tr.delete(undoable.from, undoable.to);
+        }
+        dispatch(tr);
+      }
+      return true;
+    }
+  }
+  return false;
+};
+var emDash = new InputRule(/--$/, "\u2014");
+var ellipsis = new InputRule(/\.\.\.$/, "\u2026");
+var openDoubleQuote = new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/, "\u201C");
+var closeDoubleQuote = new InputRule(/"$/, "\u201D");
+var openSingleQuote = new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/, "\u2018");
+var closeSingleQuote = new InputRule(/'$/, "\u2019");
+var smartQuotes = [openDoubleQuote, closeDoubleQuote, openSingleQuote, closeSingleQuote];
+function wrappingInputRule(regexp, nodeType, getAttrs = null, joinPredicate) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    let attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+    let tr = state.tr.delete(start, end);
+    let $start = tr.doc.resolve(start), range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs);
+    if (!wrapping)
+      return null;
+    tr.wrap(range, wrapping);
+    let before = tr.doc.resolve(start - 1).nodeBefore;
+    if (before && before.type == nodeType && canJoin(tr.doc, start - 1) && (!joinPredicate || joinPredicate(match, before)))
+      tr.join(start - 1);
+    return tr;
+  });
+}
+function textblockTypeInputRule(regexp, nodeType, getAttrs = null) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    let $start = state.doc.resolve(start);
+    let attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+    if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType))
+      return null;
+    return state.tr.delete(start, end).setBlockType(start, start, nodeType, attrs);
+  });
+}
+
+export {
+  InputRule,
+  inputRules,
+  undoInputRule,
+  emDash,
+  ellipsis,
+  openDoubleQuote,
+  closeDoubleQuote,
+  openSingleQuote,
+  closeSingleQuote,
+  smartQuotes,
+  wrappingInputRule,
+  textblockTypeInputRule
+};

package/dist/chunk-LXCCO2LO.js

@@ -0,0 +1,52 @@
+import {
+  addCommands,
+  addKeymap,
+  addMarkSpec,
+  defineExtension,
+  toggleMark
+} from "./chunk-2MVHS73Q.js";
+
+// ../extension-italic/src/index.ts
+function addItalicSpec() {
+  return addMarkSpec({
+    name: "italic",
+    spec: {
+      parseDOM: [
+        { tag: "i" },
+        { tag: "em" },
+        { style: "font-style=italic" },
+        {
+          style: "font-style=normal",
+          clearMark: (m) => m.type.name === "italic"
+        }
+      ],
+      toDOM() {
+        return ["em", 0];
+      }
+    }
+  });
+}
+function addItalicCommands() {
+  return addCommands({
+    toggleItalic: () => toggleMark({ type: "italic" })
+  });
+}
+function addItalicKeymap() {
+  return addKeymap({
+    "Mod-i": toggleMark({ type: "italic" })
+  });
+}
+function addItalic() {
+  return defineExtension([
+    addItalicSpec(),
+    addItalicCommands(),
+    addItalicKeymap()
+  ]);
+}
+
+export {
+  addItalicSpec,
+  addItalicCommands,
+  addItalicKeymap,
+  addItalic
+};