@knitting-tools/core 2.0.0

package/dist/index.js

@@ -0,0 +1,2572 @@
+// src/constants/units.ts
+var INCH_TO_CM = 2.54;
+var CM_TO_INCH = 1 / INCH_TO_CM;
+var MM_TO_CM = 0.1;
+var CM_TO_MM = 10;
+
+// src/gauge/gauge.ts
+var unitToCm = (value, unit) => {
+  if (unit === "metric") return value / 10;
+  else return value / 4 / INCH_TO_CM;
+};
+function stitchesPerCm(gauge) {
+  if (gauge.unit === "metric") {
+    return unitToCm(gauge.stitchesPer10cm, "metric");
+  }
+  return unitToCm(gauge.stitchesPer4in, "imperial");
+}
+function rowsPerCm(gauge) {
+  if (gauge.unit === "metric") {
+    return unitToCm(gauge.rowsPer10cm, "metric");
+  }
+  return unitToCm(gauge.rowsPer4in, "imperial");
+}
+
+// src/gauge/conversion.ts
+function cmToStitches(cm, gauge) {
+  return Math.round(stitchesPerCm(gauge) * cm);
+}
+function cmToRows(cm, gauge) {
+  return Math.round(rowsPerCm(gauge) * cm);
+}
+
+// src/measurement/measurement.ts
+function convertLength(value, from, to) {
+  if (from === to) {
+    return value;
+  }
+  if (from === "cm" && to === "in") {
+    return value * CM_TO_INCH;
+  }
+  if (from === "in" && to === "cm") {
+    return value * INCH_TO_CM;
+  }
+  throw new Error(`Unsupported conversion from ${from} \u2192 ${to}`);
+}
+function normaliseMeasurement(value, unit) {
+  return convertLength(value, unit, "cm");
+}
+function roundStitches(stitches) {
+  if (!Number.isFinite(stitches)) {
+    throw new Error("Stitch count must be a finite number.");
+  }
+  return Math.round(stitches);
+}
+
+// src/pattern/row.ts
+var InstructionBuffer = class {
+  items = [];
+  append(instruction, count = instruction.count) {
+    this.items[this.items.length] = cloneInstruction(instruction, count);
+  }
+  toArray() {
+    return this.items;
+  }
+};
+var SHAPING_CONSUME = {
+  decrease: 2,
+  increase: 1
+};
+var SHAPING_PRODUCE = {
+  decrease: 1,
+  increase: 2
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRepeatBlock(element) {
+  return element.type === "repeat";
+}
+function isShapingElement(element) {
+  return element.type === "shaping";
+}
+function isEdgeShapingElement(element) {
+  return element.type === "shaping";
+}
+function isStitchInstruction(element) {
+  return !isRepeatBlock(element) && !isShapingElement(element);
+}
+function countEdgeSourceStitches(stitches) {
+  return (stitches == null ? void 0 : stitches.reduce(
+    (sum, stitch) => sum + (isEdgeShapingElement(stitch) ? stitch.count * SHAPING_CONSUME[stitch.shapingType] : stitch.count),
+    0
+  )) ?? 0;
+}
+function countSequenceStitches(elements) {
+  let total = 0;
+  for (const element of elements) {
+    if (isStitchInstruction(element)) {
+      total += element.count;
+      continue;
+    }
+    if (isShapingElement(element)) {
+      total += element.count * SHAPING_CONSUME[element.shapingType];
+      continue;
+    }
+    if (element.times !== void 0) {
+      const inner = countSequenceStitches(element.sequence);
+      if (inner === null) {
+        return null;
+      }
+      total += element.times * inner;
+      continue;
+    }
+    return null;
+  }
+  return total;
+}
+function cloneVariantParameters(variantParameters) {
+  return variantParameters ? { ...variantParameters } : void 0;
+}
+function cloneInstruction(instruction, count = instruction.count) {
+  return {
+    count,
+    type: instruction.type,
+    variant: instruction.variant,
+    variantParameters: cloneVariantParameters(instruction.variantParameters)
+  };
+}
+function inferDecreaseVariant(element) {
+  const isPurl = element.stitch === "purl";
+  switch (element.direction) {
+    case "left":
+      return isPurl ? "ssp" : "ssk";
+    case "right":
+      return isPurl ? "p2tog" : "k2tog";
+    default:
+      return isPurl ? "p2tog" : void 0;
+  }
+}
+function inferIncreaseVariant(element) {
+  switch (element.direction) {
+    case "left":
+      return "inv-l";
+    case "right":
+      return "inv-r";
+    default:
+      return void 0;
+  }
+}
+function inferShapingVariant(element) {
+  if (element.shapingType === "decrease") {
+    return inferDecreaseVariant(element);
+  }
+  return inferIncreaseVariant(element);
+}
+function createInstructionFromShaping(element, operationCount) {
+  const inferredVariant = element.variant ?? inferShapingVariant(element);
+  return {
+    count: operationCount * SHAPING_PRODUCE[element.shapingType],
+    type: element.shapingType,
+    variant: inferredVariant,
+    variantParameters: cloneVariantParameters(element.variantParameters)
+  };
+}
+function areVariantParametersEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (left === void 0 || right === void 0) {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  for (const key of leftKeys) {
+    if (!(key in right) || left[key] !== right[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function canMergeInstructions(left, right) {
+  return left.type === right.type && left.variant === right.variant && areVariantParametersEqual(left.variantParameters, right.variantParameters);
+}
+function assertPositiveInteger(value, label) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${label} must be a positive integer. Received ${String(value)}.`);
+  }
+}
+function assertNonNegativeInteger(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer. Received ${String(value)}.`);
+  }
+}
+function validateVariantParameters(variantParameters, path) {
+  if (variantParameters === void 0) {
+    return;
+  }
+  if (!isRecord(variantParameters)) {
+    throw new Error(`${path} must be a plain object when provided.`);
+  }
+  for (const [key, value] of Object.entries(variantParameters)) {
+    const valueType = typeof value;
+    if (valueType !== "string" && valueType !== "boolean" && (valueType !== "number" || !Number.isFinite(value))) {
+      throw new Error(
+        `${path}.${key} must be a string, finite number, or boolean. Received ${String(value)}.`
+      );
+    }
+  }
+}
+function validateStitchInstruction(instruction, path) {
+  if (!isRecord(instruction)) {
+    throw new Error(`${path} must be an object.`);
+  }
+  assertPositiveInteger(instruction.count, `${path}.count`);
+  validateVariantParameters(instruction.variantParameters, `${path}.variantParameters`);
+}
+function validateShapingElement(element, path) {
+  if (!isRecord(element)) {
+    throw new Error(`${path} must be an object.`);
+  }
+  if (element.shapingType !== "decrease" && element.shapingType !== "increase") {
+    throw new Error(`${path}.shapingType must be 'decrease' or 'increase'.`);
+  }
+  if (element.direction !== void 0 && element.direction !== "left" && element.direction !== "right" && element.direction !== "centre") {
+    throw new Error(`${path}.direction must be 'left', 'right', or 'centre' when provided.`);
+  }
+  if (element.stitch !== void 0 && element.stitch !== "knit" && element.stitch !== "purl") {
+    throw new Error(`${path}.stitch must be 'knit' or 'purl' when provided.`);
+  }
+  assertPositiveInteger(element.count, `${path}.count`);
+  validateVariantParameters(element.variantParameters, `${path}.variantParameters`);
+}
+function assertRepeatPositiveInteger(value, label) {
+  if (typeof value !== "number") {
+    throw new TypeError(`${label} must be a positive integer.`);
+  }
+  assertPositiveInteger(value, label);
+  return value;
+}
+function assertOptionalRepeatPositiveInteger(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return assertRepeatPositiveInteger(value, label);
+}
+function getRepeatMode(repeat, path) {
+  const repeatRecord = repeat;
+  const hasTimes = repeatRecord.times !== void 0;
+  const hasToEnd = repeatRecord.toEnd !== void 0;
+  const hasTargetStitches = repeatRecord.targetStitches !== void 0;
+  const hasRemainingStitches = repeatRecord.remainingStitches !== void 0;
+  const modes = [hasTimes, hasToEnd, hasTargetStitches, hasRemainingStitches].filter(
+    Boolean
+  ).length;
+  if (modes !== 1) {
+    throw new Error(
+      `${path} must define exactly one termination mode: times, toEnd, targetStitches, or remainingStitches.`
+    );
+  }
+  const assertMaxRepeats = () => {
+    assertOptionalRepeatPositiveInteger(repeatRecord.maxRepeats, `${path}.maxRepeats`);
+  };
+  if (hasTimes) {
+    assertRepeatPositiveInteger(repeatRecord.times, `${path}.times`);
+    if (repeatRecord.maxRepeats !== void 0) {
+      throw new Error(`${path}.maxRepeats cannot be combined with fixed times.`);
+    }
+    return "times";
+  }
+  if (hasToEnd) {
+    if (repeatRecord.toEnd !== true) {
+      throw new Error(`${path}.toEnd must be true when provided.`);
+    }
+    if (repeatRecord.allowPartial !== void 0 && typeof repeatRecord.allowPartial !== "boolean") {
+      throw new Error(`${path}.allowPartial must be a boolean when provided.`);
+    }
+    assertMaxRepeats();
+    return "to-end";
+  }
+  if (hasRemainingStitches) {
+    assertRepeatPositiveInteger(repeatRecord.remainingStitches, `${path}.remainingStitches`);
+    assertMaxRepeats();
+    return "until-remaining";
+  }
+  assertRepeatPositiveInteger(repeatRecord.targetStitches, `${path}.targetStitches`);
+  assertMaxRepeats();
+  return "until-stitches";
+}
+function validateRowElements(elements, path, isNested = false) {
+  if (!Array.isArray(elements)) {
+    throw new TypeError(`${path} must be an array.`);
+  }
+  for (let index = 0; index < elements.length; index += 1) {
+    const element = elements[index];
+    const elementPath = `${path}[${index}]`;
+    if (isStitchInstruction(element)) {
+      validateStitchInstruction(element, elementPath);
+      continue;
+    }
+    if (isShapingElement(element)) {
+      validateShapingElement(element, elementPath);
+      continue;
+    }
+    if (!isRecord(element)) {
+      throw new Error(`${elementPath} must be an object.`);
+    }
+    if (!Array.isArray(element.sequence) || element.sequence.length === 0) {
+      throw new Error(`${elementPath}.sequence must be a non-empty array.`);
+    }
+    getRepeatMode(element, elementPath);
+    if (isNested && "remainingStitches" in element && element.remainingStitches !== void 0) {
+      throw new Error(
+        `${elementPath}.remainingStitches can only be used in top-level repeats, not nested repeats.`
+      );
+    }
+    validateRowElements(element.sequence, `${elementPath}.sequence`, true);
+  }
+}
+function validateEdgeElements(stitches, path) {
+  if (stitches === void 0) {
+    return;
+  }
+  if (!Array.isArray(stitches)) {
+    throw new TypeError(`${path} must be an array when provided.`);
+  }
+  for (let index = 0; index < stitches.length; index += 1) {
+    const edge = stitches[index];
+    const edgePath = `${path}[${index}]`;
+    if (isEdgeShapingElement(edge)) {
+      validateShapingElement(edge, edgePath);
+      continue;
+    }
+    validateStitchInstruction(edge, edgePath);
+  }
+}
+function validateRowInput(row, totalStitches) {
+  if (!isRecord(row)) {
+    throw new Error("row must be an object.");
+  }
+  assertNonNegativeInteger(totalStitches, "totalStitches");
+  validateEdgeElements(row.edgeStart, "row.edgeStart");
+  validateEdgeElements(row.edgeEnd, "row.edgeEnd");
+  validateRowElements(row.elements, "row.elements");
+}
+function createFrame(elements, path, repeat, applyRemainingConstraint = false) {
+  return {
+    applyRemainingConstraint,
+    elements,
+    index: 0,
+    iterationsCompleted: 0,
+    path,
+    producedInIteration: 0,
+    producedStitches: 0,
+    repeat
+  };
+}
+function getRemainingCapacity(frame, available, used) {
+  if (!frame.repeat || !frame.applyRemainingConstraint || frame.repeat.remainingStitches === void 0) {
+    return null;
+  }
+  return available - frame.repeat.remainingStitches - used;
+}
+function getFrameRemaining(frame, bodyStitchesUsed, available) {
+  if (!frame.repeat) {
+    return null;
+  }
+  if (frame.repeat.targetStitches !== void 0) {
+    return frame.repeat.targetStitches - (frame.producedStitches + frame.producedInIteration);
+  }
+  return getRemainingCapacity(frame, available, bodyStitchesUsed);
+}
+function shouldStopFrameEarly(frame, bodyStitchesUsed, available) {
+  if (!frame.repeat) {
+    return false;
+  }
+  if (bodyStitchesUsed >= available) {
+    return true;
+  }
+  const remaining = getFrameRemaining(frame, bodyStitchesUsed, available);
+  return remaining !== null && remaining <= 0;
+}
+function shouldContinueRepeat(frame, bodyStitchesUsed, available) {
+  const repeat = frame.repeat;
+  if (!repeat || bodyStitchesUsed >= available) {
+    return false;
+  }
+  if (repeat.times !== void 0) {
+    return frame.iterationsCompleted < repeat.times;
+  }
+  if (repeat.maxRepeats !== void 0 && frame.iterationsCompleted >= repeat.maxRepeats) {
+    return false;
+  }
+  const remainingCapacity = getRemainingCapacity(frame, available, bodyStitchesUsed);
+  if (remainingCapacity !== null) {
+    return remainingCapacity > 0;
+  }
+  if (repeat.targetStitches !== void 0) {
+    return frame.producedStitches < repeat.targetStitches;
+  }
+  return true;
+}
+var MAX_EXPANSION_STEPS = 1e5;
+function increaseProducedInIteration(frames, amount) {
+  for (const frame of frames) {
+    if (frame.repeat) {
+      frame.producedInIteration += amount;
+    }
+  }
+}
+function fillInstructionInBody(state, instruction) {
+  const remaining = state.available - state.bodyStitchesUsed;
+  if (remaining <= 0) {
+    return;
+  }
+  let stitchesToAdd = Math.min(instruction.count, remaining);
+  for (const frame of state.frames) {
+    const frameRemaining = getFrameRemaining(frame, state.bodyStitchesUsed, state.available);
+    if (frameRemaining !== null) {
+      stitchesToAdd = Math.min(stitchesToAdd, frameRemaining);
+    }
+  }
+  if (stitchesToAdd <= 0) {
+    return;
+  }
+  state.result.append(instruction, stitchesToAdd);
+  state.bodyStitchesUsed += stitchesToAdd;
+  increaseProducedInIteration(state.frames, stitchesToAdd);
+}
+function fillShapingInBody(state, element) {
+  const remaining = state.available - state.bodyStitchesUsed;
+  if (remaining <= 0) {
+    return;
+  }
+  let operationsToAdd = Math.min(
+    element.count,
+    Math.floor(remaining / SHAPING_CONSUME[element.shapingType])
+  );
+  for (const frame of state.frames) {
+    const frameRemaining = getFrameRemaining(frame, state.bodyStitchesUsed, state.available);
+    if (frameRemaining !== null) {
+      operationsToAdd = Math.min(
+        operationsToAdd,
+        Math.floor(frameRemaining / SHAPING_CONSUME[element.shapingType])
+      );
+    }
+  }
+  if (operationsToAdd <= 0) {
+    return;
+  }
+  state.result.append(createInstructionFromShaping(element, operationsToAdd));
+  const consumed = operationsToAdd * SHAPING_CONSUME[element.shapingType];
+  state.bodyStitchesUsed += consumed;
+  increaseProducedInIteration(state.frames, consumed);
+}
+function shouldPopForCycleConstraint(frame, state) {
+  const repeat = frame.repeat;
+  if (!repeat || frame.index !== 0 || frame.producedInIteration !== 0) {
+    return false;
+  }
+  const toEndRequiresCycles = repeat.toEnd === true && !repeat.allowPartial;
+  const remainingConstraintActive = frame.applyRemainingConstraint;
+  if (!toEndRequiresCycles && !remainingConstraintActive) {
+    return false;
+  }
+  const seqSize = countSequenceStitches(repeat.sequence);
+  if (seqSize === null) {
+    throw new Error(
+      `${frame.path} must have a fixed stitch count (no nested to-end/target repeats) when used with 'to last' or strict to-end.`
+    );
+  }
+  const reserved = remainingConstraintActive ? repeat.remainingStitches ?? 0 : 0;
+  return state.available - state.bodyStitchesUsed - reserved < seqSize;
+}
+function handleCompletedFrame(frame, state) {
+  if (frame.index < frame.elements.length) {
+    return false;
+  }
+  if (!frame.repeat) {
+    state.frames.pop();
+    return true;
+  }
+  if (frame.producedInIteration === 0) {
+    if (frame.iterationsCompleted === 0) {
+      throw new Error(`${frame.path} must consume at least one stitch per iteration.`);
+    }
+    state.frames.pop();
+    return true;
+  }
+  frame.producedStitches += frame.producedInIteration;
+  frame.producedInIteration = 0;
+  frame.iterationsCompleted += 1;
+  if (shouldContinueRepeat(frame, state.bodyStitchesUsed, state.available)) {
+    frame.index = 0;
+    return true;
+  }
+  state.frames.pop();
+  return true;
+}
+function pushChildRepeatFrame(state, element, elementPath) {
+  const hasRemainingConstraintAncestor = state.frames.some(
+    (candidate) => candidate.applyRemainingConstraint === true
+  );
+  const applyRemainingConstraint = element.remainingStitches !== void 0 && !hasRemainingConstraintAncestor;
+  state.frames.push(
+    createFrame(element.sequence, `${elementPath}.sequence`, element, applyRemainingConstraint)
+  );
+}
+function shouldAdvanceFrame(frame, state) {
+  const shouldPop = shouldStopFrameEarly(frame, state.bodyStitchesUsed, state.available) || shouldPopForCycleConstraint(frame, state);
+  if (shouldPop) {
+    state.frames.pop();
+    return false;
+  }
+  return !handleCompletedFrame(frame, state);
+}
+function runBodyExpansion(state) {
+  let expansionSteps = 0;
+  while (state.frames.length > 0 && state.bodyStitchesUsed < state.available) {
+    expansionSteps += 1;
+    if (expansionSteps > MAX_EXPANSION_STEPS) {
+      throw new Error(
+        `Row expansion exceeded ${MAX_EXPANSION_STEPS} steps. Possible infinite loop in repeat structure.`
+      );
+    }
+    const frame = state.frames.at(-1);
+    if (!frame) {
+      break;
+    }
+    if (!shouldAdvanceFrame(frame, state)) {
+      continue;
+    }
+    const element = frame.elements[frame.index];
+    const elementPath = `${frame.path}[${frame.index}]`;
+    frame.index += 1;
+    if (isStitchInstruction(element)) {
+      fillInstructionInBody(state, element);
+      continue;
+    }
+    if (isShapingElement(element)) {
+      fillShapingInBody(state, element);
+      continue;
+    }
+    pushChildRepeatFrame(state, element, elementPath);
+  }
+}
+function expandRow(row, totalStitches) {
+  validateRowInput(row, totalStitches);
+  if (totalStitches === 0) {
+    return [];
+  }
+  const result = new InstructionBuffer();
+  let used = 0;
+  const appendEdgeElements = (edges) => {
+    if (!edges) {
+      return;
+    }
+    for (const edge of edges) {
+      if (isEdgeShapingElement(edge)) {
+        result.append(createInstructionFromShaping(edge, edge.count));
+        used += edge.count * SHAPING_CONSUME[edge.shapingType];
+      } else {
+        result.append(edge);
+        used += edge.count;
+      }
+    }
+  };
+  appendEdgeElements(row.edgeStart);
+  const edgeEndCount = countEdgeSourceStitches(row.edgeEnd);
+  if (used + edgeEndCount > totalStitches) {
+    throw new Error("Edge stitches exceed total stitches for the row.");
+  }
+  const available = totalStitches - used - edgeEndCount;
+  const bodyState = {
+    available,
+    bodyStitchesUsed: 0,
+    frames: [createFrame(row.elements, "row.elements")],
+    result
+  };
+  runBodyExpansion(bodyState);
+  appendEdgeElements(row.edgeEnd);
+  return result.toArray();
+}
+function expandRowToStitches(row, totalStitches) {
+  const expanded = expandRow(row, totalStitches);
+  const final = [];
+  for (const instr of expanded) {
+    const last = final.at(-1);
+    if (last && canMergeInstructions(last, instr)) {
+      last.count += instr.count;
+    } else {
+      final.push(cloneInstruction(instr));
+    }
+  }
+  return final;
+}
+function countStitchesInInstructions(instructions) {
+  return instructions.reduce((sum, instruction) => sum + instruction.count, 0);
+}
+function expandRowToStitchTypes(row, totalStitches) {
+  const instructions = expandRow(row, totalStitches);
+  const totalCount = countStitchesInInstructions(instructions);
+  const stitches = new Array(totalCount);
+  let writeIndex = 0;
+  for (const instr of instructions) {
+    for (let i = 0; i < instr.count; i++) {
+      stitches[writeIndex] = instr.type;
+      writeIndex += 1;
+    }
+  }
+  return stitches;
+}
+
+// src/parser/repeatTermination.ts
+function buildRepeatBlock(sequence, termination) {
+  switch (termination.mode) {
+    case "times":
+      return { sequence, times: termination.times, type: "repeat" };
+    case "until-stitches":
+      return termination.maxRepeats === void 0 ? { sequence, targetStitches: termination.targetStitches, type: "repeat" } : {
+        maxRepeats: termination.maxRepeats,
+        sequence,
+        targetStitches: termination.targetStitches,
+        type: "repeat"
+      };
+    case "until-remaining":
+      return termination.maxRepeats === void 0 ? { remainingStitches: termination.remainingStitches, sequence, type: "repeat" } : {
+        maxRepeats: termination.maxRepeats,
+        remainingStitches: termination.remainingStitches,
+        sequence,
+        type: "repeat"
+      };
+    case "to-end":
+      return termination.maxRepeats === void 0 && termination.allowPartial === void 0 ? { sequence, toEnd: true, type: "repeat" } : (() => {
+        const repeat = {
+          sequence,
+          toEnd: true,
+          type: "repeat"
+        };
+        if (termination.allowPartial === void 0) {
+        } else {
+          repeat.allowPartial = termination.allowPartial;
+        }
+        if (termination.maxRepeats === void 0) {
+        } else {
+          repeat.maxRepeats = termination.maxRepeats;
+        }
+        return repeat;
+      })();
+  }
+}
+function getRepeatTermination(repeat) {
+  if ("times" in repeat && repeat.times !== void 0) {
+    return { mode: "times", times: repeat.times };
+  }
+  if ("targetStitches" in repeat && repeat.targetStitches !== void 0) {
+    return {
+      maxRepeats: repeat.maxRepeats,
+      mode: "until-stitches",
+      targetStitches: repeat.targetStitches
+    };
+  }
+  if ("remainingStitches" in repeat && repeat.remainingStitches !== void 0) {
+    return {
+      maxRepeats: repeat.maxRepeats,
+      mode: "until-remaining",
+      remainingStitches: repeat.remainingStitches
+    };
+  }
+  return {
+    allowPartial: repeat.allowPartial,
+    maxRepeats: repeat.maxRepeats,
+    mode: "to-end"
+  };
+}
+
+// src/parser/stitchRegistryData.ts
+var STITCH_TYPE_MAP = {
+  dec: "decrease",
+  decrease: "decrease",
+  inc: "increase",
+  increase: "increase",
+  k: "knit",
+  knit: "knit",
+  p: "purl",
+  purl: "purl"
+};
+var STITCH_ABBREVIATION_MAP = {
+  "k1-b": "knit",
+  k2tog: "decrease",
+  kfb: "increase",
+  kfbf: "increase",
+  "inv-l": "increase",
+  "inv-r": "increase",
+  m1: "increase",
+  "p1-b": "purl",
+  p2tog: "decrease",
+  pfb: "increase",
+  psso: "decrease",
+  s2kp: "decrease",
+  sk2p: "decrease",
+  skp: "decrease",
+  sl: "knit",
+  sl1: "knit",
+  slip: "knit",
+  ssp: "decrease",
+  ssk: "decrease",
+  tbl: "knit",
+  yfon: "increase",
+  yfrn: "increase",
+  yon: "increase",
+  yrn: "increase",
+  yo: "increase"
+};
+var STITCH_DEFAULT_COUNT_MAP = {
+  kfbf: 2
+};
+var STITCH_LOCKED_COUNT_VARIANTS = /* @__PURE__ */ new Set([
+  "k1-b",
+  "k2tog",
+  "kfbf",
+  "p1-b",
+  "p2tog",
+  "s2kp",
+  "sk2p",
+  "sl1"
+]);
+
+// src/parser/rowDslSerialiser.ts
+var STITCH_TYPE_TO_TOKEN = /* @__PURE__ */ (() => {
+  const map = {
+    decrease: "dec",
+    increase: "inc",
+    knit: "k",
+    purl: "p"
+  };
+  return map;
+})();
+function isLockedCountVariant(variant) {
+  return STITCH_LOCKED_COUNT_VARIANTS.has(variant);
+}
+function serialiseStitchInstruction(instr) {
+  if (instr.variant) {
+    if (isLockedCountVariant(instr.variant)) {
+      if (instr.count === 1) {
+        return instr.variant;
+      }
+      return `(${instr.variant}) *${instr.count}`;
+    }
+    return instr.count === 1 ? instr.variant : `${instr.variant}${instr.count}`;
+  }
+  const token = STITCH_TYPE_TO_TOKEN[instr.type] ?? instr.type;
+  return `${token}${instr.count}`;
+}
+function serialiseShapingElement(el) {
+  const typeToken = el.shapingType === "decrease" ? "dec" : "inc";
+  let dirToken = "";
+  if (el.direction !== void 0) {
+    dirToken = `-${el.direction}`;
+  }
+  return `shape-${typeToken}${dirToken}${el.count}`;
+}
+function serialiseMaxRepeats(maxRepeats) {
+  if (maxRepeats === void 0) {
+    return "";
+  }
+  return ` max ${maxRepeats} repeats`;
+}
+function serialiseRowElement(el) {
+  if (el.type === "shaping") {
+    return serialiseShapingElement(el);
+  }
+  if (el.type === "repeat") {
+    return serialiseRepeatBlock(el);
+  }
+  return serialiseStitchInstruction(el);
+}
+function serialiseRepeatBlock(block) {
+  const inner = block.sequence.map(serialiseRowElement).join(" ");
+  const body = `(${inner})`;
+  const termination = getRepeatTermination(block);
+  switch (termination.mode) {
+    case "times":
+      return `${body} *${termination.times}`;
+    case "until-stitches": {
+      const maxPart = serialiseMaxRepeats(termination.maxRepeats);
+      return `${body} until ${termination.targetStitches}${maxPart}`;
+    }
+    case "until-remaining": {
+      const maxPart = serialiseMaxRepeats(termination.maxRepeats);
+      return `${body} to last ${termination.remainingStitches}${maxPart}`;
+    }
+    case "to-end": {
+      const allowPartialPart = termination.allowPartial === true ? " allow partial" : "";
+      const maxPart = serialiseMaxRepeats(termination.maxRepeats);
+      return `${body}${allowPartialPart}${maxPart}`;
+    }
+  }
+}
+function serialiseEdgeElements(elements) {
+  return elements.map(serialiseRowElement).join(" ");
+}
+function rowToRowDsl(row) {
+  const parts = [];
+  if (row.edgeStart && row.edgeStart.length > 0) {
+    parts.push(`[${serialiseEdgeElements(row.edgeStart)}]s`);
+  }
+  for (const element of row.elements) {
+    parts.push(serialiseRowElement(element));
+  }
+  if (row.edgeEnd && row.edgeEnd.length > 0) {
+    parts.push(`[${serialiseEdgeElements(row.edgeEnd)}]e`);
+  }
+  return parts.join(" ");
+}
+
+// src/pattern/patternEngine.ts
+var patternDebugLogger = globalThis.console;
+function getCarriedStitches(mode, inputStitches, outputStitches) {
+  return mode === "shaped" ? outputStitches : inputStitches;
+}
+function isShapingEl(element) {
+  return element.type === "shaping";
+}
+function isRepeatEl(element) {
+  return element.type === "repeat";
+}
+function collectRowShaping(row) {
+  const ops = [];
+  function walkEdge(elements) {
+    for (const el of elements ?? []) {
+      if (isShapingEl(el)) {
+        ops.push({
+          count: el.count,
+          direction: el.direction,
+          shapingType: el.shapingType,
+          variant: el.variant
+        });
+      }
+    }
+  }
+  function walkElements(elements) {
+    for (const el of elements) {
+      if (isShapingEl(el)) {
+        ops.push({
+          count: el.count,
+          direction: el.direction,
+          shapingType: el.shapingType,
+          variant: el.variant
+        });
+      } else if (isRepeatEl(el)) {
+        walkElements(el.sequence);
+      }
+    }
+  }
+  walkEdge(row.edgeStart);
+  walkElements(row.elements);
+  walkEdge(row.edgeEnd);
+  return ops;
+}
+function compilePattern(pattern, initialStitches, options = {}) {
+  var _a;
+  const mode = options.mode ?? "shaped";
+  const rows = [];
+  let currentStitches = initialStitches;
+  const verticalRepeats = pattern.repeatRows ?? 1;
+  let rowNumber = 1;
+  for (let repeat = 0; repeat < verticalRepeats; repeat++) {
+    for (let sourceRowIndex = 0; sourceRowIndex < pattern.rows.length; sourceRowIndex += 1) {
+      const row = pattern.rows[sourceRowIndex];
+      const inputStitches = currentStitches;
+      const stitches = expandRowToStitches(row, inputStitches);
+      const outputStitches = countStitchesInInstructions(stitches);
+      const carriedStitches = getCarriedStitches(mode, inputStitches, outputStitches);
+      const shapingOperations = collectRowShaping(row);
+      rows.push({
+        carriedStitches,
+        hasShaping: shapingOperations.length > 0,
+        inputStitches,
+        normalisedRowDsl: rowToRowDsl(row),
+        outputStitches,
+        repeatIndex: repeat,
+        rowNumber,
+        shapingOperations,
+        sourceRowIndex,
+        stitchDelta: outputStitches - inputStitches,
+        stitches
+      });
+      currentStitches = carriedStitches;
+      rowNumber += 1;
+    }
+  }
+  return {
+    finalStitches: ((_a = rows.at(-1)) == null ? void 0 : _a.carriedStitches) ?? initialStitches,
+    initialStitches,
+    mode,
+    rows
+  };
+}
+function expandPattern(pattern, stitchesPerRow) {
+  return compilePattern(pattern, stitchesPerRow, { mode: "fixed" }).rows.map((row) => row.stitches);
+}
+function shapedExpandPattern(pattern, initialStitches) {
+  return compilePattern(pattern, initialStitches, { mode: "shaped" }).rows.map(
+    (row) => row.stitches
+  );
+}
+var stitchSymbols = {
+  knit: "K",
+  purl: "P",
+  increase: "+",
+  decrease: "-"
+};
+function printPattern(pattern, stitchesPerRow) {
+  const expanded = expandPattern(pattern, stitchesPerRow);
+  expanded.forEach((row, rowIndex) => {
+    const rowStr = row.map((stitch) => {
+      const symbol = stitchSymbols[stitch.type] ?? "?";
+      return symbol.repeat(stitch.count);
+    }).join(" ");
+    patternDebugLogger == null ? void 0 : patternDebugLogger.log(`Row ${rowIndex + 1}: ${rowStr}`);
+  });
+}
+function createRepeatRow(sequence, times) {
+  return {
+    elements: [
+      {
+        type: "repeat",
+        times,
+        sequence
+      }
+    ]
+  };
+}
+
+// src/public/errors.ts
+var KnittingMathError = class extends Error {
+  code;
+  context;
+  constructor(name, code, message, context, cause) {
+    super(message);
+    this.name = name;
+    this.code = code;
+    this.context = context;
+    if (cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        configurable: true,
+        enumerable: false,
+        value: cause,
+        writable: true
+      });
+    }
+  }
+};
+var KnittingMathParseError = class extends KnittingMathError {
+  constructor(message, context, cause) {
+    super("KnittingMathParseError", "PARSE_ERROR", message, context, cause);
+  }
+};
+var KnittingMathValidationError = class extends KnittingMathError {
+  constructor(message, context, cause) {
+    super("KnittingMathValidationError", "VALIDATION_ERROR", message, context, cause);
+  }
+};
+var KnittingMathExpansionError = class extends KnittingMathError {
+  constructor(message, context, cause) {
+    super("KnittingMathExpansionError", "EXPANSION_ERROR", message, context, cause);
+  }
+};
+function getErrorMessage(error) {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  return "An unknown knitting-math error occurred.";
+}
+function ensureKnittingMathError(error, createError) {
+  if (error instanceof KnittingMathError) {
+    return error;
+  }
+  return createError(getErrorMessage(error), error);
+}
+
+// src/public/pattern.ts
+function wrapExpansionError(error, operation) {
+  return ensureKnittingMathError(
+    error,
+    (message, cause) => new KnittingMathExpansionError(message, { operation }, cause)
+  );
+}
+function compilePattern2(pattern, initialStitches, options) {
+  try {
+    return compilePattern(pattern, initialStitches, options);
+  } catch (error) {
+    throw wrapExpansionError(error, "compilePattern");
+  }
+}
+function expandPattern2(pattern, stitchesPerRow) {
+  try {
+    return expandPattern(pattern, stitchesPerRow);
+  } catch (error) {
+    throw wrapExpansionError(error, "expandPattern");
+  }
+}
+function shapedExpandPattern2(pattern, initialStitches) {
+  try {
+    return shapedExpandPattern(pattern, initialStitches);
+  } catch (error) {
+    throw wrapExpansionError(error, "shapedExpandPattern");
+  }
+}
+function printPattern2(pattern, stitchesPerRow) {
+  try {
+    printPattern(pattern, stitchesPerRow);
+  } catch (error) {
+    throw wrapExpansionError(error, "printPattern");
+  }
+}
+
+// src/stitches/castOn.ts
+function calculateCastOn(input) {
+  return calculateCastOnStitches({ ...input, ease: 0 });
+}
+function calculateCastOnStitches(input) {
+  const { size, unit, gauge, ease = 0, easeUnit = unit } = input;
+  const sizeInCm = normaliseMeasurement(size, unit);
+  const easeCm = normaliseMeasurement(ease, easeUnit);
+  const finalSizeInCm = sizeInCm + easeCm;
+  if (finalSizeInCm <= 0) {
+    throw new Error("Final size must be greater than 0 after applying ease.");
+  }
+  const stitches = finalSizeInCm * stitchesPerCm(gauge);
+  return roundStitches(stitches);
+}
+
+// src/parser/compatibilityNormaliser.ts
+function isWordBoundaryCharacter(char) {
+  return char === void 0 || /[^a-z]/i.test(char);
+}
+function isIndexWithinBounds(input, index) {
+  return index >= 0 && index < input.length;
+}
+function skipWhitespace(input, cursor) {
+  let next = cursor;
+  while (next < input.length && /\s/.test(input[next] ?? "")) {
+    next += 1;
+  }
+  return next;
+}
+function hasRepeatKeywordAt(input, cursor) {
+  const repeatKeyword = input.slice(cursor, cursor + 6);
+  return repeatKeyword.toLowerCase() === "repeat" && isWordBoundaryCharacter(input[cursor + 6]);
+}
+function normaliseDirectionToken(direction) {
+  const lowered = direction.toLowerCase();
+  if (lowered === "l" || lowered === "left") {
+    return "left";
+  }
+  if (lowered === "r" || lowered === "right") {
+    return "right";
+  }
+  return "centre";
+}
+function normaliseDirectionalShapingPhrases(input) {
+  let output = input;
+  output = output.replaceAll(
+    /\b(dec|decrease)\s+(left|right|centre|center|l|r|c)\s+(\d+)\b/gi,
+    (_match, _op, direction, count) => `shape-dec-${normaliseDirectionToken(direction)}${count}`
+  );
+  output = output.replaceAll(
+    /\b(inc|increase)\s+(left|right|centre|center|l|r|c)\s+(\d+)\b/gi,
+    (_match, _op, direction, count) => `shape-inc-${normaliseDirectionToken(direction)}${count}`
+  );
+  return output;
+}
+function findStarCompatibilityBlockEnd(input, startIndex) {
+  for (let i = startIndex + 1; i < input.length; i += 1) {
+    if (input[i] === "*") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findBracketCompatibilityBlockEnd(input, startIndex) {
+  let depth = 0;
+  for (let i = startIndex; i < input.length; i += 1) {
+    if (!isIndexWithinBounds(input, i)) {
+      break;
+    }
+    const char = input[i];
+    if (char === "[") {
+      depth += 1;
+      continue;
+    }
+    if (char !== "]") {
+      continue;
+    }
+    depth -= 1;
+    if (depth !== 0) {
+      continue;
+    }
+    const after = skipWhitespace(input, i + 1);
+    return hasRepeatKeywordAt(input, after) ? i : -1;
+  }
+  return -1;
+}
+function findCompatibilityBlockEnd(input, startIndex) {
+  if (!isIndexWithinBounds(input, startIndex)) {
+    return -1;
+  }
+  const opener = input[startIndex];
+  if (opener !== "*" && opener !== "[") {
+    return -1;
+  }
+  if (opener === "[") {
+    return findBracketCompatibilityBlockEnd(input, startIndex);
+  }
+  return findStarCompatibilityBlockEnd(input, startIndex);
+}
+function consumeNumberToken(input, cursor) {
+  let nextCursor = cursor;
+  while (nextCursor < input.length && /\d/.test(input[nextCursor] ?? "")) {
+    nextCursor += 1;
+  }
+  if (nextCursor === cursor) {
+    return { nextCursor };
+  }
+  return {
+    nextCursor,
+    value: Number.parseInt(input.slice(cursor, nextCursor), 10)
+  };
+}
+function consumeOptionalStitchUnit(input, cursor) {
+  const unitMatch = /^(stitches|stitch|sts|st)\b/i.exec(input.slice(cursor));
+  return unitMatch ? cursor + unitMatch[0].length : cursor;
+}
+function parseToLastClause(input, cursor) {
+  const afterLast = skipWhitespace(input, cursor);
+  const numberToken = consumeNumberToken(input, afterLast);
+  if (numberToken.value === void 0) {
+    throw new Error("Expected a stitch count after 'to last' in repeat clause.");
+  }
+  if (numberToken.value <= 0) {
+    throw new Error("Repeat remaining-stitches value must be greater than 0.");
+  }
+  const afterCount = skipWhitespace(input, numberToken.nextCursor);
+  const nextIndex = consumeOptionalStitchUnit(input, afterCount);
+  return {
+    kind: "to-last",
+    nextIndex,
+    remainingStitches: numberToken.value
+  };
+}
+function parseToClause(input, cursor) {
+  const toKeyword = input.slice(cursor, cursor + 2);
+  if (toKeyword.toLowerCase() !== "to" || !isWordBoundaryCharacter(input[cursor + 2])) {
+    return {
+      kind: "to-end",
+      nextIndex: cursor
+    };
+  }
+  let nextCursor = skipWhitespace(input, cursor + 2);
+  const lastKeyword = input.slice(nextCursor, nextCursor + 4);
+  if (lastKeyword.toLowerCase() === "last" && isWordBoundaryCharacter(input[nextCursor + 4])) {
+    return parseToLastClause(input, nextCursor + 4);
+  }
+  const endKeyword = input.slice(nextCursor, nextCursor + 3);
+  if (endKeyword.toLowerCase() !== "end" || !isWordBoundaryCharacter(input[nextCursor + 3])) {
+    throw new Error("Expected 'end' after 'to' in repeat clause.");
+  }
+  nextCursor += 3;
+  return {
+    kind: "to-end",
+    nextIndex: nextCursor
+  };
+}
+function parseTimesClause(input, cursor) {
+  const numberToken = consumeNumberToken(input, cursor);
+  if (numberToken.value === void 0) {
+    return {
+      kind: "to-end",
+      nextIndex: cursor
+    };
+  }
+  if (numberToken.value <= 0) {
+    throw new Error("Repeat times must be greater than 0.");
+  }
+  let nextCursor = skipWhitespace(input, numberToken.nextCursor);
+  const timesKeyword = input.slice(nextCursor, nextCursor + 5);
+  if (timesKeyword.toLowerCase() === "times" && isWordBoundaryCharacter(input[nextCursor + 5])) {
+    nextCursor += 5;
+  }
+  return {
+    kind: "times",
+    nextIndex: nextCursor,
+    times: numberToken.value
+  };
+}
+function parseRepeatClause(input, opener, closingIndex) {
+  let cursor = skipWhitespace(input, closingIndex + 1);
+  if (!hasRepeatKeywordAt(input, cursor)) {
+    throw new Error(`Expected 'repeat' after '${opener}...${opener === "*" ? "*" : "]"}' block.`);
+  }
+  cursor = skipWhitespace(input, cursor + 6);
+  const toClause = parseToClause(input, cursor);
+  if (toClause.kind === "to-last") {
+    return toClause;
+  }
+  if (toClause.nextIndex !== cursor) {
+    return toClause;
+  }
+  return parseTimesClause(input, cursor);
+}
+function renderCompletedClause(clause, completed) {
+  if (clause.kind === "times") {
+    return `(${completed}) * ${clause.times}`;
+  }
+  if (clause.kind === "to-last") {
+    return `(${completed}) to last ${clause.remainingStitches} stitches`;
+  }
+  return `(${completed})`;
+}
+function completeFrame(frames) {
+  const frame = frames.pop();
+  const completed = frame.result;
+  if (frames.length === 0) {
+    return completed;
+  }
+  const parent = frames.at(-1);
+  const pending = parent.pending;
+  if (!pending) {
+    throw new Error("Invalid normaliser state: missing pending replacement.");
+  }
+  parent.result += renderCompletedClause(pending.clause, completed);
+  parent.index = pending.clause.nextIndex;
+  parent.pending = void 0;
+  return null;
+}
+function processLiteralChar(frame) {
+  frame.result += frame.input[frame.index] ?? "";
+  frame.index += 1;
+}
+function processBlockOpener(frame, frames) {
+  const opener = frame.input[frame.index];
+  if (opener !== "*" && opener !== "[") {
+    processLiteralChar(frame);
+    return;
+  }
+  const closingIndex = findCompatibilityBlockEnd(frame.input, frame.index);
+  if (closingIndex === -1) {
+    if (opener === "*") {
+      throw new Error("Unclosed repeat block (*).");
+    }
+    processLiteralChar(frame);
+    return;
+  }
+  const sequence = frame.input.slice(frame.index + 1, closingIndex).trim();
+  if (sequence.length === 0) {
+    if (opener === "*") {
+      throw new Error("Repeat block sequence cannot be empty.");
+    }
+    frame.result += frame.input.slice(frame.index, closingIndex + 1);
+    frame.index = closingIndex + 1;
+    return;
+  }
+  const clause = parseRepeatClause(frame.input, opener, closingIndex);
+  frame.pending = { clause };
+  frames.push({
+    input: sequence,
+    index: 0,
+    result: ""
+  });
+}
+function normaliseCompatibilitySyntax(input) {
+  const frames = [
+    {
+      input: normaliseDirectionalShapingPhrases(input),
+      index: 0,
+      result: ""
+    }
+  ];
+  let completedResult = "";
+  while (frames.length > 0) {
+    const frame = frames.at(-1);
+    if (!isIndexWithinBounds(frame.input, frame.index)) {
+      const completed = completeFrame(frames);
+      if (completed !== null) {
+        completedResult = completed;
+        break;
+      }
+      continue;
+    }
+    processBlockOpener(frame, frames);
+  }
+  return completedResult;
+}
+
+// src/parser/rowLexer.ts
+var WORD_TOKEN_RE = /[a-z0-9-]+/iy;
+var COUNT_RE = /\d+/y;
+function readWordToken(input, index) {
+  WORD_TOKEN_RE.lastIndex = index;
+  const match = WORD_TOKEN_RE.exec(input);
+  if (!match) {
+    return null;
+  }
+  return {
+    nextIndex: WORD_TOKEN_RE.lastIndex,
+    value: match[0]
+  };
+}
+function readCountToken(input, index) {
+  COUNT_RE.lastIndex = index;
+  const match = COUNT_RE.exec(input);
+  if (!match) {
+    return null;
+  }
+  return {
+    nextIndex: COUNT_RE.lastIndex,
+    value: match[0]
+  };
+}
+function isDigitAt(input, index) {
+  const char = input[index] ?? "";
+  return /\d/.test(char);
+}
+function skipWhitespaceFrom(input, index) {
+  let next = index;
+  while (next < input.length && /\s/.test(input.charAt(next))) {
+    next += 1;
+  }
+  return next;
+}
+function skipSeparatorsFrom(input, index) {
+  let next = index;
+  while (next < input.length && /[\s,]/.test(input.charAt(next))) {
+    next += 1;
+  }
+  return next;
+}
+
+// src/parser/stitchRegistry.ts
+var ERR_NON_EMPTY_TOKEN = "Token must be a non-empty string.";
+var ERR_DEFAULT_COUNT_INVALID = "Default count must be a positive integer.";
+var ERR_RESOLVE_OPTIONS_INVALID = "Resolve options must be an object when provided.";
+var ERR_RESOLVE_THROW_ON_UNKNOWN_INVALID = "Resolve option 'throwOnUnknown' must be a boolean when provided.";
+var InMemoryStitchRegistry = class {
+  typeMap = /* @__PURE__ */ new Map();
+  abbreviationMap = /* @__PURE__ */ new Map();
+  defaultCounts = /* @__PURE__ */ new Map();
+  lockedCountVariants = /* @__PURE__ */ new Set();
+  /**
+   * Normalise a required token for storage.
+   *
+   * @param token - The caller-provided token value.
+   * @returns The trimmed, lower-cased token.
+   * @throws Error when the token is not a non-empty string.
+   */
+  normaliseRequiredToken(token) {
+    if (typeof token !== "string") {
+      throw new Error(ERR_NON_EMPTY_TOKEN);
+    }
+    const normalised = token.trim().toLowerCase();
+    if (normalised.length === 0) {
+      throw new Error(ERR_NON_EMPTY_TOKEN);
+    }
+    return normalised;
+  }
+  /**
+   * Normalise an optional lookup token.
+   *
+   * @param token - The caller-provided token value.
+   * @returns The trimmed, lower-cased token, or null when blank.
+   * @throws Error when the token is not a string.
+   */
+  normaliseLookupToken(token) {
+    if (typeof token !== "string") {
+      throw new Error(ERR_NON_EMPTY_TOKEN);
+    }
+    const normalised = token.trim().toLowerCase();
+    if (normalised.length === 0) {
+      return null;
+    }
+    return normalised;
+  }
+  /**
+   * Determine whether a normalised token exists in either registry map.
+   *
+   * @param normalisedToken - A lower-cased token already normalised for lookup.
+   * @returns True when the token is registered as either a type alias or abbreviation.
+   */
+  hasRegisteredToken(normalisedToken) {
+    return this.typeMap.has(normalisedToken) || this.abbreviationMap.has(normalisedToken);
+  }
+  /**
+   * Validate and read the strict unknown-token behaviour from optional resolve options.
+   *
+   * @param options - Optional resolve configuration.
+   * @returns True when unknown tokens should throw instead of returning null.
+   * @throws Error when the options value or throwOnUnknown flag has an invalid runtime type.
+   */
+  shouldThrowOnUnknown(options) {
+    if (options === void 0) {
+      return false;
+    }
+    if (typeof options !== "object" || options === null) {
+      throw new Error(ERR_RESOLVE_OPTIONS_INVALID);
+    }
+    if (options.throwOnUnknown !== void 0 && typeof options.throwOnUnknown !== "boolean") {
+      throw new Error(ERR_RESOLVE_THROW_ON_UNKNOWN_INVALID);
+    }
+    return options.throwOnUnknown === true;
+  }
+  /**
+   * Check whether a normalised variant token is configured as locked-count.
+   *
+   * @param normalisedVariant - A lower-cased variant token, or null for blank input.
+   * @returns True when the variant exists and is locked.
+   */
+  isLocked(normalisedVariant) {
+    return normalisedVariant !== null && this.lockedCountVariants.has(normalisedVariant);
+  }
+  /**
+   * Resolve a normalised token from the type alias map or abbreviation map.
+   *
+   * @param normalisedToken - A lower-cased token already normalised for lookup.
+   * @returns The canonical stitch type, or null when unknown.
+   */
+  resolveKnownType(normalisedToken) {
+    return this.typeMap.get(normalisedToken) ?? this.abbreviationMap.get(normalisedToken) ?? null;
+  }
+  /**
+   * Build a descriptive strict-mode error suffix listing valid registered tokens.
+   *
+   * @returns A human-readable description of the currently registered token set.
+   */
+  describeExpectedTokens() {
+    const allTokens = /* @__PURE__ */ new Set([...this.typeMap.keys(), ...this.abbreviationMap.keys()]);
+    if (allTokens.size === 0) {
+      return "Expected a valid KnittingPattern::StitchType token or registered abbreviation, but no stitch tokens are currently registered.";
+    }
+    return `Expected a valid KnittingPattern::StitchType token or registered abbreviation. Known stitch tokens: ${Array.from(
+      allTokens
+    ).sort().join(", ")}.`;
+  }
+  registerType(alias, canonicalType) {
+    this.typeMap.set(this.normaliseRequiredToken(alias), canonicalType);
+  }
+  registerAbbreviation(abbreviation, canonicalType) {
+    this.abbreviationMap.set(this.normaliseRequiredToken(abbreviation), canonicalType);
+  }
+  registerDefaultCount(variant, count) {
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new Error(ERR_DEFAULT_COUNT_INVALID);
+    }
+    this.defaultCounts.set(this.normaliseRequiredToken(variant), count);
+  }
+  registerLockedCountVariant(variant) {
+    this.lockedCountVariants.add(this.normaliseRequiredToken(variant));
+  }
+  isKnown(token) {
+    const normalised = this.normaliseLookupToken(token);
+    if (normalised === null) {
+      return false;
+    }
+    return this.hasRegisteredToken(normalised);
+  }
+  isVariant(token) {
+    const normalised = this.normaliseLookupToken(token);
+    if (normalised === null) {
+      return false;
+    }
+    return this.abbreviationMap.has(normalised);
+  }
+  resolve(token, options) {
+    const throwOnUnknown = this.shouldThrowOnUnknown(options);
+    const normalised = this.normaliseLookupToken(token);
+    if (normalised === null) {
+      if (throwOnUnknown) {
+        throw new Error(`Unknown stitch token '${token}'. ${this.describeExpectedTokens()}`);
+      }
+      return null;
+    }
+    const resolved = this.resolveKnownType(normalised);
+    if (resolved === null && throwOnUnknown) {
+      throw new Error(`Unknown stitch token '${token}'. ${this.describeExpectedTokens()}`);
+    }
+    return resolved;
+  }
+  getDefaultCount(variant) {
+    const normalised = this.normaliseLookupToken(variant);
+    if (normalised === null) {
+      return 1;
+    }
+    return this.defaultCounts.get(normalised) ?? 1;
+  }
+  isLockedCountVariant(variant) {
+    const normalised = this.normaliseLookupToken(variant);
+    return this.isLocked(normalised);
+  }
+};
+function createDefaultStitchRegistry() {
+  const registry = new InMemoryStitchRegistry();
+  for (const [alias, canonicalType] of Object.entries(STITCH_TYPE_MAP)) {
+    registry.registerType(alias, canonicalType);
+  }
+  for (const [abbr, canonicalType] of Object.entries(STITCH_ABBREVIATION_MAP)) {
+    registry.registerAbbreviation(abbr, canonicalType);
+  }
+  for (const [variant, count] of Object.entries(STITCH_DEFAULT_COUNT_MAP)) {
+    registry.registerDefaultCount(variant, count);
+  }
+  for (const variant of STITCH_LOCKED_COUNT_VARIANTS) {
+    registry.registerLockedCountVariant(variant);
+  }
+  return registry;
+}
+function createEmptyStitchRegistry() {
+  return new InMemoryStitchRegistry();
+}
+
+// src/parser/rowAstParser.ts
+var SHAPING_TOKEN_RE = /^shape-(dec|decrease|inc|increase)(?:-(l|left|r|right|c|centre|center))?(\d+)$/;
+var COMPACT_STITCH_TOKEN_RE = /^([a-z-]+)(\d+)$/i;
+var RowDslParser = class {
+  input;
+  registry;
+  index = 0;
+  constructor(input, registry) {
+    this.input = input;
+    this.registry = registry ?? createDefaultStitchRegistry();
+  }
+  parseElements() {
+    const elements = [];
+    while (true) {
+      this.skipSeparators();
+      if (this.isDone()) {
+        break;
+      }
+      const char = this.current();
+      if (char === ")") {
+        throw this.error("Unmatched group delimiter.");
+      }
+      if (char === "(") {
+        elements.push(this.parseRepeat());
+        continue;
+      }
+      elements.push(this.parseStitchInstruction());
+    }
+    return elements;
+  }
+  isDone() {
+    return this.index >= this.input.length;
+  }
+  current() {
+    return this.input[this.index] ?? "";
+  }
+  advance() {
+    this.index += 1;
+  }
+  parseRepeat() {
+    this.advance();
+    const sequence = this.parseRepeatSequence();
+    if (sequence.length === 0) {
+      throw this.error("Repeat block sequence cannot be empty.");
+    }
+    this.skipWhitespace();
+    const termination = this.parseRepeatTermination();
+    return buildRepeatBlock(sequence, termination);
+  }
+  parseRepeatSequence() {
+    const sequence = [];
+    while (true) {
+      this.skipSeparators();
+      if (this.isDone()) {
+        throw this.error("Unmatched group delimiter.");
+      }
+      if (this.current() === ")") {
+        this.advance();
+        break;
+      }
+      if (this.current() === "(") {
+        sequence.push(this.parseRepeat());
+        continue;
+      }
+      sequence.push(this.parseStitchInstruction());
+    }
+    return sequence;
+  }
+  parseRepeatTermination() {
+    if (this.current() === "*" || this.current().toLowerCase() === "x") {
+      return this.parseTimesTermination();
+    }
+    if (this.consumeKeyword("until")) {
+      return this.parseUntilTermination();
+    }
+    if (this.consumeKeyword("to")) {
+      return this.parseToLastTermination();
+    }
+    return {
+      maxRepeats: this.parseOptionalMaxRepeats(),
+      mode: "to-end"
+    };
+  }
+  parseTimesTermination() {
+    this.advance();
+    this.skipWhitespace();
+    const times = this.readCount();
+    if (times <= 0) {
+      throw this.error("Repeat times must be greater than 0.");
+    }
+    if (this.parseOptionalMaxRepeats() !== void 0) {
+      throw this.error("Max repeats cannot be combined with fixed repeat times.");
+    }
+    return { mode: "times", times };
+  }
+  parseUntilTermination() {
+    this.skipWhitespace();
+    const untilCount = this.readCount();
+    if (untilCount <= 0) {
+      throw this.error("Repeat until-stitches value must be greater than 0.");
+    }
+    this.consumeOptionalStitchUnit();
+    this.skipWhitespace();
+    const maxRepeats = this.parseOptionalMaxRepeats();
+    if (this.consumeKeyword("remain") || this.consumeKeyword("remaining") || this.consumeKeyword("left")) {
+      return {
+        maxRepeats,
+        mode: "until-remaining",
+        remainingStitches: untilCount
+      };
+    }
+    return {
+      maxRepeats,
+      mode: "until-stitches",
+      targetStitches: untilCount
+    };
+  }
+  parseToLastTermination() {
+    this.skipWhitespace();
+    if (!this.consumeKeyword("last")) {
+      throw this.error("Expected 'last' after 'to' in repeat clause.");
+    }
+    this.skipWhitespace();
+    const remainingStitches = this.readCount();
+    if (remainingStitches <= 0) {
+      throw this.error("Repeat remaining-stitches value must be greater than 0.");
+    }
+    this.consumeOptionalStitchUnit();
+    return {
+      maxRepeats: this.parseOptionalMaxRepeats(),
+      mode: "until-remaining",
+      remainingStitches
+    };
+  }
+  consumeOptionalStitchUnit() {
+    this.skipWhitespace();
+    if (this.startsWithKeyword("stitches")) {
+      this.consumeKeyword("stitches");
+      return;
+    }
+    if (this.startsWithKeyword("stitch")) {
+      this.consumeKeyword("stitch");
+      return;
+    }
+    if (this.startsWithKeyword("sts")) {
+      this.consumeKeyword("sts");
+      return;
+    }
+    if (this.startsWithKeyword("st")) {
+      this.consumeKeyword("st");
+    }
+  }
+  startsWithKeyword(keyword) {
+    const segment = this.input.slice(this.index, this.index + keyword.length).toLowerCase();
+    if (segment !== keyword.toLowerCase()) {
+      return false;
+    }
+    const charAfter = this.input[this.index + keyword.length];
+    return charAfter === void 0 || /[^a-z]/i.test(charAfter);
+  }
+  consumeKeyword(keyword) {
+    if (!this.startsWithKeyword(keyword)) {
+      return false;
+    }
+    this.index += keyword.length;
+    return true;
+  }
+  parseOptionalMaxRepeats() {
+    const saved = this.index;
+    this.skipWhitespace();
+    if (!this.consumeKeyword("max")) {
+      this.index = saved;
+      return void 0;
+    }
+    this.skipWhitespace();
+    const maxRepeats = this.readCount();
+    if (maxRepeats <= 0) {
+      throw this.error("Max repeats must be greater than 0.");
+    }
+    this.skipWhitespace();
+    if (this.startsWithKeyword("repeats")) {
+      this.consumeKeyword("repeats");
+    } else if (this.startsWithKeyword("repeat")) {
+      this.consumeKeyword("repeat");
+    }
+    return maxRepeats;
+  }
+  parseStitchInstruction() {
+    const token = this.readWord();
+    const lowered = token.toLowerCase();
+    const shaping = this.parseExplicitShapingToken(lowered);
+    if (shaping) {
+      return shaping;
+    }
+    const parsed = this.resolveStitchToken(lowered);
+    if (!parsed.stitchType) {
+      throw this.error(`Invalid stitch token: ${token}.`);
+    }
+    const count = this.resolveInstructionCount(parsed.variant, parsed.count);
+    const finalCount = count ?? 1;
+    if (finalCount <= 0) {
+      throw this.error("Stitch count must be greater than 0.");
+    }
+    return {
+      count: finalCount,
+      type: parsed.stitchType,
+      variant: parsed.variant
+    };
+  }
+  /**
+   * Parse explicit shaping tokens into first-class shaping elements.
+   *
+   * Supported forms:
+   * - shape-dec2
+   * - shape-inc3
+   * - shape-dec-left2
+   * - shape-inc-right1
+   */
+  parseExplicitShapingToken(loweredToken) {
+    const match = SHAPING_TOKEN_RE.exec(loweredToken);
+    if (!match) {
+      return null;
+    }
+    const shapingTypeToken = match[1] ?? "";
+    const directionToken = match[2];
+    const countToken = match[3] ?? "";
+    const shapingType = shapingTypeToken === "dec" || shapingTypeToken === "decrease" ? "decrease" : "increase";
+    let direction;
+    if (directionToken === void 0) {
+      direction = void 0;
+    } else if (directionToken === "l" || directionToken === "left") {
+      direction = "left";
+    } else if (directionToken === "r" || directionToken === "right") {
+      direction = "right";
+    } else {
+      direction = "centre";
+    }
+    const count = Number.parseInt(countToken, 10);
+    if (!Number.isInteger(count) || count <= 0) {
+      throw this.error("Shaping count must be greater than 0.");
+    }
+    return {
+      count,
+      direction,
+      shapingType,
+      type: "shaping"
+    };
+  }
+  applyResolvedToken(parsed, loweredToken) {
+    if (this.registry.isVariant(loweredToken)) {
+      parsed.stitchType = this.registry.resolve(loweredToken) ?? void 0;
+      parsed.variant = loweredToken;
+      const defaultCount = this.registry.getDefaultCount(loweredToken);
+      if (defaultCount > 1) {
+        parsed.count = defaultCount;
+      }
+      return;
+    }
+    parsed.stitchType = this.registry.resolve(loweredToken) ?? void 0;
+  }
+  parseCompactStitchToken(loweredToken) {
+    const compactMatch = COMPACT_STITCH_TOKEN_RE.exec(loweredToken);
+    if (!compactMatch) {
+      return null;
+    }
+    const base = compactMatch[1] ?? "";
+    const parsedCount = Number.parseInt(compactMatch[2] ?? "", 10);
+    return { base, parsedCount };
+  }
+  applyCompactToken(parsed, base, parsedCount) {
+    if (this.registry.isVariant(base)) {
+      if (this.registry.isLockedCountVariant(base)) {
+        throw this.error(
+          `'${base}' does not accept an explicit count; use a repeat block to work it multiple times.`
+        );
+      }
+      parsed.stitchType = this.registry.resolve(base) ?? void 0;
+      parsed.variant = base;
+      parsed.count = parsedCount;
+      return;
+    }
+    const baseType = this.registry.resolve(base) ?? void 0;
+    if (baseType) {
+      parsed.stitchType = baseType;
+      parsed.count = parsedCount;
+    }
+  }
+  /**
+   * Resolve a token into its stitch type, variant, and any implicit or compact count.
+   *
+   * @param loweredToken - The already lower-cased token text.
+   * @returns Parsed token metadata used to build a stitch instruction.
+   */
+  resolveStitchToken(loweredToken) {
+    const parsed = {};
+    this.applyResolvedToken(parsed, loweredToken);
+    if (!parsed.stitchType) {
+      const compactToken = this.parseCompactStitchToken(loweredToken);
+      if (compactToken) {
+        this.applyCompactToken(parsed, compactToken.base, compactToken.parsedCount);
+      }
+    }
+    return parsed;
+  }
+  /**
+   * Finalise the stitch count for an instruction, enforcing locked-count variants.
+   *
+   * @param variant - The parsed stitch variant, when present.
+   * @param baseCount - A count derived from defaults or compact token syntax.
+   * @returns The explicit or inferred count, or undefined when no count is provided.
+   */
+  resolveInstructionCount(variant, baseCount) {
+    if (variant !== void 0 && this.registry.isLockedCountVariant(variant)) {
+      const saved = this.index;
+      this.skipWhitespace();
+      if (this.peekDigit()) {
+        throw this.error(
+          `'${variant}' does not accept an explicit count; use a repeat block to work it multiple times.`
+        );
+      }
+      this.index = saved;
+      return baseCount;
+    }
+    let count = baseCount;
+    if (count === void 0) {
+      const saved = this.index;
+      this.skipWhitespace();
+      if (this.peekDigit()) {
+        count = this.readCount();
+      } else {
+        this.index = saved;
+      }
+    }
+    return count;
+  }
+  /**
+   * Read the next stitch-token word from the current parser cursor.
+   *
+   * @returns The parsed word token.
+   * @throws Error when no word token starts at the current cursor.
+   */
+  readWord() {
+    const token = readWordToken(this.input, this.index);
+    if (!token) {
+      throw this.error("Expected stitch instruction.");
+    }
+    this.index = token.nextIndex;
+    return token.value;
+  }
+  /**
+   * Read the next decimal count token from the current parser cursor.
+   *
+   * @returns The parsed numeric count.
+   * @throws Error when no numeric token starts at the current cursor.
+   */
+  readCount() {
+    const token = readCountToken(this.input, this.index);
+    if (!token) {
+      throw this.error("Expected a numeric count.");
+    }
+    this.index = token.nextIndex;
+    return Number.parseInt(token.value, 10);
+  }
+  peekDigit() {
+    return isDigitAt(this.input, this.index);
+  }
+  skipWhitespace() {
+    this.index = skipWhitespaceFrom(this.input, this.index);
+  }
+  skipSeparators() {
+    this.index = skipSeparatorsFrom(this.input, this.index);
+  }
+  error(message) {
+    return new Error(`${message} At position ${this.index + 1}.`);
+  }
+};
+
+// src/parser/edgeParser.ts
+var EDGE_CONTENT_CAPTURE_FRAGMENT = String.raw`\[([^\]]*)\]`;
+var OPTIONAL_WHITESPACE_FRAGMENT = String.raw`\s*`;
+function buildEdgeRegex(side, syntax, marker) {
+  const anchorStart = side === "start" ? "^" : "";
+  const anchorEnd = side === "end" ? "$" : "";
+  const label = side === "start" ? "edge-start" : "edge-end";
+  const body = syntax === "named" ? `${label}${OPTIONAL_WHITESPACE_FRAGMENT}:${OPTIONAL_WHITESPACE_FRAGMENT}${EDGE_CONTENT_CAPTURE_FRAGMENT}` : `${EDGE_CONTENT_CAPTURE_FRAGMENT}${OPTIONAL_WHITESPACE_FRAGMENT}${marker}`;
+  return new RegExp(
+    `${anchorStart}${OPTIONAL_WHITESPACE_FRAGMENT}${body}${OPTIONAL_WHITESPACE_FRAGMENT}${anchorEnd}`,
+    "i"
+  );
+}
+var EDGE_END_NAMED_RE = buildEdgeRegex("end", "named", "e");
+var EDGE_END_SHORT_RE = buildEdgeRegex("end", "short", "e");
+var EDGE_START_NAMED_RE = buildEdgeRegex("start", "named", "s");
+var EDGE_START_SHORT_RE = buildEdgeRegex("start", "short", "s");
+var EDGE_END_PATTERNS = [EDGE_END_NAMED_RE, EDGE_END_SHORT_RE];
+var EDGE_START_PATTERNS = [EDGE_START_NAMED_RE, EDGE_START_SHORT_RE];
+function parseEdgeInstructions(content, registry) {
+  if (content.trim().length === 0) {
+    return [];
+  }
+  const parser = new RowDslParser(content, registry);
+  const parsed = parser.parseElements();
+  const stitches = [];
+  for (const element of parsed) {
+    if (element.type === "repeat") {
+      throw new Error("Only stitch instructions are allowed inside edge instructions.");
+    }
+    stitches.push(element);
+  }
+  return stitches;
+}
+function findFirstMatch(input, patterns) {
+  for (const regex of patterns) {
+    const match = regex.exec(input);
+    if (match) {
+      return { match, regex };
+    }
+  }
+  return null;
+}
+function extractEdge(input, patterns, registry) {
+  const matchData = findFirstMatch(input, patterns);
+  if (!matchData) {
+    return null;
+  }
+  const content = matchData.match[1] ?? "";
+  const edge = parseEdgeInstructions(content, registry);
+  const body = input.replace(matchData.regex, "").trim();
+  return { body, edge };
+}
+function extractEdgeEnd(input, registry) {
+  const extracted = extractEdge(input, EDGE_END_PATTERNS, registry);
+  if (extracted) {
+    return { body: extracted.body, edgeEnd: extracted.edge };
+  }
+  return { body: input.trim() };
+}
+function extractEdgeStart(input, registry) {
+  const extracted = extractEdge(input, EDGE_START_PATTERNS, registry);
+  if (extracted) {
+    return { body: extracted.body, edgeStart: extracted.edge };
+  }
+  return { body: input.trim() };
+}
+
+// src/parser/rowDslAst.ts
+var EXACTLY_ONE = 1;
+var NO_EDGES = 0;
+var ERR_EXPECTED_ONE_BODY = "Row DSL AST must contain exactly one body element.";
+var ERR_MAX_ONE_EDGE_START = "Row DSL AST can contain at most one edge-start element.";
+var ERR_MAX_ONE_EDGE_END = "Row DSL AST can contain at most one edge-end element.";
+function countRowDslAstElements(ast) {
+  const counts = {
+    bodyCount: 0,
+    edgeEndCount: 0,
+    edgeStartCount: 0
+  };
+  for (const element of ast.elements) {
+    if (element.type === "body") {
+      counts.bodyCount += 1;
+      continue;
+    }
+    if (element.type === "edge-start") {
+      counts.edgeStartCount += 1;
+      continue;
+    }
+    counts.edgeEndCount += 1;
+  }
+  return counts;
+}
+function assertRowDslAstShape(counts) {
+  if (counts.bodyCount !== EXACTLY_ONE) {
+    throw new Error(ERR_EXPECTED_ONE_BODY);
+  }
+  if (counts.edgeStartCount > EXACTLY_ONE) {
+    throw new Error(ERR_MAX_ONE_EDGE_START);
+  }
+  if (counts.edgeEndCount > EXACTLY_ONE) {
+    throw new Error(ERR_MAX_ONE_EDGE_END);
+  }
+}
+function applyEdgeStitches(row, edgeType, stitches) {
+  if (stitches.length <= NO_EDGES) {
+    return;
+  }
+  if (edgeType === "edge-start") {
+    row.edgeStart = stitches;
+    return;
+  }
+  row.edgeEnd = stitches;
+}
+function extractEdgesAndBody(input, registry) {
+  const { body: bodyWithoutEnd, edgeEnd } = extractEdgeEnd(input, registry);
+  const { body, edgeStart } = extractEdgeStart(bodyWithoutEnd, registry);
+  return { body, edgeEnd, edgeStart };
+}
+function buildRowDslAstElements(elements, edgeStart, edgeEnd) {
+  const astElements = [];
+  if (edgeStart && edgeStart.length > NO_EDGES) {
+    astElements.push({ stitches: edgeStart, type: "edge-start" });
+  }
+  astElements.push({ elements, type: "body" });
+  if (edgeEnd && edgeEnd.length > NO_EDGES) {
+    astElements.push({ stitches: edgeEnd, type: "edge-end" });
+  }
+  return astElements;
+}
+function isRowDslAstWellFormed(ast) {
+  const counts = countRowDslAstElements(ast);
+  return counts.bodyCount === EXACTLY_ONE && counts.edgeStartCount <= EXACTLY_ONE && counts.edgeEndCount <= EXACTLY_ONE;
+}
+function parseRowDslAst(input, registry) {
+  const normalised = input.trim();
+  if (normalised.length <= NO_EDGES) {
+    return {
+      elements: [{ elements: [], type: "body" }]
+    };
+  }
+  const { body, edgeEnd, edgeStart } = extractEdgesAndBody(normalised, registry);
+  const parser = new RowDslParser(body, registry);
+  const elements = parser.parseElements();
+  return { elements: buildRowDslAstElements(elements, edgeStart, edgeEnd) };
+}
+function parseCompatibleRowDslAst(input, registry) {
+  return parseRowDslAst(normaliseCompatibilitySyntax(input), registry);
+}
+function resolveRowDslAst(ast) {
+  const counts = countRowDslAstElements(ast);
+  assertRowDslAstShape(counts);
+  const row = { elements: [] };
+  for (const element of ast.elements) {
+    switch (element.type) {
+      case "body":
+        row.elements = element.elements;
+        break;
+      case "edge-start":
+        applyEdgeStitches(row, "edge-start", element.stitches);
+        break;
+      case "edge-end":
+        applyEdgeStitches(row, "edge-end", element.stitches);
+        break;
+    }
+  }
+  return row;
+}
+
+// src/parser/rowDsl.ts
+function parseWithAstParser(parser, input, registry) {
+  return resolveRowDslAst(parser(input, registry));
+}
+function compileWithParser(parser, input, totalStitches, registry) {
+  return expandRowToStitches(parser(input, registry), totalStitches);
+}
+function parseRowDsl(input, registry) {
+  return parseWithAstParser(parseRowDslAst, input, registry);
+}
+function parseCompatibleRowDsl(input, registry) {
+  return parseWithAstParser(parseCompatibleRowDslAst, input, registry);
+}
+function compileRowDsl(input, totalStitches, registry) {
+  return compileWithParser(parseRowDsl, input, totalStitches, registry);
+}
+function compileCompatibleRowDsl(input, totalStitches, registry) {
+  return compileWithParser(parseCompatibleRowDsl, input, totalStitches, registry);
+}
+
+// src/public/parser.ts
+function wrapParseError(error, operation) {
+  return ensureKnittingMathError(
+    error,
+    (message, cause) => new KnittingMathParseError(message, { operation }, cause)
+  );
+}
+function wrapValidationError(error, operation) {
+  return ensureKnittingMathError(
+    error,
+    (message, cause) => new KnittingMathValidationError(message, { operation }, cause)
+  );
+}
+function wrapExpansionError2(error, operation) {
+  return ensureKnittingMathError(
+    error,
+    (message, cause) => new KnittingMathExpansionError(message, { operation }, cause)
+  );
+}
+function parseRowDsl2(input, registry) {
+  try {
+    return parseRowDsl(input, registry);
+  } catch (error) {
+    throw wrapParseError(error, "parseRowDsl");
+  }
+}
+function parseCompatibleRowDsl2(input, registry) {
+  try {
+    return parseCompatibleRowDsl(input, registry);
+  } catch (error) {
+    throw wrapParseError(error, "parseCompatibleRowDsl");
+  }
+}
+function compileRowDsl2(input, totalStitches, registry) {
+  try {
+    return compileRowDsl(input, totalStitches, registry);
+  } catch (error) {
+    throw wrapExpansionError2(error, "compileRowDsl");
+  }
+}
+function compileCompatibleRowDsl2(input, totalStitches, registry) {
+  try {
+    return compileCompatibleRowDsl(input, totalStitches, registry);
+  } catch (error) {
+    throw wrapExpansionError2(error, "compileCompatibleRowDsl");
+  }
+}
+function rowToRowDsl2(row) {
+  try {
+    return rowToRowDsl(row);
+  } catch (error) {
+    throw wrapValidationError(error, "rowToRowDsl");
+  }
+}
+function parseRowDslAst2(input, registry) {
+  try {
+    return parseRowDslAst(input, registry);
+  } catch (error) {
+    throw wrapParseError(error, "parseRowDslAst");
+  }
+}
+function parseCompatibleRowDslAst2(input, registry) {
+  try {
+    return parseCompatibleRowDslAst(input, registry);
+  } catch (error) {
+    throw wrapParseError(error, "parseCompatibleRowDslAst");
+  }
+}
+function resolveRowDslAst2(ast) {
+  try {
+    return resolveRowDslAst(ast);
+  } catch (error) {
+    throw wrapValidationError(error, "resolveRowDslAst");
+  }
+}
+
+// src/shaping/distribution.ts
+function distributeEvenly(totalStitches, operations) {
+  if (operations <= 0) {
+    return { spacing: [] };
+  }
+  const baseSpacing = Math.floor(totalStitches / operations);
+  const remainder = totalStitches % operations;
+  const spacing = [];
+  for (let i = 0; i < operations; i++) {
+    const shouldAddExtra = Math.floor(i * remainder / operations) !== Math.floor((i + 1) * remainder / operations);
+    spacing.push(baseSpacing + (shouldAddExtra ? 1 : 0));
+  }
+  return { spacing };
+}
+
+// src/shaping/shapingRules.ts
+var SHAPING_RULES = {
+  decrease: { consume: 2, produce: 1 },
+  // k2tog -  A decrease consumes 2 stitches and produces 1.
+  increase: { consume: 1, produce: 2 }
+  // M1 - An increase consumes 1 stitch and produces 2 stitches.
+};
+
+// src/shaping/shaping.ts
+function getShapingPositions(length, count) {
+  if (count <= 0 || length <= 0) {
+    return [];
+  }
+  const { spacing } = distributeEvenly(length, count);
+  const positions = [];
+  let current = 0;
+  for (const gap of spacing) {
+    positions.push(current);
+    current += gap;
+  }
+  return positions.filter((position) => position >= 0 && position < length);
+}
+function applyPhysicalShaping(stitches, shapingType, positions) {
+  const rule = SHAPING_RULES[shapingType];
+  const result = [];
+  let i = 0;
+  let positionIndex = 0;
+  while (i < stitches.length) {
+    if (positionIndex < positions.length && i === positions[positionIndex]) {
+      for (let j = 0; j < rule.produce; j++) {
+        result.push({
+          isShaping: true,
+          operationIndex: positionIndex,
+          shapingType,
+          sourceIndex: i,
+          type: shapingType
+        });
+      }
+      i += rule.consume;
+      positionIndex++;
+    } else {
+      result.push(stitches[i]);
+      i++;
+    }
+  }
+  return result;
+}
+function compressStitches(stitches) {
+  const result = [];
+  for (const stitch of stitches) {
+    const last = result.at(-1);
+    if ((last == null ? void 0 : last.type) === stitch.type) {
+      last.count++;
+    } else {
+      result.push({ type: stitch.type, count: 1 });
+    }
+  }
+  return result;
+}
+function shapeRow(input) {
+  const { row, totalStitches, shaping } = input;
+  if (shaping.count < 0) {
+    throw new Error("Shaping count must be 0 or greater.");
+  }
+  const expanded = expandRowToStitchTypes(row, totalStitches).map((type, sourceIndex) => ({
+    sourceIndex,
+    type
+  }));
+  const rule = SHAPING_RULES[shaping.type];
+  if (shaping.count * rule.consume > expanded.length) {
+    throw new Error("Cannot apply more shaping operations than stitches in the row.");
+  }
+  const shapingPositions = getShapingPositions(expanded.length, shaping.count);
+  const shapedStitches = applyPhysicalShaping(expanded, shaping.type, shapingPositions);
+  const stitches = compressStitches(shapedStitches);
+  const resultingStitches = totalStitches + shaping.count * (rule.produce - rule.consume);
+  return { shapedStitches, stitches, totalStitches: resultingStitches };
+}
+function groupShapedStitchesByOperation(shapedStitches) {
+  const groups = /* @__PURE__ */ new Map();
+  for (let outputIndex = 0; outputIndex < shapedStitches.length; outputIndex += 1) {
+    const stitch = shapedStitches[outputIndex];
+    if (!stitch.isShaping || stitch.operationIndex === void 0 || stitch.shapingType === void 0) {
+      continue;
+    }
+    const existing = groups.get(stitch.operationIndex);
+    if (existing) {
+      if (existing.shapingType !== stitch.shapingType) {
+        throw new Error("Shaping operation contains mixed shaping types.");
+      }
+      existing.stitches.push(stitch);
+      existing.outputIndices.push(outputIndex);
+      existing.sourceIndices.push(stitch.sourceIndex);
+      continue;
+    }
+    groups.set(stitch.operationIndex, {
+      operationIndex: stitch.operationIndex,
+      outputIndices: [outputIndex],
+      shapingType: stitch.shapingType,
+      sourceIndices: [stitch.sourceIndex],
+      stitches: [stitch]
+    });
+  }
+  return Array.from(groups.values());
+}
+
+// src/shaping/shapingDsl.ts
+var SHAPING_CLAUSE_RE = /^(?:shape|shaping)\s*:?\s*(increase|decrease)\s+(\d+)$/i;
+var TOTAL_CLAUSE_RE = /^(?:total|total-stitches|stitches)\s*:?\s*(\d+)$/i;
+var ROW_PREFIX_RE = /^row\s*:\s*/i;
+function parsePositiveInteger(input, fieldName) {
+  const value = Number.parseInt(input, 10);
+  if (!Number.isFinite(value) || Number.isNaN(value) || value < 0) {
+    throw new Error(`${fieldName} must be a non-negative integer.`);
+  }
+  return value;
+}
+function hasAtLeastOneInstruction(row) {
+  return row.elements.length > 0 || row.edgeStart !== void 0 && row.edgeStart.length > 0 || row.edgeEnd !== void 0 && row.edgeEnd.length > 0;
+}
+function parseShapingDslAst(input) {
+  const normalised = input.trim();
+  if (normalised.length === 0) {
+    throw new Error("Shaping DSL input cannot be empty.");
+  }
+  const clauses = normalised.split(";").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (clauses.length === 0) {
+    throw new Error("Shaping DSL input cannot be empty.");
+  }
+  const elements = [];
+  for (const clause of clauses) {
+    const shapingMatch = SHAPING_CLAUSE_RE.exec(clause);
+    if (shapingMatch) {
+      elements.push({
+        shapingCount: parsePositiveInteger(shapingMatch[2] ?? "", "Shaping count"),
+        shapingType: (shapingMatch[1] ?? "").toLowerCase(),
+        type: "shaping"
+      });
+      continue;
+    }
+    const totalMatch = TOTAL_CLAUSE_RE.exec(clause);
+    if (totalMatch) {
+      elements.push({
+        totalStitches: parsePositiveInteger(totalMatch[1] ?? "", "Total stitches"),
+        type: "total"
+      });
+      continue;
+    }
+    const isExplicitRow = ROW_PREFIX_RE.test(clause);
+    const rowClause = clause.replace(ROW_PREFIX_RE, "").trim();
+    if (isExplicitRow && rowClause.length === 0) {
+      throw new Error("Row clause cannot be empty.");
+    }
+    elements.push({ row: parseCompatibleRowDsl(rowClause), type: "row" });
+  }
+  return { elements };
+}
+function ensureResolvedShapingInput(row, shapingType, shapingCount, totalStitches) {
+  if (!row) {
+    throw new Error("Missing row clause.");
+  }
+  if (!hasAtLeastOneInstruction(row)) {
+    throw new Error("Row must contain at least one instruction.");
+  }
+  if (shapingType === void 0 || shapingCount === void 0) {
+    throw new Error("Missing shaping clause.");
+  }
+  if (totalStitches === void 0) {
+    throw new Error("Missing total stitches clause.");
+  }
+  return { row, shapingCount, shapingType, totalStitches };
+}
+function validateFeasibleShaping(shapingType, shapingCount, totalStitches) {
+  const rule = SHAPING_RULES[shapingType];
+  const stichesConsumed = shapingCount * rule.consume;
+  if (stichesConsumed > totalStitches) {
+    throw new Error(
+      `Cannot apply ${shapingCount} ${shapingType}(s): would require ${stichesConsumed} stitches, but only ${totalStitches} total stitches available.`
+    );
+  }
+  const delta = shapingCount * (rule.produce - rule.consume);
+  const finalCount = totalStitches + delta;
+  if (finalCount < 0) {
+    throw new Error("Shaping results in negative stitch count.");
+  }
+}
+function resolveShapingDslAst(ast) {
+  let row;
+  let shapingType;
+  let shapingCount;
+  let totalStitches;
+  for (const element of ast.elements) {
+    switch (element.type) {
+      case "row":
+        if (row !== void 0) {
+          throw new Error("Multiple row clauses detected. Only one row definition is allowed.");
+        }
+        row = element.row;
+        break;
+      case "shaping":
+        if (shapingType !== void 0) {
+          throw new Error("Shaping clause was provided more than once.");
+        }
+        shapingType = element.shapingType;
+        shapingCount = element.shapingCount;
+        break;
+      case "total":
+        if (totalStitches !== void 0) {
+          throw new Error("Total stitches clause was provided more than once.");
+        }
+        totalStitches = element.totalStitches;
+        break;
+    }
+  }
+  const resolved = ensureResolvedShapingInput(row, shapingType, shapingCount, totalStitches);
+  validateFeasibleShaping(resolved.shapingType, resolved.shapingCount, resolved.totalStitches);
+  return {
+    row: resolved.row,
+    shaping: {
+      type: resolved.shapingType,
+      count: resolved.shapingCount
+    },
+    totalStitches: resolved.totalStitches
+  };
+}
+function parseShapingDsl(input) {
+  return resolveShapingDslAst(parseShapingDslAst(input));
+}
+function compileShapingDsl(input) {
+  return shapeRow(parseShapingDsl(input));
+}
+
+// src/shaping/shapingDebug.ts
+var DEFAULT_SYMBOLS = {
+  decrease: "\\",
+  increase: "/",
+  knit: "K",
+  purl: "P"
+};
+var FALLBACK_SYMBOL = "?";
+var debugLogger = globalThis.console;
+function renderShapingDebug(shapedStitches, options = {}) {
+  const { cellWidth = 1, markerSymbol = "^", symbols: symbolOverrides } = options;
+  const symbolMap = {
+    ...DEFAULT_SYMBOLS,
+    ...symbolOverrides
+  };
+  const cells = [];
+  const markerCells = [];
+  const seenOperations = /* @__PURE__ */ new Set();
+  for (const stitch of shapedStitches) {
+    const symbol = symbolMap[stitch.type] ?? FALLBACK_SYMBOL;
+    cells.push(symbol.padEnd(cellWidth).slice(0, cellWidth));
+    const operationIndex = stitch.operationIndex;
+    const isFirstOfOperation = stitch.isShaping && operationIndex !== void 0 && !seenOperations.has(operationIndex);
+    if (isFirstOfOperation) {
+      seenOperations.add(operationIndex);
+    }
+    markerCells.push(
+      isFirstOfOperation ? markerSymbol.padEnd(cellWidth).slice(0, cellWidth) : " ".repeat(cellWidth)
+    );
+  }
+  const separator = cellWidth > 1 ? " " : "";
+  const shapingTypes = new Set(
+    shapedStitches.filter((s) => s.isShaping && s.shapingType).map((s) => s.shapingType)
+  );
+  const legendParts = [];
+  for (const type of shapingTypes) {
+    const sym = symbolMap[type] ?? FALLBACK_SYMBOL;
+    legendParts.push(`${sym} = ${type}`);
+  }
+  legendParts.push(`${markerSymbol} = shaping position`);
+  return {
+    legend: legendParts.join("  |  "),
+    markers: markerCells.join(separator),
+    row: cells.join(separator)
+  };
+}
+function renderShapingDebugForInput(input, options = {}) {
+  return renderShapingDebug(shapeRow(input).shapedStitches, options);
+}
+function printShapingDebug(shapedStitches, label, options = {}) {
+  const { legend, markers, row } = renderShapingDebug(shapedStitches, options);
+  if (label) {
+    debugLogger == null ? void 0 : debugLogger.log(label);
+  }
+  debugLogger == null ? void 0 : debugLogger.log(row);
+  debugLogger == null ? void 0 : debugLogger.log(markers);
+  debugLogger == null ? void 0 : debugLogger.log(legend);
+}
+
+// src/public/shaping.ts
+function wrapParseError2(error, operation) {
+  return ensureKnittingMathError(
+    error,
+    (message, cause) => new KnittingMathParseError(message, { operation }, cause)
+  );
+}
+function wrapValidationError2(error, operation) {
+  return ensureKnittingMathError(
+    error,
+    (message, cause) => new KnittingMathValidationError(message, { operation }, cause)
+  );
+}
+function wrapExpansionError3(error, operation) {
+  return ensureKnittingMathError(
+    error,
+    (message, cause) => new KnittingMathExpansionError(message, { operation }, cause)
+  );
+}
+function parseShapingDslAst2(input) {
+  try {
+    return parseShapingDslAst(input);
+  } catch (error) {
+    throw wrapParseError2(error, "parseShapingDslAst");
+  }
+}
+function parseShapingDsl2(input) {
+  try {
+    return parseShapingDsl(input);
+  } catch (error) {
+    throw wrapValidationError2(error, "parseShapingDsl");
+  }
+}
+function compileShapingDsl2(input) {
+  try {
+    return compileShapingDsl(input);
+  } catch (error) {
+    throw wrapExpansionError3(error, "compileShapingDsl");
+  }
+}
+function shapeRow2(input) {
+  try {
+    return shapeRow(input);
+  } catch (error) {
+    throw wrapExpansionError3(error, "shapeRow");
+  }
+}
+function groupShapedStitchesByOperation2(shapedStitches) {
+  try {
+    return groupShapedStitchesByOperation(shapedStitches);
+  } catch (error) {
+    throw wrapValidationError2(error, "groupShapedStitchesByOperation");
+  }
+}
+export {
+  CM_TO_INCH,
+  CM_TO_MM,
+  INCH_TO_CM,
+  KnittingMathError,
+  KnittingMathExpansionError,
+  KnittingMathParseError,
+  KnittingMathValidationError,
+  MM_TO_CM,
+  calculateCastOn,
+  calculateCastOnStitches,
+  cmToRows,
+  cmToStitches,
+  compileCompatibleRowDsl2 as compileCompatibleRowDsl,
+  compilePattern2 as compilePattern,
+  compileRowDsl2 as compileRowDsl,
+  compileShapingDsl2 as compileShapingDsl,
+  convertLength,
+  countStitchesInInstructions,
+  createDefaultStitchRegistry,
+  createEmptyStitchRegistry,
+  createRepeatRow,
+  ensureKnittingMathError,
+  expandPattern2 as expandPattern,
+  expandRow,
+  expandRowToStitchTypes,
+  expandRowToStitches,
+  groupShapedStitchesByOperation2 as groupShapedStitchesByOperation,
+  isRowDslAstWellFormed,
+  normaliseMeasurement,
+  parseCompatibleRowDsl2 as parseCompatibleRowDsl,
+  parseCompatibleRowDslAst2 as parseCompatibleRowDslAst,
+  parseRowDsl2 as parseRowDsl,
+  parseRowDslAst2 as parseRowDslAst,
+  parseShapingDsl2 as parseShapingDsl,
+  parseShapingDslAst2 as parseShapingDslAst,
+  printPattern2 as printPattern,
+  printShapingDebug,
+  renderShapingDebug,
+  renderShapingDebugForInput,
+  resolveRowDslAst2 as resolveRowDslAst,
+  roundStitches,
+  rowToRowDsl2 as rowToRowDsl,
+  rowsPerCm,
+  shapeRow2 as shapeRow,
+  shapedExpandPattern2 as shapedExpandPattern,
+  stitchesPerCm
+};