svelte-origin 0.0.0 → 1.0.0-next.15

package/dist/post-process.js

@@ -0,0 +1,3071 @@
+// src/post-process.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// ../../node_modules/.bun/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = 44;
+var semicolon = 59;
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0;i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function encodeInteger(builder, num, relative) {
+  let delta = num - relative;
+  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+  do {
+    let clamped = delta & 31;
+    delta >>>= 5;
+    if (delta > 0)
+      clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (delta > 0);
+  return num;
+}
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder : typeof Buffer !== "undefined" ? {
+  decode(buf) {
+    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+    return out.toString();
+  }
+} : {
+  decode(buf) {
+    let out = "";
+    for (let i = 0;i < buf.length; i++) {
+      out += String.fromCharCode(buf[i]);
+    }
+    return out;
+  }
+};
+var StringWriter = class {
+  constructor() {
+    this.pos = 0;
+    this.out = "";
+    this.buffer = new Uint8Array(bufLength);
+  }
+  write(v) {
+    const { buffer } = this;
+    buffer[this.pos++] = v;
+    if (this.pos === bufLength) {
+      this.out += td.decode(buffer);
+      this.pos = 0;
+    }
+  }
+  flush() {
+    const { buffer, out, pos } = this;
+    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+  }
+};
+function encode(decoded) {
+  const writer = new StringWriter;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  for (let i = 0;i < decoded.length; i++) {
+    const line = decoded[i];
+    if (i > 0)
+      writer.write(semicolon);
+    if (line.length === 0)
+      continue;
+    let genColumn = 0;
+    for (let j = 0;j < line.length; j++) {
+      const segment = line[j];
+      if (j > 0)
+        writer.write(comma);
+      genColumn = encodeInteger(writer, segment[0], genColumn);
+      if (segment.length === 1)
+        continue;
+      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+      sourceLine = encodeInteger(writer, segment[2], sourceLine);
+      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+      if (segment.length === 4)
+        continue;
+      namesIndex = encodeInteger(writer, segment[4], namesIndex);
+    }
+  }
+  return writer.flush();
+}
+
+// ../../node_modules/.bun/magic-string@0.30.21/node_modules/magic-string/dist/magic-string.es.mjs
+class BitSet {
+  constructor(arg) {
+    this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+  }
+  add(n) {
+    this.bits[n >> 5] |= 1 << (n & 31);
+  }
+  has(n) {
+    return !!(this.bits[n >> 5] & 1 << (n & 31));
+  }
+}
+
+class Chunk {
+  constructor(start, end, content) {
+    this.start = start;
+    this.end = end;
+    this.original = content;
+    this.intro = "";
+    this.outro = "";
+    this.content = content;
+    this.storeName = false;
+    this.edited = false;
+    {
+      this.previous = null;
+      this.next = null;
+    }
+  }
+  appendLeft(content) {
+    this.outro += content;
+  }
+  appendRight(content) {
+    this.intro = this.intro + content;
+  }
+  clone() {
+    const chunk = new Chunk(this.start, this.end, this.original);
+    chunk.intro = this.intro;
+    chunk.outro = this.outro;
+    chunk.content = this.content;
+    chunk.storeName = this.storeName;
+    chunk.edited = this.edited;
+    return chunk;
+  }
+  contains(index) {
+    return this.start < index && index < this.end;
+  }
+  eachNext(fn) {
+    let chunk = this;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.next;
+    }
+  }
+  eachPrevious(fn) {
+    let chunk = this;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.previous;
+    }
+  }
+  edit(content, storeName, contentOnly) {
+    this.content = content;
+    if (!contentOnly) {
+      this.intro = "";
+      this.outro = "";
+    }
+    this.storeName = storeName;
+    this.edited = true;
+    return this;
+  }
+  prependLeft(content) {
+    this.outro = content + this.outro;
+  }
+  prependRight(content) {
+    this.intro = content + this.intro;
+  }
+  reset() {
+    this.intro = "";
+    this.outro = "";
+    if (this.edited) {
+      this.content = this.original;
+      this.storeName = false;
+      this.edited = false;
+    }
+  }
+  split(index) {
+    const sliceIndex = index - this.start;
+    const originalBefore = this.original.slice(0, sliceIndex);
+    const originalAfter = this.original.slice(sliceIndex);
+    this.original = originalBefore;
+    const newChunk = new Chunk(index, this.end, originalAfter);
+    newChunk.outro = this.outro;
+    this.outro = "";
+    this.end = index;
+    if (this.edited) {
+      newChunk.edit("", false);
+      this.content = "";
+    } else {
+      this.content = originalBefore;
+    }
+    newChunk.next = this.next;
+    if (newChunk.next)
+      newChunk.next.previous = newChunk;
+    newChunk.previous = this;
+    this.next = newChunk;
+    return newChunk;
+  }
+  toString() {
+    return this.intro + this.content + this.outro;
+  }
+  trimEnd(rx) {
+    this.outro = this.outro.replace(rx, "");
+    if (this.outro.length)
+      return true;
+    const trimmed = this.content.replace(rx, "");
+    if (trimmed.length) {
+      if (trimmed !== this.content) {
+        this.split(this.start + trimmed.length).edit("", undefined, true);
+        if (this.edited) {
+          this.edit(trimmed, this.storeName, true);
+        }
+      }
+      return true;
+    } else {
+      this.edit("", undefined, true);
+      this.intro = this.intro.replace(rx, "");
+      if (this.intro.length)
+        return true;
+    }
+  }
+  trimStart(rx) {
+    this.intro = this.intro.replace(rx, "");
+    if (this.intro.length)
+      return true;
+    const trimmed = this.content.replace(rx, "");
+    if (trimmed.length) {
+      if (trimmed !== this.content) {
+        const newChunk = this.split(this.end - trimmed.length);
+        if (this.edited) {
+          newChunk.edit(trimmed, this.storeName, true);
+        }
+        this.edit("", undefined, true);
+      }
+      return true;
+    } else {
+      this.edit("", undefined, true);
+      this.outro = this.outro.replace(rx, "");
+      if (this.outro.length)
+        return true;
+    }
+  }
+}
+function getBtoa() {
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+    return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+  } else if (typeof Buffer === "function") {
+    return (str) => Buffer.from(str, "utf-8").toString("base64");
+  } else {
+    return () => {
+      throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+    };
+  }
+}
+var btoa = /* @__PURE__ */ getBtoa();
+
+class SourceMap {
+  constructor(properties) {
+    this.version = 3;
+    this.file = properties.file;
+    this.sources = properties.sources;
+    this.sourcesContent = properties.sourcesContent;
+    this.names = properties.names;
+    this.mappings = encode(properties.mappings);
+    if (typeof properties.x_google_ignoreList !== "undefined") {
+      this.x_google_ignoreList = properties.x_google_ignoreList;
+    }
+    if (typeof properties.debugId !== "undefined") {
+      this.debugId = properties.debugId;
+    }
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  toUrl() {
+    return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
+  }
+}
+function guessIndent(code) {
+  const lines = code.split(`
+`);
+  const tabbed = lines.filter((line) => /^\t+/.test(line));
+  const spaced = lines.filter((line) => /^ {2,}/.test(line));
+  if (tabbed.length === 0 && spaced.length === 0) {
+    return null;
+  }
+  if (tabbed.length >= spaced.length) {
+    return "\t";
+  }
+  const min = spaced.reduce((previous, current) => {
+    const numSpaces = /^ +/.exec(current)[0].length;
+    return Math.min(numSpaces, previous);
+  }, Infinity);
+  return new Array(min + 1).join(" ");
+}
+function getRelativePath(from, to) {
+  const fromParts = from.split(/[/\\]/);
+  const toParts = to.split(/[/\\]/);
+  fromParts.pop();
+  while (fromParts[0] === toParts[0]) {
+    fromParts.shift();
+    toParts.shift();
+  }
+  if (fromParts.length) {
+    let i = fromParts.length;
+    while (i--)
+      fromParts[i] = "..";
+  }
+  return fromParts.concat(toParts).join("/");
+}
+var toString = Object.prototype.toString;
+function isObject(thing) {
+  return toString.call(thing) === "[object Object]";
+}
+function getLocator(source) {
+  const originalLines = source.split(`
+`);
+  const lineOffsets = [];
+  for (let i = 0, pos = 0;i < originalLines.length; i++) {
+    lineOffsets.push(pos);
+    pos += originalLines[i].length + 1;
+  }
+  return function locate(index) {
+    let i = 0;
+    let j = lineOffsets.length;
+    while (i < j) {
+      const m = i + j >> 1;
+      if (index < lineOffsets[m]) {
+        j = m;
+      } else {
+        i = m + 1;
+      }
+    }
+    const line = i - 1;
+    const column = index - lineOffsets[line];
+    return { line, column };
+  };
+}
+var wordRegex = /\w/;
+
+class Mappings {
+  constructor(hires) {
+    this.hires = hires;
+    this.generatedCodeLine = 0;
+    this.generatedCodeColumn = 0;
+    this.raw = [];
+    this.rawSegments = this.raw[this.generatedCodeLine] = [];
+    this.pending = null;
+  }
+  addEdit(sourceIndex, content, loc, nameIndex) {
+    if (content.length) {
+      const contentLengthMinusOne = content.length - 1;
+      let contentLineEnd = content.indexOf(`
+`, 0);
+      let previousContentLineEnd = -1;
+      while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+        const segment2 = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+        if (nameIndex >= 0) {
+          segment2.push(nameIndex);
+        }
+        this.rawSegments.push(segment2);
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        previousContentLineEnd = contentLineEnd;
+        contentLineEnd = content.indexOf(`
+`, contentLineEnd + 1);
+      }
+      const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+      if (nameIndex >= 0) {
+        segment.push(nameIndex);
+      }
+      this.rawSegments.push(segment);
+      this.advance(content.slice(previousContentLineEnd + 1));
+    } else if (this.pending) {
+      this.rawSegments.push(this.pending);
+      this.advance(content);
+    }
+    this.pending = null;
+  }
+  addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+    let originalCharIndex = chunk.start;
+    let first = true;
+    let charInHiresBoundary = false;
+    while (originalCharIndex < chunk.end) {
+      if (original[originalCharIndex] === `
+`) {
+        loc.line += 1;
+        loc.column = 0;
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        first = true;
+        charInHiresBoundary = false;
+      } else {
+        if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+          const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+          if (this.hires === "boundary") {
+            if (wordRegex.test(original[originalCharIndex])) {
+              if (!charInHiresBoundary) {
+                this.rawSegments.push(segment);
+                charInHiresBoundary = true;
+              }
+            } else {
+              this.rawSegments.push(segment);
+              charInHiresBoundary = false;
+            }
+          } else {
+            this.rawSegments.push(segment);
+          }
+        }
+        loc.column += 1;
+        this.generatedCodeColumn += 1;
+        first = false;
+      }
+      originalCharIndex += 1;
+    }
+    this.pending = null;
+  }
+  advance(str) {
+    if (!str)
+      return;
+    const lines = str.split(`
+`);
+    if (lines.length > 1) {
+      for (let i = 0;i < lines.length - 1; i++) {
+        this.generatedCodeLine++;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+      }
+      this.generatedCodeColumn = 0;
+    }
+    this.generatedCodeColumn += lines[lines.length - 1].length;
+  }
+}
+var n = `
+`;
+var warned = {
+  insertLeft: false,
+  insertRight: false,
+  storeName: false
+};
+
+class MagicString {
+  constructor(string, options = {}) {
+    const chunk = new Chunk(0, string.length, string);
+    Object.defineProperties(this, {
+      original: { writable: true, value: string },
+      outro: { writable: true, value: "" },
+      intro: { writable: true, value: "" },
+      firstChunk: { writable: true, value: chunk },
+      lastChunk: { writable: true, value: chunk },
+      lastSearchedChunk: { writable: true, value: chunk },
+      byStart: { writable: true, value: {} },
+      byEnd: { writable: true, value: {} },
+      filename: { writable: true, value: options.filename },
+      indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+      sourcemapLocations: { writable: true, value: new BitSet },
+      storedNames: { writable: true, value: {} },
+      indentStr: { writable: true, value: undefined },
+      ignoreList: { writable: true, value: options.ignoreList },
+      offset: { writable: true, value: options.offset || 0 }
+    });
+    this.byStart[0] = chunk;
+    this.byEnd[string.length] = chunk;
+  }
+  addSourcemapLocation(char) {
+    this.sourcemapLocations.add(char);
+  }
+  append(content) {
+    if (typeof content !== "string")
+      throw new TypeError("outro content must be a string");
+    this.outro += content;
+    return this;
+  }
+  appendLeft(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string")
+      throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byEnd[index];
+    if (chunk) {
+      chunk.appendLeft(content);
+    } else {
+      this.intro += content;
+    }
+    return this;
+  }
+  appendRight(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string")
+      throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byStart[index];
+    if (chunk) {
+      chunk.appendRight(content);
+    } else {
+      this.outro += content;
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset });
+    let originalChunk = this.firstChunk;
+    let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+    while (originalChunk) {
+      cloned.byStart[clonedChunk.start] = clonedChunk;
+      cloned.byEnd[clonedChunk.end] = clonedChunk;
+      const nextOriginalChunk = originalChunk.next;
+      const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+      if (nextClonedChunk) {
+        clonedChunk.next = nextClonedChunk;
+        nextClonedChunk.previous = clonedChunk;
+        clonedChunk = nextClonedChunk;
+      }
+      originalChunk = nextOriginalChunk;
+    }
+    cloned.lastChunk = clonedChunk;
+    if (this.indentExclusionRanges) {
+      cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+    }
+    cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+    cloned.intro = this.intro;
+    cloned.outro = this.outro;
+    return cloned;
+  }
+  generateDecodedMap(options) {
+    options = options || {};
+    const sourceIndex = 0;
+    const names = Object.keys(this.storedNames);
+    const mappings = new Mappings(options.hires);
+    const locate = getLocator(this.original);
+    if (this.intro) {
+      mappings.advance(this.intro);
+    }
+    this.firstChunk.eachNext((chunk) => {
+      const loc = locate(chunk.start);
+      if (chunk.intro.length)
+        mappings.advance(chunk.intro);
+      if (chunk.edited) {
+        mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+      } else {
+        mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+      }
+      if (chunk.outro.length)
+        mappings.advance(chunk.outro);
+    });
+    if (this.outro) {
+      mappings.advance(this.outro);
+    }
+    return {
+      file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+      sources: [
+        options.source ? getRelativePath(options.file || "", options.source) : options.file || ""
+      ],
+      sourcesContent: options.includeContent ? [this.original] : undefined,
+      names,
+      mappings: mappings.raw,
+      x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined
+    };
+  }
+  generateMap(options) {
+    return new SourceMap(this.generateDecodedMap(options));
+  }
+  _ensureindentStr() {
+    if (this.indentStr === undefined) {
+      this.indentStr = guessIndent(this.original);
+    }
+  }
+  _getRawIndentString() {
+    this._ensureindentStr();
+    return this.indentStr;
+  }
+  getIndentString() {
+    this._ensureindentStr();
+    return this.indentStr === null ? "\t" : this.indentStr;
+  }
+  indent(indentStr, options) {
+    const pattern = /^[^\r\n]/gm;
+    if (isObject(indentStr)) {
+      options = indentStr;
+      indentStr = undefined;
+    }
+    if (indentStr === undefined) {
+      this._ensureindentStr();
+      indentStr = this.indentStr || "\t";
+    }
+    if (indentStr === "")
+      return this;
+    options = options || {};
+    const isExcluded = {};
+    if (options.exclude) {
+      const exclusions = typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude;
+      exclusions.forEach((exclusion) => {
+        for (let i = exclusion[0];i < exclusion[1]; i += 1) {
+          isExcluded[i] = true;
+        }
+      });
+    }
+    let shouldIndentNextCharacter = options.indentStart !== false;
+    const replacer = (match) => {
+      if (shouldIndentNextCharacter)
+        return `${indentStr}${match}`;
+      shouldIndentNextCharacter = true;
+      return match;
+    };
+    this.intro = this.intro.replace(pattern, replacer);
+    let charIndex = 0;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      const end = chunk.end;
+      if (chunk.edited) {
+        if (!isExcluded[charIndex]) {
+          chunk.content = chunk.content.replace(pattern, replacer);
+          if (chunk.content.length) {
+            shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === `
+`;
+          }
+        }
+      } else {
+        charIndex = chunk.start;
+        while (charIndex < end) {
+          if (!isExcluded[charIndex]) {
+            const char = this.original[charIndex];
+            if (char === `
+`) {
+              shouldIndentNextCharacter = true;
+            } else if (char !== "\r" && shouldIndentNextCharacter) {
+              shouldIndentNextCharacter = false;
+              if (charIndex === chunk.start) {
+                chunk.prependRight(indentStr);
+              } else {
+                this._splitChunk(chunk, charIndex);
+                chunk = chunk.next;
+                chunk.prependRight(indentStr);
+              }
+            }
+          }
+          charIndex += 1;
+        }
+      }
+      charIndex = chunk.end;
+      chunk = chunk.next;
+    }
+    this.outro = this.outro.replace(pattern, replacer);
+    return this;
+  }
+  insert() {
+    throw new Error("magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)");
+  }
+  insertLeft(index, content) {
+    if (!warned.insertLeft) {
+      console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
+      warned.insertLeft = true;
+    }
+    return this.appendLeft(index, content);
+  }
+  insertRight(index, content) {
+    if (!warned.insertRight) {
+      console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
+      warned.insertRight = true;
+    }
+    return this.prependRight(index, content);
+  }
+  move(start, end, index) {
+    start = start + this.offset;
+    end = end + this.offset;
+    index = index + this.offset;
+    if (index >= start && index <= end)
+      throw new Error("Cannot move a selection inside itself");
+    this._split(start);
+    this._split(end);
+    this._split(index);
+    const first = this.byStart[start];
+    const last = this.byEnd[end];
+    const oldLeft = first.previous;
+    const oldRight = last.next;
+    const newRight = this.byStart[index];
+    if (!newRight && last === this.lastChunk)
+      return this;
+    const newLeft = newRight ? newRight.previous : this.lastChunk;
+    if (oldLeft)
+      oldLeft.next = oldRight;
+    if (oldRight)
+      oldRight.previous = oldLeft;
+    if (newLeft)
+      newLeft.next = first;
+    if (newRight)
+      newRight.previous = last;
+    if (!first.previous)
+      this.firstChunk = last.next;
+    if (!last.next) {
+      this.lastChunk = first.previous;
+      this.lastChunk.next = null;
+    }
+    first.previous = newLeft;
+    last.next = newRight || null;
+    if (!newLeft)
+      this.firstChunk = first;
+    if (!newRight)
+      this.lastChunk = last;
+    return this;
+  }
+  overwrite(start, end, content, options) {
+    options = options || {};
+    return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+  }
+  update(start, end, content, options) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (typeof content !== "string")
+      throw new TypeError("replacement content must be a string");
+    if (this.original.length !== 0) {
+      while (start < 0)
+        start += this.original.length;
+      while (end < 0)
+        end += this.original.length;
+    }
+    if (end > this.original.length)
+      throw new Error("end is out of bounds");
+    if (start === end)
+      throw new Error("Cannot overwrite a zero-length range – use appendLeft or prependRight instead");
+    this._split(start);
+    this._split(end);
+    if (options === true) {
+      if (!warned.storeName) {
+        console.warn("The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string");
+        warned.storeName = true;
+      }
+      options = { storeName: true };
+    }
+    const storeName = options !== undefined ? options.storeName : false;
+    const overwrite = options !== undefined ? options.overwrite : false;
+    if (storeName) {
+      const original = this.original.slice(start, end);
+      Object.defineProperty(this.storedNames, original, {
+        writable: true,
+        value: true,
+        enumerable: true
+      });
+    }
+    const first = this.byStart[start];
+    const last = this.byEnd[end];
+    if (first) {
+      let chunk = first;
+      while (chunk !== last) {
+        if (chunk.next !== this.byStart[chunk.end]) {
+          throw new Error("Cannot overwrite across a split point");
+        }
+        chunk = chunk.next;
+        chunk.edit("", false);
+      }
+      first.edit(content, storeName, !overwrite);
+    } else {
+      const newChunk = new Chunk(start, end, "").edit(content, storeName);
+      last.next = newChunk;
+      newChunk.previous = last;
+    }
+    return this;
+  }
+  prepend(content) {
+    if (typeof content !== "string")
+      throw new TypeError("outro content must be a string");
+    this.intro = content + this.intro;
+    return this;
+  }
+  prependLeft(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string")
+      throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byEnd[index];
+    if (chunk) {
+      chunk.prependLeft(content);
+    } else {
+      this.intro = content + this.intro;
+    }
+    return this;
+  }
+  prependRight(index, content) {
+    index = index + this.offset;
+    if (typeof content !== "string")
+      throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byStart[index];
+    if (chunk) {
+      chunk.prependRight(content);
+    } else {
+      this.outro = content + this.outro;
+    }
+    return this;
+  }
+  remove(start, end) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0)
+        start += this.original.length;
+      while (end < 0)
+        end += this.original.length;
+    }
+    if (start === end)
+      return this;
+    if (start < 0 || end > this.original.length)
+      throw new Error("Character is out of bounds");
+    if (start > end)
+      throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.intro = "";
+      chunk.outro = "";
+      chunk.edit("");
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
+  reset(start, end) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0)
+        start += this.original.length;
+      while (end < 0)
+        end += this.original.length;
+    }
+    if (start === end)
+      return this;
+    if (start < 0 || end > this.original.length)
+      throw new Error("Character is out of bounds");
+    if (start > end)
+      throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.reset();
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
+  lastChar() {
+    if (this.outro.length)
+      return this.outro[this.outro.length - 1];
+    let chunk = this.lastChunk;
+    do {
+      if (chunk.outro.length)
+        return chunk.outro[chunk.outro.length - 1];
+      if (chunk.content.length)
+        return chunk.content[chunk.content.length - 1];
+      if (chunk.intro.length)
+        return chunk.intro[chunk.intro.length - 1];
+    } while (chunk = chunk.previous);
+    if (this.intro.length)
+      return this.intro[this.intro.length - 1];
+    return "";
+  }
+  lastLine() {
+    let lineIndex = this.outro.lastIndexOf(n);
+    if (lineIndex !== -1)
+      return this.outro.substr(lineIndex + 1);
+    let lineStr = this.outro;
+    let chunk = this.lastChunk;
+    do {
+      if (chunk.outro.length > 0) {
+        lineIndex = chunk.outro.lastIndexOf(n);
+        if (lineIndex !== -1)
+          return chunk.outro.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.outro + lineStr;
+      }
+      if (chunk.content.length > 0) {
+        lineIndex = chunk.content.lastIndexOf(n);
+        if (lineIndex !== -1)
+          return chunk.content.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.content + lineStr;
+      }
+      if (chunk.intro.length > 0) {
+        lineIndex = chunk.intro.lastIndexOf(n);
+        if (lineIndex !== -1)
+          return chunk.intro.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.intro + lineStr;
+      }
+    } while (chunk = chunk.previous);
+    lineIndex = this.intro.lastIndexOf(n);
+    if (lineIndex !== -1)
+      return this.intro.substr(lineIndex + 1) + lineStr;
+    return this.intro + lineStr;
+  }
+  slice(start = 0, end = this.original.length - this.offset) {
+    start = start + this.offset;
+    end = end + this.offset;
+    if (this.original.length !== 0) {
+      while (start < 0)
+        start += this.original.length;
+      while (end < 0)
+        end += this.original.length;
+    }
+    let result = "";
+    let chunk = this.firstChunk;
+    while (chunk && (chunk.start > start || chunk.end <= start)) {
+      if (chunk.start < end && chunk.end >= end) {
+        return result;
+      }
+      chunk = chunk.next;
+    }
+    if (chunk && chunk.edited && chunk.start !== start)
+      throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+    const startChunk = chunk;
+    while (chunk) {
+      if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+        result += chunk.intro;
+      }
+      const containsEnd = chunk.start < end && chunk.end >= end;
+      if (containsEnd && chunk.edited && chunk.end !== end)
+        throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+      const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+      const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+      result += chunk.content.slice(sliceStart, sliceEnd);
+      if (chunk.outro && (!containsEnd || chunk.end === end)) {
+        result += chunk.outro;
+      }
+      if (containsEnd) {
+        break;
+      }
+      chunk = chunk.next;
+    }
+    return result;
+  }
+  snip(start, end) {
+    const clone = this.clone();
+    clone.remove(0, start);
+    clone.remove(end, clone.original.length);
+    return clone;
+  }
+  _split(index) {
+    if (this.byStart[index] || this.byEnd[index])
+      return;
+    let chunk = this.lastSearchedChunk;
+    let previousChunk = chunk;
+    const searchForward = index > chunk.end;
+    while (chunk) {
+      if (chunk.contains(index))
+        return this._splitChunk(chunk, index);
+      chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+      if (chunk === previousChunk)
+        return;
+      previousChunk = chunk;
+    }
+  }
+  _splitChunk(chunk, index) {
+    if (chunk.edited && chunk.content.length) {
+      const loc = getLocator(this.original)(index);
+      throw new Error(`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
+    }
+    const newChunk = chunk.split(index);
+    this.byEnd[index] = chunk;
+    this.byStart[index] = newChunk;
+    this.byEnd[newChunk.end] = newChunk;
+    if (chunk === this.lastChunk)
+      this.lastChunk = newChunk;
+    this.lastSearchedChunk = chunk;
+    return true;
+  }
+  toString() {
+    let str = this.intro;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      str += chunk.toString();
+      chunk = chunk.next;
+    }
+    return str + this.outro;
+  }
+  isEmpty() {
+    let chunk = this.firstChunk;
+    do {
+      if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim())
+        return false;
+    } while (chunk = chunk.next);
+    return true;
+  }
+  length() {
+    let chunk = this.firstChunk;
+    let length = 0;
+    do {
+      length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+    } while (chunk = chunk.next);
+    return length;
+  }
+  trimLines() {
+    return this.trim("[\\r\\n]");
+  }
+  trim(charType) {
+    return this.trimStart(charType).trimEnd(charType);
+  }
+  trimEndAborted(charType) {
+    const rx = new RegExp((charType || "\\s") + "+$");
+    this.outro = this.outro.replace(rx, "");
+    if (this.outro.length)
+      return true;
+    let chunk = this.lastChunk;
+    do {
+      const end = chunk.end;
+      const aborted = chunk.trimEnd(rx);
+      if (chunk.end !== end) {
+        if (this.lastChunk === chunk) {
+          this.lastChunk = chunk.next;
+        }
+        this.byEnd[chunk.end] = chunk;
+        this.byStart[chunk.next.start] = chunk.next;
+        this.byEnd[chunk.next.end] = chunk.next;
+      }
+      if (aborted)
+        return true;
+      chunk = chunk.previous;
+    } while (chunk);
+    return false;
+  }
+  trimEnd(charType) {
+    this.trimEndAborted(charType);
+    return this;
+  }
+  trimStartAborted(charType) {
+    const rx = new RegExp("^" + (charType || "\\s") + "+");
+    this.intro = this.intro.replace(rx, "");
+    if (this.intro.length)
+      return true;
+    let chunk = this.firstChunk;
+    do {
+      const end = chunk.end;
+      const aborted = chunk.trimStart(rx);
+      if (chunk.end !== end) {
+        if (chunk === this.lastChunk)
+          this.lastChunk = chunk.next;
+        this.byEnd[chunk.end] = chunk;
+        this.byStart[chunk.next.start] = chunk.next;
+        this.byEnd[chunk.next.end] = chunk.next;
+      }
+      if (aborted)
+        return true;
+      chunk = chunk.next;
+    } while (chunk);
+    return false;
+  }
+  trimStart(charType) {
+    this.trimStartAborted(charType);
+    return this;
+  }
+  hasChanged() {
+    return this.original !== this.toString();
+  }
+  _replaceRegexp(searchValue, replacement) {
+    function getReplacement(match, str) {
+      if (typeof replacement === "string") {
+        return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+          if (i === "$")
+            return "$";
+          if (i === "&")
+            return match[0];
+          const num = +i;
+          if (num < match.length)
+            return match[+i];
+          return `$${i}`;
+        });
+      } else {
+        return replacement(...match, match.index, str, match.groups);
+      }
+    }
+    function matchAll(re, str) {
+      let match;
+      const matches = [];
+      while (match = re.exec(str)) {
+        matches.push(match);
+      }
+      return matches;
+    }
+    if (searchValue.global) {
+      const matches = matchAll(searchValue, this.original);
+      matches.forEach((match) => {
+        if (match.index != null) {
+          const replacement2 = getReplacement(match, this.original);
+          if (replacement2 !== match[0]) {
+            this.overwrite(match.index, match.index + match[0].length, replacement2);
+          }
+        }
+      });
+    } else {
+      const match = this.original.match(searchValue);
+      if (match && match.index != null) {
+        const replacement2 = getReplacement(match, this.original);
+        if (replacement2 !== match[0]) {
+          this.overwrite(match.index, match.index + match[0].length, replacement2);
+        }
+      }
+    }
+    return this;
+  }
+  _replaceString(string, replacement) {
+    const { original } = this;
+    const index = original.indexOf(string);
+    if (index !== -1) {
+      if (typeof replacement === "function") {
+        replacement = replacement(string, index, original);
+      }
+      if (string !== replacement) {
+        this.overwrite(index, index + string.length, replacement);
+      }
+    }
+    return this;
+  }
+  replace(searchValue, replacement) {
+    if (typeof searchValue === "string") {
+      return this._replaceString(searchValue, replacement);
+    }
+    return this._replaceRegexp(searchValue, replacement);
+  }
+  _replaceAllString(string, replacement) {
+    const { original } = this;
+    const stringLength = string.length;
+    for (let index = original.indexOf(string);index !== -1; index = original.indexOf(string, index + stringLength)) {
+      const previous = original.slice(index, index + stringLength);
+      let _replacement = replacement;
+      if (typeof replacement === "function") {
+        _replacement = replacement(previous, index, original);
+      }
+      if (previous !== _replacement)
+        this.overwrite(index, index + stringLength, _replacement);
+    }
+    return this;
+  }
+  replaceAll(searchValue, replacement) {
+    if (typeof searchValue === "string") {
+      return this._replaceAllString(searchValue, replacement);
+    }
+    if (!searchValue.global) {
+      throw new TypeError("MagicString.prototype.replaceAll called with a non-global RegExp argument");
+    }
+    return this._replaceRegexp(searchValue, replacement);
+  }
+}
+
+// src/transform/patterns.ts
+var patterns = {
+  hasMacros: /\$origin|\$attrs\.(origin|for)|\$attrs\s*\(/,
+  origin: /\$origin\s*\(/g,
+  originWithParents: /\$origin\s*\(\s*\[/,
+  attrsInOrigin: /\$attrs\s*\(\s*\{/g,
+  standaloneAttrs: /(?:let|const|export\s+const|export\s+let)\s+\w+\s*=\s*\$attrs\s*\(/g,
+  bindableInAttrs: /\$bindable\s*\(/g,
+  attrsOrigin: /\$attrs\s*\.\s*origin\s*\(\s*(\w+)\s*\)/g,
+  attrsForOrigin: /\$attrs\s*\.\s*for\s*\(\s*(\w+)\s*\)/g,
+  attrsForElement: /\$attrs\s*\.\s*for\s*\(\s*['"]([\w-]+)['"]\s*\)/g
+};
+function containsMacros(source) {
+  return patterns.hasMacros.test(source);
+}
+function isInsideStringOrComment(source, position) {
+  let i = 0;
+  while (i < position) {
+    const char = source[i];
+    if (char === "/" && source[i + 1] === "/") {
+      const endLine = source.indexOf(`
+`, i + 2);
+      if (endLine === -1) {
+        return position > i;
+      }
+      if (position > i && position <= endLine) {
+        return true;
+      }
+      i = endLine + 1;
+      continue;
+    }
+    if (char === "/" && source[i + 1] === "*") {
+      const endComment = source.indexOf("*/", i + 2);
+      if (endComment === -1) {
+        return position > i;
+      }
+      if (position > i && position < endComment + 2) {
+        return true;
+      }
+      i = endComment + 2;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      const stringStart = i;
+      i++;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === quote) {
+          if (position > stringStart && position <= i) {
+            return true;
+          }
+          i++;
+          break;
+        }
+        if (quote === "`" && source[i] === "$" && source[i + 1] === "{") {
+          const exprStart = i;
+          i += 2;
+          let depth = 1;
+          while (i < source.length && depth > 0) {
+            if (source[i] === "{")
+              depth++;
+            else if (source[i] === "}")
+              depth--;
+            else if (source[i] === "\\")
+              i++;
+            i++;
+          }
+          if (position > stringStart && position < exprStart) {
+            return true;
+          }
+          continue;
+        }
+        i++;
+      }
+      continue;
+    }
+    i++;
+  }
+  return false;
+}
+function extractBindable(value) {
+  if (!value.startsWith("$bindable"))
+    return { isBindable: false };
+  let i = 9;
+  if (value[i] === "<") {
+    let depth = 1;
+    i++;
+    while (i < value.length && depth > 0) {
+      const char = value[i];
+      if (char === "=" && value[i + 1] === ">") {
+        i += 2;
+        continue;
+      }
+      if (char === "<")
+        depth++;
+      else if (char === ">")
+        depth--;
+      i++;
+    }
+  }
+  while (i < value.length && /\s/.test(value[i]))
+    i++;
+  if (value[i] !== "(")
+    return { isBindable: false };
+  const openParen = i;
+  const closeParen = findMatchingBracket(value, openParen);
+  if (closeParen === -1)
+    return { isBindable: false };
+  const innerValue = value.slice(openParen + 1, closeParen).trim() || "undefined";
+  return { isBindable: true, innerValue };
+}
+function findTopLevelAs(value) {
+  let depth = 0;
+  let angleDepth = 0;
+  for (let i = 0;i < value.length - 4; i++) {
+    const char = value[i];
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      i++;
+      while (i < value.length && value[i] !== quote) {
+        if (value[i] === "\\")
+          i++;
+        i++;
+      }
+      continue;
+    }
+    if (char === "{" || char === "(" || char === "[") {
+      depth++;
+    } else if (char === "}" || char === ")" || char === "]") {
+      depth--;
+    } else if (char === "<") {
+      const prevChar = i > 0 ? value[i - 1] : "";
+      if (/[\w$)]/.test(prevChar)) {
+        angleDepth++;
+      }
+    } else if (char === ">") {
+      if (i > 0 && value[i - 1] === "=") {
+        continue;
+      }
+      if (angleDepth > 0) {
+        angleDepth--;
+      }
+    } else if (depth === 0 && angleDepth === 0 && value.slice(i, i + 4) === " as ") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findMatchingBracket(source, openIndex, openChar = "(", closeChar = ")") {
+  let depth = 0;
+  for (let i = openIndex;i < source.length; i++) {
+    const char = source[i];
+    if (char === "/" && source[i + 1] === "/") {
+      const endLine = source.indexOf(`
+`, i + 2);
+      if (endLine !== -1) {
+        i = endLine;
+      } else {
+        i = source.length;
+      }
+      continue;
+    }
+    if (char === "/" && source[i + 1] === "*") {
+      const endComment = source.indexOf("*/", i + 2);
+      if (endComment !== -1) {
+        i = endComment + 1;
+      } else {
+        i = source.length;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      i++;
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\")
+          i++;
+        i++;
+      }
+      continue;
+    }
+    if (char === openChar) {
+      depth++;
+    } else if (char === closeChar) {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+
+// src/transform/codegen.ts
+function generateRuntimeImport(functions) {
+  return `import { ${functions.join(", ")} } from 'svelte-origin/runtime'`;
+}
+
+// src/transform/declaration-parser.ts
+function findVariableDeclarationsWithMacro(source, macroPattern) {
+  const results = [];
+  const parts = macroPattern.split(".");
+  const escapedParts = parts.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const patternWithSpaces = escapedParts.join("\\s*\\.\\s*");
+  const macroRegex = new RegExp(patternWithSpaces + "\\s*\\(", "g");
+  let match;
+  while ((match = macroRegex.exec(source)) !== null) {
+    const macroStart = match.index;
+    const macroOpenParen = macroStart + match[0].length - 1;
+    if (isInsideStringOrComment(source, macroStart)) {
+      continue;
+    }
+    const declaration = findDeclarationBefore(source, macroStart);
+    if (declaration) {
+      results.push({
+        ...declaration,
+        macroOpenParen
+      });
+    }
+  }
+  return results;
+}
+function findDeclarationBefore(source, beforeIndex) {
+  let i = beforeIndex - 1;
+  while (i >= 0 && /\s/.test(source[i]))
+    i--;
+  if (source[i] !== "=")
+    return null;
+  const equalsIndex = i;
+  i--;
+  while (i >= 0 && /\s/.test(source[i]))
+    i--;
+  let typeAnnotation = null;
+  let typeEnd = -1;
+  const posAfterTypeOrName = i + 1;
+  let depth = 0;
+  let colonIndex = -1;
+  let tempI = i;
+  while (tempI >= 0) {
+    const char = source[tempI];
+    if (char === '"' || char === "'" || char === "`") {
+      tempI--;
+      while (tempI >= 0 && source[tempI] !== char) {
+        if (source[tempI - 1] === "\\")
+          tempI--;
+        tempI--;
+      }
+      tempI--;
+      continue;
+    }
+    if (char === ">" || char === ")" || char === "]" || char === "}") {
+      depth++;
+    } else if (char === "<" || char === "(" || char === "[" || char === "{") {
+      depth--;
+    } else if (char === ":" && depth === 0) {
+      colonIndex = tempI;
+      break;
+    } else if (depth === 0 && /[;\n{]/.test(char)) {
+      break;
+    }
+    tempI--;
+  }
+  if (colonIndex !== -1) {
+    typeEnd = posAfterTypeOrName;
+    typeAnnotation = source.slice(colonIndex + 1, typeEnd).trim();
+    i = colonIndex - 1;
+    while (i >= 0 && /\s/.test(source[i]))
+      i--;
+  }
+  if (!/[\w$]/.test(source[i]))
+    return null;
+  const nameEnd = i + 1;
+  while (i >= 0 && /[\w$]/.test(source[i]))
+    i--;
+  const nameStart = i + 1;
+  const varName = source.slice(nameStart, nameEnd);
+  if (!varName)
+    return null;
+  while (i >= 0 && /\s/.test(source[i]))
+    i--;
+  let keywordStart = -1;
+  if (source.slice(i - 4, i + 1) === "const") {
+    keywordStart = i - 4;
+    i -= 5;
+  } else if (source.slice(i - 2, i + 1) === "let") {
+    keywordStart = i - 2;
+    i -= 3;
+  } else if (source.slice(i - 2, i + 1) === "var") {
+    keywordStart = i - 2;
+    i -= 3;
+  } else {
+    return null;
+  }
+  let startIndex = keywordStart;
+  while (i >= 0 && /\s/.test(source[i]))
+    i--;
+  let hasExport = false;
+  if (source.slice(i - 5, i + 1) === "export") {
+    hasExport = true;
+    startIndex = i - 5;
+    i -= 6;
+    while (i >= 0 && /\s/.test(source[i]))
+      i--;
+  }
+  const valueStartIndex = equalsIndex + 1;
+  return {
+    varName,
+    startIndex,
+    valueStartIndex,
+    hasExport,
+    typeAnnotation
+  };
+}
+function hasExistingPropsDeclaration(source) {
+  return /\b(type|interface)\s+\$\$Props\b/.test(source);
+}
+function findPropsInjectionPosition(source) {
+  let lastImportEnd = 0;
+  let i = 0;
+  const scriptTagMatch = source.match(/^<script[^>]*>/);
+  if (scriptTagMatch) {
+    i = scriptTagMatch[0].length;
+    lastImportEnd = i;
+  }
+  while (i < source.length) {
+    while (i < source.length && /\s/.test(source[i]))
+      i++;
+    if (source.slice(i, i + 6) === "import") {
+      i += 6;
+      while (i < source.length && /\s/.test(source[i]))
+        i++;
+      if (source.slice(i, i + 4) === "type" && /\s/.test(source[i + 4])) {
+        i += 4;
+        while (i < source.length && /\s/.test(source[i]))
+          i++;
+      }
+      let foundFrom = false;
+      while (i < source.length) {
+        const char = source[i];
+        if (char === "{") {
+          const closeIndex = findMatchingBracket(source, i, "{", "}");
+          if (closeIndex !== -1) {
+            i = closeIndex + 1;
+            continue;
+          }
+        }
+        if (char === '"' || char === "'" || char === "`") {
+          const quote = char;
+          i++;
+          while (i < source.length && source[i] !== quote) {
+            if (source[i] === "\\")
+              i++;
+            i++;
+          }
+          i++;
+          while (i < source.length && source[i] !== `
+` && source[i] !== ";") {
+            i++;
+          }
+          if (source[i] === ";")
+            i++;
+          if (source[i] === `
+`)
+            i++;
+          lastImportEnd = i;
+          foundFrom = true;
+          break;
+        }
+        if (source.slice(i, i + 4) === "from" && /\s/.test(source[i + 4])) {
+          i += 4;
+          while (i < source.length && /\s/.test(source[i]))
+            i++;
+          continue;
+        }
+        i++;
+      }
+      if (!foundFrom) {
+        break;
+      }
+      continue;
+    }
+    if (source[i] === "<") {
+      break;
+    }
+    if (/[a-zA-Z_$]/.test(source[i])) {
+      if (source.slice(i, i + 6) === "export") {
+        const afterExport = source.slice(i + 6, i + 20);
+        if (!/\s*(const|let|var|function|class|default|type|interface|\{)/.test(afterExport)) {
+          break;
+        }
+      }
+      break;
+    }
+    i++;
+  }
+  if (lastImportEnd > 0) {
+    return lastImportEnd;
+  }
+  const scriptMatch = source.match(/<script[^>]*>/);
+  if (scriptMatch) {
+    return scriptMatch.index + scriptMatch[0].length;
+  }
+  return 0;
+}
+
+// src/transform/attrs-schema.ts
+function generateAttrSchemaFromSource(attrsSource) {
+  const entries = [];
+  const attrs = splitAttrsSource(attrsSource);
+  for (const attr of attrs) {
+    const trimmed = attr.trim();
+    if (!trimmed)
+      continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    const asIndex = findTopLevelAs(value);
+    if (asIndex !== -1) {
+      value = value.slice(0, asIndex).trim();
+    }
+    const bindableResult = extractBindable(value);
+    if (bindableResult.isBindable) {
+      const defaultVal = bindableResult.innerValue;
+      const hasDefault = defaultVal !== "" && defaultVal !== "undefined";
+      entries.push(`${key}: { default: ${defaultVal}, bindable: true, hasDefault: ${hasDefault} }`);
+    } else {
+      const hasDefault = value !== "undefined";
+      entries.push(`${key}: { default: ${value}, bindable: false, hasDefault: ${hasDefault} }`);
+    }
+  }
+  return `{ ${entries.join(", ")} }`;
+}
+function parseAttrsSource(attrsSource) {
+  const result = [];
+  const attrs = splitAttrsSource(attrsSource);
+  for (const attr of attrs) {
+    let trimmed = attr.trim();
+    if (!trimmed)
+      continue;
+    while (trimmed.startsWith("/*")) {
+      const endComment = trimmed.indexOf("*/");
+      if (endComment !== -1) {
+        trimmed = trimmed.slice(endComment + 2).trim();
+      } else {
+        break;
+      }
+    }
+    while (trimmed.startsWith("//")) {
+      const endLine = trimmed.indexOf(`
+`);
+      if (endLine !== -1) {
+        trimmed = trimmed.slice(endLine + 1).trim();
+      } else {
+        trimmed = "";
+        break;
+      }
+    }
+    if (!trimmed)
+      continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    const asIndex = findTopLevelAs(value);
+    if (asIndex !== -1) {
+      value = value.slice(0, asIndex).trim();
+    }
+    const bindableResult = extractBindable(value);
+    if (bindableResult.isBindable) {
+      const defaultVal = bindableResult.innerValue;
+      const hasDefault = defaultVal !== "" && defaultVal !== "undefined";
+      result.push({ key, defaultValue: defaultVal, bindable: true, hasDefault });
+    } else {
+      const hasDefault = value !== "undefined";
+      result.push({ key, defaultValue: value, bindable: false, hasDefault });
+    }
+  }
+  return result;
+}
+function splitAttrsSource(source) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let angleDepth = 0;
+  let i = 0;
+  while (i < source.length) {
+    const char = source[i];
+    if (char === "/" && source[i + 1] === "/") {
+      const endLine = source.indexOf(`
+`, i + 2);
+      if (endLine !== -1) {
+        current += source.slice(i, endLine + 1);
+        i = endLine + 1;
+      } else {
+        current += source.slice(i);
+        i = source.length;
+      }
+      continue;
+    }
+    if (char === "/" && source[i + 1] === "*") {
+      const endComment = source.indexOf("*/", i + 2);
+      if (endComment !== -1) {
+        current += source.slice(i, endComment + 2);
+        i = endComment + 2;
+      } else {
+        current += source.slice(i);
+        i = source.length;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      current += char;
+      i++;
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\") {
+          current += source[i];
+          i++;
+        }
+        if (i < source.length) {
+          current += source[i];
+          i++;
+        }
+      }
+      if (i < source.length) {
+        current += source[i];
+        i++;
+      }
+      continue;
+    }
+    if (char === "<") {
+      const prevChar = current.length > 0 ? current[current.length - 1] : "";
+      const isGeneric = /[\w$)]/.test(prevChar);
+      if (isGeneric) {
+        angleDepth++;
+      }
+      current += char;
+      i++;
+      continue;
+    }
+    if (char === ">") {
+      if (i > 0 && source[i - 1] === "=") {
+        current += char;
+        i++;
+        continue;
+      }
+      if (angleDepth > 0) {
+        angleDepth--;
+      }
+      current += char;
+      i++;
+      continue;
+    }
+    if (char === "{" || char === "(" || char === "[") {
+      depth++;
+      current += char;
+    } else if (char === "}" || char === ")" || char === "]") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0 && angleDepth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+    i++;
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function parseObjectMembers(source) {
+  const members = [];
+  let i = 0;
+  while (i < source.length) {
+    while (i < source.length && /[\s,]/.test(source[i]))
+      i++;
+    if (i >= source.length)
+      break;
+    if (source.slice(i, i + 2) === "/*") {
+      const endComment = source.indexOf("*/", i + 2);
+      if (endComment !== -1) {
+        i = endComment + 2;
+        continue;
+      }
+    }
+    if (source.slice(i, i + 2) === "//") {
+      const endLine = source.indexOf(`
+`, i + 2);
+      if (endLine !== -1) {
+        i = endLine + 1;
+        continue;
+      } else {
+        break;
+      }
+    }
+    let isGetter = false;
+    let isSetter = false;
+    let isAsync = false;
+    let isGenerator = false;
+    if (source.slice(i).match(/^get\s+/)) {
+      isGetter = true;
+      i += source.slice(i).match(/^get\s+/)[0].length;
+    } else if (source.slice(i).match(/^set\s+/)) {
+      isSetter = true;
+      i += source.slice(i).match(/^set\s+/)[0].length;
+    } else if (source.slice(i).match(/^async\s+\*/)) {
+      isAsync = true;
+      isGenerator = true;
+      i += source.slice(i).match(/^async\s+\*/)[0].length;
+      while (i < source.length && /\s/.test(source[i]))
+        i++;
+    } else if (source.slice(i).match(/^async\s+/)) {
+      isAsync = true;
+      i += source.slice(i).match(/^async\s+/)[0].length;
+    } else if (source[i] === "*") {
+      isGenerator = true;
+      i++;
+      while (i < source.length && /\s/.test(source[i]))
+        i++;
+    }
+    let isComputed = false;
+    let key = "";
+    if (source[i] === "[") {
+      isComputed = true;
+      const bracketStart = i;
+      let depth = 1;
+      i++;
+      while (i < source.length && depth > 0) {
+        if (source[i] === "[")
+          depth++;
+        else if (source[i] === "]")
+          depth--;
+        i++;
+      }
+      key = source.slice(bracketStart, i);
+    } else {
+      const keyMatch = source.slice(i).match(/^(\$?\w+)/);
+      if (!keyMatch)
+        break;
+      key = keyMatch[1];
+      i += key.length;
+    }
+    while (i < source.length && /\s/.test(source[i]))
+      i++;
+    if (source[i] === ":") {
+      i++;
+      const valueStart = i;
+      let depth = 0;
+      let angleDepth = 0;
+      while (i < source.length) {
+        const char = source[i];
+        if (char === "/" && source[i + 1] === "/") {
+          const endLine = source.indexOf(`
+`, i + 2);
+          if (endLine !== -1) {
+            i = endLine + 1;
+            continue;
+          } else {
+            break;
+          }
+        }
+        if (char === "/" && source[i + 1] === "*") {
+          const endComment = source.indexOf("*/", i + 2);
+          if (endComment !== -1) {
+            i = endComment + 2;
+            continue;
+          } else {
+            break;
+          }
+        }
+        if (char === '"' || char === "'" || char === "`") {
+          const quote = char;
+          i++;
+          while (i < source.length && source[i] !== quote) {
+            if (source[i] === "\\")
+              i++;
+            i++;
+          }
+          i++;
+          continue;
+        }
+        if ((char === "," || char === "}") && depth === 0 && angleDepth === 0)
+          break;
+        if (char === "{" || char === "(" || char === "[")
+          depth++;
+        if (char === "}" || char === ")" || char === "]")
+          depth--;
+        if (char === "<" && i > 0 && /\w/.test(source[i - 1]))
+          angleDepth++;
+        if (char === ">" && angleDepth > 0)
+          angleDepth--;
+        i++;
+      }
+      const value = source.slice(valueStart, i).trim();
+      members.push({ key, value, isGetter, isSetter, isMethod: false, isAsync, isGenerator, isComputed });
+    } else if (source[i] === "(") {
+      const bodyStart = i;
+      let depth = 1;
+      i++;
+      while (i < source.length && depth > 0) {
+        if (source[i] === "(")
+          depth++;
+        if (source[i] === ")")
+          depth--;
+        i++;
+      }
+      while (i < source.length && /\s/.test(source[i]))
+        i++;
+      if (source[i] === ":") {
+        i++;
+        let typeDepth = 0;
+        while (i < source.length) {
+          const char = source[i];
+          if (char === "<" || char === "(" || char === "[")
+            typeDepth++;
+          if (char === ">" || char === ")" || char === "]")
+            typeDepth--;
+          if (char === "{" && typeDepth === 0)
+            break;
+          i++;
+        }
+      }
+      if (source[i] === "{") {
+        const braceStart = i;
+        depth = 1;
+        i++;
+        while (i < source.length && depth > 0) {
+          if (source[i] === "{")
+            depth++;
+          if (source[i] === "}")
+            depth--;
+          i++;
+        }
+        const bodyEnd = i;
+        if (isGetter) {
+          const value = source.slice(braceStart, bodyEnd);
+          members.push({ key, value, isGetter, isSetter, isMethod: false, isAsync, isGenerator, isComputed });
+        } else if (isSetter) {
+          const value = source.slice(bodyStart, bodyEnd);
+          members.push({ key, value, isGetter, isSetter, isMethod: false, isAsync, isGenerator, isComputed });
+        } else {
+          const value = source.slice(bodyStart, bodyEnd);
+          members.push({ key, value, isGetter: false, isSetter: false, isMethod: true, isAsync, isGenerator, isComputed });
+        }
+      } else {
+        const value = source.slice(bodyStart, i);
+        members.push({ key, value, isGetter, isSetter, isMethod: !isGetter && !isSetter, isAsync, isGenerator, isComputed });
+      }
+    } else if (source[i] === "{") {
+      const bodyStart = i;
+      let depth = 1;
+      i++;
+      while (i < source.length && depth > 0) {
+        if (source[i] === "{")
+          depth++;
+        if (source[i] === "}")
+          depth--;
+        i++;
+      }
+      const value = source.slice(bodyStart, i);
+      members.push({ key, value, isGetter, isSetter, isMethod: false, isAsync, isGenerator, isComputed });
+    } else {
+      break;
+    }
+  }
+  return members;
+}
+
+// src/transform/origin-transform.ts
+function transformOriginCalls(s, source, neededImports) {
+  const regex = /\$origin\s*\(/g;
+  let match;
+  let changed = false;
+  while ((match = regex.exec(source)) !== null) {
+    const startIndex = match.index;
+    if (isInsideStringOrComment(source, startIndex)) {
+      continue;
+    }
+    const openParenIndex = startIndex + match[0].length - 1;
+    const closeParenIndex = findMatchingBracket(source, openParenIndex);
+    if (closeParenIndex === -1) {
+      console.warn(`[svelte-origin] Could not find matching ) for $origin( at index ${startIndex}`);
+      continue;
+    }
+    const definitionContent = source.slice(openParenIndex + 1, closeParenIndex);
+    const transformed = transformOriginDefinition(definitionContent);
+    s.overwrite(startIndex, closeParenIndex + 1, `__createOrigin(${transformed})`);
+    neededImports.add("__createOrigin");
+    changed = true;
+  }
+  return changed;
+}
+function transformOriginDefinition(content) {
+  let parents = [];
+  let bodyContent = content.trim();
+  let initCallback = null;
+  if (bodyContent.startsWith("[")) {
+    const closeBracket = findMatchingBracket(bodyContent, 0, "[", "]");
+    if (closeBracket !== -1) {
+      const parentsContent = bodyContent.slice(1, closeBracket);
+      parents = parentsContent.split(",").map((p) => p.trim()).filter((p) => p);
+      let i = closeBracket + 1;
+      while (i < bodyContent.length && /[\s,]/.test(bodyContent[i]))
+        i++;
+      bodyContent = bodyContent.slice(i);
+    }
+  }
+  if (bodyContent.startsWith("{")) {
+    const closeIndex = findMatchingBracket(bodyContent, 0, "{", "}");
+    if (closeIndex !== -1) {
+      let remaining = bodyContent.slice(closeIndex + 1).trim();
+      if (remaining.startsWith(",")) {
+        remaining = remaining.slice(1).trim();
+        if (remaining) {
+          initCallback = remaining;
+        }
+      }
+      bodyContent = bodyContent.slice(1, closeIndex);
+    }
+  }
+  const attrsMatch = bodyContent.match(/(\w+)\s*:\s*\$attrs\s*\(/);
+  let attrSchemaCode = "{}";
+  let attrsContent = "";
+  let contentWithoutAttrs = bodyContent;
+  let attrPropertyName = "props";
+  if (attrsMatch) {
+    attrPropertyName = attrsMatch[1];
+    const attrsStart = attrsMatch.index;
+    const attrsCallOpenParen = attrsStart + attrsMatch[0].length - 1;
+    const attrsCallCloseParen = findMatchingBracket(bodyContent, attrsCallOpenParen);
+    if (attrsCallCloseParen !== -1) {
+      let attrsCallContent = bodyContent.slice(attrsCallOpenParen + 1, attrsCallCloseParen).trim();
+      if (attrsCallContent.startsWith("[")) {
+        const closeBracket = findMatchingBracket(attrsCallContent, 0, "[", "]");
+        if (closeBracket !== -1) {
+          let i = closeBracket + 1;
+          while (i < attrsCallContent.length && /[\s,]/.test(attrsCallContent[i]))
+            i++;
+          attrsCallContent = attrsCallContent.slice(i);
+        }
+      }
+      if (attrsCallContent.startsWith("{")) {
+        const objCloseIndex = findMatchingBracket(attrsCallContent, 0, "{", "}");
+        if (objCloseIndex !== -1) {
+          attrsContent = attrsCallContent.slice(1, objCloseIndex);
+        }
+      }
+      attrSchemaCode = generateAttrSchemaFromSource(attrsContent);
+      let cutEnd = attrsCallCloseParen + 1;
+      while (cutEnd < bodyContent.length && (bodyContent[cutEnd] === "," || bodyContent[cutEnd] === " " || bodyContent[cutEnd] === `
+` || bodyContent[cutEnd] === "\t")) {
+        cutEnd++;
+      }
+      contentWithoutAttrs = bodyContent.slice(0, attrsStart) + bodyContent.slice(cutEnd);
+    }
+  }
+  const attrDetails = parseAttrsSource(attrsContent);
+  const { body: createFnBody, attachments } = transformOriginBody(contentWithoutAttrs.trim(), parents, attrDetails, attrPropertyName);
+  const parentsCode = parents.length > 0 ? `[${parents.join(", ")}]` : "undefined";
+  let configCode = `{
+	__attrSchema: ${attrSchemaCode},
+	__parents: ${parentsCode},
+	__create: (__inputAttrs${parents.length > 0 ? ", __super" : ""}) => {
+${createFnBody}
+	}`;
+  if (attachments.length > 0) {
+    configCode += `,
+	__attachments: { ${attachments.join(", ")} }`;
+  }
+  if (initCallback) {
+    configCode += `,
+	__onInit: ${initCallback}`;
+  }
+  configCode += `
+}`;
+  return configCode;
+}
+function transformOriginBody(content, parents = [], attrDetails = [], propName = "props") {
+  let body = content.trim();
+  const hasParents = parents.length > 0;
+  const attrGettersSetters = [];
+  for (const attr of attrDetails) {
+    if (attr.hasDefault) {
+      attrGettersSetters.push(`get ${attr.key}() { return __inputAttrs.${attr.key} ?? ${attr.defaultValue} }`);
+    } else {
+      attrGettersSetters.push(`get ${attr.key}() { return __inputAttrs.${attr.key} }`);
+    }
+    attrGettersSetters.push(`set ${attr.key}(v) { __inputAttrs.${attr.key} = v }`);
+  }
+  const propsObjectCode = attrGettersSetters.length > 0 ? `		const __props = {
+			${attrGettersSetters.join(`,
+			`)}
+		}` : `		const __props = __inputAttrs`;
+  if (!body) {
+    const baseMembers = [`get ${propName}() { return __props }`];
+    if (hasParents)
+      baseMembers.push("get super() { return __super }");
+    return {
+      body: `${propsObjectCode}
+		return { ${baseMembers.join(", ")} }`,
+      attachments: []
+    };
+  }
+  const members = parseObjectMembers(body);
+  const derivedNames = new Set;
+  const stateNames = new Set;
+  const valueNames = new Set;
+  const methodNames = new Set;
+  for (const member of members) {
+    const { key, value, isGetter, isMethod, isSetter } = member;
+    if (!isGetter && !isMethod && !isSetter && value.startsWith("$state")) {
+      stateNames.add(key);
+    } else if (!isGetter && !isMethod && !isSetter) {
+      valueNames.add(key);
+    }
+    if (isMethod) {
+      methodNames.add(key);
+    }
+    if (isGetter && /return\s+\$derived(\.by)?\s*\(/.test(value)) {
+      derivedNames.add(key);
+    }
+  }
+  const stateDeclarations = [];
+  const returnMembers = [`get ${propName}() { return __props }`];
+  const attachmentMethods = [];
+  if (hasParents) {
+    returnMembers.push("get super() { return __super }");
+  }
+  for (const member of members) {
+    const { key, value, isGetter, isMethod, isSetter, isAsync, isGenerator, isComputed } = member;
+    if (key === propName)
+      continue;
+    if (isMethod && key.startsWith("$")) {
+      const attachmentName = key.slice(1);
+      const asyncPrefix2 = isAsync ? "async " : "";
+      attachmentMethods.push(`${attachmentName}: ${asyncPrefix2}function${value}`);
+      continue;
+    }
+    if (!isGetter && !isMethod && !isSetter && value.startsWith("$state")) {
+      let stateVariant = "$state";
+      let genericType = "";
+      let parenStart = 6;
+      if (value[parenStart] === ".") {
+        const methodMatch = value.slice(parenStart).match(/^\.([a-zA-Z_][a-zA-Z0-9_]*)/);
+        if (methodMatch) {
+          stateVariant = `$state.${methodMatch[1]}`;
+          parenStart += methodMatch[0].length;
+        }
+      }
+      if (value[parenStart] === "<") {
+        const closeAngle = findMatchingBracket(value, parenStart, "<", ">");
+        if (closeAngle !== -1) {
+          genericType = value.slice(parenStart, closeAngle + 1);
+          parenStart = closeAngle + 1;
+        }
+      }
+      while (parenStart < value.length && /\s/.test(value[parenStart])) {
+        parenStart++;
+      }
+      if (value[parenStart] === "(") {
+        const closeParen = findMatchingBracket(value, parenStart);
+        if (closeParen !== -1) {
+          const initialValue = value.slice(parenStart + 1, closeParen).trim() || "undefined";
+          stateDeclarations.push(`		let ${key} = ${stateVariant}${genericType}(${initialValue})`);
+          returnMembers.push(`get ${key}() { return ${key} }`);
+          returnMembers.push(`set ${key}(v) { ${key} = v }`);
+          continue;
+        }
+      }
+    }
+    const propAccessPattern = new RegExp(`\\bthis\\.${propName}\\.`, "g");
+    let transformedValue = value.replace(propAccessPattern, "__props.").replace(/\bthis\.super\./g, "__super.").replace(/\bthis\.super\b/g, "__super").replace(/\bthis\.(\w+)/g, (_, name) => {
+      if (derivedNames.has(name)) {
+        return `__${name}`;
+      }
+      if (stateNames.has(name)) {
+        return name;
+      }
+      if (valueNames.has(name)) {
+        return name;
+      }
+      return `this.${name}`;
+    });
+    const asyncPrefix = isAsync ? "async " : "";
+    const generatorPrefix = isGenerator ? "*" : "";
+    const outputKey = isComputed ? key : key;
+    if (isGetter) {
+      const derivedMatch = transformedValue.match(/return\s+\$derived(\.by)?\s*\(/);
+      if (derivedMatch) {
+        const derivedPrefix = derivedMatch[1] ? "$derived.by" : "$derived";
+        const derivedStart = transformedValue.indexOf(derivedPrefix + "(");
+        const openParen = derivedStart + derivedPrefix.length;
+        const closeParen = findMatchingBracket(transformedValue, openParen);
+        if (closeParen !== -1) {
+          const derivedArg = transformedValue.slice(openParen + 1, closeParen).trim();
+          stateDeclarations.push(`		let __${key} = ${derivedPrefix}(${derivedArg})`);
+          returnMembers.push(`get ${key}() { return __${key} }`);
+          continue;
+        }
+      }
+      returnMembers.push(`get ${key}() ${transformedValue}`);
+    } else if (isSetter) {
+      returnMembers.push(`set ${key}${transformedValue}`);
+    } else if (isMethod) {
+      returnMembers.push(`${asyncPrefix}${generatorPrefix}${outputKey}${transformedValue}`);
+    } else {
+      stateDeclarations.push(`		let ${key} = ${transformedValue}`);
+      returnMembers.push(`get ${key}() { return ${key} }`);
+      returnMembers.push(`set ${key}(v) { ${key} = v }`);
+    }
+  }
+  const stateSection = stateDeclarations.length > 0 ? stateDeclarations.join(`
+`) + `
+` : "";
+  return {
+    body: `${propsObjectCode}
+${stateSection}		return {
+			${returnMembers.join(`,
+			`)}
+		}`,
+    attachments: attachmentMethods
+  };
+}
+
+// src/transform/standalone-attrs-transform.ts
+function transformStandaloneAttrsCalls(s, source, neededImports) {
+  const regex = /\$attrs\s*\(/g;
+  let match;
+  let changed = false;
+  while ((match = regex.exec(source)) !== null) {
+    const startIndex = match.index;
+    if (isInsideStringOrComment(source, startIndex)) {
+      continue;
+    }
+    const beforeContent = source.slice(Math.max(0, startIndex - 20), startIndex);
+    if (/:\s*$/.test(beforeContent)) {
+      continue;
+    }
+    const afterDollarAttrs = source.slice(startIndex + 6, startIndex + 20);
+    if (/^\s*\.\s*(origin|for)\s*\(/.test(afterDollarAttrs)) {
+      continue;
+    }
+    const openParenIndex = startIndex + match[0].length - 1;
+    const closeParenIndex = findMatchingBracket(source, openParenIndex);
+    if (closeParenIndex === -1) {
+      console.warn(`[svelte-origin] Could not find matching ) for $attrs( at index ${startIndex}`);
+      continue;
+    }
+    const attrsContent = source.slice(openParenIndex + 1, closeParenIndex).trim();
+    const transformed = transformStandaloneAttrsDefinition(attrsContent);
+    s.overwrite(startIndex, closeParenIndex + 1, `__createAttrs(${transformed})`);
+    neededImports.add("__createAttrs");
+    changed = true;
+  }
+  return changed;
+}
+function transformStandaloneAttrsDefinition(content) {
+  let parents = [];
+  let bodyContent = content.trim();
+  if (bodyContent.startsWith("[")) {
+    const closeBracket = findMatchingBracket(bodyContent, 0, "[", "]");
+    if (closeBracket !== -1) {
+      const parentsContent = bodyContent.slice(1, closeBracket);
+      parents = parentsContent.split(",").map((p) => p.trim()).filter((p) => p);
+      let i = closeBracket + 1;
+      while (i < bodyContent.length && /[\s,]/.test(bodyContent[i]))
+        i++;
+      bodyContent = bodyContent.slice(i);
+    }
+  }
+  let attrsContent = "";
+  if (bodyContent.startsWith("{")) {
+    const closeIndex = findMatchingBracket(bodyContent, 0, "{", "}");
+    if (closeIndex !== -1) {
+      attrsContent = bodyContent.slice(1, closeIndex);
+    }
+  }
+  const attrSchemaCode = generateAttrSchemaFromSource(attrsContent);
+  const parentsCode = parents.length > 0 ? `[${parents.join(", ")}]` : "undefined";
+  return `{
+	__attrSchema: ${attrSchemaCode},
+	__parents: ${parentsCode}
+}`;
+}
+
+// src/transform/schema.ts
+function parseOriginSchemaFromSource(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const originStart = match.index + match[0].length - 1;
+  const originEnd = findMatchingBracket(source, originStart);
+  if (originEnd === -1)
+    return null;
+  const originContent = source.slice(originStart + 1, originEnd);
+  let parentNames = [];
+  let bodyContent = originContent.trim();
+  if (bodyContent.startsWith("[")) {
+    const closeBracket = findMatchingBracket(bodyContent, 0, "[", "]");
+    if (closeBracket !== -1) {
+      const parentsContent = bodyContent.slice(1, closeBracket);
+      parentNames = parentsContent.split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+      let i = closeBracket + 1;
+      while (i < bodyContent.length && /[\s,]/.test(bodyContent[i]))
+        i++;
+      bodyContent = bodyContent.slice(i);
+    }
+  }
+  const attrsMatch = bodyContent.match(/(\w+)\s*:\s*\$attrs\s*\(\s*\{/);
+  if (!attrsMatch) {
+    return { attrs: [], parentNames };
+  }
+  const attrsStart = attrsMatch.index;
+  const attrsObjStart = bodyContent.indexOf("{", attrsStart + attrsMatch[0].length - 1);
+  const attrsObjEnd = findMatchingBracket(bodyContent, attrsObjStart, "{", "}");
+  if (attrsObjEnd === -1) {
+    return { attrs: [], parentNames };
+  }
+  const attrsContent = bodyContent.slice(attrsObjStart + 1, attrsObjEnd);
+  const attrs = parseAttrsContent(attrsContent);
+  return { attrs, parentNames };
+}
+function parseAttrsContent(content) {
+  const result = [];
+  const parts = splitByTopLevelCommas(content);
+  for (const part of parts) {
+    let trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    trimmed = stripComments(trimmed);
+    if (!trimmed)
+      continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    const asIndex = findTopLevelAs(value);
+    if (asIndex !== -1) {
+      value = value.slice(0, asIndex).trim();
+    }
+    const bindableResult = extractBindable(value);
+    if (bindableResult.isBindable) {
+      const defaultVal = bindableResult.innerValue;
+      const hasDefault = defaultVal !== "" && defaultVal !== "undefined";
+      result.push({
+        key,
+        defaultValue: defaultVal,
+        bindable: true,
+        hasDefault
+      });
+    } else {
+      const hasDefault = value !== "undefined";
+      result.push({
+        key,
+        defaultValue: value,
+        bindable: false,
+        hasDefault
+      });
+    }
+  }
+  return result;
+}
+function splitByTopLevelCommas(source) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let angleDepth = 0;
+  for (let i = 0;i < source.length; i++) {
+    const char = source[i];
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      current += char;
+      i++;
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\") {
+          current += source[i];
+          i++;
+        }
+        if (i < source.length) {
+          current += source[i];
+          i++;
+        }
+      }
+      if (i < source.length) {
+        current += source[i];
+      }
+      continue;
+    }
+    if (char === "<") {
+      const prevChar = current.length > 0 ? current[current.length - 1] : "";
+      if (/[\w$)]/.test(prevChar)) {
+        angleDepth++;
+      }
+      current += char;
+    } else if (char === ">") {
+      if (current.length > 0 && current[current.length - 1] === "=") {
+        current += char;
+        continue;
+      }
+      if (angleDepth > 0) {
+        angleDepth--;
+      }
+      current += char;
+    } else if (char === "{" || char === "(" || char === "[") {
+      depth++;
+      current += char;
+    } else if (char === "}" || char === ")" || char === "]") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0 && angleDepth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function stripComments(str) {
+  let result = str.trim();
+  while (result.startsWith("/*")) {
+    const endComment = result.indexOf("*/");
+    if (endComment !== -1) {
+      result = result.slice(endComment + 2).trim();
+    } else {
+      break;
+    }
+  }
+  while (result.startsWith("//")) {
+    const endLine = result.indexOf(`
+`);
+    if (endLine !== -1) {
+      result = result.slice(endLine + 1).trim();
+    } else {
+      result = "";
+      break;
+    }
+  }
+  return result;
+}
+function generatePropsDestructuring(attrs, factoryName) {
+  const parts = [];
+  for (const attr of attrs) {
+    if (attr.bindable) {
+      if (attr.hasDefault) {
+        parts.push(`${attr.key} = $bindable(${attr.defaultValue})`);
+      } else {
+        parts.push(`${attr.key} = $bindable()`);
+      }
+    } else if (attr.hasDefault) {
+      parts.push(`${attr.key} = ${attr.defaultValue}`);
+    } else {
+      parts.push(attr.key);
+    }
+  }
+  return `let { ${parts.join(", ")} }: $attrs.Of<typeof ${factoryName}> = $props()`;
+}
+function generateFactoryCallFromAttrs(factoryName, attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    parts.push(`get ${attr.key}() { return ${attr.key} }`);
+    if (attr.bindable) {
+      parts.push(`set ${attr.key}(v) { ${attr.key} = v }`);
+    }
+  }
+  return `${factoryName}({ ${parts.join(", ")} })`;
+}
+function findImportPath(source, identifier) {
+  const patterns2 = [
+    new RegExp(`import\\s*\\{[^}]*\\b${identifier}\\b[^}]*\\}\\s*from\\s*['"]([^'"]+)['"]`),
+    new RegExp(`import\\s*\\{[^}]*\\bas\\s+${identifier}\\b[^}]*\\}\\s*from\\s*['"]([^'"]+)['"]`),
+    new RegExp(`import\\s+${identifier}\\s+from\\s*['"]([^'"]+)['"]`),
+    new RegExp(`import\\s*\\*\\s*as\\s+${identifier}\\s+from\\s*['"]([^'"]+)['"]`)
+  ];
+  for (const pattern of patterns2) {
+    const match = pattern.exec(source);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function generatePropsInterface(schema) {
+  const lines = [];
+  const bindings = [];
+  for (const attr of schema.attrs) {
+    const type = inferTypeFromDefault(attr.defaultValue);
+    const optional = attr.hasDefault ? "?" : "";
+    lines.push(`${attr.key}${optional}: ${type}`);
+    if (attr.bindable) {
+      bindings.push(attr.key);
+    }
+  }
+  const interfaceContent = lines.length > 0 ? `{ ${lines.join("; ")} }` : "{}";
+  return { interfaceContent, bindings };
+}
+function inferTypeFromDefault(defaultValue) {
+  if (defaultValue === "undefined")
+    return "unknown";
+  if (defaultValue === "true" || defaultValue === "false")
+    return "boolean";
+  if (/^-?\d+$/.test(defaultValue))
+    return "number";
+  if (/^-?\d+\.\d+$/.test(defaultValue))
+    return "number";
+  if (/^['"]/.test(defaultValue))
+    return "string";
+  if (defaultValue.startsWith("["))
+    return "unknown[]";
+  if (defaultValue.startsWith("{"))
+    return "Record<string, unknown>";
+  if (defaultValue === "null")
+    return "null";
+  return "unknown";
+}
+function generateDtsContent(factoryName, importPath, schema, comment = "regenerated on save") {
+  const propsLines = [];
+  const bindableProps = [];
+  for (const attr of schema.attrs) {
+    const type = inferTypeFromDefault(attr.defaultValue);
+    const optional = attr.hasDefault ? "?" : "";
+    propsLines.push(`    ${attr.key}${optional}: ${type};`);
+    if (attr.bindable) {
+      bindableProps.push(`"${attr.key}"`);
+    }
+  }
+  const propsType = propsLines.length > 0 ? `{
+${propsLines.join(`
+`)}
+}` : "{}";
+  const bindingsType = bindableProps.length > 0 ? bindableProps.join(" | ") : "never";
+  return `// Auto-generated by svelte-origin
+// Do not edit manually - ${comment}
+
+import type { Component } from 'svelte';
+import type { ${factoryName} } from '${importPath}';
+
+/**
+ * Props derived from ${factoryName} origin factory.
+ * 
+ * Bindable props: ${bindableProps.length > 0 ? bindableProps.join(", ") : "none"}
+ */
+type Props = ${propsType};
+
+declare const __component: Component<Props, {}, ${bindingsType}>;
+export default __component;
+`;
+}
+
+// src/transform/attrs-origin-transform.ts
+function isCallExpression(expr) {
+  const trimmed = expr.trim();
+  return trimmed.endsWith(")");
+}
+function hasGenericTypeParams(expr) {
+  const trimmed = expr.trim();
+  let depth = 0;
+  for (let i = 0;i < trimmed.length; i++) {
+    const char = trimmed[i];
+    if (char === "(")
+      depth++;
+    else if (char === ")")
+      depth--;
+    else if (char === "<" && depth === 0)
+      return true;
+  }
+  return false;
+}
+function normalizeFactoryCall(expr) {
+  const trimmed = expr.trim();
+  if (hasGenericTypeParams(trimmed) && !isCallExpression(trimmed)) {
+    return `${trimmed}()`;
+  }
+  return trimmed;
+}
+function extractFactoryFromCall(expr) {
+  const trimmed = expr.trim();
+  let depth = 0;
+  for (let i = trimmed.length - 1;i >= 0; i--) {
+    if (trimmed[i] === ")")
+      depth++;
+    else if (trimmed[i] === "(") {
+      depth--;
+      if (depth === 0) {
+        return trimmed.slice(0, i);
+      }
+    }
+  }
+  return trimmed;
+}
+function transformAttrsOriginCallsSync(s, source, neededImports) {
+  const declarations = findVariableDeclarationsWithMacro(source, "$attrs.origin");
+  let changed = false;
+  let firstFactoryExpr = null;
+  let propsTypeDeclaration = null;
+  let isFirstDeclaration = true;
+  const needsPropsInjection = declarations.length > 0 && !hasExistingPropsDeclaration(source);
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source, macroOpenParen);
+    if (closeParenIndex === -1) {
+      console.warn(`[svelte-origin] Could not find matching ) for $attrs.origin( at index ${macroOpenParen}`);
+      continue;
+    }
+    const factoryExpr = source.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    if (!firstFactoryExpr) {
+      firstFactoryExpr = factoryExpr;
+    }
+    const normalizedFactoryCall = normalizeFactoryCall(factoryExpr);
+    const expansionLines = [];
+    if (isFirstDeclaration && needsPropsInjection) {
+      const isGeneric = hasGenericTypeParams(factoryExpr);
+      const typeExpr = isGeneric ? `ReturnType<typeof ${extractFactoryFromCall(normalizedFactoryCall)}>` : `typeof ${factoryExpr}`;
+      expansionLines.push(`type $$Props = $attrs.Of<${typeExpr}>`);
+      propsTypeDeclaration = "";
+    }
+    expansionLines.push(`let ___attrs: $$Props = $props()`, `let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ___attrs))`);
+    s.overwrite(startIndex, endIndex, expansionLines.join(`
+`));
+    neededImports.add("__attrsFor");
+    changed = true;
+    isFirstDeclaration = false;
+  }
+  return { changed, propsTypeDeclaration };
+}
+async function transformAttrsOriginCalls(s, source, neededImports, schemaResolver) {
+  const declarations = findVariableDeclarationsWithMacro(source, "$attrs.origin");
+  let changed = false;
+  let propsTypeDeclaration = null;
+  const needsPropsInjection = declarations.length > 0 && !hasExistingPropsDeclaration(source);
+  const matches = [];
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source, macroOpenParen);
+    if (closeParenIndex === -1) {
+      console.warn(`[svelte-origin] Could not find matching ) for $attrs.origin( at index ${macroOpenParen}`);
+      continue;
+    }
+    const factoryExpr = source.slice(macroOpenParen + 1, closeParenIndex).trim();
+    matches.push({
+      varName,
+      factoryExpr,
+      startIndex,
+      endIndex: closeParenIndex + 1,
+      isGeneric: hasGenericTypeParams(factoryExpr)
+    });
+  }
+  let firstFactoryExpr = null;
+  let isFirstDeclaration = true;
+  for (const { varName, factoryExpr, startIndex, endIndex, isGeneric } of matches) {
+    const expansionLines = [];
+    let usesFallback = true;
+    if (!firstFactoryExpr) {
+      firstFactoryExpr = factoryExpr;
+    }
+    if (isFirstDeclaration && needsPropsInjection) {
+      const isGenericFirst = hasGenericTypeParams(factoryExpr);
+      const normalizedFactoryCallFirst = normalizeFactoryCall(factoryExpr);
+      const typeExpr = isGenericFirst ? `ReturnType<typeof ${extractFactoryFromCall(normalizedFactoryCallFirst)}>` : `typeof ${factoryExpr}`;
+      expansionLines.push(`type $$Props = $attrs.Of<${typeExpr}>`);
+      propsTypeDeclaration = "";
+    }
+    if (schemaResolver && !isGeneric) {
+      const importPath = findImportPath(source, factoryExpr);
+      if (importPath) {
+        const schema = await schemaResolver.resolve(importPath, factoryExpr);
+        if (schema && schema.attrs.length > 0) {
+          const propsDestructure = generatePropsDestructuring(schema.attrs, factoryExpr);
+          const factoryCall = generateFactoryCallFromAttrs(factoryExpr, schema.attrs);
+          expansionLines.push(propsDestructure, `let ${varName} = ${factoryCall}`);
+          usesFallback = false;
+        }
+      }
+    }
+    if (usesFallback) {
+      const normalizedFactoryCall = normalizeFactoryCall(factoryExpr);
+      expansionLines.push(`let ___attrs: $$Props = $props()`, `let ${varName} = ${normalizedFactoryCall}(__attrsFor(${normalizedFactoryCall}, ___attrs))`);
+      neededImports.add("__attrsFor");
+    }
+    s.overwrite(startIndex, endIndex, expansionLines.join(`
+`));
+    changed = true;
+    isFirstDeclaration = false;
+  }
+  return { changed, propsTypeDeclaration };
+}
+
+// src/transform/element-types.ts
+function getElementTypeImport(element) {
+  return `svelteHTML.IntrinsicElements['${element}']`;
+}
+
+// src/transform/attrs-for-transform.ts
+function transformAttrsForCalls(s, source, neededImports) {
+  let changed = false;
+  const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  let restVarName = null;
+  let existingPropsStart = -1;
+  let existingDestructureContent = "";
+  if (existingPropsMatch) {
+    existingPropsStart = existingPropsMatch.index;
+    existingDestructureContent = existingPropsMatch[1];
+    const restMatch = existingDestructureContent.match(/\.\.\.\s*(\w+)\s*$/);
+    if (restMatch) {
+      restVarName = restMatch[1];
+    }
+  }
+  const originDeclarations = findVariableDeclarationsWithMacro(source, "$attrs.for");
+  for (const decl of originDeclarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source, macroOpenParen);
+    if (closeParenIndex === -1)
+      continue;
+    const arg = source.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    const stringMatch = arg.match(/^['"](\w+)['"]$/);
+    if (stringMatch) {
+      const element = stringMatch[1];
+      const typeImport = getElementTypeImport(element);
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = ${restVarName} as ${typeImport}`);
+      } else {
+        const expansion = `let { ...${varName} } = $props<${typeImport}>()`;
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+    } else {
+      const factoryName = arg;
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${restVarName})`);
+      } else {
+        const expansion = [
+          `let ___attrs: $attrs.Of<typeof ${factoryName}> = $props()`,
+          `let ${varName} = __attrsFor(${factoryName}, ___attrs)`
+        ].join(`
+`);
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+      neededImports.add("__attrsFor");
+    }
+    changed = true;
+  }
+  return changed;
+}
+
+// src/transform/core.ts
+function transformScript(source, options = {}) {
+  if (options.schemaResolver) {
+    return transformScriptAsync(source, options);
+  }
+  if (!containsMacros(source)) {
+    return { code: source, changed: false };
+  }
+  const s = new MagicString(source);
+  const { isComponent = false } = options;
+  let changed = false;
+  const neededImports = new Set;
+  let propsTypeDeclaration = null;
+  if (!isComponent) {
+    changed = transformOriginCalls(s, source, neededImports) || changed;
+    changed = transformStandaloneAttrsCalls(s, source, neededImports) || changed;
+  }
+  if (isComponent) {
+    const result = transformAttrsOriginCallsSync(s, source, neededImports);
+    changed = result.changed || changed;
+    propsTypeDeclaration = result.propsTypeDeclaration;
+  }
+  if (isComponent) {
+    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+  }
+  const needsPropsInjection = propsTypeDeclaration && propsTypeDeclaration.length > 0;
+  if (isComponent && (neededImports.size > 0 || needsPropsInjection)) {
+    const scriptMatch = source.match(/<script[^>]*>/);
+    if (scriptMatch) {
+      const scriptEnd = scriptMatch.index + scriptMatch[0].length;
+      const afterImports = findPropsInjectionPosition(source);
+      if (neededImports.size > 0) {
+        const importStatement = generateRuntimeImport([...neededImports]);
+        s.appendLeft(scriptEnd, `
+` + importStatement);
+      }
+      if (needsPropsInjection) {
+        const propsPos = afterImports > scriptEnd ? afterImports : scriptEnd;
+        s.appendLeft(propsPos, `
+` + propsTypeDeclaration);
+      }
+    } else {
+      const afterImports = findPropsInjectionPosition(source);
+      if (neededImports.size > 0) {
+        const importStatement = generateRuntimeImport([...neededImports]);
+        s.prepend(importStatement + `
+`);
+      }
+      if (needsPropsInjection) {
+        s.appendLeft(afterImports, propsTypeDeclaration + `
+`);
+      }
+    }
+  } else if (neededImports.size > 0) {
+    const importStatement = generateRuntimeImport([...neededImports]);
+    s.prepend(importStatement + `
+`);
+  }
+  if (!changed) {
+    return { code: source, changed: false };
+  }
+  return {
+    code: s.toString(),
+    changed: true,
+    map: s.generateMap({ hires: true })
+  };
+}
+async function transformScriptAsync(source, options) {
+  if (!containsMacros(source)) {
+    return { code: source, changed: false };
+  }
+  const s = new MagicString(source);
+  const { isComponent = false, schemaResolver } = options;
+  let changed = false;
+  const neededImports = new Set;
+  let propsTypeDeclaration = null;
+  if (!isComponent) {
+    changed = transformOriginCalls(s, source, neededImports) || changed;
+    changed = transformStandaloneAttrsCalls(s, source, neededImports) || changed;
+  }
+  if (isComponent) {
+    const result = await transformAttrsOriginCalls(s, source, neededImports, schemaResolver);
+    changed = result.changed || changed;
+    propsTypeDeclaration = result.propsTypeDeclaration;
+  }
+  if (isComponent) {
+    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+  }
+  const needsPropsInjectionAsync = propsTypeDeclaration && propsTypeDeclaration.length > 0;
+  if (isComponent && (neededImports.size > 0 || needsPropsInjectionAsync)) {
+    const scriptMatch = source.match(/<script[^>]*>/);
+    if (scriptMatch) {
+      const scriptEnd = scriptMatch.index + scriptMatch[0].length;
+      const afterImports = findPropsInjectionPosition(source);
+      if (neededImports.size > 0) {
+        const importStatement = generateRuntimeImport([...neededImports]);
+        s.appendLeft(scriptEnd, `
+` + importStatement);
+      }
+      if (needsPropsInjectionAsync) {
+        const propsPos = afterImports > scriptEnd ? afterImports : scriptEnd;
+        s.appendLeft(propsPos, `
+` + propsTypeDeclaration);
+      }
+    } else {
+      const afterImports = findPropsInjectionPosition(source);
+      if (neededImports.size > 0) {
+        const importStatement = generateRuntimeImport([...neededImports]);
+        s.prepend(importStatement + `
+`);
+      }
+      if (needsPropsInjectionAsync) {
+        s.appendLeft(afterImports, propsTypeDeclaration + `
+`);
+      }
+    }
+  } else if (neededImports.size > 0) {
+    const importStatement = generateRuntimeImport([...neededImports]);
+    s.prepend(importStatement + `
+`);
+  }
+  if (!changed) {
+    return { code: source, changed: false };
+  }
+  return {
+    code: s.toString(),
+    changed: true,
+    map: s.generateMap({ hires: true })
+  };
+}
+async function transformScriptContent(source, options) {
+  if (!containsMacros(source)) {
+    return { code: source, changed: false };
+  }
+  const s = new MagicString(source);
+  const { isComponent = false, schemaResolver } = options;
+  let changed = false;
+  const neededImports = new Set;
+  let propsTypeDeclaration = null;
+  if (!isComponent) {
+    changed = transformOriginCalls(s, source, neededImports) || changed;
+  }
+  if (isComponent) {
+    const result = await transformAttrsOriginCalls(s, source, neededImports, schemaResolver);
+    changed = result.changed || changed;
+    propsTypeDeclaration = result.propsTypeDeclaration;
+  }
+  if (isComponent) {
+    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+  }
+  if (neededImports.size > 0) {
+    const importStatement = generateRuntimeImport([...neededImports]);
+    s.prepend(importStatement + `
+`);
+  }
+  if (propsTypeDeclaration) {
+    const afterImports = findPropsInjectionPosition(source);
+    const offset = neededImports.size > 0 ? generateRuntimeImport([...neededImports]).length + 1 : 0;
+    s.appendLeft(afterImports + offset, propsTypeDeclaration + `
+`);
+  }
+  if (!changed) {
+    return { code: source, changed: false };
+  }
+  return {
+    code: s.toString(),
+    changed: true,
+    map: s.generateMap({ hires: true })
+  };
+}
+
+// src/post-process.ts
+var EXTENSIONS = [".svelte", ".svelte.ts", ".svelte.js", ".js", ".ts"];
+function cleanupForLibrary(code, schemaCache) {
+  let result = code;
+  result = result.replace(/\ntype \$\$Props = \$attrs\.Of<[^>]+>\n/g, `
+`);
+  const attrsOfPattern = /(\}\s*:\s*)\$attrs\.Of<typeof (\w+)>(\s*=\s*\$props\(\))/g;
+  result = result.replace(attrsOfPattern, (_match, prefix, factoryName, suffix) => {
+    for (const [key, schema] of schemaCache.entries()) {
+      if (schema && key.endsWith(`::${factoryName}`)) {
+        const { interfaceContent } = generatePropsInterface(schema);
+        return `${prefix}${interfaceContent}${suffix}`;
+      }
+    }
+    return `${prefix}Record<string, unknown>${suffix}`;
+  });
+  return result;
+}
+function generateCleanDts(componentName, schema) {
+  if (!schema || schema.attrs.length === 0) {
+    return `import type { Component } from 'svelte'
+
+declare const ${componentName}: Component<{}, {}, ''>
+type ${componentName} = typeof ${componentName}
+
+export { ${componentName} as default }
+`;
+  }
+  const { interfaceContent, bindings } = generatePropsInterface(schema);
+  const bindingsStr = bindings.length > 0 ? `'${bindings.join("' | '")}'` : "''";
+  return `import type { Component } from 'svelte'
+
+export interface Props ${interfaceContent}
+
+declare const ${componentName}: Component<Props, {}, ${bindingsStr}>
+type ${componentName} = typeof ${componentName}
+
+export { ${componentName} as default }
+`;
+}
+function findOriginFactoryName(source) {
+  const match = source.match(/\$attrs\.origin\s*\(\s*(\w+)\s*\)/);
+  return match ? match[1] : null;
+}
+function findFiles(dir, extensions) {
+  const files = [];
+  function walk(currentDir) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const matchesExt = extensions.some((ext) => entry.name.endsWith(ext));
+        if (matchesExt) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+  walk(dir);
+  return files;
+}
+function createDistSchemaResolver(distDir, schemaCache, verbose) {
+  return {
+    resolve: async (importPath, exportName) => {
+      const cacheKey = `${importPath}::${exportName}`;
+      if (schemaCache.has(cacheKey)) {
+        return schemaCache.get(cacheKey) || null;
+      }
+      try {
+        let resolvedPath;
+        if (importPath.startsWith(".")) {
+          resolvedPath = path.resolve(distDir, importPath);
+        } else {
+          schemaCache.set(cacheKey, null);
+          return null;
+        }
+        const extensions = [".svelte.ts", ".svelte.js", ".ts", ".js"];
+        let filePath = resolvedPath;
+        if (!fs.existsSync(filePath)) {
+          for (const ext of extensions) {
+            if (fs.existsSync(resolvedPath + ext)) {
+              filePath = resolvedPath + ext;
+              break;
+            }
+          }
+        }
+        if (!fs.existsSync(filePath)) {
+          schemaCache.set(cacheKey, null);
+          return null;
+        }
+        const source = fs.readFileSync(filePath, "utf-8");
+        const schema = parseOriginSchemaFromSource(source, exportName);
+        if (verbose && schema) {
+          console.log(`    Resolved schema for ${exportName}: ${schema.attrs.map((a) => a.key).join(", ")}`);
+        }
+        schemaCache.set(cacheKey, schema);
+        return schema;
+      } catch {
+        schemaCache.set(cacheKey, null);
+        return null;
+      }
+    }
+  };
+}
+async function postProcess(options) {
+  const { dir, dryRun = false, verbose = false } = options;
+  const result = {
+    filesProcessed: 0,
+    files: [],
+    errors: []
+  };
+  const files = findFiles(dir, EXTENSIONS);
+  if (verbose) {
+    console.log(`  Found ${files.length} files to check`);
+  }
+  const schemaCache = new Map;
+  const schemaResolver = createDistSchemaResolver(dir, schemaCache, verbose);
+  for (const filePath of files) {
+    try {
+      const source = fs.readFileSync(filePath, "utf-8");
+      if (!containsMacros(source)) {
+        continue;
+      }
+      if (verbose) {
+        console.log(`  Processing: ${path.relative(dir, filePath)}`);
+      }
+      const isComponent = filePath.endsWith(".svelte");
+      const transformed = await transformScript(source, {
+        filename: filePath,
+        isComponent,
+        schemaResolver
+      });
+      if (transformed.changed) {
+        result.filesProcessed++;
+        result.files.push(filePath);
+        let finalCode = cleanupForLibrary(transformed.code, schemaCache);
+        if (!dryRun) {
+          fs.writeFileSync(filePath, finalCode, "utf-8");
+        }
+        if (verbose) {
+          console.log(`    ${dryRun ? "Would transform" : "Transformed"}: ${path.relative(dir, filePath)}`);
+        }
+        if (isComponent) {
+          const dtsPath = filePath + ".d.ts";
+          if (fs.existsSync(dtsPath)) {
+            const factoryName = findOriginFactoryName(source);
+            let schema = null;
+            if (factoryName) {
+              for (const [key, cachedSchema] of schemaCache.entries()) {
+                if (cachedSchema && key.endsWith(`::${factoryName}`)) {
+                  schema = cachedSchema;
+                  break;
+                }
+              }
+            }
+            const componentName = path.basename(filePath, ".svelte");
+            const cleanDts = generateCleanDts(componentName, schema);
+            if (!dryRun) {
+              fs.writeFileSync(dtsPath, cleanDts, "utf-8");
+            }
+            if (verbose) {
+              console.log(`    ${dryRun ? "Would regenerate" : "Regenerated"} .d.ts: ${path.basename(dtsPath)}`);
+            }
+            result.files.push(dtsPath);
+          }
+        }
+      }
+    } catch (error) {
+      const errorMsg = `Error processing ${path.relative(dir, filePath)}: ${error}`;
+      result.errors.push(errorMsg);
+      if (verbose) {
+        console.error(`    ${errorMsg}`);
+      }
+    }
+  }
+  return result;
+}
+var post_process_default = postProcess;
+export {
+  postProcess,
+  post_process_default as default
+};