@smthrs/std 0.0.0-stage → 1.0.0-rc.12

package/dist/cjs/internal/ApplyPatch.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Faithful port of the Codex CLI apply_patch engine.
+ *
+ * Mirrors `codex-rs/apply-patch/src/{parser,streaming_parser,seek_sequence}.rs`
+ * and the applier in `lib.rs`: the V4A patch grammar, the lenient heredoc
+ * boundary handling, the fuzzy context-matching ladder, and every error
+ * string, so ChatGPT-family models see exactly the behavior they were
+ * posttrained on. Pure module: no host access.
+ *
+ * @since 1.0.0
+ */
+import * as Schema from "effect/Schema";
+declare const ParseError_base: Schema.Class<ParseError, Schema.TaggedStruct<"@smthrs/std/ParseError", {
+    readonly kind: Schema.Literals<readonly ["invalid_patch", "invalid_hunk"]>;
+    readonly detail: Schema.String;
+    readonly lineNumber: Schema.UndefinedOr<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Parse failure with Codex-identical message text.
+ *
+ * `invalid patch: {message}` for patch-level failures and
+ * `invalid hunk at line {line}, {message}` for hunk-level failures.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare class ParseError extends ParseError_base {
+    get message(): string;
+}
+/**
+ * One replaced region of an update hunk.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export interface UpdateFileChunk {
+    changeContext: string | undefined;
+    oldLines: Array<string>;
+    newLines: Array<string>;
+    isEndOfFile: boolean;
+}
+/**
+ * A parsed patch hunk.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export type Hunk = {
+    readonly kind: "add";
+    readonly path: string;
+    contents: string;
+} | {
+    readonly kind: "delete";
+    readonly path: string;
+} | {
+    readonly kind: "update";
+    readonly path: string;
+    movePath: string | undefined;
+    readonly chunks: Array<UpdateFileChunk>;
+};
+/**
+ * Parsed patch: hunks plus the optional environment id preamble.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export interface ParsedPatch {
+    readonly hunks: ReadonlyArray<Hunk>;
+    readonly environmentId: string | undefined;
+}
+/**
+ * Streaming line state machine for the V4A patch grammar; a faithful port of
+ * `StreamingPatchParser`.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare class StreamingPatchParser {
+    private lineBuffer;
+    private mode;
+    private hunks;
+    private lineNumber;
+    private _environmentId;
+    environmentId(): string | undefined;
+    private ensureUpdateHunkIsNotEmpty;
+    private handleHunkHeadersAndEndPatch;
+    pushDelta(delta: string): ReadonlyArray<Hunk>;
+    finish(): ReadonlyArray<Hunk>;
+    private processLine;
+}
+/**
+ * Parse a complete patch text; lenient mode (heredoc unwrapping) is always
+ * on, matching Codex.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const parsePatch: (patch: string) => ParsedPatch;
+/**
+ * Fuzzy sequence search with the Codex leniency ladder: exact, rstrip, trim,
+ * then unicode-normalised comparison; end-of-file patterns anchor at the end
+ * first.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const seekSequence: (lines: ReadonlyArray<string>, pattern: ReadonlyArray<string>, start: number, eof: boolean) => number | undefined;
+declare const ComputeReplacementsError_base: Schema.Class<ComputeReplacementsError, Schema.TaggedStruct<"@smthrs/std/ComputeReplacementsError", {
+    readonly reason: Schema.Literals<readonly ["context_not_found", "lines_not_found"]>;
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Applier failure carrying the Codex message text verbatim.
+ *
+ * `context_not_found` is an `@@` context line absent from the file;
+ * `lines_not_found` is a chunk whose expected lines are absent.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare class ComputeReplacementsError extends ComputeReplacementsError_base {
+}
+/**
+ * Derive the new file contents for an update hunk from the original
+ * contents, matching Codex `derive_new_contents_from_chunks`.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const deriveNewContents: (originalContents: string, path: string, chunks: ReadonlyArray<UpdateFileChunk>) => string;
+/**
+ * Render the Codex success summary: `Success. Updated the following files:`
+ * with `A`/`M`/`D` lines for adds, updates, and deletes in that order.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const printSummary: (affected: {
+    readonly added: ReadonlyArray<string>;
+    readonly modified: ReadonlyArray<string>;
+    readonly deleted: ReadonlyArray<string>;
+}) => string;
+export {};
+//# sourceMappingURL=ApplyPatch.d.ts.map

package/dist/cjs/internal/ApplyPatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplyPatch.d.ts","sourceRoot":"","sources":["../../../src/internal/ApplyPatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;;;;;;AAcvC;;;;;;;;GAQG;AACH,qBAAa,UAAW,SAAQ,eAI9B;IACA,IAAa,OAAO,IAAI,MAAM,CAI7B;CACF;AAKD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACvB,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACvB,WAAW,EAAE,OAAO,CAAA;CACrB;AAED;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GACZ;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACjE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAClD;IACA,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;CACxC,CAAA;AAEH;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAA;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;CAC3C;AAwBD;;;;;;GAMG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,cAAc,CAAoB;IAE1C,aAAa,IAAI,MAAM,GAAG,SAAS;IAInC,OAAO,CAAC,0BAA0B;IAmBlC,OAAO,CAAC,4BAA4B;IA4CpC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC;IAe7C,MAAM,IAAI,aAAa,CAAC,IAAI,CAAC;IAkB7B,OAAO,CAAC,WAAW;CA0HpB;AAqCD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,WAQ1C,CAAA;AA0CD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,aAAa,CAAC,MAAM,CAAC,EAC5B,SAAS,aAAa,CAAC,MAAM,CAAC,EAC9B,OAAO,MAAM,EACb,KAAK,OAAO,KACX,MAAM,GAAG,SAwBX,CAAA;;;;;;AAED;;;;;;;;GAQG;AACH,qBAAa,wBAAyB,SAAQ,6BAO7C;CAAG;AAmEJ;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,kBAAkB,MAAM,EACxB,MAAM,MAAM,EACZ,QAAQ,aAAa,CAAC,eAAe,CAAC,KACrC,MAMF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU;IACrC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACxC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACxC,KAAG,MAMH,CAAA"}

package/dist/cjs/internal/ApplyPatch.js

@@ -0,0 +1,462 @@
+"use strict";
+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 __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 __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 ApplyPatch_exports = {};
+__export(ApplyPatch_exports, {
+  ComputeReplacementsError: () => ComputeReplacementsError,
+  ParseError: () => ParseError,
+  StreamingPatchParser: () => StreamingPatchParser,
+  deriveNewContents: () => deriveNewContents,
+  parsePatch: () => parsePatch,
+  printSummary: () => printSummary,
+  seekSequence: () => seekSequence
+});
+module.exports = __toCommonJS(ApplyPatch_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_Text = require("./Text.js");
+const BEGIN_PATCH_MARKER = "*** Begin Patch";
+const END_PATCH_MARKER = "*** End Patch";
+const ADD_FILE_MARKER = "*** Add File: ";
+const DELETE_FILE_MARKER = "*** Delete File: ";
+const UPDATE_FILE_MARKER = "*** Update File: ";
+const MOVE_TO_MARKER = "*** Move to: ";
+const EOF_MARKER = "*** End of File";
+const CHANGE_CONTEXT_MARKER = "@@ ";
+const EMPTY_CHANGE_CONTEXT_MARKER = "@@";
+const ENVIRONMENT_ID_MARKER = "*** Environment ID:";
+class ParseError extends Schema.TaggedError()("@smthrs/std/ParseError", {
+  kind: Schema.Literals(["invalid_patch", "invalid_hunk"]),
+  detail: Schema.String,
+  lineNumber: Schema.UndefinedOr(Schema.Number)
+}) {
+  get message() {
+    return this.kind === "invalid_patch" ? `invalid patch: ${this.detail}` : `invalid hunk at line ${this.lineNumber}, ${this.detail}`;
+  }
+}
+const parseError = (kind, detail, lineNumber) => new ParseError({ kind, detail, lineNumber });
+const invalidHunkHeader = (trimmed, lineNumber) => parseError(
+  "invalid_hunk",
+  `'${trimmed}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`,
+  lineNumber
+);
+const unexpectedUpdateLine = (line, lineNumber) => parseError(
+  "invalid_hunk",
+  `Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`,
+  lineNumber
+);
+class StreamingPatchParser {
+  lineBuffer = "";
+  mode = { _tag: "NotStarted" };
+  hunks = [];
+  lineNumber = 0;
+  _environmentId;
+  environmentId() {
+    return this._environmentId;
+  }
+  ensureUpdateHunkIsNotEmpty(line) {
+    const last = this.hunks[this.hunks.length - 1];
+    if (last === void 0 || last.kind !== "update") return;
+    if (last.chunks.length === 0 && this.mode._tag === "UpdateFile") {
+      throw parseError(
+        "invalid_hunk",
+        `Update file hunk for path '${last.path}' is empty`,
+        this.mode.hunkLineNumber
+      );
+    }
+    const chunk = last.chunks[last.chunks.length - 1];
+    if (chunk !== void 0 && chunk.oldLines.length === 0 && chunk.newLines.length === 0) {
+      if (line === END_PATCH_MARKER) {
+        throw parseError("invalid_hunk", "Update hunk does not contain any lines", this.lineNumber);
+      }
+      throw unexpectedUpdateLine(line, this.lineNumber);
+    }
+  }
+  handleHunkHeadersAndEndPatch(trimmed) {
+    if (this.mode._tag === "StartedPatch" && trimmed.startsWith(ENVIRONMENT_ID_MARKER)) {
+      if (this._environmentId !== void 0) {
+        throw parseError("invalid_patch", "apply_patch environment_id cannot be specified more than once");
+      }
+      const environmentId = trimmed.slice(ENVIRONMENT_ID_MARKER.length).trim();
+      if (environmentId === "") {
+        throw parseError("invalid_patch", "apply_patch environment_id cannot be empty");
+      }
+      this._environmentId = environmentId;
+      return true;
+    }
+    if (trimmed === END_PATCH_MARKER) {
+      this.ensureUpdateHunkIsNotEmpty(trimmed);
+      this.mode = { _tag: "EndedPatch" };
+      return true;
+    }
+    if (trimmed.startsWith(ADD_FILE_MARKER)) {
+      this.ensureUpdateHunkIsNotEmpty(trimmed);
+      this.hunks.push({ kind: "add", path: trimmed.slice(ADD_FILE_MARKER.length), contents: "" });
+      this.mode = { _tag: "AddFile" };
+      return true;
+    }
+    if (trimmed.startsWith(DELETE_FILE_MARKER)) {
+      this.ensureUpdateHunkIsNotEmpty(trimmed);
+      this.hunks.push({ kind: "delete", path: trimmed.slice(DELETE_FILE_MARKER.length) });
+      this.mode = { _tag: "DeleteFile" };
+      return true;
+    }
+    if (trimmed.startsWith(UPDATE_FILE_MARKER)) {
+      this.ensureUpdateHunkIsNotEmpty(trimmed);
+      const hunk = {
+        kind: "update",
+        path: trimmed.slice(UPDATE_FILE_MARKER.length),
+        movePath: void 0,
+        chunks: []
+      };
+      this.hunks.push(hunk);
+      this.mode = { _tag: "UpdateFile", hunkLineNumber: this.lineNumber, hunk };
+      return true;
+    }
+    return false;
+  }
+  pushDelta(delta) {
+    for (const ch of delta) {
+      if (ch === "\n") {
+        let line = this.lineBuffer;
+        this.lineBuffer = "";
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        this.lineNumber += 1;
+        this.processLine(line);
+      } else {
+        this.lineBuffer += ch;
+      }
+    }
+    return this.hunks;
+  }
+  finish() {
+    if (this.lineBuffer !== "") {
+      const line = this.lineBuffer;
+      this.lineBuffer = "";
+      this.lineNumber += 1;
+      if (line.trim() === END_PATCH_MARKER) {
+        this.ensureUpdateHunkIsNotEmpty(line.trim());
+        this.mode = { _tag: "EndedPatch" };
+      } else {
+        this.processLine(line);
+      }
+    }
+    if (this.mode._tag !== "EndedPatch") {
+      throw parseError("invalid_patch", "The last line of the patch must be '*** End Patch'");
+    }
+    return this.hunks;
+  }
+  processLine(line) {
+    const trimmed = line.trim();
+    switch (this.mode._tag) {
+      case "NotStarted": {
+        if (trimmed === BEGIN_PATCH_MARKER) {
+          this.mode = { _tag: "StartedPatch" };
+          return;
+        }
+        throw parseError("invalid_patch", "The first line of the patch must be '*** Begin Patch'");
+      }
+      case "StartedPatch": {
+        if (this.handleHunkHeadersAndEndPatch(trimmed)) return;
+        throw invalidHunkHeader(trimmed, this.lineNumber);
+      }
+      case "AddFile": {
+        if (this.handleHunkHeadersAndEndPatch(trimmed)) return;
+        const last = this.hunks[this.hunks.length - 1];
+        if (line.startsWith("+") && last !== void 0 && last.kind === "add") {
+          last.contents += `${line.slice(1)}
+`;
+          return;
+        }
+        throw invalidHunkHeader(trimmed, this.lineNumber);
+      }
+      case "DeleteFile": {
+        if (this.handleHunkHeadersAndEndPatch(trimmed)) return;
+        throw invalidHunkHeader(trimmed, this.lineNumber);
+      }
+      case "UpdateFile": {
+        const updateLine = line.replace(/\s+$/, "");
+        if (this.handleHunkHeadersAndEndPatch(updateLine)) return;
+        const hunk = this.mode.hunk;
+        const chunks = hunk.chunks;
+        const lastChunk = chunks[chunks.length - 1];
+        if (lastChunk !== void 0 && lastChunk.isEndOfFile) {
+          if (updateLine === "") return;
+          if (updateLine !== EMPTY_CHANGE_CONTEXT_MARKER && !updateLine.startsWith(CHANGE_CONTEXT_MARKER)) {
+            throw parseError(
+              "invalid_hunk",
+              `Expected update hunk to start with a @@ context marker, got: '${line}'`,
+              this.lineNumber
+            );
+          }
+        }
+        if (chunks.length === 0 && hunk.movePath === void 0 && updateLine.startsWith(MOVE_TO_MARKER)) {
+          hunk.movePath = updateLine.slice(MOVE_TO_MARKER.length);
+          return;
+        }
+        if ((updateLine === EMPTY_CHANGE_CONTEXT_MARKER || updateLine.startsWith(CHANGE_CONTEXT_MARKER)) && lastChunk !== void 0 && lastChunk.oldLines.length === 0 && lastChunk.newLines.length === 0) {
+          throw unexpectedUpdateLine(line, this.lineNumber);
+        }
+        if (updateLine === EMPTY_CHANGE_CONTEXT_MARKER) {
+          chunks.push({ changeContext: void 0, oldLines: [], newLines: [], isEndOfFile: false });
+          return;
+        }
+        if (updateLine.startsWith(CHANGE_CONTEXT_MARKER)) {
+          chunks.push({
+            changeContext: updateLine.slice(CHANGE_CONTEXT_MARKER.length),
+            oldLines: [],
+            newLines: [],
+            isEndOfFile: false
+          });
+          return;
+        }
+        if (updateLine === EOF_MARKER) {
+          if (lastChunk !== void 0 && lastChunk.oldLines.length === 0 && lastChunk.newLines.length === 0) {
+            throw parseError("invalid_hunk", "Update hunk does not contain any lines", this.lineNumber);
+          }
+          if (lastChunk !== void 0) lastChunk.isEndOfFile = true;
+          return;
+        }
+        const ensureChunk = () => {
+          if (chunks.length === 0) {
+            chunks.push({ changeContext: void 0, oldLines: [], newLines: [], isEndOfFile: false });
+          }
+          return chunks[chunks.length - 1];
+        };
+        if (line === "") {
+          const chunk = ensureChunk();
+          chunk.oldLines.push("");
+          chunk.newLines.push("");
+          return;
+        }
+        if (line.startsWith(" ")) {
+          const chunk = ensureChunk();
+          chunk.oldLines.push(line.slice(1));
+          chunk.newLines.push(line.slice(1));
+          return;
+        }
+        if (line.startsWith("+")) {
+          ensureChunk().newLines.push(line.slice(1));
+          return;
+        }
+        if (line.startsWith("-")) {
+          ensureChunk().oldLines.push(line.slice(1));
+          return;
+        }
+        if (lastChunk !== void 0 && (lastChunk.oldLines.length > 0 || lastChunk.newLines.length > 0)) {
+          throw parseError(
+            "invalid_hunk",
+            `Expected update hunk to start with a @@ context marker, got: '${line}'`,
+            this.lineNumber
+          );
+        }
+        throw unexpectedUpdateLine(line, this.lineNumber);
+      }
+      case "EndedPatch": {
+        if (trimmed === "") return;
+        throw parseError("invalid_patch", "The last line of the patch must be '*** End Patch'");
+      }
+    }
+  }
+}
+const checkStartAndEndLinesStrict = (firstLine, lastLine) => {
+  const first = firstLine?.trim();
+  const last = lastLine?.trim();
+  if (first === BEGIN_PATCH_MARKER && last === END_PATCH_MARKER) return;
+  if (first !== void 0 && first !== BEGIN_PATCH_MARKER) {
+    throw parseError("invalid_patch", "The first line of the patch must be '*** Begin Patch'");
+  }
+  throw parseError("invalid_patch", "The last line of the patch must be '*** End Patch'");
+};
+const checkPatchBoundariesStrict = (lines) => {
+  checkStartAndEndLinesStrict(lines[0], lines.length === 0 ? void 0 : lines[lines.length - 1]);
+  return lines;
+};
+const checkPatchBoundariesLenient = (originalLines) => {
+  let originalError;
+  try {
+    return checkPatchBoundariesStrict(originalLines);
+  } catch (error) {
+    originalError = error;
+  }
+  if (originalLines.length >= 2) {
+    const first = originalLines[0];
+    const last = originalLines[originalLines.length - 1];
+    if ((first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"') && last.endsWith("EOF") && originalLines.length >= 4) {
+      return checkPatchBoundariesStrict(originalLines.slice(1, -1));
+    }
+  }
+  throw originalError;
+};
+const parsePatch = (patch) => {
+  const trimmed = patch.trim();
+  const lines = trimmed === "" ? [] : trimmed.split("\n");
+  const patchLines = checkPatchBoundariesLenient(lines);
+  const parser = new StreamingPatchParser();
+  parser.pushDelta(`${patchLines.join("\n")}
+`);
+  const hunks = parser.finish();
+  return { hunks, environmentId: parser.environmentId() };
+};
+const normalise = (s) => [...s.trim()].map((c) => {
+  switch (c) {
+    case "\u2010":
+    case "\u2011":
+    case "\u2012":
+    case "\u2013":
+    case "\u2014":
+    case "\u2015":
+    case "\u2212":
+      return "-";
+    case "\u2018":
+    case "\u2019":
+    case "\u201A":
+    case "\u201B":
+      return "'";
+    case "\u201C":
+    case "\u201D":
+    case "\u201E":
+    case "\u201F":
+      return '"';
+    case "\xA0":
+    case "\u2002":
+    case "\u2003":
+    case "\u2004":
+    case "\u2005":
+    case "\u2006":
+    case "\u2007":
+    case "\u2008":
+    case "\u2009":
+    case "\u200A":
+    case "\u202F":
+    case "\u205F":
+    case "\u3000":
+      return " ";
+    default:
+      return c;
+  }
+}).join("");
+const seekSequence = (lines, pattern, start, eof) => {
+  if (pattern.length === 0) return start;
+  if (pattern.length > lines.length) return void 0;
+  const searchStart = eof && lines.length >= pattern.length ? lines.length - pattern.length : start;
+  const upper = lines.length - pattern.length;
+  const passes = [
+    (a, b) => a === b,
+    (a, b) => a.replace(/\s+$/, "") === b.replace(/\s+$/, ""),
+    (a, b) => a.trim() === b.trim(),
+    (a, b) => normalise(a) === normalise(b)
+  ];
+  for (const equals of passes) {
+    for (let i = searchStart; i <= upper; i++) {
+      let ok = true;
+      for (let p = 0; p < pattern.length; p++) {
+        if (!equals(lines[i + p], pattern[p])) {
+          ok = false;
+          break;
+        }
+      }
+      if (ok) return i;
+    }
+  }
+  return void 0;
+};
+class ComputeReplacementsError extends Schema.TaggedError()(
+  "@smthrs/std/ComputeReplacementsError",
+  {
+    reason: Schema.Literals(["context_not_found", "lines_not_found"]),
+    path: Schema.String,
+    message: Schema.String
+  }
+) {
+}
+const computeReplacements = (originalLines, path, chunks) => {
+  const replacements = [];
+  let lineIndex = 0;
+  for (const chunk of chunks) {
+    if (chunk.changeContext !== void 0) {
+      const idx = seekSequence(originalLines, [chunk.changeContext], lineIndex, false);
+      if (idx === void 0) {
+        throw new ComputeReplacementsError({
+          reason: "context_not_found",
+          path,
+          message: `Failed to find context '${chunk.changeContext}' in ${path}`
+        });
+      }
+      lineIndex = idx + 1;
+    }
+    if (chunk.oldLines.length === 0) {
+      const insertionIdx = originalLines.length > 0 && originalLines[originalLines.length - 1] === "" ? originalLines.length - 1 : originalLines.length;
+      replacements.push([insertionIdx, 0, [...chunk.newLines]]);
+      continue;
+    }
+    let pattern = chunk.oldLines;
+    let newSlice = chunk.newLines;
+    let found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
+    if (found === void 0 && pattern[pattern.length - 1] === "") {
+      pattern = pattern.slice(0, -1);
+      if (newSlice[newSlice.length - 1] === "") newSlice = newSlice.slice(0, -1);
+      found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
+    }
+    if (found !== void 0) {
+      replacements.push([found, pattern.length, [...newSlice]]);
+      lineIndex = found + pattern.length;
+    } else {
+      throw new ComputeReplacementsError({
+        reason: "lines_not_found",
+        path,
+        message: `Failed to find expected lines in ${path}:
+${chunk.oldLines.join("\n")}`
+      });
+    }
+  }
+  replacements.sort((a, b) => a[0] - b[0]);
+  return replacements;
+};
+const applyReplacements = (lines, replacements) => {
+  for (let r = replacements.length - 1; r >= 0; r--) {
+    const [startIdx, oldLength, newSegment] = replacements[r];
+    lines.splice(startIdx, Math.min(oldLength, Math.max(lines.length - startIdx, 0)), ...newSegment);
+  }
+  return lines;
+};
+const deriveNewContents = (originalContents, path, chunks) => {
+  const originalLines = (0, import_Text.sourceLines)(originalContents);
+  const replacements = computeReplacements(originalLines, path, chunks);
+  const newLines = applyReplacements([...originalLines], replacements);
+  if (newLines[newLines.length - 1] !== "") newLines.push("");
+  return newLines.join("\n");
+};
+const printSummary = (affected) => {
+  const lines = ["Success. Updated the following files:"];
+  for (const path of affected.added) lines.push(`A ${path}`);
+  for (const path of affected.modified) lines.push(`M ${path}`);
+  for (const path of affected.deleted) lines.push(`D ${path}`);
+  return `${lines.join("\n")}
+`;
+};
+//# sourceMappingURL=ApplyPatch.js.map