@eggjs/mock 6.1.0-beta.3 → 6.1.0-beta.5

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/array.js

@@ -0,0 +1,29 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_base } from "./base.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/array.js
+var require_array = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/array.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.diffArrays = diffArrays;
+	/*istanbul ignore end*/
+	var _base = _interopRequireDefault(require_base());
+	/*istanbul ignore start*/ function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	/*istanbul ignore end*/
+	var arrayDiff = exports.arrayDiff = new _base["default"]();
+	arrayDiff.tokenize = function(value) {
+		return value.slice();
+	};
+	arrayDiff.join = arrayDiff.removeEmpty = function(value) {
+		return value;
+	};
+	function diffArrays(oldArr, newArr, callback) {
+		return arrayDiff.diff(oldArr, newArr, callback);
+	}
+}) });
+
+//#endregion
+export default require_array();
+
+export { require_array };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/base.js

@@ -0,0 +1,185 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/base.js
+var require_base = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/base.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports["default"] = Diff;
+	/*istanbul ignore end*/
+	function Diff() {}
+	Diff.prototype = {
+		diff: function diff(oldString, newString) {
+			/*istanbul ignore start*/
+			var _options$timeout;
+			var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+			var callback = options.callback;
+			if (typeof options === "function") {
+				callback = options;
+				options = {};
+			}
+			var self = this;
+			function done(value) {
+				value = self.postProcess(value, options);
+				if (callback) {
+					setTimeout(function() {
+						callback(value);
+					}, 0);
+					return true;
+				} else return value;
+			}
+			oldString = this.castInput(oldString, options);
+			newString = this.castInput(newString, options);
+			oldString = this.removeEmpty(this.tokenize(oldString, options));
+			newString = this.removeEmpty(this.tokenize(newString, options));
+			var newLen = newString.length, oldLen = oldString.length;
+			var editLength = 1;
+			var maxEditLength = newLen + oldLen;
+			if (options.maxEditLength != null) maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+			var maxExecutionTime = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
+			var abortAfterTimestamp = Date.now() + maxExecutionTime;
+			var bestPath = [{
+				oldPos: -1,
+				lastComponent: void 0
+			}];
+			var newPos = this.extractCommon(bestPath[0], newString, oldString, 0, options);
+			if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) return done(buildValues(self, bestPath[0].lastComponent, newString, oldString, self.useLongestToken));
+			var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+			function execEditLength() {
+				for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+					var basePath = void 0;
+					var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+					if (removePath) bestPath[diagonalPath - 1] = void 0;
+					var canAdd = false;
+					if (addPath) {
+						var addPathNewPos = addPath.oldPos - diagonalPath;
+						canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+					}
+					var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+					if (!canAdd && !canRemove) {
+						bestPath[diagonalPath] = void 0;
+						continue;
+					}
+					if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) basePath = self.addToPath(addPath, true, false, 0, options);
+					else basePath = self.addToPath(removePath, false, true, 1, options);
+					newPos = self.extractCommon(basePath, newString, oldString, diagonalPath, options);
+					if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
+					else {
+						bestPath[diagonalPath] = basePath;
+						if (basePath.oldPos + 1 >= oldLen) maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+						if (newPos + 1 >= newLen) minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+					}
+				}
+				editLength++;
+			}
+			if (callback) (function exec() {
+				setTimeout(function() {
+					if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) return callback();
+					if (!execEditLength()) exec();
+				}, 0);
+			})();
+			else while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+				var ret = execEditLength();
+				if (ret) return ret;
+			}
+		},
+		addToPath: function addToPath(path, added, removed, oldPosInc, options) {
+			var last = path.lastComponent;
+			if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) return {
+				oldPos: path.oldPos + oldPosInc,
+				lastComponent: {
+					count: last.count + 1,
+					added,
+					removed,
+					previousComponent: last.previousComponent
+				}
+			};
+			else return {
+				oldPos: path.oldPos + oldPosInc,
+				lastComponent: {
+					count: 1,
+					added,
+					removed,
+					previousComponent: last
+				}
+			};
+		},
+		extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath, options) {
+			var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+			while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldString[oldPos + 1], newString[newPos + 1], options)) {
+				newPos++;
+				oldPos++;
+				commonCount++;
+				if (options.oneChangePerToken) basePath.lastComponent = {
+					count: 1,
+					previousComponent: basePath.lastComponent,
+					added: false,
+					removed: false
+				};
+			}
+			if (commonCount && !options.oneChangePerToken) basePath.lastComponent = {
+				count: commonCount,
+				previousComponent: basePath.lastComponent,
+				added: false,
+				removed: false
+			};
+			basePath.oldPos = oldPos;
+			return newPos;
+		},
+		equals: function equals(left, right, options) {
+			if (options.comparator) return options.comparator(left, right);
+			else return left === right || options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+		},
+		removeEmpty: function removeEmpty(array) {
+			var ret = [];
+			for (var i = 0; i < array.length; i++) if (array[i]) ret.push(array[i]);
+			return ret;
+		},
+		castInput: function castInput(value) {
+			return value;
+		},
+		tokenize: function tokenize(value) {
+			return Array.from(value);
+		},
+		join: function join(chars) {
+			return chars.join("");
+		},
+		postProcess: function postProcess(changeObjects) {
+			return changeObjects;
+		}
+	};
+	function buildValues(diff, lastComponent, newString, oldString, useLongestToken) {
+		var components = [];
+		var nextComponent;
+		while (lastComponent) {
+			components.push(lastComponent);
+			nextComponent = lastComponent.previousComponent;
+			delete lastComponent.previousComponent;
+			lastComponent = nextComponent;
+		}
+		components.reverse();
+		var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
+		for (; componentPos < componentLen; componentPos++) {
+			var component = components[componentPos];
+			if (!component.removed) {
+				if (!component.added && useLongestToken) {
+					var value = newString.slice(newPos, newPos + component.count);
+					value = value.map(function(value$1, i) {
+						var oldValue = oldString[oldPos + i];
+						return oldValue.length > value$1.length ? oldValue : value$1;
+					});
+					component.value = diff.join(value);
+				} else component.value = diff.join(newString.slice(newPos, newPos + component.count));
+				newPos += component.count;
+				if (!component.added) oldPos += component.count;
+			} else {
+				component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
+				oldPos += component.count;
+			}
+		}
+		return components;
+	}
+}) });
+
+//#endregion
+export default require_base();
+
+export { require_base };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/character.js

@@ -0,0 +1,23 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_base } from "./base.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/character.js
+var require_character = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/character.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.diffChars = diffChars;
+	/*istanbul ignore end*/
+	var _base = _interopRequireDefault(require_base());
+	/*istanbul ignore start*/ function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	/*istanbul ignore end*/
+	var characterDiff = exports.characterDiff = new _base["default"]();
+	function diffChars(oldStr, newStr, options) {
+		return characterDiff.diff(oldStr, newStr, options);
+	}
+}) });
+
+//#endregion
+export default require_character();
+
+export { require_character };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/css.js

@@ -0,0 +1,26 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_base } from "./base.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/css.js
+var require_css = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/css.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.diffCss = diffCss;
+	/*istanbul ignore end*/
+	var _base = _interopRequireDefault(require_base());
+	/*istanbul ignore start*/ function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	/*istanbul ignore end*/
+	var cssDiff = exports.cssDiff = new _base["default"]();
+	cssDiff.tokenize = function(value) {
+		return value.split(/([{}:;,]|\s+)/);
+	};
+	function diffCss(oldStr, newStr, callback) {
+		return cssDiff.diff(oldStr, newStr, callback);
+	}
+}) });
+
+//#endregion
+export default require_css();
+
+export { require_css };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/json.js

@@ -0,0 +1,83 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_base } from "./base.js";
+import { require_line } from "./line.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/json.js
+var require_json = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/json.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.canonicalize = canonicalize;
+	exports.diffJson = diffJson;
+	/*istanbul ignore end*/
+	var _base = _interopRequireDefault(require_base());
+	var _line = require_line();
+	/*istanbul ignore start*/ function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	function _typeof(o) {
+		"@babel/helpers - typeof";
+		return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+			return typeof o$1;
+		} : function(o$1) {
+			return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+		}, _typeof(o);
+	}
+	/*istanbul ignore end*/
+	var jsonDiff = exports.jsonDiff = new _base["default"]();
+	jsonDiff.useLongestToken = true;
+	jsonDiff.tokenize = _line.lineDiff.tokenize;
+	jsonDiff.castInput = function(value, options) {
+		var undefinedReplacement = options.undefinedReplacement, _options$stringifyRep = options.stringifyReplacer, stringifyReplacer = _options$stringifyRep === void 0 ? function(k, v) {
+			return typeof v === "undefined" ? undefinedReplacement : v;
+		} : _options$stringifyRep;
+		return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
+	};
+	jsonDiff.equals = function(left, right, options) {
+		return _base["default"].prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
+	};
+	function diffJson(oldObj, newObj, options) {
+		return jsonDiff.diff(oldObj, newObj, options);
+	}
+	function canonicalize(obj, stack, replacementStack, replacer, key) {
+		stack = stack || [];
+		replacementStack = replacementStack || [];
+		if (replacer) obj = replacer(key, obj);
+		var i;
+		for (i = 0; i < stack.length; i += 1) if (stack[i] === obj) return replacementStack[i];
+		var canonicalizedObj;
+		if ("[object Array]" === Object.prototype.toString.call(obj)) {
+			stack.push(obj);
+			canonicalizedObj = new Array(obj.length);
+			replacementStack.push(canonicalizedObj);
+			for (i = 0; i < obj.length; i += 1) canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
+			stack.pop();
+			replacementStack.pop();
+			return canonicalizedObj;
+		}
+		if (obj && obj.toJSON) obj = obj.toJSON();
+		if (_typeof(
+			/*istanbul ignore end*/
+			obj
+		) === "object" && obj !== null) {
+			stack.push(obj);
+			canonicalizedObj = {};
+			replacementStack.push(canonicalizedObj);
+			var sortedKeys = [], _key;
+			for (_key in obj)
+ /* istanbul ignore else */
+			if (Object.prototype.hasOwnProperty.call(obj, _key)) sortedKeys.push(_key);
+			sortedKeys.sort();
+			for (i = 0; i < sortedKeys.length; i += 1) {
+				_key = sortedKeys[i];
+				canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
+			}
+			stack.pop();
+			replacementStack.pop();
+		} else canonicalizedObj = obj;
+		return canonicalizedObj;
+	}
+}) });
+
+//#endregion
+export default require_json();
+
+export { require_json };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/line.js

@@ -0,0 +1,51 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_base } from "./base.js";
+import { require_params } from "../util/params.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/line.js
+var require_line = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/line.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.diffLines = diffLines;
+	exports.diffTrimmedLines = diffTrimmedLines;
+	/*istanbul ignore end*/
+	var _base = _interopRequireDefault(require_base());
+	var _params = require_params();
+	/*istanbul ignore start*/ function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	/*istanbul ignore end*/
+	var lineDiff = exports.lineDiff = new _base["default"]();
+	lineDiff.tokenize = function(value, options) {
+		if (options.stripTrailingCr) value = value.replace(/\r\n/g, "\n");
+		var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+		if (!linesAndNewlines[linesAndNewlines.length - 1]) linesAndNewlines.pop();
+		for (var i = 0; i < linesAndNewlines.length; i++) {
+			var line = linesAndNewlines[i];
+			if (i % 2 && !options.newlineIsToken) retLines[retLines.length - 1] += line;
+			else retLines.push(line);
+		}
+		return retLines;
+	};
+	lineDiff.equals = function(left, right, options) {
+		if (options.ignoreWhitespace) {
+			if (!options.newlineIsToken || !left.includes("\n")) left = left.trim();
+			if (!options.newlineIsToken || !right.includes("\n")) right = right.trim();
+		} else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+			if (left.endsWith("\n")) left = left.slice(0, -1);
+			if (right.endsWith("\n")) right = right.slice(0, -1);
+		}
+		return _base["default"].prototype.equals.call(this, left, right, options);
+	};
+	function diffLines(oldStr, newStr, callback) {
+		return lineDiff.diff(oldStr, newStr, callback);
+	}
+	function diffTrimmedLines(oldStr, newStr, callback) {
+		var options = (0, _params.generateOptions)(callback, { ignoreWhitespace: true });
+		return lineDiff.diff(oldStr, newStr, options);
+	}
+}) });
+
+//#endregion
+export default require_line();
+
+export { require_line };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/sentence.js

@@ -0,0 +1,26 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_base } from "./base.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/sentence.js
+var require_sentence = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/sentence.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.diffSentences = diffSentences;
+	/*istanbul ignore end*/
+	var _base = _interopRequireDefault(require_base());
+	/*istanbul ignore start*/ function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	/*istanbul ignore end*/
+	var sentenceDiff = exports.sentenceDiff = new _base["default"]();
+	sentenceDiff.tokenize = function(value) {
+		return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+	};
+	function diffSentences(oldStr, newStr, callback) {
+		return sentenceDiff.diff(oldStr, newStr, callback);
+	}
+}) });
+
+//#endregion
+export default require_sentence();
+
+export { require_sentence };

package/dist/node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/word.js

@@ -0,0 +1,151 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_base } from "./base.js";
+import { require_string } from "../util/string.js";
+
+//#region ../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/word.js
+var require_word = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/diff@7.0.0/node_modules/diff/lib/diff/word.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.diffWords = diffWords;
+	exports.diffWordsWithSpace = diffWordsWithSpace;
+	/*istanbul ignore end*/
+	var _base = _interopRequireDefault(require_base());
+	var _string = require_string();
+	/*istanbul ignore start*/ function _interopRequireDefault(obj) {
+		return obj && obj.__esModule ? obj : { "default": obj };
+	}
+	/*istanbul ignore end*/
+	var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+	var tokenizeIncludingWhitespace = new RegExp(
+		/*istanbul ignore start*/
+		"[".concat(
+			/*istanbul ignore end*/
+			extendedWordChars,
+			"]+|\\s+|[^"
+		).concat(extendedWordChars, "]"),
+		"ug"
+	);
+	var wordDiff = exports.wordDiff = new _base["default"]();
+	wordDiff.equals = function(left, right, options) {
+		if (options.ignoreCase) {
+			left = left.toLowerCase();
+			right = right.toLowerCase();
+		}
+		return left.trim() === right.trim();
+	};
+	wordDiff.tokenize = function(value) {
+		/*istanbul ignore start*/
+		var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+		var parts;
+		if (options.intlSegmenter) {
+			if (options.intlSegmenter.resolvedOptions().granularity != "word") throw new Error("The segmenter passed must have a granularity of \"word\"");
+			parts = Array.from(options.intlSegmenter.segment(value), function(segment) {
+				return segment.segment;
+			});
+		} else parts = value.match(tokenizeIncludingWhitespace) || [];
+		var tokens = [];
+		var prevPart = null;
+		parts.forEach(function(part) {
+			if (/\s/.test(part)) if (prevPart == null) tokens.push(part);
+			else tokens.push(tokens.pop() + part);
+			else if (/\s/.test(prevPart)) if (tokens[tokens.length - 1] == prevPart) tokens.push(tokens.pop() + part);
+			else tokens.push(prevPart + part);
+			else tokens.push(part);
+			prevPart = part;
+		});
+		return tokens;
+	};
+	wordDiff.join = function(tokens) {
+		return tokens.map(function(token, i) {
+			if (i == 0) return token;
+			else return token.replace(/^\s+/, "");
+		}).join("");
+	};
+	wordDiff.postProcess = function(changes, options) {
+		if (!changes || options.oneChangePerToken) return changes;
+		var lastKeep = null;
+		var insertion = null;
+		var deletion = null;
+		changes.forEach(function(change) {
+			if (change.added) insertion = change;
+			else if (change.removed) deletion = change;
+			else {
+				if (insertion || deletion) dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+				lastKeep = change;
+				insertion = null;
+				deletion = null;
+			}
+		});
+		if (insertion || deletion) dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
+		return changes;
+	};
+	function diffWords(oldStr, newStr, options) {
+		if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) return diffWordsWithSpace(oldStr, newStr, options);
+		return wordDiff.diff(oldStr, newStr, options);
+	}
+	function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
+		if (deletion && insertion) {
+			var oldWsPrefix = deletion.value.match(/^\s*/)[0];
+			var oldWsSuffix = deletion.value.match(/\s*$/)[0];
+			var newWsPrefix = insertion.value.match(/^\s*/)[0];
+			var newWsSuffix = insertion.value.match(/\s*$/)[0];
+			if (startKeep) {
+				var commonWsPrefix = (0, _string.longestCommonPrefix)(oldWsPrefix, newWsPrefix);
+				startKeep.value = (0, _string.replaceSuffix)(startKeep.value, newWsPrefix, commonWsPrefix);
+				deletion.value = (0, _string.removePrefix)(deletion.value, commonWsPrefix);
+				insertion.value = (0, _string.removePrefix)(insertion.value, commonWsPrefix);
+			}
+			if (endKeep) {
+				var commonWsSuffix = (0, _string.longestCommonSuffix)(oldWsSuffix, newWsSuffix);
+				endKeep.value = (0, _string.replacePrefix)(endKeep.value, newWsSuffix, commonWsSuffix);
+				deletion.value = (0, _string.removeSuffix)(deletion.value, commonWsSuffix);
+				insertion.value = (0, _string.removeSuffix)(insertion.value, commonWsSuffix);
+			}
+		} else if (insertion) {
+			if (startKeep) insertion.value = insertion.value.replace(/^\s*/, "");
+			if (endKeep) endKeep.value = endKeep.value.replace(/^\s*/, "");
+		} else if (startKeep && endKeep) {
+			var newWsFull = endKeep.value.match(/^\s*/)[0], delWsStart = deletion.value.match(/^\s*/)[0], delWsEnd = deletion.value.match(/\s*$/)[0];
+			var newWsStart = (0, _string.longestCommonPrefix)(newWsFull, delWsStart);
+			deletion.value = (0, _string.removePrefix)(deletion.value, newWsStart);
+			var newWsEnd = (0, _string.longestCommonSuffix)(
+				/*istanbul ignore start*/
+				(0, _string.removePrefix)(newWsFull, newWsStart),
+				delWsEnd
+			);
+			deletion.value = (0, _string.removeSuffix)(deletion.value, newWsEnd);
+			endKeep.value = (0, _string.replacePrefix)(endKeep.value, newWsFull, newWsEnd);
+			startKeep.value = (0, _string.replaceSuffix)(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+		} else if (endKeep) {
+			var endKeepWsPrefix = endKeep.value.match(/^\s*/)[0];
+			var deletionWsSuffix = deletion.value.match(/\s*$/)[0];
+			var overlap = (0, _string.maximumOverlap)(deletionWsSuffix, endKeepWsPrefix);
+			deletion.value = (0, _string.removeSuffix)(deletion.value, overlap);
+		} else if (startKeep) {
+			var startKeepWsSuffix = startKeep.value.match(/\s*$/)[0];
+			var deletionWsPrefix = deletion.value.match(/^\s*/)[0];
+			var _overlap = (0, _string.maximumOverlap)(startKeepWsSuffix, deletionWsPrefix);
+			deletion.value = (0, _string.removePrefix)(deletion.value, _overlap);
+		}
+	}
+	var wordWithSpaceDiff = exports.wordWithSpaceDiff = new _base["default"]();
+	wordWithSpaceDiff.tokenize = function(value) {
+		var regex = new RegExp(
+			/*istanbul ignore start*/
+			"(\\r?\\n)|[".concat(
+				/*istanbul ignore end*/
+				extendedWordChars,
+				"]+|[^\\S\\n\\r]+|[^"
+			).concat(extendedWordChars, "]"),
+			"ug"
+		);
+		return value.match(regex) || [];
+	};
+	function diffWordsWithSpace(oldStr, newStr, options) {
+		return wordWithSpaceDiff.diff(oldStr, newStr, options);
+	}
+}) });
+
+//#endregion
+export default require_word();
+
+export { require_word };