@valbuild/server 0.146.4 → 0.147.0

package/dist/jsonValuesModule-d1bb8d8f.cjs.prod.js

@@ -0,0 +1,288 @@
+'use strict';
+
+var ts = require('typescript');
+var fp = require('@valbuild/core/fp');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+class ValSyntaxError {
+  constructor(message, node) {
+    this.message = message;
+    this.node = node;
+  }
+}
+function forEachError(tree, callback) {
+  if (Array.isArray(tree)) {
+    for (const subtree of tree) {
+      forEachError(subtree, callback);
+    }
+  } else {
+    callback(tree);
+  }
+}
+function flatMapErrors(tree, cb) {
+  const result = [];
+  forEachError(tree, error => result.push(cb(error)));
+  return result;
+}
+function formatSyntaxError(error, sourceFile) {
+  const pos = sourceFile.getLineAndCharacterOfPosition(error.node.pos);
+  return `${pos.line}:${pos.character} ${error.message}`;
+}
+function formatSyntaxErrorTree(tree, sourceFile) {
+  return flatMapErrors(tree, error => formatSyntaxError(error, sourceFile));
+}
+function isLiteralPropertyName(name) {
+  return ts__default["default"].isIdentifier(name) || ts__default["default"].isStringLiteral(name) || ts__default["default"].isNumericLiteral(name);
+}
+function validateObjectProperties(nodes) {
+  const errors = [];
+  for (const node of nodes) {
+    if (!ts__default["default"].isPropertyAssignment(node)) {
+      errors.push(new ValSyntaxError("Object literal element must be property assignment", node));
+    } else if (!isLiteralPropertyName(node.name)) {
+      errors.push(new ValSyntaxError("Object literal element key must be an identifier or a literal", node));
+    }
+  }
+  if (errors.length > 0) {
+    return fp.result.err(errors);
+  }
+  return fp.result.ok(nodes);
+}
+
+/**
+ * Validates that the expression is a JSON compatible type of expression without
+ * validating its children.
+ */
+function shallowValidateExpression(value) {
+  return ts__default["default"].isStringLiteralLike(value) || ts__default["default"].isNumericLiteral(value) || value.kind === ts__default["default"].SyntaxKind.TrueKeyword || value.kind === ts__default["default"].SyntaxKind.FalseKeyword || value.kind === ts__default["default"].SyntaxKind.NullKeyword || ts__default["default"].isArrayLiteralExpression(value) || ts__default["default"].isObjectLiteralExpression(value) ? undefined : new ValSyntaxError("Expression must be a literal", value);
+}
+
+/**
+ * Evaluates the expression as a JSON value
+ */
+function evaluateExpression(value) {
+  // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,
+  // or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.
+  // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
+  // https://github.com/microsoft/TypeScript/blob/4b794fe1dd0d184d3f8f17e94d8187eace57c91e/src/compiler/types.ts#L2127-L2131
+
+  if (ts__default["default"].isStringLiteralLike(value)) {
+    return fp.result.ok(value.text);
+  } else if (ts__default["default"].isNumericLiteral(value)) {
+    return fp.result.ok(Number(value.text));
+  } else if (value.kind === ts__default["default"].SyntaxKind.TrueKeyword) {
+    return fp.result.ok(true);
+  } else if (value.kind === ts__default["default"].SyntaxKind.FalseKeyword) {
+    return fp.result.ok(false);
+  } else if (value.kind === ts__default["default"].SyntaxKind.NullKeyword) {
+    return fp.result.ok(null);
+  } else if (ts__default["default"].isArrayLiteralExpression(value)) {
+    return fp.result.all(value.elements.map(evaluateExpression));
+  } else if (ts__default["default"].isObjectLiteralExpression(value)) {
+    return fp.pipe(validateObjectProperties(value.properties), fp.result.flatMap(assignments => fp.pipe(assignments.map(assignment => fp.pipe(evaluateExpression(assignment.initializer), fp.result.map(value => [assignment.name.text, value]))), fp.result.all)), fp.result.map(Object.fromEntries));
+  } else {
+    return fp.result.err(new ValSyntaxError("Expression must be a literal", value));
+  }
+}
+function findObjectPropertyAssignment(value, key) {
+  return fp.pipe(validateObjectProperties(value.properties), fp.result.flatMap(assignments => {
+    const matchingAssignments = assignments.filter(assignment => assignment.name.text === key);
+    if (matchingAssignments.length === 0) return fp.result.ok(undefined);
+    if (matchingAssignments.length > 1) {
+      return fp.result.err(new ValSyntaxError(`Object key "${key}" is ambiguous`, value));
+    }
+    const [assignment] = matchingAssignments;
+    return fp.result.ok(assignment);
+  }));
+}
+function validateInitializers(nodes) {
+  for (const node of nodes) {
+    if (ts__default["default"].isSpreadElement(node)) {
+      return new ValSyntaxError("Unexpected spread element", node);
+    }
+  }
+  return undefined;
+}
+
+function isPath(node, path) {
+  let currentNode = node;
+  for (let i = path.length - 1; i > 0; --i) {
+    const name = path[i];
+    if (!ts__default["default"].isPropertyAccessExpression(currentNode)) {
+      return false;
+    }
+    if (!ts__default["default"].isIdentifier(currentNode.name) || currentNode.name.text !== name) {
+      return false;
+    }
+    currentNode = currentNode.expression;
+  }
+  return ts__default["default"].isIdentifier(currentNode) && currentNode.text === path[0];
+}
+function validateArguments(node, validators) {
+  return fp.result.allV([node.arguments.length === validators.length ? fp.result.voidOk : fp.result.err(new ValSyntaxError(`Expected ${validators.length} arguments`, node)), ...node.arguments.slice(0, validators.length).map((argument, index) => validators[index](argument))]);
+}
+function analyzeDefaultExport(node) {
+  const cDefine = node.expression;
+  if (!ts__default["default"].isCallExpression(cDefine)) {
+    return fp.result.err(new ValSyntaxError("Expected default expression to be a call expression", cDefine));
+  }
+  if (!isPath(cDefine.expression, ["c", "define"])) {
+    return fp.result.err(new ValSyntaxError("Expected default expression to be calling c.define", cDefine.expression));
+  }
+  return fp.pipe(validateArguments(cDefine, [id => {
+    // TODO: validate ID value here?
+    if (!ts__default["default"].isStringLiteralLike(id)) {
+      return fp.result.err(new ValSyntaxError("Expected first argument to c.define to be a string literal", id));
+    }
+    return fp.result.voidOk;
+  }, () => {
+    return fp.result.voidOk;
+  }, () => {
+    return fp.result.voidOk;
+  }]), fp.result.map(() => {
+    const [, schema, source] = cDefine.arguments;
+    return {
+      schema,
+      source
+    };
+  }));
+}
+function analyzeValModule(sourceFile) {
+  const analysis = sourceFile.forEachChild(node => {
+    if (ts__default["default"].isExportAssignment(node)) {
+      return analyzeDefaultExport(node);
+    }
+  });
+  if (!analysis) {
+    throw Error("Failed to find fixed content node in val module");
+  }
+  return analysis;
+}
+
+/**
+ * Given the `source` object-literal expression of a `.jsonValues()` record /
+ * router (the 3rd argument to `c.define`, via {@link analyzeValModule}),
+ * extracts each entry's `c.json(() => import("..."))` import path, keyed by
+ * entry key. Entries whose value is not a `c.json(...)` call are skipped.
+ */
+function analyzeJsonValuesEntries(source) {
+  const entries = new Map();
+  if (!ts__default["default"].isObjectLiteralExpression(source)) {
+    return entries;
+  }
+  for (const prop of source.properties) {
+    if (!ts__default["default"].isPropertyAssignment(prop)) {
+      continue;
+    }
+    const key = getPropertyKey(prop.name);
+    if (key === null) {
+      continue;
+    }
+    const entry = analyzeCJsonCall(prop.initializer);
+    if (entry) {
+      entries.set(key, entry);
+    }
+  }
+  return entries;
+}
+
+/**
+ * Every key of a `.jsonValues()` record's source literal, thunked or not.
+ *
+ * {@link analyzeJsonValuesEntries} answers "which entries have a file behind
+ * them", which is the question for resolving a path. This is the other one:
+ * which keys the record HAS. They differ on a value that is not a
+ * `c.json(...)` call - written inline, or mid-edit - and telling an existing
+ * key from a new one is what decides whether a whole-record write adds a
+ * `c.json(...)` thunk or replaces one. Using the thunk set for that would
+ * insert a second property with a key the literal already has.
+ */
+function jsonValuesRecordKeys(source) {
+  const keys = [];
+  if (!ts__default["default"].isObjectLiteralExpression(source)) {
+    return keys;
+  }
+  for (const prop of source.properties) {
+    if (!ts__default["default"].isPropertyAssignment(prop)) {
+      continue;
+    }
+    const key = getPropertyKey(prop.name);
+    if (key !== null) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+function getPropertyKey(name) {
+  if (ts__default["default"].isStringLiteralLike(name)) {
+    return name.text;
+  }
+  if (ts__default["default"].isIdentifier(name)) {
+    return name.text;
+  }
+  return null;
+}
+function analyzeCJsonCall(node) {
+  // c.json(() => import("path"))
+  if (!ts__default["default"].isCallExpression(node) || !isCJson(node.expression)) {
+    return null;
+  }
+  const [thunk] = node.arguments;
+  if (!thunk) {
+    return null;
+  }
+  const importPath = getImportPathFromThunk(thunk);
+  if (importPath === null) {
+    return null;
+  }
+  return {
+    importPath
+  };
+}
+function isCJson(expr) {
+  // c.json
+  return ts__default["default"].isPropertyAccessExpression(expr) && ts__default["default"].isIdentifier(expr.expression) && expr.expression.text === "c" && ts__default["default"].isIdentifier(expr.name) && expr.name.text === "json";
+}
+function getImportPathFromThunk(thunk) {
+  // () => import("path")   (concise body)   OR   () => { return import("path"); }
+  if (!ts__default["default"].isArrowFunction(thunk)) {
+    return null;
+  }
+  let importCall;
+  if (ts__default["default"].isCallExpression(thunk.body)) {
+    importCall = thunk.body;
+  } else if (ts__default["default"].isBlock(thunk.body)) {
+    for (const stmt of thunk.body.statements) {
+      if (ts__default["default"].isReturnStatement(stmt) && stmt.expression && ts__default["default"].isCallExpression(stmt.expression)) {
+        importCall = stmt.expression;
+        break;
+      }
+    }
+  }
+  if (!importCall || !ts__default["default"].isCallExpression(importCall)) {
+    return null;
+  }
+  const isImport = importCall.expression.kind === ts__default["default"].SyntaxKind.ImportKeyword || ts__default["default"].isIdentifier(importCall.expression) && importCall.expression.text === "import";
+  if (!isImport) {
+    return null;
+  }
+  const arg = importCall.arguments[0];
+  if (arg && ts__default["default"].isStringLiteralLike(arg)) {
+    return arg.text;
+  }
+  return null;
+}
+
+exports.analyzeJsonValuesEntries = analyzeJsonValuesEntries;
+exports.analyzeValModule = analyzeValModule;
+exports.evaluateExpression = evaluateExpression;
+exports.findObjectPropertyAssignment = findObjectPropertyAssignment;
+exports.flatMapErrors = flatMapErrors;
+exports.formatSyntaxError = formatSyntaxError;
+exports.formatSyntaxErrorTree = formatSyntaxErrorTree;
+exports.jsonValuesRecordKeys = jsonValuesRecordKeys;
+exports.shallowValidateExpression = shallowValidateExpression;
+exports.validateInitializers = validateInitializers;

package/dist/ops-0d05feaf.esm.js

@@ -0,0 +1,353 @@
+import ts from 'typescript';
+import { pipe, result } from '@valbuild/core/fp';
+import { a as analyzeValModule, e as findObjectPropertyAssignment, s as shallowValidateExpression, g as evaluateExpression, v as validateInitializers } from './jsonValuesModule-427d68c8.esm.js';
+import { PatchError, deepEqual, parseAndValidateArrayIndex, isNotRoot } from '@valbuild/core/patch';
+
+function isValidIdentifier(text) {
+  if (text.length === 0) {
+    return false;
+  }
+  if (!ts.isIdentifierStart(text.charCodeAt(0), ts.ScriptTarget.ES2020)) {
+    return false;
+  }
+  for (let i = 1; i < text.length; ++i) {
+    if (!ts.isIdentifierPart(text.charCodeAt(i), ts.ScriptTarget.ES2020)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createPropertyAssignment(key, value) {
+  return ts.factory.createPropertyAssignment(isValidIdentifier(key) ? ts.factory.createIdentifier(key) : ts.factory.createStringLiteral(key), toExpression(value));
+}
+
+/**
+ * Builds the expression `c.json(() => import("<importPath>"))` used to reference
+ * a lazily-loaded `*.val.json` entry of a `.jsonValues()` record.
+ */
+function createValJsonReference(importPath) {
+  // () => import("<importPath>")
+  // NOTE: an `import` identifier prints as the dynamic-import keyword call,
+  // which avoids casting the ImportKeyword token (not typed as an Expression).
+  const importCall = ts.factory.createCallExpression(ts.factory.createIdentifier("import"), undefined, [ts.factory.createStringLiteral(importPath)]);
+  const thunk = ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), importCall);
+  // c.json(<thunk>)
+  return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("c"), ts.factory.createIdentifier("json")), undefined, [thunk]);
+}
+
+/**
+ * Inserts a new `.jsonValues()` entry `"<key>": c.json(() => import("<importPath>"))`
+ * into the record's object literal in a `.val.ts` module. `recordPath` is the
+ * path from the module source to the record (empty for a root record/router).
+ * Fails if the entry key already exists.
+ */
+function insertValJsonEntry(document, recordPath, key, importPath) {
+  return pipe(analyzeValModule(document), result.flatMap(({
+    source
+  }) => getAtPath(source, recordPath)), result.flatMap(recordNode => {
+    if (!ts.isObjectLiteralExpression(recordNode)) {
+      return result.err(new PatchError("Cannot add jsonValues entry: record source is not an object literal"));
+    }
+    return pipe(findObjectPropertyAssignment(recordNode, key), result.flatMap(assignment => {
+      if (assignment) {
+        return result.err(new PatchError(`Cannot add jsonValues entry '${key}': it already exists`));
+      }
+      const property = ts.factory.createPropertyAssignment(isValidIdentifier(key) ? ts.factory.createIdentifier(key) : ts.factory.createStringLiteral(key), createValJsonReference(importPath));
+      return result.ok(insertAt(document, recordNode.properties, recordNode.properties.length, property));
+    }));
+  }));
+}
+
+/**
+ * Removes the `.jsonValues()` entry `"<key>"` from the record's object literal
+ * in a `.val.ts` module. `recordPath` is the path from the module source to the
+ * record (empty for a root record/router). Fails if the entry key is missing.
+ */
+function removeValJsonEntry(document, recordPath, key) {
+  return pipe(analyzeValModule(document), result.flatMap(({
+    source
+  }) => getAtPath(source, recordPath)), result.flatMap(recordNode => {
+    if (!ts.isObjectLiteralExpression(recordNode)) {
+      return result.err(new PatchError("Cannot remove jsonValues entry: record source is not an object literal"));
+    }
+    return pipe(findObjectPropertyAssignment(recordNode, key), result.flatMap(assignment => {
+      if (!assignment) {
+        return result.err(new PatchError(`Cannot remove jsonValues entry '${key}': it does not exist`));
+      }
+      const [doc] = removeAt(document, recordNode.properties, recordNode.properties.indexOf(assignment));
+      return result.ok(doc);
+    }));
+  }));
+}
+function toExpression(value) {
+  if (typeof value === "string") {
+    // TODO: Use configuration/heuristics to determine use of single quote or double quote
+    return ts.factory.createStringLiteral(value);
+  } else if (typeof value === "number") {
+    // TODO: do we want to do something like this for very large numbers?
+    // if (value > Number.MAX_SAFE_INTEGER) {
+    //   return ts.factory.createBigIntLiteral(`${value}n`);
+    // }
+    // if (value < Number.MIN_SAFE_INTEGER) {
+    //   return ts.factory.createPrefixUnaryExpression(
+    //     ts.SyntaxKind.MinusToken,
+    //     ts.factory.createBigIntLiteral(`${value}n`),
+    //   );
+    // }
+    if (value < 0) {
+      return ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(Math.abs(value)));
+    }
+    return ts.factory.createNumericLiteral(value);
+  } else if (typeof value === "boolean") {
+    return value ? ts.factory.createTrue() : ts.factory.createFalse();
+  } else if (value === null) {
+    return ts.factory.createNull();
+  } else if (Array.isArray(value)) {
+    return ts.factory.createArrayLiteralExpression(value.map(toExpression));
+  } else if (typeof value === "object") {
+    return ts.factory.createObjectLiteralExpression(Object.entries(value)
+    // `patch_id` is injected server-side onto a media source whose bytes are
+    // not committed yet. It describes the draft, not the content, and a
+    // whole-object write built from the client's optimistic view would
+    // otherwise print it into the user's file.
+    .filter(([key]) => key !== "patch_id").map(([key, value]) => createPropertyAssignment(key, value)));
+  } else {
+    return ts.factory.createStringLiteral(value);
+  }
+}
+
+// TODO: Choose newline based on project settings/heuristics/system default?
+const newLine = ts.NewLineKind.LineFeed;
+// TODO: Handle indentation of printed code
+const printer = ts.createPrinter({
+  newLine: newLine
+  // neverAsciiEscape: true,
+});
+function replaceNodeValue(document, node, value) {
+  const replacementText = printer.printNode(ts.EmitHint.Unspecified, toExpression(value), document);
+  const span = ts.createTextSpanFromBounds(node.getStart(document, false), node.end);
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts.textSpanEnd(span))}`;
+  return [document.update(newText, ts.createTextChangeRange(span, replacementText.length)), node];
+}
+function isIndentation(s) {
+  for (let i = 0; i < s.length; ++i) {
+    const c = s.charAt(i);
+    if (c !== " " && c !== "\t") {
+      return false;
+    }
+  }
+  return true;
+}
+function newLineStr(kind) {
+  if (kind === ts.NewLineKind.CarriageReturnLineFeed) {
+    return "\r\n";
+  } else {
+    return "\n";
+  }
+}
+function getSeparator(document, neighbor) {
+  const startPos = neighbor.getStart(document, true);
+  const basis = document.getLineAndCharacterOfPosition(startPos);
+  const lineStartPos = document.getPositionOfLineAndCharacter(basis.line, 0);
+  const maybeIndentation = document.getText().substring(lineStartPos, startPos);
+  if (isIndentation(maybeIndentation)) {
+    return `,${newLineStr(newLine)}${maybeIndentation}`;
+  } else {
+    return `, `;
+  }
+}
+function insertAt(document, nodes, index, node) {
+  let span;
+  let replacementText;
+  if (nodes.length === 0) {
+    // Replace entire range of nodes
+    replacementText = printer.printNode(ts.EmitHint.Unspecified, node, document);
+    span = ts.createTextSpanFromBounds(nodes.pos, nodes.end);
+  } else if (index === nodes.length) {
+    // Insert after last node
+    const neighbor = nodes[nodes.length - 1];
+    replacementText = `${getSeparator(document, neighbor)}${printer.printNode(ts.EmitHint.Unspecified, node, document)}`;
+    span = ts.createTextSpan(neighbor.end, 0);
+  } else {
+    // Insert before node
+    const neighbor = nodes[index];
+    replacementText = `${printer.printNode(ts.EmitHint.Unspecified, node, document)}${getSeparator(document, neighbor)}`;
+    span = ts.createTextSpan(neighbor.getStart(document, true), 0);
+  }
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts.textSpanEnd(span))}`;
+  return document.update(newText, ts.createTextChangeRange(span, replacementText.length));
+}
+function removeAt(document, nodes, index) {
+  const node = nodes[index];
+  let span;
+  if (nodes.length === 1) {
+    span = ts.createTextSpanFromBounds(nodes.pos, nodes.end);
+  } else if (index === nodes.length - 1) {
+    // Remove until previous node
+    const neighbor = nodes[index - 1];
+    span = ts.createTextSpanFromBounds(neighbor.end, node.end);
+  } else {
+    // Remove before next node
+    const neighbor = nodes[index + 1];
+    span = ts.createTextSpanFromBounds(node.getStart(document, true), neighbor.getStart(document, true));
+  }
+  const newText = `${document.text.substring(0, span.start)}${document.text.substring(ts.textSpanEnd(span))}`;
+  return [document.update(newText, ts.createTextChangeRange(span, 0)), node];
+}
+function parseAndValidateArrayInsertIndex(key, nodes) {
+  if (key === "-") {
+    // For insertion, all nodes up until the insertion index must be valid
+    // initializers
+    const err = validateInitializers(nodes);
+    if (err) {
+      return result.err(err);
+    }
+    return result.ok(nodes.length);
+  }
+  return pipe(parseAndValidateArrayIndex(key), result.flatMap(index => {
+    // For insertion, all nodes up until the insertion index must be valid
+    // initializers
+    const err = validateInitializers(nodes.slice(0, index));
+    if (err) {
+      return result.err(err);
+    }
+    if (index > nodes.length) {
+      return result.err(new PatchError("Array index out of bounds"));
+    } else {
+      return result.ok(index);
+    }
+  }));
+}
+function parseAndValidateArrayInboundsIndex(key, nodes) {
+  return pipe(parseAndValidateArrayIndex(key), result.flatMap(index => {
+    // For in-bounds operations, all nodes up until and including the index
+    // must be valid initializers
+    const err = validateInitializers(nodes.slice(0, index + 1));
+    if (err) {
+      return result.err(err);
+    }
+    if (index >= nodes.length) {
+      return result.err(new PatchError("Array index out of bounds"));
+    } else {
+      return result.ok(index);
+    }
+  }));
+}
+function replaceInNode(document, node, key, value) {
+  if (ts.isArrayLiteralExpression(node)) {
+    return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => replaceNodeValue(document, node.elements[index], value)));
+  } else if (ts.isObjectLiteralExpression(node)) {
+    return pipe(findObjectPropertyAssignment(node, key), result.flatMap(assignment => {
+      if (!assignment) {
+        return result.err(new PatchError("Cannot replace object element which does not exist"));
+      }
+      return result.ok(assignment);
+    }), result.map(assignment => replaceNodeValue(document, assignment.initializer, value)));
+  } else {
+    return result.err(shallowValidateExpression(node) ?? new PatchError("Cannot replace in non-object/array"));
+  }
+}
+function replaceAtPath(document, rootNode, path, value) {
+  if (isNotRoot(path)) {
+    return pipe(getPointerFromPath(rootNode, path), result.flatMap(([node, key]) => replaceInNode(document, node, key, value)));
+  } else {
+    return result.ok(replaceNodeValue(document, rootNode, value));
+  }
+}
+function getFromNode(node, key) {
+  if (ts.isArrayLiteralExpression(node)) {
+    return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => node.elements[index]));
+  } else if (ts.isObjectLiteralExpression(node)) {
+    return pipe(findObjectPropertyAssignment(node, key), result.map(assignment => assignment === null || assignment === void 0 ? void 0 : assignment.initializer));
+  } else {
+    return result.err(shallowValidateExpression(node) ?? new PatchError("Cannot access non-object/array"));
+  }
+}
+function getPointerFromPath(node, path) {
+  let targetNode = node;
+  let key = path[0];
+  for (let i = 0; i < path.length - 1; ++i, key = path[i]) {
+    const childNode = getFromNode(targetNode, key);
+    if (result.isErr(childNode)) {
+      return childNode;
+    }
+    if (childNode.value === undefined) {
+      return result.err(new PatchError(`Path refers to non-existing object/array: ${path.join("/")}`));
+    }
+    targetNode = childNode.value;
+  }
+  return result.ok([targetNode, key]);
+}
+function getAtPath(rootNode, path) {
+  return pipe(path, result.flatMapReduce((node, key) => pipe(getFromNode(node, key), result.filterOrElse(childNode => childNode !== undefined, () => new PatchError("Path refers to non-existing object/array"))), rootNode));
+}
+function removeFromNode(document, node, key) {
+  if (ts.isArrayLiteralExpression(node)) {
+    return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => removeAt(document, node.elements, index)));
+  } else if (ts.isObjectLiteralExpression(node)) {
+    return pipe(findObjectPropertyAssignment(node, key), result.flatMap(assignment => {
+      if (!assignment) {
+        return result.err(new PatchError("Cannot remove object element which does not exist"));
+      }
+      return result.ok(assignment);
+    }), result.map(assignment => [removeAt(document, node.properties, node.properties.indexOf(assignment))[0], assignment.initializer]));
+  } else {
+    return result.err(shallowValidateExpression(node) ?? new PatchError("Cannot remove from non-object/array"));
+  }
+}
+function removeAtPath(document, rootNode, path) {
+  return pipe(getPointerFromPath(rootNode, path), result.flatMap(([node, key]) => removeFromNode(document, node, key)));
+}
+function addToNode(document, node, key, value) {
+  if (ts.isArrayLiteralExpression(node)) {
+    return pipe(parseAndValidateArrayInsertIndex(key, node.elements), result.map(index => [insertAt(document, node.elements, index, toExpression(value))]));
+  } else if (ts.isObjectLiteralExpression(node)) {
+    return pipe(findObjectPropertyAssignment(node, key), result.map(assignment => {
+      if (!assignment) {
+        return [insertAt(document, node.properties, node.properties.length, createPropertyAssignment(key, value))];
+      } else {
+        return replaceNodeValue(document, assignment.initializer, value);
+      }
+    }));
+  } else {
+    return result.err(shallowValidateExpression(node) ?? new PatchError("Cannot add to non-object/array"));
+  }
+}
+function addAtPath(document, rootNode, path, value) {
+  if (isNotRoot(path)) {
+    return pipe(getPointerFromPath(rootNode, path), result.flatMap(([node, key]) => addToNode(document, node, key, value)));
+  } else {
+    return result.ok(replaceNodeValue(document, rootNode, value));
+  }
+}
+function pickDocument([document]) {
+  return document;
+}
+class TSOps {
+  constructor(findRoot) {
+    this.findRoot = findRoot;
+  }
+  get(document, path) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => getAtPath(rootNode, path)), result.flatMap(evaluateExpression));
+  }
+  add(document, path, value) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => addAtPath(document, rootNode, path, value)), result.map(pickDocument));
+  }
+  remove(document, path) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => removeAtPath(document, rootNode, path)), result.map(pickDocument));
+  }
+  replace(document, path, value) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => replaceAtPath(document, rootNode, path, value)), result.map(pickDocument));
+  }
+  move(document, from, path) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => removeAtPath(document, rootNode, from)), result.flatMap(([document, removedNode]) => pipe(evaluateExpression(removedNode), result.map(removedValue => [document, removedValue]))), result.flatMap(([document, removedValue]) => pipe(document, this.findRoot, result.flatMap(root => addAtPath(document, root, path, removedValue)))), result.map(pickDocument));
+  }
+  copy(document, from, path) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => pipe(getAtPath(rootNode, from), result.flatMap(evaluateExpression), result.flatMap(value => addAtPath(document, rootNode, path, value)))), result.map(pickDocument));
+  }
+  test(document, path, value) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => getAtPath(rootNode, path)), result.flatMap(evaluateExpression), result.map(documentValue => deepEqual(value, documentValue)));
+  }
+}
+
+export { TSOps as T, insertValJsonEntry as i, removeValJsonEntry as r };