lineputscript 1.0.0

package/dist/chunk-MMWDSPQ5.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+// src/utils/hashing.ts
+function getHashCode(text) {
+  const hash = crypto__default.default.createHash("sha512");
+  hash.update(text, "utf-8");
+  const buf = hash.digest();
+  return buf.readBigInt64LE(0);
+}
+function getHashCode32(text) {
+  return Number(getHashCode(text) & 0xffffffffn);
+}
+
+exports.getHashCode = getHashCode;
+exports.getHashCode32 = getHashCode32;

package/dist/chunk-OV7CLVHP.mjs

@@ -0,0 +1,156 @@
+import { splitLimited, textDeReplace, textReplace, FInt64 } from './chunk-4RRNVMEO.mjs';
+
+// src/structure/string-structure.ts
+var StringStructure = class {
+  constructor(setstr, getstr, single = true) {
+    this._cache = null;
+    this.setstr = setstr;
+    this.getstr = getstr;
+    this.single = single;
+  }
+  get cache() {
+    if (!this.single || this._cache === null) {
+      this._cache = /* @__PURE__ */ new Map();
+      const raw = this.getstr();
+      if (raw) {
+        const pairs = splitLimited(raw, "/n");
+        for (const pair of pairs) {
+          const eqIdx = pair.indexOf("=");
+          if (eqIdx >= 0) {
+            const key = pair.substring(0, eqIdx);
+            const val = pair.substring(eqIdx + 1);
+            this._cache.set(key, val);
+          }
+        }
+      }
+    }
+    return this._cache;
+  }
+  set cache(value) {
+    const parts = [];
+    for (const [key, val] of value) {
+      parts.push(`${key}=${val}`);
+    }
+    this.setstr(parts.join("/n"));
+  }
+  getString(key, defaultValue) {
+    if (this._cache?.has(key) ?? this.cache.has(key)) {
+      return textDeReplace(this.cache.get(key)).replace("/!n", "\n");
+    }
+    return defaultValue !== void 0 ? defaultValue : null;
+  }
+  setString(key, value) {
+    const c = this.cache;
+    if (value === null) {
+      c.delete(key);
+    } else {
+      c.set(key, textReplace(value.replace("\n", "/!n")));
+    }
+    this.cache = c;
+  }
+  get(key) {
+    return this.getString(key) ?? "";
+  }
+  set(key, value) {
+    this.setString(key, value);
+  }
+  getBool(key, defaultValue = false) {
+    if (this.cache.has(key)) {
+      const val = this.cache.get(key).toLowerCase();
+      return val === "true" || val === "1" || val === "t";
+    }
+    return defaultValue;
+  }
+  setBool(key, value) {
+    this.setString(key, value ? "true" : "false");
+  }
+  getInt(key, defaultValue = 0) {
+    if (this.cache.has(key)) {
+      return parseInt(this.cache.get(key), 10) || 0;
+    }
+    return defaultValue;
+  }
+  setInt(key, value) {
+    this.setString(key, value.toString());
+  }
+  getInt64(key, defaultValue = 0n) {
+    if (this.cache.has(key)) {
+      return BigInt(this.cache.get(key));
+    }
+    return defaultValue;
+  }
+  setInt64(key, value) {
+    this.setString(key, value.toString());
+  }
+  getFloat(key, defaultValue) {
+    if (this.cache.has(key)) {
+      return FInt64.parse(this.cache.get(key));
+    }
+    return defaultValue ?? FInt64.Zero;
+  }
+  setFloat(key, value) {
+    this.setString(key, value.toStoreString());
+  }
+  getDateTime(key, defaultValue) {
+    if (this.cache.has(key)) {
+      const raw = this.cache.get(key);
+      const longMatch = /^-?\d+$/.test(raw);
+      if (longMatch) {
+        try {
+          const ticks = BigInt(raw);
+          const ticksPerMs = 10000n;
+          const epochOffset = 621355968000000000n;
+          const ms = Number((ticks - epochOffset) / ticksPerMs);
+          return new Date(ms);
+        } catch {
+          return defaultValue ?? null;
+        }
+      }
+      const d = new Date(raw);
+      if (!isNaN(d.getTime())) return d;
+    }
+    return defaultValue ?? null;
+  }
+  setDateTime(key, value) {
+    const ticksPerMs = 10000n;
+    const epochOffset = 621355968000000000n;
+    const ticks = BigInt(value.getTime()) * ticksPerMs + epochOffset;
+    this.setString(key, ticks.toString());
+  }
+  getDouble(key, defaultValue = 0) {
+    if (this.cache.has(key)) {
+      return parseFloat(this.cache.get(key)) || 0;
+    }
+    return defaultValue;
+  }
+  setDouble(key, value) {
+    this.setString(key, value.toString());
+  }
+  containsKey(key) {
+    return this.cache.has(key);
+  }
+  get keys() {
+    return Array.from(this.cache.keys());
+  }
+  get values() {
+    return Array.from(this.cache.values());
+  }
+  get count() {
+    return this.cache.size;
+  }
+  clear() {
+    this._cache = null;
+    this.setstr("");
+  }
+  remove(key) {
+    const c = this.cache;
+    const result = c.delete(key);
+    if (result) this.cache = c;
+    return result;
+  }
+  [Symbol.iterator]() {
+    return this.cache.entries();
+  }
+};
+
+export { StringStructure };

package/dist/chunk-WZIZGAEG.js

@@ -0,0 +1,238 @@
+'use strict';
+
+// src/utils/escaping.ts
+function textReplace(text) {
+  if (text === null || text === void 0) return "";
+  let result = text;
+  result = result.replace(/\|/g, "/|");
+  result = result.replace(/\//g, "/!");
+  result = result.replace(/:\|/g, "/stop");
+  result = result.replace(/\t/g, "/tab");
+  result = result.replace(/\n/g, "/n");
+  result = result.replace(/\r/g, "/r");
+  result = result.replace(/#/g, "/id");
+  result = result.replace(/,/g, "/com");
+  return result;
+}
+function textDeReplace(text) {
+  if (text === null || text === void 0) return "";
+  let result = text;
+  result = result.replace(/\/stop/g, ":|");
+  result = result.replace(/\/equ/g, "=");
+  result = result.replace(/\/tab/g, "	");
+  result = result.replace(/\/n/g, "\n");
+  result = result.replace(/\/r/g, "\r");
+  result = result.replace(/\/id/g, "#");
+  result = result.replace(/\/com/g, ",");
+  result = result.replace(/\/!/g, "/");
+  result = result.replace(/\/\|/g, "|");
+  return result;
+}
+
+// src/utils/fint64.ts
+var Anchor = 1000000000n;
+var Anchord = 1e9;
+var NaNValue = 9223372036854775807n - 1n;
+var NegativeInfinityValue = -9223372036854775807n + 1n;
+var PositiveInfinityValue = 9223372036854775807n;
+var _FInt64 = class _FInt64 {
+  constructor(value) {
+    this.m_value = value;
+  }
+  static fromLong(value) {
+    return new _FInt64(value);
+  }
+  static fromDouble(value) {
+    return new _FInt64(BigInt(Math.round(value * Anchord)));
+  }
+  static fromNumber(value) {
+    return _FInt64.fromDouble(value);
+  }
+  static fromInt(value) {
+    return new _FInt64(BigInt(value) * Anchor);
+  }
+  static fromObject(value) {
+    if (value instanceof _FInt64) return value;
+    if (typeof value === "bigint") return new _FInt64(value);
+    if (typeof value === "number") {
+      if (Number.isInteger(value)) return _FInt64.fromInt(value);
+      return _FInt64.fromDouble(value);
+    }
+    if (typeof value === "string") return _FInt64.parse(value);
+    return _FInt64.NaN;
+  }
+  toDouble() {
+    if (this.isNaN()) return NaN;
+    return Number(this.m_value) / Anchord;
+  }
+  toStoreString() {
+    return this.m_value.toString();
+  }
+  toString() {
+    return this.toDouble().toString();
+  }
+  isNaN() {
+    return this.m_value === NaNValue;
+  }
+  isNegativeInfinity() {
+    return this.m_value === NegativeInfinityValue;
+  }
+  isPositiveInfinity() {
+    return this.m_value === PositiveInfinityValue;
+  }
+  isFinite() {
+    return !this.isNaN() && !this.isNegativeInfinity() && !this.isPositiveInfinity();
+  }
+  isInfinity() {
+    return this.isPositiveInfinity() || this.isNegativeInfinity();
+  }
+  isNegative() {
+    return this.m_value < 0n;
+  }
+  isNormal() {
+    return this.m_value !== 0n && this.isFinite();
+  }
+  toBoolean() {
+    return this.m_value > Anchor;
+  }
+  toInt32() {
+    return Math.trunc(this.toDouble());
+  }
+  toInt64() {
+    return this.m_value / Anchor;
+  }
+  // Arithmetic
+  add(other) {
+    return new _FInt64(this.m_value + other.m_value);
+  }
+  sub(other) {
+    return new _FInt64(this.m_value - other.m_value);
+  }
+  mul(other) {
+    return new _FInt64(this.m_value / 1000n * (other.m_value / 1000n) / 1000n);
+  }
+  div(other) {
+    return new _FInt64(this.m_value * 100000n / other.m_value * 10000n);
+  }
+  addDouble(other) {
+    return new _FInt64(this.m_value + BigInt(Math.round(other * Anchord)));
+  }
+  subDouble(other) {
+    return new _FInt64(this.m_value - BigInt(Math.round(other * Anchord)));
+  }
+  mulDouble(other) {
+    return new _FInt64(BigInt(Math.round(Number(this.m_value) * other)));
+  }
+  divDouble(other) {
+    return new _FInt64(BigInt(Math.round(Number(this.m_value) / other)));
+  }
+  negate() {
+    return new _FInt64(-this.m_value);
+  }
+  increment() {
+    return new _FInt64(this.m_value + Anchor);
+  }
+  decrement() {
+    return new _FInt64(this.m_value - Anchor);
+  }
+  // Bitwise
+  and(other) {
+    return new _FInt64(this.m_value & other.m_value);
+  }
+  or(other) {
+    return new _FInt64(this.m_value | other.m_value);
+  }
+  xor(other) {
+    return new _FInt64(this.m_value ^ other.m_value);
+  }
+  not() {
+    return new _FInt64(~this.m_value);
+  }
+  // Comparison
+  compareTo(other) {
+    if (this.isNaN()) return -1;
+    if (other.isNaN()) return 1;
+    if (this.m_value < other.m_value) return -1;
+    if (this.m_value > other.m_value) return 1;
+    return 0;
+  }
+  equals(other) {
+    if (this.isNaN() || other.isNaN()) return false;
+    return this.m_value === other.m_value;
+  }
+  // Parse
+  static parse(s) {
+    if (s === null || s === void 0) return _FInt64.NaN;
+    const longMatch = /^-?\d+$/.test(s);
+    if (longMatch) {
+      try {
+        const bi = BigInt(s);
+        return new _FInt64(bi);
+      } catch {
+      }
+    }
+    const d = Number(s);
+    if (!isNaN(d)) {
+      return _FInt64.fromDouble(d);
+    }
+    return _FInt64.NaN;
+  }
+  static tryParse(s) {
+    if (s === null || s === void 0) return { result: _FInt64.Zero, success: false };
+    const parsed = _FInt64.parse(s);
+    if (parsed.isNaN()) return { result: _FInt64.Zero, success: false };
+    return { result: parsed, success: true };
+  }
+  // Static helpers
+  static isFinite(d) {
+    return d.isFinite();
+  }
+  static isInfinity(d) {
+    return d.isInfinity();
+  }
+  static isNaNStatic(d) {
+    return d.isNaN();
+  }
+  static isNegative(d) {
+    return d.isNegative();
+  }
+  static isNormal(d) {
+    return d.isNormal();
+  }
+};
+// Constants
+_FInt64.Anchor = Anchor;
+_FInt64.Anchord = Anchord;
+_FInt64.MinValue = new _FInt64(-9223372036854775807n - 1n);
+_FInt64.MaxValue = new _FInt64(9223372036854775807n);
+_FInt64.NaN = new _FInt64(NaNValue);
+_FInt64.NegativeInfinity = new _FInt64(NegativeInfinityValue);
+_FInt64.PositiveInfinity = new _FInt64(PositiveInfinityValue);
+_FInt64.Zero = new _FInt64(0n);
+_FInt64.One = new _FInt64(Anchor);
+_FInt64.NegativeOne = _FInt64.fromDouble(-1);
+_FInt64.AdditiveIdentity = new _FInt64(0n);
+_FInt64.MultiplicativeIdentity = new _FInt64(Anchor);
+var FInt64 = _FInt64;
+
+// src/utils/parsing.ts
+function splitLimited(text, separator, count = -1) {
+  if (count === -1) {
+    return text.split(separator);
+  }
+  const result = [];
+  let remaining = text;
+  for (let i = 0; i < count; i++) {
+    const idx = remaining.indexOf(separator);
+    if (idx === -1) break;
+    result.push(remaining.substring(0, idx));
+    remaining = remaining.substring(idx + separator.length);
+  }
+  result.push(remaining);
+  return result;
+}
+
+exports.FInt64 = FInt64;
+exports.splitLimited = splitLimited;
+exports.textDeReplace = textDeReplace;
+exports.textReplace = textReplace;

package/dist/chunk-X2OHQJFP.mjs

@@ -0,0 +1,14 @@
+import crypto from 'crypto';
+
+// src/utils/hashing.ts
+function getHashCode(text) {
+  const hash = crypto.createHash("sha512");
+  hash.update(text, "utf-8");
+  const buf = hash.digest();
+  return buf.readBigInt64LE(0);
+}
+function getHashCode32(text) {
+  return Number(getHashCode(text) & 0xffffffffn);
+}
+
+export { getHashCode, getHashCode32 };

package/dist/core.d.ts

@@ -0,0 +1,264 @@
+import { ISub, ILine, ILpsDocument } from './types.js';
+import { F as FInt64 } from './fint64-C-6kmcgU.js';
+import { StringStructure } from './structure.js';
+
+declare class Sub implements ISub {
+    name: string;
+    protected _info: string;
+    constructor();
+    constructor(lpsSub: string);
+    constructor(name: string, info: string);
+    constructor(name: string, ...infos: string[]);
+    getStoreString(): string;
+    getString(): string;
+    getInteger64(): bigint;
+    getInteger(): number;
+    getDouble(): number;
+    getFloat(): FInt64;
+    getDateTime(): Date;
+    getBoolean(): boolean;
+    setString(value: string): void;
+    setInteger(value: number): void;
+    setInteger64(value: bigint): void;
+    setDouble(value: number): void;
+    setFloat(value: FInt64): void;
+    setDateTime(value: Date): void;
+    setBoolean(value: boolean): void;
+    get info(): string;
+    set info(value: string);
+    get infoDisplay(): string;
+    set infoDisplay(value: string);
+    get infoToInt(): number;
+    set infoToInt(value: number);
+    get infoToInt64(): bigint;
+    set infoToInt64(value: bigint);
+    get infoToDouble(): number;
+    set infoToDouble(value: number);
+    get infoToBoolean(): boolean;
+    set infoToBoolean(value: boolean);
+    private _infos;
+    get infos(): StringStructure;
+    load(lps: string): void;
+    load(name: string, info: string): void;
+    set(other: ISub): void;
+    getInfo(): string;
+    getInfos(): string[];
+    first(): string | null;
+    last(): string | null;
+    getLongHashCode(): bigint;
+    toString(): string;
+    static split(text: string, separator: string, count?: number): string[];
+}
+
+declare class Line extends Sub implements ILine {
+    subs: ISub[];
+    _text: string;
+    comments: string;
+    constructor();
+    constructor(lpsLine: string);
+    constructor(line: ILine);
+    constructor(name: string, info: string, text?: string, ...subs: ISub[]);
+    load(lps: string): void;
+    load(name: string, info: string, text?: string, subs?: ISub[]): void;
+    load(line: ILine): void;
+    get text(): string;
+    set text(value: string);
+    get textDisplay(): string;
+    set textDisplay(value: string);
+    get textToInt(): number;
+    set textToInt(value: number);
+    get textToInt64(): bigint;
+    set textToInt64(value: bigint);
+    get textToDouble(): number;
+    set textToDouble(value: number);
+    getText(): string;
+    private _texts;
+    get texts(): StringStructure;
+    addSub(newSub: ISub): void;
+    addorReplaceSub(newSub: ISub): void;
+    addRange(newSubs: ISub[]): void;
+    insertSub(index: number, newSub: ISub): void;
+    insertRange(index: number, newSubs: ISub[]): void;
+    remove(sub: ISub): boolean;
+    removeByName(subName: string): boolean;
+    removeAll(subName: string): void;
+    removeAt(index: number): void;
+    contains(sub: ISub): boolean;
+    containsByName(value: string): boolean;
+    find(subName: string): ISub | null;
+    find(subName: string, subinfo: string): ISub | null;
+    findInfo(subinfo: string): ISub | null;
+    findAll(subName: string): ISub[];
+    findAll(subName: string, subinfo: string): ISub[];
+    findAllInfo(subinfo: string): ISub[];
+    findorAdd(subName: string): ISub;
+    searchAll(value: string): ISub[];
+    search(value: string): ISub | null;
+    indexOf(subName: string): number;
+    indexsOf(subName: string): number[];
+    getSubBool(subName: string): boolean;
+    setSubBool(subName: string, value: boolean): void;
+    getSubInt(subName: string, defaultValue?: number): number;
+    setSubInt(subName: string, value: number): void;
+    getSubInt64(subName: string, defaultValue?: bigint): bigint;
+    setSubInt64(subName: string, value: bigint): void;
+    getSubFloat(subName: string, defaultValue?: FInt64): FInt64;
+    setSubFloat(subName: string, value: FInt64): void;
+    getSubDateTime(subName: string, defaultValue?: Date): Date | null;
+    setSubDateTime(subName: string, value: Date): void;
+    getSubString(subName: string, defaultValue?: string | null): string | null;
+    setSubString(subName: string, value: string | null): void;
+    getSubDouble(subName: string, defaultValue?: number): number;
+    setSubDouble(subName: string, value: number): void;
+    getLongHashCode(): bigint;
+    toList(): ISub[];
+    toString(sb?: string[]): string;
+}
+
+declare class LineDict extends Sub implements ILine {
+    private _subs;
+    _text: string;
+    comments: string;
+    constructor();
+    constructor(lpsLine: string);
+    constructor(line: ILine);
+    constructor(name: string, info: string, text?: string, ...subs: ISub[]);
+    load(lps: string): void;
+    load(name: string, info: string, text?: string, subs?: ISub[]): void;
+    load(line: ILine): void;
+    get text(): string;
+    set text(value: string);
+    get textDisplay(): string;
+    set textDisplay(value: string);
+    get textToInt(): number;
+    set textToInt(value: number);
+    get textToInt64(): bigint;
+    set textToInt64(value: bigint);
+    get textToDouble(): number;
+    set textToDouble(value: number);
+    getText(): string;
+    private _texts;
+    get texts(): StringStructure;
+    get subs(): ISub[];
+    set subs(value: ISub[]);
+    addSub(newSub: ISub): void;
+    addorReplaceSub(newSub: ISub): void;
+    addRange(newSubs: ISub[]): void;
+    insertSub(index: number, newSub: ISub): void;
+    insertRange(index: number, newSubs: ISub[]): void;
+    remove(sub: ISub): boolean;
+    removeByName(subName: string): boolean;
+    removeAll(subName: string): void;
+    removeAt(index: number): void;
+    contains(sub: ISub): boolean;
+    containsByName(value: string): boolean;
+    find(subName: string): ISub | null;
+    find(subName: string, subinfo: string): ISub | null;
+    findInfo(subinfo: string): ISub | null;
+    findAll(subName: string): ISub[];
+    findAll(subName: string, subinfo: string): ISub[];
+    findAllInfo(subinfo: string): ISub[];
+    findorAdd(subName: string): ISub;
+    searchAll(value: string): ISub[];
+    search(value: string): ISub | null;
+    indexOf(subName: string): number;
+    indexsOf(subName: string): number[];
+    getSubBool(subName: string): boolean;
+    setSubBool(subName: string, value: boolean): void;
+    getSubInt(subName: string, defaultValue?: number): number;
+    setSubInt(subName: string, value: number): void;
+    getSubInt64(subName: string, defaultValue?: bigint): bigint;
+    setSubInt64(subName: string, value: bigint): void;
+    getSubFloat(subName: string, defaultValue?: FInt64): FInt64;
+    setSubFloat(subName: string, value: FInt64): void;
+    getSubDateTime(subName: string, defaultValue?: Date): Date | null;
+    setSubDateTime(subName: string, value: Date): void;
+    getSubString(subName: string, defaultValue?: string | null): string | null;
+    setSubString(subName: string, value: string | null): void;
+    getSubDouble(subName: string, defaultValue?: number): number;
+    setSubDouble(subName: string, value: number): void;
+    getLongHashCode(): bigint;
+    toList(): ISub[];
+    toString(sb?: string[]): string;
+}
+
+declare class LPS implements ILpsDocument {
+    assemblage: ILine[];
+    constructor();
+    constructor(lps: string);
+    constructor(line: ILine, ...lines: ILine[]);
+    constructor(lines: ILine[]);
+    load(lps: string): void;
+    load(lines: ILine[]): void;
+    addLine(newLine: ILine): void;
+    addorReplaceLine(newLine: ILine): void;
+    addRange(newLines: ILine[]): void;
+    insertLine(index: number, newLine: ILine): void;
+    insertRange(index: number, newLines: ILine[]): void;
+    remove(target: ILine | string): boolean;
+    removeAll(target: ILine | string): void;
+    removeAt(index: number): void;
+    contains(target: ILine | ISub): boolean;
+    containsLine(value: string): boolean;
+    containsSub(value: string): boolean;
+    findLine(lineName: string): ILine | null;
+    findLine(lineName: string, lineinfo: string): ILine | null;
+    findLineInfo(lineinfo: string): ILine | null;
+    findorAddLine(lineName: string): ILine;
+    findAllLine(lineName: string): ILine[];
+    findAllLine(lineName: string, lineinfo: string): ILine[];
+    findAllLineInfo(lineinfo: string): ILine[];
+    findSub(subName: string): ISub | null;
+    findSub(subName: string, subinfo: string): ISub | null;
+    findSubInfo(subinfo: string): ISub | null;
+    findAllSub(subName: string): ISub[];
+    findAllSub(subName: string, subinfo: string): ISub[];
+    findAllSubInfo(subinfo: string): ISub[];
+    searchAllLine(value: string): ILine[];
+    searchLine(value: string): ILine | null;
+    searchAllSub(value: string): ISub[];
+    searchSub(value: string): ISub | null;
+    indexOf(lineName: string): number;
+    indexsOf(lineName: string): number[];
+    first(): ILine | null;
+    last(): ILine | null;
+    getLongHashCode(): bigint;
+    getLineBool(lineName: string): boolean;
+    setLineBool(lineName: string, value: boolean): void;
+    getLineInt(lineName: string, defaultValue?: number): number;
+    setLineInt(lineName: string, value: number): void;
+    getLineInt64(lineName: string, defaultValue?: bigint): bigint;
+    setLineInt64(lineName: string, value: bigint): void;
+    getLineString(lineName: string, defaultValue?: string | null): string | null;
+    setLineString(lineName: string, value: string | null): void;
+    getLineDouble(lineName: string, defaultValue?: number): number;
+    setLineDouble(lineName: string, value: number): void;
+    getLineFloat(lineName: string, defaultValue?: FInt64): FInt64;
+    setLineFloat(lineName: string, value: FInt64): void;
+    getLineDateTime(lineName: string, defaultValue?: Date): Date | null;
+    setLineDateTime(lineName: string, value: Date): void;
+    get length(): number;
+    get count(): number;
+    toString(): string;
+}
+
+declare class LpsDocument extends LPS {
+    private _lineNode;
+    constructor();
+    constructor(lps: string);
+    constructor(line: ILine, ...lines: ILine[]);
+    constructor(lines: ILine[]);
+    get lineNode(): number;
+    set lineNode(value: number);
+    readNext(): ILine | null;
+    read(): ILine | null;
+    append(newLine: ILine): void;
+    append(newlineName: string, info?: string, text?: string, ...subs: ISub[]): void;
+    appendSub(...newSubs: ISub[]): void;
+    appendSubByName(newSubName: string, subInfo?: string): void;
+    readReset(): void;
+    readEnd(): void;
+    readCanNext(): boolean;
+}
+
+export { LPS, Line, LineDict, LpsDocument, Sub };