lineputscript 1.0.0

package/dist/chunk-JI4LI6KU.mjs

@@ -0,0 +1,965 @@
+import { getHashCode } from './chunk-X2OHQJFP.mjs';
+import { StringStructure } from './chunk-OV7CLVHP.mjs';
+import { textReplace, FInt64, textDeReplace, splitLimited } from './chunk-4RRNVMEO.mjs';
+
+// src/core/sub.ts
+var Sub = class {
+  constructor(nameOrLps, infoOrSecond, ...rest) {
+    this._infos = null;
+    if (nameOrLps === void 0) {
+      this.name = "";
+      this._info = "";
+    } else if (infoOrSecond === void 0 && rest.length === 0) {
+      this.name = "";
+      this._info = "";
+      this.load(nameOrLps);
+    } else {
+      this.name = nameOrLps;
+      if (rest.length > 0) {
+        const allInfos = [infoOrSecond ?? "", ...rest];
+        const joined = allInfos.map((s) => textReplace(s)).join(",");
+        this._info = joined;
+      } else {
+        this._info = textReplace(infoOrSecond ?? "");
+      }
+    }
+  }
+  getStoreString() {
+    return this._info;
+  }
+  getString() {
+    return this.infoDisplay;
+  }
+  getInteger64() {
+    return BigInt(this._info || "0");
+  }
+  getInteger() {
+    return parseInt(this._info, 10) || 0;
+  }
+  getDouble() {
+    return parseFloat(this._info) || 0;
+  }
+  getFloat() {
+    return FInt64.parse(this._info);
+  }
+  getDateTime() {
+    const longMatch = /^-?\d+$/.test(this._info);
+    if (longMatch) {
+      try {
+        const ticks = BigInt(this._info);
+        const ticksPerMs = 10000n;
+        const epochOffset = 621355968000000000n;
+        const ms = Number((ticks - epochOffset) / ticksPerMs);
+        return new Date(ms);
+      } catch {
+        return /* @__PURE__ */ new Date(0);
+      }
+    }
+    const d = new Date(this._info);
+    if (!isNaN(d.getTime())) return d;
+    return /* @__PURE__ */ new Date(0);
+  }
+  getBoolean() {
+    const lower = this._info.toLowerCase();
+    return lower === "true" || lower === "t" || lower === "1";
+  }
+  setString(value) {
+    this._info = textReplace(value);
+  }
+  setInteger(value) {
+    this._info = value.toString();
+  }
+  setInteger64(value) {
+    this._info = value.toString();
+  }
+  setDouble(value) {
+    this._info = value.toString();
+  }
+  setFloat(value) {
+    this._info = value.toStoreString();
+  }
+  setDateTime(value) {
+    const ticksPerMs = 10000n;
+    const epochOffset = 621355968000000000n;
+    const ticks = BigInt(value.getTime()) * ticksPerMs + epochOffset;
+    this._info = ticks.toString();
+  }
+  setBoolean(value) {
+    this._info = value ? "True" : "False";
+  }
+  get info() {
+    return this._info;
+  }
+  set info(value) {
+    this._info = value;
+  }
+  get infoDisplay() {
+    return textDeReplace(this._info);
+  }
+  set infoDisplay(value) {
+    this._info = textReplace(value);
+  }
+  get infoToInt() {
+    return this.getInteger();
+  }
+  set infoToInt(value) {
+    this.setInteger(value);
+  }
+  get infoToInt64() {
+    return this.getInteger64();
+  }
+  set infoToInt64(value) {
+    this.setInteger64(value);
+  }
+  get infoToDouble() {
+    return this.getDouble();
+  }
+  set infoToDouble(value) {
+    this.setDouble(value);
+  }
+  get infoToBoolean() {
+    return this.getBoolean();
+  }
+  set infoToBoolean(value) {
+    this.setBoolean(value);
+  }
+  get infos() {
+    if (!this._infos) {
+      this._infos = new StringStructure(
+        (x) => {
+          this._info = x;
+        },
+        () => this._info
+      );
+    }
+    return this._infos;
+  }
+  load(nameOrLps, info) {
+    if (info === void 0) {
+      const st = splitLimited(nameOrLps, "#", 1);
+      this.name = st[0];
+      this._info = st.length > 1 ? st[1] : "";
+    } else {
+      this.name = nameOrLps;
+      this._info = textReplace(info);
+    }
+  }
+  set(other) {
+    this.name = other.name;
+    this._info = other.info;
+  }
+  getInfo() {
+    return this.infoDisplay;
+  }
+  getInfos() {
+    if (!this._info) return [];
+    return this._info.split(",").filter((x) => x.length > 0).map((s) => textDeReplace(s));
+  }
+  first() {
+    const infos = this.getInfos();
+    return infos.length > 0 ? infos[0] : null;
+  }
+  last() {
+    const infos = this.getInfos();
+    return infos.length > 0 ? infos[infos.length - 1] : null;
+  }
+  getLongHashCode() {
+    return getHashCode(this.name) * 2n + getHashCode(this._info) * 3n;
+  }
+  toString() {
+    if (!this._info) return `${this.name}:|`;
+    return `${this.name}#${this._info}:|`;
+  }
+  static split(text, separator, count = -1) {
+    return splitLimited(text, separator, count);
+  }
+};
+
+// src/core/line.ts
+var Line = class extends Sub {
+  constructor(nameOrLps, info, text, ...subs) {
+    super();
+    this._texts = null;
+    this._text = "";
+    this.comments = "";
+    this.subs = [];
+    if (nameOrLps === void 0) return;
+    if (typeof nameOrLps !== "string") {
+      this.name = nameOrLps.name;
+      this._info = nameOrLps.info;
+      this._text = nameOrLps.text;
+      this.comments = nameOrLps.comments;
+      for (const sub of nameOrLps.subs) this.subs.push(sub);
+      return;
+    }
+    if (info === void 0) {
+      this.load(nameOrLps);
+    } else {
+      this.name = nameOrLps;
+      this._info = textReplace(info);
+      this._text = textReplace(text ?? "");
+      for (const sub of subs) this.subs.push(sub);
+    }
+  }
+  load(nameOrLps, info, text, subs) {
+    if (typeof nameOrLps !== "string") {
+      this.name = nameOrLps.name;
+      this._info = nameOrLps.info;
+      this._text = nameOrLps.text;
+      this.comments = nameOrLps.comments;
+      this.subs = [];
+      for (const sub of nameOrLps.subs) this.subs.push(sub);
+    } else if (info === void 0) {
+      const sts = splitLimited(nameOrLps, "///", 1);
+      if (sts.length === 2) this.comments = sts[1];
+      const parts = sts[0].split(":|");
+      const st = splitLimited(parts[0], "#", 1);
+      this.name = st[0];
+      this._info = st.length > 1 ? st[1] : "";
+      this._text = parts[parts.length - 1];
+      this.subs = [];
+      for (let i = 1; i < parts.length - 1; i++) {
+        const sub = new Sub();
+        sub.load(parts[i]);
+        this.subs.push(sub);
+      }
+    } else {
+      this.name = nameOrLps;
+      this._info = textReplace(info);
+      this._text = textReplace(text ?? "");
+      this.subs = [];
+      if (subs) for (const sub of subs) this.subs.push(sub);
+    }
+  }
+  get text() {
+    return this._text;
+  }
+  set text(value) {
+    this._text = value;
+  }
+  get textDisplay() {
+    return textDeReplace(this._text);
+  }
+  set textDisplay(value) {
+    this._text = textReplace(value);
+  }
+  get textToInt() {
+    return parseInt(this._text, 10) || 0;
+  }
+  set textToInt(value) {
+    this._text = value.toString();
+  }
+  get textToInt64() {
+    return BigInt(this._text || "0");
+  }
+  set textToInt64(value) {
+    this._text = value.toString();
+  }
+  get textToDouble() {
+    return parseFloat(this._text) || 0;
+  }
+  set textToDouble(value) {
+    this._text = value.toString();
+  }
+  getText() {
+    return this.textDisplay;
+  }
+  get texts() {
+    if (!this._texts) this._texts = new StringStructure((x) => {
+      this._text = x;
+    }, () => this._text);
+    return this._texts;
+  }
+  addSub(newSub) {
+    this.subs.push(newSub);
+  }
+  addorReplaceSub(newSub) {
+    const old = this.find(newSub.name);
+    if (old) old.set(newSub);
+    else this.subs.push(newSub);
+  }
+  addRange(newSubs) {
+    for (const sub of newSubs) this.subs.push(sub);
+  }
+  insertSub(index, newSub) {
+    this.subs.splice(index, 0, newSub);
+  }
+  insertRange(index, newSubs) {
+    this.subs.splice(index, 0, ...newSubs);
+  }
+  remove(sub) {
+    const idx = this.subs.indexOf(sub);
+    if (idx === -1) return false;
+    this.subs.splice(idx, 1);
+    return true;
+  }
+  removeByName(subName) {
+    for (let i = 0; i < this.subs.length; i++) {
+      if (this.subs[i].name === subName) {
+        this.subs.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+  removeAll(subName) {
+    for (let i = this.subs.length - 1; i >= 0; i--)
+      if (this.subs[i].name === subName) this.subs.splice(i, 1);
+  }
+  removeAt(index) {
+    this.subs.splice(index, 1);
+  }
+  contains(sub) {
+    return this.subs.indexOf(sub) !== -1;
+  }
+  containsByName(value) {
+    return this.subs.some((x) => x.name === value);
+  }
+  find(subName, subinfo) {
+    if (subinfo === void 0) return this.subs.find((x) => x.name === subName) ?? null;
+    return this.subs.find((x) => x.name === subName && x.info === subinfo) ?? null;
+  }
+  findInfo(subinfo) {
+    return this.subs.find((x) => x.info === subinfo) ?? null;
+  }
+  findAll(subName, subinfo) {
+    if (subinfo === void 0) return this.subs.filter((x) => x.name === subName);
+    return this.subs.filter((x) => x.name === subName && x.info === subinfo);
+  }
+  findAllInfo(subinfo) {
+    return this.subs.filter((x) => x.info === subinfo);
+  }
+  findorAdd(subName) {
+    const existing = this.find(subName);
+    if (existing) return existing;
+    const sub = new Sub();
+    sub.name = subName;
+    this.subs.push(sub);
+    return sub;
+  }
+  searchAll(value) {
+    return this.subs.filter((x) => x.name.includes(value));
+  }
+  search(value) {
+    return this.subs.find((x) => x.name.includes(value)) ?? null;
+  }
+  indexOf(subName) {
+    return this.subs.findIndex((x) => x.name === subName);
+  }
+  indexsOf(subName) {
+    const indices = [];
+    for (let i = 0; i < this.subs.length; i++)
+      if (this.subs[i].name === subName) indices.push(i);
+    return indices;
+  }
+  // Typed shorthands on subs
+  getSubBool(subName) {
+    return this.find(subName)?.getBoolean() ?? false;
+  }
+  setSubBool(subName, value) {
+    this.findorAdd(subName).infoToBoolean = value;
+  }
+  getSubInt(subName, defaultValue = 0) {
+    return this.find(subName)?.infoToInt ?? defaultValue;
+  }
+  setSubInt(subName, value) {
+    this.findorAdd(subName).infoToInt = value;
+  }
+  getSubInt64(subName, defaultValue = 0n) {
+    return this.find(subName)?.infoToInt64 ?? defaultValue;
+  }
+  setSubInt64(subName, value) {
+    this.findorAdd(subName).infoToInt64 = value;
+  }
+  getSubFloat(subName, defaultValue) {
+    return this.find(subName)?.getFloat() ?? (defaultValue ?? FInt64.Zero);
+  }
+  setSubFloat(subName, value) {
+    this.findorAdd(subName).setFloat(value);
+  }
+  getSubDateTime(subName, defaultValue) {
+    return this.find(subName)?.getDateTime() ?? (defaultValue ?? null);
+  }
+  setSubDateTime(subName, value) {
+    this.findorAdd(subName).setDateTime(value);
+  }
+  getSubString(subName, defaultValue) {
+    return this.find(subName)?.infoDisplay ?? (defaultValue ?? null);
+  }
+  setSubString(subName, value) {
+    this.findorAdd(subName).infoDisplay = value ?? "";
+  }
+  getSubDouble(subName, defaultValue = 0) {
+    return this.find(subName)?.infoToDouble ?? defaultValue;
+  }
+  setSubDouble(subName, value) {
+    this.findorAdd(subName).infoToDouble = value;
+  }
+  getLongHashCode() {
+    let hash = getHashCode(this.name) * 2n + getHashCode(this._info) * 3n + getHashCode(this._text) * 4n;
+    for (const sub of this.subs) hash += sub.getLongHashCode();
+    return hash;
+  }
+  toList() {
+    return [...this.subs];
+  }
+  toString(sb) {
+    const parts = [this.name];
+    if (this._info) parts.push(`#${this._info}`);
+    if (parts.length > 0 || this.subs.length > 0 || this._text || this.comments) parts.push(":|");
+    for (const sub of this.subs) parts.push(sub.toString());
+    parts.push(this._text);
+    if (this.comments) parts.push(`///${this.comments}`);
+    const result = parts.join("");
+    if (sb) {
+      sb.push("\n");
+      sb.push(result);
+    }
+    return result;
+  }
+};
+
+// src/core/line-dict.ts
+var LineDict = class extends Sub {
+  constructor(nameOrLps, info, text, ...subs) {
+    super();
+    this._texts = null;
+    this._text = "";
+    this.comments = "";
+    this._subs = /* @__PURE__ */ new Map();
+    if (nameOrLps === void 0) return;
+    if (typeof nameOrLps !== "string") {
+      this.name = nameOrLps.name;
+      this._info = nameOrLps.info;
+      this._text = nameOrLps.text;
+      this.comments = nameOrLps.comments;
+      for (const sub of nameOrLps.subs) this._subs.set(sub.name, sub);
+      return;
+    }
+    if (info === void 0) {
+      this.load(nameOrLps);
+    } else {
+      this.name = nameOrLps;
+      this._info = textReplace(info);
+      this._text = textReplace(text ?? "");
+      for (const sub of subs) this._subs.set(sub.name, sub);
+    }
+  }
+  load(nameOrLps, info, text, subs) {
+    if (typeof nameOrLps !== "string") {
+      this.name = nameOrLps.name;
+      this._info = nameOrLps.info;
+      this._text = nameOrLps.text;
+      this.comments = nameOrLps.comments;
+      this._subs.clear();
+      for (const sub of nameOrLps.subs) this._subs.set(sub.name, sub);
+    } else if (info === void 0) {
+      const sts = splitLimited(nameOrLps, "///", 1);
+      if (sts.length === 2) this.comments = sts[1];
+      const parts = sts[0].split(":|");
+      const st = splitLimited(parts[0], "#", 1);
+      this.name = st[0];
+      this._info = st.length > 1 ? st[1] : "";
+      this._text = parts[parts.length - 1];
+      this._subs.clear();
+      for (let i = 1; i < parts.length - 1; i++) {
+        const sub = new Sub();
+        sub.load(parts[i]);
+        this._subs.set(sub.name, sub);
+      }
+    } else {
+      this.name = nameOrLps;
+      this._info = textReplace(info);
+      this._text = textReplace(text ?? "");
+      this._subs.clear();
+      if (subs) for (const sub of subs) this._subs.set(sub.name, sub);
+    }
+  }
+  get text() {
+    return this._text;
+  }
+  set text(value) {
+    this._text = value;
+  }
+  get textDisplay() {
+    return textDeReplace(this._text);
+  }
+  set textDisplay(value) {
+    this._text = textReplace(value);
+  }
+  get textToInt() {
+    return parseInt(this._text, 10) || 0;
+  }
+  set textToInt(value) {
+    this._text = value.toString();
+  }
+  get textToInt64() {
+    return BigInt(this._text || "0");
+  }
+  set textToInt64(value) {
+    this._text = value.toString();
+  }
+  get textToDouble() {
+    return parseFloat(this._text) || 0;
+  }
+  set textToDouble(value) {
+    this._text = value.toString();
+  }
+  getText() {
+    return this.textDisplay;
+  }
+  get texts() {
+    if (!this._texts) this._texts = new StringStructure((x) => {
+      this._text = x;
+    }, () => this._text);
+    return this._texts;
+  }
+  get subs() {
+    return Array.from(this._subs.values());
+  }
+  set subs(value) {
+    this._subs.clear();
+    for (const sub of value) this._subs.set(sub.name, sub);
+  }
+  addSub(newSub) {
+    this._subs.set(newSub.name, newSub);
+  }
+  addorReplaceSub(newSub) {
+    this._subs.set(newSub.name, newSub);
+  }
+  addRange(newSubs) {
+    for (const sub of newSubs) this._subs.set(sub.name, sub);
+  }
+  insertSub(index, newSub) {
+    const entries = Array.from(this._subs.entries());
+    entries.splice(index, 0, [newSub.name, newSub]);
+    this._subs = new Map(entries);
+  }
+  insertRange(index, newSubs) {
+    const entries = Array.from(this._subs.entries());
+    const insert = newSubs.map((s) => [s.name, s]);
+    entries.splice(index, 0, ...insert);
+    this._subs = new Map(entries);
+  }
+  remove(sub) {
+    return this._subs.delete(sub.name);
+  }
+  removeByName(subName) {
+    return this._subs.delete(subName);
+  }
+  removeAll(subName) {
+    this._subs.delete(subName);
+  }
+  removeAt(index) {
+    const entries = Array.from(this._subs.entries());
+    if (index < entries.length) {
+      entries.splice(index, 1);
+      this._subs = new Map(entries);
+    }
+  }
+  contains(sub) {
+    const existing = this._subs.get(sub.name);
+    return existing !== void 0 && existing.info === sub.info;
+  }
+  containsByName(value) {
+    return this._subs.has(value);
+  }
+  find(subName, subinfo) {
+    const sub = this._subs.get(subName);
+    if (!sub) return null;
+    if (subinfo !== void 0 && sub.info !== subinfo) return null;
+    return sub;
+  }
+  findInfo(subinfo) {
+    for (const sub of this._subs.values()) if (sub.info === subinfo) return sub;
+    return null;
+  }
+  findAll(subName, subinfo) {
+    const sub = this._subs.get(subName);
+    if (!sub) return [];
+    if (subinfo !== void 0 && sub.info !== subinfo) return [];
+    return [sub];
+  }
+  findAllInfo(subinfo) {
+    const result = [];
+    for (const sub of this._subs.values()) if (sub.info === subinfo) result.push(sub);
+    return result;
+  }
+  findorAdd(subName) {
+    const existing = this._subs.get(subName);
+    if (existing) return existing;
+    const sub = new Sub();
+    sub.name = subName;
+    this._subs.set(subName, sub);
+    return sub;
+  }
+  searchAll(value) {
+    return this.subs.filter((x) => x.name.includes(value));
+  }
+  search(value) {
+    return this.subs.find((x) => x.name.includes(value)) ?? null;
+  }
+  indexOf(subName) {
+    return Array.from(this._subs.keys()).indexOf(subName);
+  }
+  indexsOf(subName) {
+    const idx = this.indexOf(subName);
+    return idx >= 0 ? [idx] : [];
+  }
+  // Typed shorthands on subs
+  getSubBool(subName) {
+    return this._subs.get(subName)?.getBoolean() ?? false;
+  }
+  setSubBool(subName, value) {
+    this.findorAdd(subName).infoToBoolean = value;
+  }
+  getSubInt(subName, defaultValue = 0) {
+    return this._subs.get(subName)?.infoToInt ?? defaultValue;
+  }
+  setSubInt(subName, value) {
+    this.findorAdd(subName).infoToInt = value;
+  }
+  getSubInt64(subName, defaultValue = 0n) {
+    return this._subs.get(subName)?.infoToInt64 ?? defaultValue;
+  }
+  setSubInt64(subName, value) {
+    this.findorAdd(subName).infoToInt64 = value;
+  }
+  getSubFloat(subName, defaultValue) {
+    return this._subs.get(subName)?.getFloat() ?? (defaultValue ?? FInt64.Zero);
+  }
+  setSubFloat(subName, value) {
+    this.findorAdd(subName).setFloat(value);
+  }
+  getSubDateTime(subName, defaultValue) {
+    return this._subs.get(subName)?.getDateTime() ?? (defaultValue ?? null);
+  }
+  setSubDateTime(subName, value) {
+    this.findorAdd(subName).setDateTime(value);
+  }
+  getSubString(subName, defaultValue) {
+    return this._subs.get(subName)?.infoDisplay ?? (defaultValue ?? null);
+  }
+  setSubString(subName, value) {
+    this.findorAdd(subName).infoDisplay = value ?? "";
+  }
+  getSubDouble(subName, defaultValue = 0) {
+    return this._subs.get(subName)?.infoToDouble ?? defaultValue;
+  }
+  setSubDouble(subName, value) {
+    this.findorAdd(subName).infoToDouble = value;
+  }
+  getLongHashCode() {
+    let hash = getHashCode(this.name) * 2n + getHashCode(this._info) * 3n + getHashCode(this._text) * 4n;
+    for (const sub of this._subs.values()) hash += sub.getLongHashCode();
+    return hash;
+  }
+  toList() {
+    return this.subs;
+  }
+  toString(sb) {
+    const parts = [this.name];
+    if (this._info) parts.push(`#${this._info}`);
+    if (parts.length > 0 || this._subs.size > 0 || this._text || this.comments) parts.push(":|");
+    for (const sub of this._subs.values()) parts.push(sub.toString());
+    parts.push(this._text);
+    if (this.comments) parts.push(`///${this.comments}`);
+    const result = parts.join("");
+    if (sb) {
+      sb.push("\n");
+      sb.push(result);
+    }
+    return result;
+  }
+};
+
+// src/core/lps.ts
+var LPS = class {
+  constructor(lpsOrLine, ...moreLines) {
+    this.assemblage = [];
+    if (lpsOrLine === void 0) return;
+    if (typeof lpsOrLine === "string") {
+      this.load(lpsOrLine);
+    } else if (Array.isArray(lpsOrLine)) {
+      this.addRange(lpsOrLine);
+    } else {
+      this.addLine(lpsOrLine);
+      this.addRange(moreLines);
+    }
+  }
+  load(lpsOrLines) {
+    if (typeof lpsOrLines === "string") {
+      this.assemblage = [];
+      const normalized = lpsOrLines.replace(/\r/g, "").replace(/:\n\|/g, "/n").replace(/:\n:/g, "");
+      const file = normalized.split("\n").filter((line) => line.trim().length > 0);
+      for (const str of file) {
+        const line = new Line();
+        line.load(str);
+        this.assemblage.push(line);
+      }
+    } else {
+      this.assemblage = [];
+      this.addRange(lpsOrLines);
+    }
+  }
+  addLine(newLine) {
+    this.assemblage.push(newLine);
+  }
+  addorReplaceLine(newLine) {
+    const old = this.findLine(newLine.name);
+    if (old) old.load(newLine);
+    else this.assemblage.push(newLine);
+  }
+  addRange(newLines) {
+    for (const line of newLines) this.assemblage.push(line);
+  }
+  insertLine(index, newLine) {
+    this.assemblage.splice(index, 0, newLine);
+  }
+  insertRange(index, newLines) {
+    this.assemblage.splice(index, 0, ...newLines);
+  }
+  remove(target) {
+    if (typeof target === "string") {
+      for (let i = 0; i < this.assemblage.length; i++) {
+        if (this.assemblage[i].name === target) {
+          this.assemblage.splice(i, 1);
+          return true;
+        }
+      }
+      return false;
+    }
+    const idx = this.assemblage.indexOf(target);
+    if (idx === -1) return false;
+    this.assemblage.splice(idx, 1);
+    return true;
+  }
+  removeAll(target) {
+    if (typeof target === "string") {
+      for (let i = this.assemblage.length - 1; i >= 0; i--)
+        if (this.assemblage[i].name === target) this.assemblage.splice(i, 1);
+    } else {
+      for (let i = this.assemblage.length - 1; i >= 0; i--)
+        if (this.assemblage[i] === target) this.assemblage.splice(i, 1);
+    }
+  }
+  removeAt(index) {
+    this.assemblage.splice(index, 1);
+  }
+  contains(target) {
+    if ("subs" in target) return this.assemblage.includes(target);
+    return this.assemblage.some((line) => line.contains(target));
+  }
+  containsLine(value) {
+    return this.assemblage.some((line) => line.name === value);
+  }
+  containsSub(value) {
+    return this.assemblage.some((line) => line.containsByName(value));
+  }
+  findLine(lineName, lineinfo) {
+    if (lineinfo === void 0) return this.assemblage.find((x) => x.name === lineName) ?? null;
+    return this.assemblage.find((x) => x.name === lineName && x.info === lineinfo) ?? null;
+  }
+  findLineInfo(lineinfo) {
+    return this.assemblage.find((x) => x.info === lineinfo) ?? null;
+  }
+  findorAddLine(lineName) {
+    const existing = this.findLine(lineName);
+    if (existing) return existing;
+    const line = new Line();
+    line.name = lineName;
+    this.assemblage.push(line);
+    return line;
+  }
+  findAllLine(lineName, lineinfo) {
+    if (lineinfo === void 0) return this.assemblage.filter((x) => x.name === lineName);
+    return this.assemblage.filter((x) => x.name === lineName && x.info === lineinfo);
+  }
+  findAllLineInfo(lineinfo) {
+    return this.assemblage.filter((x) => x.info === lineinfo);
+  }
+  findSub(subName, subinfo) {
+    for (const line of this.assemblage) {
+      const r = subinfo !== void 0 ? line.find(subName, subinfo) : line.find(subName);
+      if (r) return r;
+    }
+    return null;
+  }
+  findSubInfo(subinfo) {
+    for (const line of this.assemblage) {
+      const r = line.findInfo(subinfo);
+      if (r) return r;
+    }
+    return null;
+  }
+  findAllSub(subName, subinfo) {
+    const results = [];
+    for (const line of this.assemblage) results.push(...subinfo !== void 0 ? line.findAll(subName, subinfo) : line.findAll(subName));
+    return results;
+  }
+  findAllSubInfo(subinfo) {
+    const results = [];
+    for (const line of this.assemblage) results.push(...line.findAllInfo(subinfo));
+    return results;
+  }
+  searchAllLine(value) {
+    return this.assemblage.filter((x) => x.name.includes(value));
+  }
+  searchLine(value) {
+    return this.assemblage.find((x) => x.name.includes(value)) ?? null;
+  }
+  searchAllSub(value) {
+    const results = [];
+    for (const line of this.assemblage) results.push(...line.searchAll(value));
+    return results;
+  }
+  searchSub(value) {
+    for (const line of this.assemblage) {
+      const r = line.search(value);
+      if (r) return r;
+    }
+    return null;
+  }
+  indexOf(lineName) {
+    return this.assemblage.findIndex((x) => x.name === lineName);
+  }
+  indexsOf(lineName) {
+    const indices = [];
+    for (let i = 0; i < this.assemblage.length; i++)
+      if (this.assemblage[i].name === lineName) indices.push(i);
+    return indices;
+  }
+  first() {
+    return this.assemblage.length > 0 ? this.assemblage[0] : null;
+  }
+  last() {
+    return this.assemblage.length > 0 ? this.assemblage[this.assemblage.length - 1] : null;
+  }
+  getLongHashCode() {
+    let hash = 0n;
+    for (const line of this.assemblage) hash += line.getLongHashCode();
+    return hash;
+  }
+  // Typed shorthands on lines
+  getLineBool(lineName) {
+    return this.findLine(lineName)?.getBoolean() ?? false;
+  }
+  setLineBool(lineName, value) {
+    this.findorAddLine(lineName).infoToBoolean = value;
+  }
+  getLineInt(lineName, defaultValue = 0) {
+    return this.findLine(lineName)?.infoToInt ?? defaultValue;
+  }
+  setLineInt(lineName, value) {
+    this.findorAddLine(lineName).infoToInt = value;
+  }
+  getLineInt64(lineName, defaultValue = 0n) {
+    return this.findLine(lineName)?.infoToInt64 ?? defaultValue;
+  }
+  setLineInt64(lineName, value) {
+    this.findorAddLine(lineName).infoToInt64 = value;
+  }
+  getLineString(lineName, defaultValue) {
+    return this.findLine(lineName)?.infoDisplay ?? (defaultValue ?? null);
+  }
+  setLineString(lineName, value) {
+    this.findorAddLine(lineName).infoDisplay = value ?? "";
+  }
+  getLineDouble(lineName, defaultValue = 0) {
+    return this.findLine(lineName)?.infoToDouble ?? defaultValue;
+  }
+  setLineDouble(lineName, value) {
+    this.findorAddLine(lineName).infoToDouble = value;
+  }
+  getLineFloat(lineName, defaultValue) {
+    return this.findLine(lineName)?.getFloat() ?? (defaultValue ?? FInt64.Zero);
+  }
+  setLineFloat(lineName, value) {
+    this.findorAddLine(lineName).setFloat(value);
+  }
+  getLineDateTime(lineName, defaultValue) {
+    return this.findLine(lineName)?.getDateTime() ?? (defaultValue ?? null);
+  }
+  setLineDateTime(lineName, value) {
+    this.findorAddLine(lineName).setDateTime(value);
+  }
+  get length() {
+    let len = 3;
+    for (const line of this.assemblage) {
+      len += line.name.length + line.getStoreString().length + line.text.length + 6;
+      for (const sub of line.subs) len += sub.name.length + sub.getStoreString().length + 3;
+    }
+    return len;
+  }
+  get count() {
+    return this.assemblage.length;
+  }
+  toString() {
+    return this.assemblage.map((line) => line.toString()).join("\n");
+  }
+};
+
+// src/core/lps-document.ts
+var LpsDocument = class extends LPS {
+  constructor(lpsOrLine, ...moreLines) {
+    super();
+    this._lineNode = 0;
+    if (lpsOrLine === void 0) return;
+    if (typeof lpsOrLine === "string") {
+      this.load(lpsOrLine);
+    } else if (Array.isArray(lpsOrLine)) {
+      this.addRange(lpsOrLine);
+    } else {
+      this.addLine(lpsOrLine);
+      this.addRange(moreLines);
+    }
+  }
+  get lineNode() {
+    return this._lineNode;
+  }
+  set lineNode(value) {
+    if (value > this.assemblage.length) this._lineNode = this.assemblage.length;
+    else if (value < 0) this._lineNode = 0;
+    else this._lineNode = value;
+  }
+  readNext() {
+    if (this._lineNode >= this.assemblage.length) return null;
+    return this.assemblage[this._lineNode++];
+  }
+  read() {
+    if (this._lineNode >= this.assemblage.length) return null;
+    return this.assemblage[this._lineNode];
+  }
+  append(newLineOrName, info = "", text = "", ...subs) {
+    if (typeof newLineOrName === "string") {
+      const line = new Line();
+      line.load(newLineOrName, info, text, subs);
+      this.insertLine(this._lineNode + 1, line);
+    } else {
+      this.insertLine(this._lineNode + 1, newLineOrName);
+    }
+  }
+  appendSub(...newSubs) {
+    const current = this.read();
+    if (current) current.addRange(newSubs);
+  }
+  appendSubByName(newSubName, subInfo = "") {
+    const current = this.read();
+    if (current) {
+      const sub = new Sub();
+      sub.load(newSubName, subInfo);
+      current.addSub(sub);
+    }
+  }
+  readReset() {
+    this._lineNode = 0;
+  }
+  readEnd() {
+    this._lineNode = this.assemblage.length;
+  }
+  readCanNext() {
+    return this._lineNode < this.assemblage.length;
+  }
+};
+
+export { LPS, Line, LineDict, LpsDocument, Sub };