notations 1.0.4 → 1.0.7

package/dist/notations.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"notations.umd.min.js","mappings":"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","sources":["webpack://Notations/webpack/universalModuleDefinition","webpack://Notations/webpack/bootstrap","webpack://Notations/webpack/runtime/define property getters","webpack://Notations/webpack/runtime/hasOwnProperty shorthand","webpack://Notations/../../src/entity.ts","webpack://Notations/../../src/types.ts","webpack://Notations/../../src/constants.ts","webpack://Notations/../../../src/comms/events.ts","webpack://Notations/../../src/list.ts","webpack://Notations/../../src/browser.ts","webpack://Notations/../../src/numberutils.ts","webpack://Notations/../../src/cycle.ts","webpack://Notations/../../src/core.ts","webpack://Notations/../../src/layouts.ts","webpack://Notations/../../src/grids.ts","webpack://Notations/../../src/beats.ts","webpack://Notations/../../src/graph.ts","webpack://Notations/../../src/sets.ts","webpack://Notations/../../src/grammar.ts","webpack://Notations/../../src/charclasses.ts","webpack://Notations/../../src/propertyescapes.ts","webpack://Notations/../../src/vm.ts","webpack://Notations/../../src/compiler.ts","webpack://Notations/../../src/errors.ts","webpack://Notations/../../src/tape.ts","webpack://Notations/../../src/token.ts","webpack://Notations/../../src/utils.ts","webpack://Notations/../../src/jsparser.ts","webpack://Notations/../../src/flexparser.ts","webpack://Notations/../../src/builder.ts","webpack://Notations/../../src/tokenizer.ts","webpack://Notations/../../src/samples.ts","webpack://Notations/../../src/dsl.ts","webpack://Notations/../../src/lr.ts","webpack://Notations/../../src/parser.ts","webpack://Notations/../../src/lritems.ts","webpack://Notations/../../src/ptables.ts","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/identity.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/visit.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/directives.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/anchors.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/applyReviver.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/toJS.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Node.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Alias.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Scalar.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/createNode.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Collection.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyComment.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/foldFlowLines.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyString.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringify.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/merge.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/addPairToJSMap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/log.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Pair.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyPair.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyCollection.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/YAMLMap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/map.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/YAMLSeq.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/seq.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/string.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/null.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/bool.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyNumber.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/float.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/int.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/json/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/bool.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/float.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/int.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/set.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/tags.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/errors.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/parse/cst-visit.js","webpack://Notations/../../../src/carnatic/gamakas.ts","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/parse/lexer.js","webpack://Notations/../../src/shapes.ts","webpack://Notations/../../src/factory.ts","webpack://Notations/../../src/debug.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Notations\"] = factory();\n\telse\n\t\troot[\"Notations\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import * as TSU from \"@panyam/tsutils\";\n\n/**\n * A common Entity base class with support for unique IDs, parent references,\n * copying, and debug info. This serves as the foundation for all entities\n * in the notation system.\n *\n * Note: Child management is intentionally NOT included here. Each container type\n * (BlockContainer, Line, Group, etc.) defines its own child management with\n * appropriate types.\n */\nexport class Entity {\n  readonly TYPE: string = \"Entity\";\n\n  private static counter = 0;\n  /** Unique identifier for this entity */\n  readonly uuid = Entity.counter++;\n  /** Parent entity in the tree hierarchy */\n  protected _parent: TSU.Nullable<Entity> = null;\n\n  /**\n   * Creates a new Entity.\n   * @param config Optional configuration object\n   */\n  constructor(config: any = null) {\n    config = config || {};\n    if (config.metadata) throw new Error(\"See where metadata is being passed\");\n  }\n\n  /**\n   * Gets the parent entity.\n   */\n  get parent(): TSU.Nullable<Entity> {\n    return this._parent;\n  }\n\n  /**\n   * Sets the parent entity.\n   * @param parent The parent entity to set\n   */\n  setParent(parent: TSU.Nullable<Entity>): void {\n    this._parent = parent;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this entity.\n   * Usually overridden by children to add more debug info.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { type: this.TYPE };\n  }\n\n  /**\n   * Returns a simple string representation of this Entity.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Entity(id = ${this.uuid})`;\n  }\n\n  /**\n   * Checks if this Entity is equal to another Entity.\n   * @param another The Entity to compare with\n   * @param expect Optional parameter\n   * @returns True if the Entities are equal, false otherwise\n   */\n  equals(another: this, expect = false): boolean {\n    if (this.TYPE != another.TYPE) return false;\n    return true;\n  }\n\n  /**\n   * Creates a clone of this entity.\n   * Cloning is a two-part process:\n   * 1. Creation of a new instance via this.newInstance()\n   * 2. Copying of data into the new instance via this.copyTo()\n   *\n   * @returns A new instance of the same type with the same properties\n   */\n  clone(): this {\n    const out = this.newInstance();\n    this.copyTo(out);\n    return out;\n  }\n\n  /**\n   * Copies information about this instance into another instance of the same type.\n   * @param another The target instance to copy properties to\n   */\n  copyTo(another: this): void {\n    // Subclasses override to copy their specific properties\n  }\n\n  /**\n   * First part of the cloning process where the instance is created.\n   * @returns A new instance of the same type\n   */\n  protected newInstance(): this {\n    return new (this.constructor as any)();\n  }\n}\n\n/**\n * Music is all about timing! TimedEntities are base of all entities that\n * have a duration. This is an abstract class that all timed entities inherit from.\n */\nexport abstract class TimedEntity extends Entity {\n  readonly TYPE: string = \"TimedEntity\";\n\n  /**\n   * Gets the duration of this entity in terms of beats.\n   * By default, entity durations are readonly.\n   */\n  abstract get duration(): TSU.Num.Fraction;\n\n  /**\n   * Checks if this TimedEntity is equal to another TimedEntity.\n   * @param another The TimedEntity to compare with\n   * @returns True if the TimedEntities are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.duration.equals(another.duration);\n  }\n}\n","export type Timestamp = number;\nexport type NumberRange = [number, number];\n\nexport type StringMap<T> = { [key: string]: T };\nexport type NumMap<T> = { [key: number]: T };\nexport type Nullable<T> = T | null;\n\nexport type Undefined<T> = T | undefined | void;\n\nexport function assert(condition: boolean, msg?: string): asserts condition {\n  if (!condition) {\n    throw new Error(msg);\n  }\n}\n","export const INFINITY = 1e48;\nexport const MAX_INT = 2 ** 32;\nexport const MAX_LONG = 2 ** 64;\n","import { Nullable, Timestamp } from \"../types\";\n\n/**\n * Super class of all Events.\n */\nexport class TEvent {\n  // Globally unique ID for all events.\n  private static counter = 0;\n  readonly uuid = TEvent.counter++;\n\n  /**\n   * The event this event was spawned from (if any).\n   */\n  protected _spawnedFrom: Nullable<this> = null;\n\n  /**\n   * Name of the event.\n   */\n  readonly name: string;\n\n  /**\n   * Source from which this event is originating.\n   */\n  readonly source: any;\n\n  /**\n   * Source state that is set by the source of the event only\n   * *it* can use.\n   */\n  sourceState: any = null;\n\n  /**\n   * Event specific payload.\n   */\n  payload: any;\n\n  /**\n   * Whether the event was cancelled.\n   */\n  cancelled = false;\n\n  /**\n   * Timestamp of the event - optional.\n   */\n  timeStamp: Timestamp = -1;\n\n  /**\n   * All child events that were spawned from this Event.\n   * The parent/spawnedFrom and child event references help us\n   * form a call tree/trace of a events as it traverses\n   * the system.\n   */\n  children: TEvent[] = [];\n\n  constructor(name: string, source: any, payload?: any) {\n    this.name = name;\n    this.source = source;\n    this.payload = payload;\n  }\n\n  get spawnedFrom(): Nullable<this> {\n    return this._spawnedFrom;\n  }\n\n  protected setSpawnedFrom(msg: Nullable<this>): void {\n    this._spawnedFrom = msg;\n    if (msg == null) this._rootEvent = this;\n    else this._rootEvent = msg.rootEvent;\n  }\n\n  spawn(name: string, source: any, payload?: any): TEvent {\n    const child = new TEvent(name, source, payload);\n    child.setSpawnedFrom(this);\n    this.children.push(child);\n    return child;\n  }\n\n  /**\n   * The first/root message in the forward chain.\n   */\n  private _rootEvent: this;\n\n  get rootEvent(): this {\n    return this._rootEvent as this;\n  }\n}\n\nexport class State {\n  private static counter = 0;\n  stateData: any = null;\n  readonly id = State.counter++;\n\n  get name(): string {\n    return this.constructor.name;\n  }\n\n  enter(data: any): void {\n    this.stateData = data;\n  }\n\n  handle(event: TEvent): void {\n    // todo\n  }\n}\n\nexport type EventCallback = ((event: TEvent) => void) | ((event: TEvent) => Promise<void>);\n\nexport class EventEmitter {\n  protected _eventHub: EventHub | null;\n  constructor() {\n    this._eventHub = new EventHub();\n  }\n  get eventHub(): EventHub | null {\n    return this._eventHub;\n  }\n  set eventHub(hub: EventHub | null) {\n    const oldHub = this._eventHub;\n    this._eventHub = hub;\n    this.eventHubChanged(oldHub);\n  }\n  protected eventHubChanged(oldHub: EventHub | null): void {\n    // Do nothing\n    console.log(\"WARNING - EventHub Change Listener not implemented: \", this.constructor.name);\n  }\n}\n\nexport class EventHub {\n  private _handlers: { [key: string]: Array<EventCallback> } = {};\n\n  on(names: Array<string> | string, callback: EventCallback): this {\n    return this._addHandler(names, this._handlers, callback);\n  }\n\n  removeOn(names: Array<string> | string, callback: EventCallback): this {\n    return this._removeHandler(names, this._handlers, callback);\n  }\n\n  _ensurestrings(names: Array<string> | string): string[] {\n    if (typeof names === \"string\") {\n      names = (names as string).split(\",\");\n    }\n    return names.map(function (v) {\n      return v.trim();\n    });\n  }\n\n  _addHandler<T>(names: Array<string> | string, handlerlist: { [key: string]: Array<T> }, handler: T): this {\n    this._ensurestrings(names).forEach(function (name) {\n      handlerlist[name] = handlerlist[name] || [];\n      handlerlist[name].push(handler);\n    });\n    return this;\n  }\n\n  _removeHandler<T>(names: Array<string> | string, handlerlist: { [key: string]: Array<T> }, handler: T): this {\n    this._ensurestrings(names).forEach(function (name) {\n      const evHandlers = handlerlist[name] || [];\n      for (let i = 0; i < evHandlers.length; i++) {\n        if (evHandlers[i] == handler) {\n          evHandlers.splice(i, 1);\n          break;\n        }\n      }\n    });\n    return this;\n  }\n\n  emit(name: string, source: any, payload?: any): boolean {\n    const evt = new TEvent(name, source, payload);\n    if (this._inBatchMode) {\n      this._events.push(evt);\n      return true;\n    } else {\n      return this.dispatchEvent(evt);\n    }\n  }\n\n  dispatchEvent(event: TEvent): boolean {\n    const evtCallbacks = this._handlers[event.name] || [];\n    for (const callback of evtCallbacks) {\n      callback(event);\n      if (event.cancelled) return false;\n    }\n    return true;\n  }\n\n  // Support for transactional/batch event handling, where\n  // the user can allow a bunch of events to first collect\n  // before triggering a batch dispatch\n  public static BATCH_EVENTS = \"BatchEvents\";\n  protected _events: TEvent[] = [];\n  protected _inBatchMode = false;\n  startBatchMode(): this {\n    if (!this._inBatchMode) {\n      this._inBatchMode = true;\n    }\n    return this;\n  }\n\n  cancelBatch(): void {\n    this._inBatchMode = false;\n    this._events = [];\n  }\n\n  commitBatch(): void {\n    this._inBatchMode = false;\n    this.emit(EventHub.BATCH_EVENTS, this, this._events);\n    this._events = [];\n  }\n}\n\n/**\n * StateMachines allow declarative and stateful chaining of events.\n */\nexport class StateMachine {\n  private _states: { [key: string]: State } = {};\n  private _rootState: Nullable<State> = null;\n  private _currentState: Nullable<State> = null;\n  constructor() {\n    this._states = {};\n    this._rootState = null;\n    this._currentState = null;\n  }\n\n  /**\n   * The starting/root state of the machine.\n   *\n   * @param {String} name  Name of the default/root state.\n   */\n  set rootState(name: string) {\n    this._rootState = this.getState(name);\n    if (this._currentState == null) {\n      this._currentState = this._rootState;\n    }\n  }\n\n  /**\n   * Exits the current state (if any) and enters a new state.\n   *\n   * @param {String}   state   Name of the new state to enter.\n   * @param {Object}   data    State specific data for the state handler to use for the new state.\n   */\n  enter(state: string, data: any = null): void {\n    if (state == \"\") {\n      this._currentState = this._rootState;\n    } else {\n      this._currentState = this.getState(state);\n    }\n    if (this._currentState != null) {\n      this._currentState.enter(data);\n    }\n  }\n\n  /**\n   * Get the state by name.\n   *\n   * @param {String} name  Name of the state being queried.\n   * @returns {State} State object associated with the name.\n   */\n  getState(name: string): State {\n    if (!(name in this._states)) {\n      throw Error(\"State '\" + name + \"' not yet registered.\");\n    }\n    return this._states[name];\n  }\n\n  /**\n   * Register a new state in the state machine.\n   *\n   * @param {State} state  State being registered.  If another State with\n   * the same name exists, then a {DuplicateError} is thrown.\n   * @param {Bool} isRoot  Whether the new state is a root state.\n   */\n  registerState(state: State, isRoot = false): void {\n    const name = state.name;\n    if (name in this._states) {\n      throw Error(\"State '\" + name + \"' already registered.\");\n    }\n    this._states[name] = state;\n    if (isRoot || false) {\n      this.rootState = state.name;\n    }\n  }\n\n  /**\n   * Handles an event from the current state in the state machine possibly resulting in a state transition.\n   *\n   * @param {Object} name    Type of event being sent.\n   * @param {EventSource} source  The source generating the event.\n   * @param {Object} data    The event specific data.\n   */\n  handle(event: TEvent): void {\n    if (this._currentState == null) return;\n\n    const nextState: any = this._currentState.handle(event);\n    if (nextState != null) {\n      if (nextState == \"\") {\n        if (this._rootState != null) {\n          this.enter(this._rootState.name);\n        } else {\n          throw new Error(\"Root state has not been set\");\n        }\n      } else {\n        this.enter(nextState);\n      }\n    }\n  }\n}\n","import { Nullable } from \"./types\";\n\nexport interface ListNode<V> {\n  nextSibling: Nullable<V>;\n  prevSibling: Nullable<V>;\n}\n\nclass MutableListNode<V> implements ListNode<MutableListNode<V>> {\n  nextSibling: Nullable<MutableListNode<V>> = null;\n  prevSibling: Nullable<MutableListNode<V>> = null;\n  constructor(public value: V) {}\n}\n\n/**\n * A list implementation where the value itself contains next and prev pointers\n * so we do not need to create wrapper classes.\n */\nexport class ValueList<V extends ListNode<V>> {\n  protected _firstChild: Nullable<V> = null;\n  protected _lastChild: Nullable<V> = null;\n  protected _size = 0;\n\n  constructor(...values: V[]) {\n    for (const v of values) this.pushBack(v);\n  }\n\n  toJSON(): V[] {\n    return Array.from(this.values());\n  }\n\n  forEach(method: (val: V) => boolean | any): number {\n    let tmp: V | null = this._firstChild;\n    let count = 0;\n    while (tmp != null) {\n      if (method(tmp) == false) {\n        break;\n      }\n      count++;\n      tmp = tmp.nextSibling;\n    }\n    return count;\n  }\n\n  equals(another: ValueList<V>, eqlFunc: (val1: V, val2: V) => boolean): boolean {\n    if (this.size != another.size) return false;\n    let tmp = this.first;\n    let tmp2 = another.first;\n    for (; tmp != null && tmp2 != null; tmp = tmp.nextSibling, tmp2 = tmp2.nextSibling) {\n      if (!eqlFunc(tmp, tmp2)) {\n        return false;\n      }\n    }\n    return tmp == null && tmp2 == null;\n  }\n\n  get isEmpty(): boolean {\n    return this._size == 0;\n  }\n\n  get size(): number {\n    return this._size;\n  }\n\n  get first(): Nullable<V> {\n    return this._firstChild;\n  }\n\n  get last(): Nullable<V> {\n    return this._lastChild;\n  }\n\n  /**\n   * Generator of values in reverse order.\n   */\n  *reversedValues(): Generator<V> {\n    let tmp = this._lastChild;\n    while (tmp != null) {\n      yield tmp;\n      tmp = tmp.prevSibling;\n    }\n  }\n\n  /**\n   * Generator of values in forward order.\n   */\n  *values(): Generator<V> {\n    let tmp = this._firstChild;\n    while (tmp != null) {\n      yield tmp;\n      tmp = tmp.nextSibling;\n    }\n  }\n\n  add(child: V, before: Nullable<V> = null): this {\n    // Ensure that this node is not added anywhere else\n    if (child.nextSibling != null || child.prevSibling != null) {\n      throw new Error(\"New node already added to a list.  Remove it first\");\n    }\n    child.nextSibling = child.prevSibling = null;\n    this._size++;\n    if (this._firstChild == null || this._lastChild == null) {\n      this._firstChild = this._lastChild = child;\n    } else if (before == null) {\n      child.prevSibling = this._lastChild;\n      child.nextSibling = null;\n      this._lastChild.nextSibling = child;\n      this._lastChild = child;\n    } else if (before == this._firstChild) {\n      child.nextSibling = before;\n      child.prevSibling = null;\n      this._firstChild.prevSibling = child;\n      this._firstChild = child;\n    } else {\n      const prev = before.prevSibling;\n      child.nextSibling = before;\n      before.prevSibling = child;\n      child.prevSibling = prev;\n      if (prev != null) {\n        prev.nextSibling = child;\n      }\n    }\n    return this;\n  }\n\n  pushFront(value: V): this {\n    return this.add(value, this._firstChild);\n  }\n\n  pushBack(value: V): this {\n    return this.add(value);\n  }\n\n  /**\n   * Removes a child node from this list.\n   * It is upto the caller to ensure that this node indeed belongs\n   * to this list otherwise deletion of a non belonging node could result\n   * in undefined behaviour.\n   */\n  remove(child: V): this {\n    const next = child.nextSibling;\n    const prev = child.prevSibling;\n\n    if (next == null) {\n      this._lastChild = prev;\n      if (prev == null) this._firstChild = null;\n    } else {\n      next.prevSibling = prev;\n    }\n\n    if (prev == null) {\n      this._firstChild = next;\n      if (next == null) this._lastChild = null;\n    } else {\n      prev.nextSibling = next;\n    }\n\n    this._size--;\n\n    child.prevSibling = child.nextSibling = null;\n    return this;\n  }\n\n  popBack(): V {\n    if (this._lastChild == null) {\n      throw new Error(\"No children\");\n    }\n    const out = this._lastChild;\n    this.remove(out);\n    return out;\n  }\n\n  popFront(): V {\n    if (this._firstChild == null) {\n      throw new Error(\"No children\");\n    }\n    const out = this._firstChild;\n    this.remove(out);\n    return out;\n  }\n}\n\n/**\n * A list implementation where the values themselves need to be wrapper in a list node.\n * If values already have sibling node properties they can be direclty used\n * via ValueLists.\n */\nexport class List<V> {\n  private container: ValueList<MutableListNode<V>>;\n\n  constructor(...values: V[]) {\n    this.container = new ValueList<MutableListNode<V>>();\n    for (const v of values) this.push(v);\n  }\n\n  toJSON(): V[] {\n    return Array.from(this.values());\n  }\n\n  forEach(method: (val: V) => boolean | any): number {\n    return this.container.forEach((v) => method(v.value));\n  }\n\n  equals(another: List<V>, eqlFunc: (val1: V, val2: V) => boolean): boolean {\n    return this.container.equals(another.container, (a, b) => eqlFunc(a.value, b.value));\n  }\n\n  find(target: V): Nullable<MutableListNode<V>> {\n    for (const v of this.container.values()) {\n      if (target == v.value) {\n        return v;\n      }\n    }\n    return null;\n  }\n\n  get isEmpty(): boolean {\n    return this.container.isEmpty;\n  }\n\n  get size(): number {\n    return this.container.size;\n  }\n\n  get first(): Nullable<MutableListNode<V>> {\n    return this.container.first;\n  }\n\n  get last(): Nullable<MutableListNode<V>> {\n    return this.container.last;\n  }\n\n  /**\n   * Generator of values in reverse order.\n   */\n  *reversedValues(): Generator<V> {\n    for (const v of this.container.reversedValues()) yield v.value;\n  }\n\n  /**\n   * Generator of values in forward order.\n   */\n  *values(): Generator<V> {\n    for (const v of this.container.values()) yield v.value;\n  }\n\n  popBack(): V {\n    return this.container.popBack().value;\n  }\n\n  popFront(): V {\n    return this.container.popFront().value;\n  }\n\n  pushFront(value: V): this {\n    return this.add(value, this.container.first);\n  }\n\n  push(value: V): this {\n    return this.add(value);\n  }\n\n  add(child: V, before: Nullable<MutableListNode<V>> = null): this {\n    this.container.add(new MutableListNode(child), before);\n    return this;\n  }\n}\n","declare let navigator: any;\nexport class Browser {\n  static IS_EXPLORER = () => navigator && navigator.userAgent.indexOf(\"MSIE\") > -1;\n  static IS_FIREFOX = () => navigator && navigator.userAgent.indexOf(\"Firefox\") > -1;\n  static IS_OPERA = () => navigator && navigator.userAgent.toLowerCase().indexOf(\"op\") > -1;\n\n  protected static UAHasChrome = () => navigator && navigator.userAgent.indexOf(\"Chrome\") > -1;\n  protected static UAHasSafari = () => navigator && navigator.userAgent.indexOf(\"Safari\") > -1;\n  static IS_SAFARI = () => navigator && Browser.UAHasSafari() && (!Browser.UAHasChrome() || !Browser.UAHasSafari());\n  static IS_CHROME = () => navigator && Browser.UAHasChrome() && (!Browser.UAHasChrome() || !Browser.IS_OPERA());\n}\n","import { Nullable } from \"./types\";\n\nexport function range(start: number, end: Nullable<number> = null, incr: Nullable<number> = 1): number[] {\n  if (end == null) {\n    const absStart = Math.abs(start);\n    const arr = Array.from({ length: absStart });\n    if (start >= 0) {\n      return arr.map((x, i) => i);\n    } else {\n      return arr.map((x, i) => i - (absStart - 1));\n    }\n  }\n  const out: number[] = [];\n  if (incr == null) {\n    incr = 1;\n  }\n  incr = Math.abs(incr);\n  if (start !== end) {\n    if (start < end) {\n      for (let i = start; i <= end; i += incr) {\n        out.push(i);\n      }\n    } else {\n      for (let i = start; i >= end; i -= incr) {\n        out.push(i);\n      }\n    }\n  }\n  return out;\n}\n\nexport function gcdof(x: number, y: number): number {\n  x = Math.abs(x);\n  y = Math.abs(y);\n  while (y > 0) {\n    const t = y;\n    y = x % y;\n    x = t;\n  }\n  return x;\n}\n\nexport class Fraction {\n  readonly num: number;\n  readonly den: number;\n\n  static readonly ZERO = new Fraction();\n  static readonly ONE = new Fraction(1, 1);\n  static readonly INFINITY = new Fraction(1, 0);\n\n  constructor(num = 0, den = 1, factorized = false) {\n    if (isNaN(num) || isNaN(den)) {\n      throw new Error(`Invalid numerator(${num}) or denminator(${den})`);\n    }\n    if (factorized) {\n      const gcd = gcdof(num, den);\n      num /= gcd;\n      den /= gcd;\n    }\n    this.num = num;\n    this.den = den;\n  }\n\n  static parse(val: string, factorized = false): Fraction {\n    const parts = val\n      .trim()\n      .split(\"/\")\n      .map((x) => x.trim());\n    let num = 1;\n    let den = 1;\n    if (parts.length == 1) num = parseInt(parts[0]);\n    else if (parts.length != 2) {\n      throw new Error(\"Invalid fraction string: \" + val);\n    } else {\n      if (parts[0].length > 0) {\n        num = parseInt(parts[0]);\n      }\n      if (parts[1].length > 0) {\n        den = parseInt(parts[1]);\n      }\n    }\n    if (isNaN(num) || isNaN(den)) {\n      throw new Error(\"Invalid fraction string: \" + val);\n    }\n    return new Fraction(num, den, factorized);\n  }\n\n  get isWhole(): boolean {\n    return this.num % this.den == 0;\n  }\n\n  get isZero(): boolean {\n    return this.num == 0;\n  }\n\n  get isInfinity(): boolean {\n    return this.den == 0;\n  }\n\n  get isOne(): boolean {\n    return this.num == this.den;\n  }\n\n  get ceil(): number {\n    if (this.num % this.den == 0) {\n      return this.num / this.den;\n    } else {\n      return 1 + Math.floor(this.num / this.den);\n    }\n  }\n\n  get floor(): number {\n    if (this.num % this.den == 0) {\n      return this.num / this.den;\n    } else {\n      return Math.floor(this.num / this.den);\n    }\n  }\n\n  plus(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den + this.den * another.num, this.den * another.den, factorized);\n  }\n\n  plusNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num + this.den * another, this.den, factorized);\n  }\n\n  minus(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den - this.den * another.num, this.den * another.den, factorized);\n  }\n\n  minusNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num - this.den * another, this.den, factorized);\n  }\n\n  times(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.num, this.den * another.den, factorized);\n  }\n\n  timesNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num * another, this.den, factorized);\n  }\n\n  divby(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den, this.den * another.num, factorized);\n  }\n\n  divbyNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num, this.den * another, factorized);\n  }\n\n  /**\n   * Returns another / this.\n   */\n  numDivby(another: number, factorized = false): Fraction {\n    return new Fraction(this.den * another, this.num, factorized);\n  }\n\n  /**\n   * Returns this % another\n   */\n  mod(another: Fraction): Fraction {\n    // a (mod b) = a − b ⌊a / b⌋\n    const d = this.divby(another);\n    const floorOfD = Math.floor(d.num / d.den);\n    return this.minus(another.timesNum(floorOfD));\n  }\n\n  /*\n   * Returns this % another\n   */\n  modNum(another: number): Fraction {\n    // a (mod b) = a − b ⌊a / b⌋\n    const d = this.divbyNum(another);\n    const floorOfD = Math.floor(d.num / d.den);\n    return this.minusNum(another * floorOfD);\n  }\n\n  get inverse(): Fraction {\n    return new Fraction(this.den, this.num);\n  }\n\n  get factorized(): Fraction {\n    const gcd = gcdof(this.num, this.den);\n    return new Fraction(this.num / gcd, this.den / gcd);\n  }\n\n  equals(another: Fraction): boolean {\n    return this.num * another.den == this.den * another.num;\n  }\n\n  equalsNum(another: number): boolean {\n    return this.num == this.den * another;\n  }\n\n  cmp(another: Fraction): number {\n    return this.num * another.den - this.den * another.num;\n  }\n\n  cmpNum(another: number): number {\n    return this.num - this.den * another;\n  }\n\n  isLT(another: Fraction): boolean {\n    return this.cmp(another) < 0;\n  }\n\n  isLTE(another: Fraction): boolean {\n    return this.cmp(another) <= 0;\n  }\n\n  isLTNum(another: number): boolean {\n    return this.cmpNum(another) < 0;\n  }\n\n  isLTENum(another: number): boolean {\n    return this.cmpNum(another) <= 0;\n  }\n\n  isGT(another: Fraction): boolean {\n    return this.cmp(another) > 0;\n  }\n\n  isGTE(another: Fraction): boolean {\n    return this.cmp(another) >= 0;\n  }\n\n  isGTNum(another: number): boolean {\n    return this.cmpNum(another) > 0;\n  }\n\n  isGTENum(another: number): boolean {\n    return this.cmpNum(another) >= 0;\n  }\n\n  toString(): string {\n    return this.num + \"/\" + this.den;\n  }\n\n  static max(f1: Fraction, f2: Fraction): Fraction {\n    return f1.cmp(f2) > 0 ? f1 : f2;\n  }\n\n  static min(f1: Fraction, f2: Fraction): Fraction {\n    return f1.cmp(f2) < 0 ? f1 : f2;\n  }\n}\n\n// Shortcut helper\nexport const Frac = (a = 0, b = 1, factorized = false): Fraction => new Fraction(a, b, factorized);\n","import * as TSU from \"@panyam/tsutils\";\nimport { Entity, TimedEntity } from \"./entity\";\n\n/**\n * Alias to TSU.Num.Fraction in tsutils.\n */\ntype Fraction = TSU.Num.Fraction;\nexport type CyclePosition = [number, number, number];\nexport type CycleIterator = Generator<[CyclePosition, Fraction]>;\n\nconst ZERO = TSU.Num.Fraction.ZERO;\nconst ONE = TSU.Num.Fraction.ONE;\n\n/**\n * A cursor that traverses through a Cycle's beats in a controlled manner.\n * Allows forward and backward navigation through the cycle.\n */\nexport class CycleCursor {\n  /**\n   * Creates a new CycleCursor.\n   * @param cycle The Cycle to traverse\n   * @param barIndex The starting bar index, defaults to 0\n   * @param beatIndex The starting beat index within the bar, defaults to 0\n   * @param instance The starting instance index within the beat, defaults to 0\n   */\n  constructor(\n    public readonly cycle: Cycle,\n    public barIndex = 0,\n    public beatIndex = 0,\n    public instance = 0,\n  ) {}\n\n  /**\n   * Advances the cursor to the next beat and returns the current position and beat length.\n   * @returns A tuple containing the current position and beat length\n   */\n  get next(): [CyclePosition, Fraction] {\n    const currBar = this.cycle.bars[this.barIndex];\n    const result: [CyclePosition, Fraction] = [\n      [this.barIndex, this.beatIndex, this.instance],\n      currBar.beatLengths[this.beatIndex],\n    ];\n    this.instance++;\n    if (!currBar.beatCounts[this.beatIndex] || this.instance >= currBar.beatCounts[this.beatIndex]) {\n      this.instance = 0;\n      this.beatIndex++;\n      if (this.beatIndex >= currBar.beatLengths.length) {\n        this.beatIndex = 0;\n        this.barIndex++;\n        if (this.barIndex >= this.cycle.bars.length) {\n          this.barIndex = 0;\n        }\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Moves the cursor to the previous beat and returns the current position and beat length.\n   * @returns A tuple containing the current position and beat length\n   */\n  get prev(): [CyclePosition, Fraction] {\n    const currBar = this.cycle.bars[this.barIndex];\n    const result: [CyclePosition, Fraction] = [\n      [this.barIndex, this.beatIndex, this.instance],\n      currBar.beatLengths[this.beatIndex],\n    ];\n    // TODO - result should be set *after* decrementing if we had already\n    // done a \"next\" before this otherwise user may have to do a prev twice\n    this.instance--;\n    if (this.instance < 0) {\n      this.beatIndex--;\n      if (this.beatIndex < 0) {\n        this.barIndex--;\n        if (this.barIndex < 0) {\n          this.barIndex = this.cycle.bars.length - 1;\n        }\n        this.beatIndex = this.cycle.bars[this.barIndex].beatCount - 1;\n      }\n      this.instance = (this.cycle.bars[this.barIndex].beatCounts[this.beatIndex] || 1) - 1;\n    }\n    return result;\n  }\n}\n\n/**\n * Represents a bar in a musical cycle.\n * A bar consists of beats with specific lengths and counts.\n */\nexport class Bar extends TimedEntity {\n  readonly TYPE: string = \"Bar\";\n\n  /** Name of the bar (e.g., \"Laghu\", \"Dhrutam\") */\n  name: string;\n\n  /** Length/Duration of each beat in the bar */\n  beatLengths: Fraction[] = [];\n\n  /** How many times each beat should be repeated (the Kalai) */\n  beatCounts: number[] = [];\n\n  /**\n   * Creates a new Bar.\n   * @param config Configuration object containing name, beatLengths, and beatCounts\n   */\n  constructor(config: any = null) {\n    super((config = config || {}));\n    this.name = config.name || \"\";\n    for (const bl of config.beatLengths || []) {\n      if (typeof bl === \"number\") {\n        this.beatLengths.push(TSU.Num.Frac(bl));\n      } else {\n        this.beatLengths.push(bl);\n      }\n    }\n    for (const bc of config.beatCounts || []) {\n      this.beatCounts.push(bc);\n    }\n    while (this.beatCounts.length < this.beatLengths.length) {\n      this.beatCounts.push(1);\n    }\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Bar.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), name: name, beatLengths: this.beatLengths };\n  }\n\n  /**\n   * Checks if this Bar is equal to another Bar.\n   * @param another The Bar to compare with\n   * @returns True if the Bars are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    if (!super.equals(another)) return false;\n    if (this.beatLengths.length != another.beatLengths.length) return false;\n    if (this.beatCounts.length != another.beatCounts.length) return false;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      if (!this.beatLengths[i].equals(another.beatLengths[i])) return false;\n    }\n    for (let i = 0; i < this.beatCounts.length; i++) {\n      if (this.beatCounts[i] != another.beatCounts[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Copies the properties of this Bar to another Bar.\n   * @param another The target Bar to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.name = this.name;\n    another.beatLengths = [...this.beatLengths];\n    another.beatCounts = [...this.beatCounts];\n  }\n\n  /**\n   * Gets the instance count for a specific beat in the bar.\n   * @param beatIndex The index of the beat\n   * @returns The number of instances for the specified beat\n   */\n  instanceCount(beatIndex: number): number {\n    if (beatIndex > this.beatCounts.length) {\n      // by default each beat has 1 instance?\n      return 1;\n    } else {\n      return this.beatCounts[beatIndex];\n    }\n  }\n\n  /**\n   * Gets the number of unique beats in this bar (irrespective of instances).\n   */\n  get beatCount(): number {\n    return this.beatLengths.length;\n  }\n\n  /**\n   * Gets the total number of beat instances in this bar.\n   */\n  get totalBeatCount(): number {\n    let out = 0;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      out += this.beatCounts[i] || 1;\n    }\n    return out;\n  }\n\n  /**\n   * Gets the total duration of time across all beats in this bar.\n   */\n  get duration(): Fraction {\n    let total = ZERO;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      total = total.plus(this.beatLengths[i].timesNum(this.beatCounts[i] || 1));\n    }\n    return total;\n  }\n}\n\n/**\n * Represents a complete rhythmic cycle pattern composed of bars.\n * In carnatic music, this typically represents a tala.\n */\nexport class Cycle extends TimedEntity {\n  readonly TYPE: string = \"Cycle\";\n\n  /** Name of the cycle (e.g., \"Adi Thalam\") */\n  name: string;\n\n  /** The bars that make up this cycle */\n  bars: Bar[];\n\n  /**\n   * Default cycle representing Adi Thalam (4+2+2 structure).\n   */\n  static readonly DEFAULT = new Cycle({\n    name: \"Adi Thalam\",\n    bars: [\n      new Bar({ name: \"Laghu\", beatLengths: [1, 1, 1, 1] }),\n      new Bar({ name: \"Dhrutam\", beatLengths: [1, 1] }),\n      new Bar({ name: \"Dhrutam\", beatLengths: [1, 1] }),\n    ],\n  });\n\n  /**\n   * Creates a new Cycle.\n   * @param config Configuration object containing name and bars\n   */\n  constructor(config: null | { name?: string; bars?: Bar[] } = null) {\n    super((config = config || {}));\n    this.name = config.name || \"\";\n    this.bars = config.bars || [];\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Cycle.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), name: name, bars: this.bars.map((p) => p.debugValue()) };\n  }\n\n  /**\n   * Gets all child entities of this Cycle.\n   * @returns An array of child entities (bars)\n   */\n  children(): Entity[] {\n    return this.bars;\n  }\n\n  /**\n   * Checks if this Cycle is equal to another Cycle.\n   * @param another The Cycle to compare with\n   * @returns True if the Cycles are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    if (!super.equals(another)) {\n      return false;\n    }\n    if (this.bars.length != another.bars.length) return false;\n    for (let i = 0; i < this.bars.length; i++) {\n      if (!this.bars[i].equals(another.bars[i])) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Given a global beat index, returns the position within the cycle.\n   *\n   * @param globalIndex The global beat index\n   * @returns A tuple containing [cycle number, position, start offset]\n   *         - cycle: The nth cycle in which the beat lies\n   *         - position: [barIndex, beatIndex, instance] within the cycle\n   *         - startOffset: Offset of the beat at this global index\n   */\n  getAtIndex(globalIndex: number): [number, CyclePosition, Fraction] {\n    let cycle = 0;\n    while (globalIndex < 0) {\n      globalIndex += this.totalBeatCount;\n      cycle--;\n    }\n    if (globalIndex >= this.totalBeatCount) {\n      cycle = Math.floor(globalIndex / this.totalBeatCount);\n    }\n    globalIndex = globalIndex % this.totalBeatCount;\n    let offset = ZERO;\n    for (let barIndex = 0; barIndex < this.bars.length; barIndex++) {\n      const bar = this.bars[barIndex];\n      if (globalIndex >= bar.totalBeatCount) {\n        globalIndex -= bar.totalBeatCount;\n        offset = offset.plus(bar.duration);\n      } else {\n        // this is the bar!\n        for (let beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {\n          const beatLength = bar.beatLengths[beatIndex];\n          const beatCount = bar.beatCounts[beatIndex] || 1;\n          if (globalIndex >= beatCount) {\n            globalIndex -= beatCount;\n            offset = offset.plus(beatLength.timesNum(beatCount));\n          } else {\n            // this is it\n            const instance = globalIndex;\n            return [cycle, [barIndex, beatIndex, instance], offset.plus(beatLength.timesNum(instance))];\n          }\n        }\n      }\n    }\n    throw new Error(\"Should not be here!\");\n  }\n\n  /**\n   * Given a global offset, returns the position within the cycle.\n   *\n   * @param globalOffset The global time offset\n   * @returns A tuple containing [cycle number, position, note offset, global index]\n   *         - cycle: The nth cycle in which the offset lies\n   *         - position: [barIndex, beatIndex, instance] within the cycle\n   *         - startOffset: The note offset within the beat\n   *         - globalIndex: The beat index within the entire cycle\n   */\n  getPosition(globalOffset: Fraction): [number, CyclePosition, Fraction, number] {\n    const duration = this.duration;\n    let cycleNum = 0;\n    if (globalOffset.isLT(ZERO)) {\n      while (globalOffset.isLT(ZERO)) {\n        cycleNum--;\n        globalOffset = globalOffset.plus(duration);\n      }\n    } else if (globalOffset.isGTE(duration)) {\n      const realOffset = globalOffset.mod(duration);\n      globalOffset = globalOffset.minus(realOffset).divby(duration);\n      TSU.assert(globalOffset.isWhole);\n      cycleNum = globalOffset.floor;\n      globalOffset = realOffset;\n    }\n\n    // here globalOffset is positive and >= 0 and < this.duration\n    let globalIndex = 0;\n    for (let barIndex = 0; barIndex < this.bars.length; barIndex++) {\n      const bar = this.bars[barIndex];\n      const barDuration = bar.duration;\n      if (globalOffset.isGTE(barDuration)) {\n        globalOffset = globalOffset.minus(barDuration);\n      } else {\n        // this is the bar!\n        for (let beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {\n          const beatLength = bar.beatLengths[beatIndex];\n          const beatCount = bar.beatCounts[beatIndex] || 1;\n          for (let instance = 0; instance < beatCount; instance++, globalIndex++) {\n            if (globalOffset.isGTE(beatLength)) {\n              globalOffset = globalOffset.minus(beatLength);\n            } else {\n              // this is it\n              return [cycleNum, [barIndex, beatIndex, instance], globalOffset, globalIndex];\n            }\n          }\n        }\n      }\n      globalIndex += bar.totalBeatCount;\n    }\n\n    throw new Error(\"Should not be here!\");\n  }\n\n  /**\n   * Creates an iterator that yields beats in sequence from a starting position.\n   *\n   * @param startBar The starting bar index, defaults to 0\n   * @param startBeat The starting beat index, defaults to 0\n   * @param startInstance The starting instance index, defaults to 0\n   * @returns A generator that yields [position, beat length] pairs\n   */\n  *iterateBeats(startBar = 0, startBeat = 0, startInstance = 0): CycleIterator {\n    let barIndex = startBar;\n    let beatIndex = startBeat;\n    let instanceIndex = startInstance;\n    while (true) {\n      const currBar = this.bars[barIndex];\n      yield [[barIndex, beatIndex, instanceIndex], currBar.beatLengths[beatIndex]];\n      instanceIndex++;\n      if (!currBar.beatCounts[beatIndex] || instanceIndex >= currBar.beatCounts[beatIndex]) {\n        instanceIndex = 0;\n        beatIndex++;\n        if (beatIndex >= currBar.beatLengths.length) {\n          beatIndex = 0;\n          barIndex++;\n          if (barIndex >= this.bars.length) {\n            barIndex = 0;\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Copies the properties of this Cycle to another Cycle.\n   * @param another The target Cycle to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.name = this.name;\n    another.bars = this.bars.map((x) => x.clone());\n  }\n\n  /**\n   * Gets the number of unique beats in this cycle (irrespective of instances).\n   */\n  get beatCount(): number {\n    let out = 0;\n    for (const bar of this.bars) out += bar.beatCount;\n    return out;\n  }\n\n  /**\n   * Gets the total number of beat instances in this cycle.\n   */\n  get totalBeatCount(): number {\n    let out = 0;\n    for (const bar of this.bars) out += bar.totalBeatCount;\n    return out;\n  }\n\n  /**\n   * Gets the total duration of time across all bars in this cycle.\n   */\n  get duration(): Fraction {\n    return this.bars.reduce((x, y) => x.plus(y.duration), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Entity, TimedEntity } from \"./entity\";\nimport { LayoutParams } from \"./layouts\";\n\n/**\n * Alias to TSU.Num.Fraction in tsutils.\n */\ntype Fraction = TSU.Num.Fraction;\nexport const ZERO = TSU.Num.Fraction.ZERO;\nexport const ONE = TSU.Num.Fraction.ONE;\n\n/**\n * AtomType enums are used to denote specific Atoms\n * Each type represents a specific musical or notational element.\n * @enum\n */\nexport enum AtomType {\n  NOTE = \"Note\",\n  LITERAL = \"Literal\",\n  SYLLABLE = \"Syllable\",\n  SPACE = \"Space\",\n  GROUP = \"Group\",\n  LABEL = \"Label\",\n  REST = \"Rest\",\n  MARKER = \"Marker\",\n}\n\n/**\n * Atoms are the base class for all timed entities that can appear in a Notation.\n * An Atom represents the fundamental building block of the notation system.\n */\nexport abstract class Atom extends TimedEntity {\n  readonly TYPE: string = \"Atom\";\n\n  protected _duration: Fraction;\n  /** Markers to be displayed before this atom */\n  markersBefore: Marker[];\n  /** Markers to be displayed after this atom */\n  markersAfter: Marker[];\n  /** Next atom in the sequence */\n  nextSibling: TSU.Nullable<Atom> = null;\n  /** Previous atom in the sequence */\n  prevSibling: TSU.Nullable<Atom> = null;\n  /** The Group this Atom belongs to, if any */\n  parentGroup: TSU.Nullable<Group> = null;\n\n  /** Indicates if this Atom is a continuation from a previous atom */\n  isContinuation = false;\n\n  /**\n   * Creates a new Atom with the specified duration.\n   * @param duration The duration of the atom, defaults to ONE (1/1)\n   */\n  constructor(duration = ONE) {\n    super();\n    this._duration = duration || ONE;\n  }\n\n  /**\n   * Splits this atom at the specified duration.\n   * @param requiredDuration The duration at which to split the atom\n   * @returns A new atom representing the portion beyond the split point, or null if no split is needed\n   */\n  abstract splitAt(requiredDuration: Fraction): TSU.Nullable<Atom>;\n\n  /**\n   * Returns a debug-friendly representation of this Atom.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = super.debugValue();\n    if (!this.duration.isOne) {\n      out.duration = this.duration.factorized.toString();\n    }\n    if (this.isContinuation) {\n      out.isContinuation = true;\n    }\n    if ((this.markersBefore || []).length > 0) {\n      out.mbef = this.markersBefore.map((m) => m.debugValue());\n    }\n    if ((this.markersAfter || []).length > 0) {\n      out.maft = this.markersAfter.map((m) => m.debugValue());\n    }\n    return out;\n  }\n\n  /**\n   * Copies the properties of this atom to another atom.\n   * @param another The target atom to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another._duration = new TSU.Num.Fraction(this.duration.num, this.duration.den);\n  }\n\n  /**\n   * Gets the duration of this atom.\n   */\n  get duration(): Fraction {\n    return this._duration;\n  }\n\n  /**\n   * Sets the duration of this atom.\n   */\n  set duration(d: Fraction) {\n    this._duration = d;\n  }\n}\n\n/**\n * Base class for atoms that cannot contain other atoms.\n * LeafAtom represents atomic elements that can't be further subdivided.\n */\nexport abstract class LeafAtom extends Atom {\n  readonly TYPE: string = \"LeafAtom\";\n\n  /** Indicates if this atom is followed by a rest */\n  beforeRest = false;\n\n  /**\n   * Splits this atom at a certain duration.\n   * If this atom's duration is longer than the given duration, it's truncated\n   * to the given duration and a continuation space is returned.\n   *\n   * @param duration The duration at which to split the atom\n   * @returns A new Space atom representing the spillover if needed, otherwise null\n   */\n  splitAt(duration: Fraction): TSU.Nullable<Atom> {\n    if (this.duration.cmp(duration) > 0) {\n      const spillOver = this.createSpilloverSpace(this.duration.minus(duration));\n      spillOver.isContinuation = true;\n      this.duration = duration;\n      // TODO - Here we need to move the markersAfter to the spill-over as it doesnt belong to this any more\n      return spillOver;\n    }\n    return null;\n  }\n\n  /**\n   * Creates a Space atom to represent spillover duration when splitting.\n   * @param duration The duration of the spillover\n   * @returns A new Space atom\n   */\n  protected createSpilloverSpace(duration: Fraction): Space {\n    return new Space(duration);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this LeafAtom.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return this.beforeRest ? { ...super.debugValue(), beforeRest: true } : super.debugValue();\n  }\n}\n\n/**\n * Represents a marker or annotation in the notation.\n * Markers can be placed before or after atoms to provide additional context.\n */\nexport class Marker extends Entity {\n  readonly TYPE = \"Marker\";\n\n  /**\n   * Creates a new Marker with the specified text.\n   * @param text The text content of the marker\n   * @param isBefore Whether the marker should appear before (true) or after (false) its associated atom\n   */\n  constructor(\n    public text: string,\n    public isBefore = true,\n  ) {\n    super();\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Marker.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), text: this.text, before: this.isBefore };\n  }\n\n  /**\n   * Returns a string representation of this Marker.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Marker(${this.text}-${this.isBefore})`;\n  }\n}\n\n/**\n * Represents a rest (silence) in the notation.\n * Rests are zero-length atoms that indicate a pause.\n */\nexport class Rest extends LeafAtom {\n  readonly TYPE = \"Rest\";\n\n  /**\n   * Creates a new Rest.\n   * Rests are zero length by default.\n   */\n  constructor() {\n    super(ZERO);\n  }\n}\n\n/**\n * Represents a space or silence in the notation.\n * Spaces can be used to denote either silence or continuations of previous notes.\n */\nexport class Space extends LeafAtom {\n  readonly TYPE = \"Space\";\n\n  /**\n   * Indicates whether this is a silent space or a continuation of the previous note.\n   */\n  isSilent = false;\n\n  /**\n   * Creates a new Space with the specified duration and silence property.\n   * @param duration The duration of the space, defaults to ONE (1/1)\n   * @param isSilent Whether the space represents silence (true) or a continuation (false)\n   */\n  constructor(duration = ONE, isSilent = false) {\n    super(duration);\n    this.isSilent = isSilent;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Space.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), isSilent: this.isSilent };\n  }\n\n  /**\n   * Returns a string representation of this Space.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Space(${this.duration}-${this.isSilent})`;\n  }\n\n  /**\n   * Copies the properties of this Space to another Space.\n   * @param another The target Space to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.isSilent = this.isSilent;\n  }\n\n  /**\n   * Checks if this Space is equal to another Space.\n   * @param another The Space to compare with\n   * @returns True if the Spaces are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.isSilent == another.isSilent;\n  }\n\n  /**\n   * Creates a Space atom to represent spillover duration when splitting.\n   * @param duration The duration of the spillover\n   * @returns A new Space atom with the same silence property as this Space\n   */\n  protected createSpilloverSpace(duration: Fraction): Space {\n    const out = super.createSpilloverSpace(duration);\n    out.isSilent = this.isSilent;\n    return out;\n  }\n}\n\n/**\n * Represents a literal value in the notation.\n * Literals are the basic building blocks for notes and syllables.\n */\nexport class Literal extends LeafAtom {\n  readonly TYPE: string = \"Literal\";\n\n  /**\n   * The embellishments applied to this Literal.\n   */\n  embelishments: any[] = [];\n\n  /**\n   * Creates a new Literal with the specified value and duration.\n   * @param value The string value of the literal\n   * @param duration The duration of the literal, defaults to ONE (1/1)\n   */\n  constructor(\n    public value: string,\n    duration = ONE,\n  ) {\n    super(duration);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Literal.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue(), value: this.value };\n    if (this.embelishments.length > 0) {\n      out.embs = this.embelishments.map((e) => (\"debugValue\" in e ? e.debugValue() : e));\n    }\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Literal.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Lit(${this.duration}-${this.value})`;\n  }\n\n  /**\n   * Checks if this Literal is equal to another Literal.\n   * @param another The Literal to compare with\n   * @returns True if the Literals are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.value == another.value;\n  }\n\n  /**\n   * Copies the properties of this Literal to another Literal.\n   * @param another The target Literal to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.value = this.value;\n  }\n}\n\n/**\n * Represents a syllable in lyrics or text to be sung.\n * Extends Literal to provide specialized handling for sung text.\n */\nexport class Syllable extends Literal {\n  readonly TYPE = \"Syllable\";\n\n  /**\n   * Creates a Syllable from a Literal.\n   * @param lit The Literal to convert to a Syllable\n   * @returns A new Syllable with the properties of the Literal\n   */\n  static fromLit(lit: Literal): Syllable {\n    if (lit.TYPE == AtomType.SYLLABLE) return lit as Syllable;\n    const out = new Syllable(lit.value, lit.duration);\n    out.embelishments = lit.embelishments;\n    out.beforeRest = lit.beforeRest;\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Syllable.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Syll(${this.duration}-${this.value})`;\n  }\n}\n\n/**\n * Represents a musical note in the notation.\n * Extends Literal to add properties specific to musical notes.\n */\nexport class Note extends Literal {\n  readonly TYPE = \"Note\";\n\n  /**\n   * Which octave the note is in. Can be positive or negative to indicate higher or lower octaves.\n   */\n  octave = 0;\n\n  /**\n   * How the note is shifted - i.e., shifted towards major or minor by # of semi-tones.\n   */\n  shift: number | boolean = 0;\n\n  /**\n   * Creates a new Note with the specified properties.\n   * @param value The string value of the note\n   * @param duration The duration of the note, defaults to ONE (1/1)\n   * @param octave The octave of the note, defaults to 0\n   * @param shift The shift of the note, defaults to 0\n   */\n  constructor(value: string, duration = ONE, octave = 0, shift = 0) {\n    super(value, duration);\n    this.octave = octave;\n    this.shift = shift;\n  }\n\n  /**\n   * Creates a Note from a Literal.\n   * @param lit The Literal to convert to a Note\n   * @returns A new Note with the properties of the Literal\n   */\n  static fromLit(lit: Literal): Note {\n    if (lit.TYPE == AtomType.NOTE) return lit as Note;\n    const out = new Note(lit.value, lit.duration);\n    out.embelishments = lit.embelishments;\n    out.beforeRest = lit.beforeRest;\n    return out;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Note.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue() };\n    if (this.octave != 0) out.octave = this.octave;\n    if (this.shift != 0) out.shift = this.shift;\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Note.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Note(${this.duration}-${this.value}-${this.octave})`;\n  }\n\n  /**\n   * Checks if this Note is equal to another Note.\n   * @param another The Note to compare with\n   * @returns True if the Notes are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.octave == another.octave && this.shift == another.shift;\n  }\n\n  /**\n   * Copies the properties of this Note to another Note.\n   * @param another The target Note to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.octave = this.octave;\n    another.shift = this.shift;\n  }\n}\n\n/**\n * Represents a group of atoms that are treated as a single unit.\n * Groups can contain any number of atoms, including other groups.\n */\nexport class Group extends Atom {\n  readonly TYPE = \"Group\";\n\n  /**\n   * Indicates whether the duration is static or linear to the number of atoms in this group.\n   * When true, the duration is used as a multiplier for the total child duration.\n   * When false, the duration is absolute.\n   */\n  durationIsMultiplier = false;\n\n  /**\n   * The list of atoms in this group.\n   */\n  readonly atoms = new TSU.Lists.ValueList<Atom>();\n\n  /**\n   * Creates a new Group containing the specified atoms.\n   * @param atoms The atoms to include in this group\n   */\n  constructor(...atoms: Atom[]) {\n    super(atoms.length == 0 ? ZERO : ONE);\n    this.addAtoms(false, ...atoms);\n  }\n\n  /**\n   * Checks if this Group is equal to another Group.\n   * @param another The Group to compare with\n   * @param expect Optional parameter\n   * @returns True if the Groups are equal, false otherwise\n   */\n  equals(another: this, expect = false): boolean {\n    if (!super.equals(another)) return false;\n    return this.atoms.equals(another.atoms, (a1, a2) => a1.equals(a2));\n  }\n\n  /**\n   * Copies the properties of this Group to another Group.\n   * @param another The target Group to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.durationIsMultiplier = this.durationIsMultiplier;\n    this.atoms.forEach((atom) => another.atoms.add(atom.clone()));\n  }\n\n  /**\n   * Gets the duration of this group.\n   * If durationIsMultiplier is true, returns the total child duration divided by the multiplier.\n   * Otherwise, returns the absolute duration.\n   */\n  get duration(): Fraction {\n    if (this.durationIsMultiplier) {\n      return this.totalChildDuration.divby(this._duration);\n    } else {\n      return this._duration;\n    }\n  }\n\n  /**\n   * Sets this group to use a multiplier for duration calculations.\n   * @param asMultiplier Whether to use the duration as a multiplier\n   * @returns This Group instance for method chaining\n   */\n  setDurationAsMultiplier(asMultiplier = true): this {\n    this.durationIsMultiplier = asMultiplier;\n    return this;\n  }\n\n  /**\n   * Sets the duration of this group.\n   * @param d The new duration\n   * @param asMultiplier Whether to use the duration as a multiplier\n   * @returns This Group instance for method chaining\n   */\n  setDuration(d: Fraction, asMultiplier = false): this {\n    this._duration = d;\n    this.durationIsMultiplier = asMultiplier;\n    return this;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Group.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue(), atoms: Array.from(this.atoms.values(), (a) => a.debugValue()) };\n    if (this.durationIsMultiplier) out.durationIsMultiplier = true;\n    return out;\n  }\n\n  /**\n   * Splits this group into two parts.\n   * The first part (this group) fits within the given duration and everything else\n   * longer than the given duration is returned as a new Group.\n   *\n   * @param requiredDuration The duration at which to split the group\n   * @returns A new Group containing the atoms beyond the split point, or null if no split is needed\n   */\n  splitAt(requiredDuration: Fraction): TSU.Nullable<Group> {\n    if (this.duration.isLTE(requiredDuration) || requiredDuration.isLTE(ZERO)) {\n      return null;\n    }\n    const targetGroup = new Group();\n    if (this.durationIsMultiplier) {\n      targetGroup.durationIsMultiplier = true;\n      targetGroup._duration = this._duration;\n    }\n\n    let remainingDur = this.duration;\n    const totalChildDuration = this.totalChildDuration;\n    const durationFactor = this.durationIsMultiplier\n      ? ONE.divby(this._duration)\n      : this._duration.divby(totalChildDuration, true);\n    while (remainingDur.isGT(requiredDuration) && this.atoms.last) {\n      const lastChild = this.atoms.last;\n      // Child's duration is absolute in its own \"system\"\n      // Its duration within the parent (this) group's frame of reference depends\n      // on whether the parent's duration is absolute or as a multiplier\n      //\n      // realChildDuration = case (group.durationIsMultiper) {\n      //  | true  => child.duration / this._duration\n      //  | false => child.duration * this._duration / total child duration\n      //  }\n      const childDuration = lastChild.duration.times(durationFactor);\n      const newDuration = remainingDur.minus(childDuration);\n      if (newDuration.isGTE(requiredDuration)) {\n        // remove ourselves and add to target\n        // in both cases duration will be adjusted if need be\n        this.removeAtoms(true, lastChild);\n        targetGroup.insertAtomsAt(targetGroup.atoms.first, true, lastChild);\n        if (newDuration.equals(requiredDuration)) {\n          // we have reached the end so return\n          return targetGroup;\n        }\n      } else {\n        // our scenario is now this:\n        //\n        // totalParentDuration = 10\n        // required = 8\n        // lastChildDuration (relative to parent) is 5\n        //\n        // durWithoutLast = 10 - 5\n        // newRequired = requiredDur - durWithoutLast = 3\n        //\n        // However 3 is a duration in the parent's frame of reference\n        // this has to be converted back to the child's FoR\n        const newRequiredDur = requiredDuration.minus(newDuration, true).divby(durationFactor, true);\n        // console.log( \"newRequiredDur: \", newRequiredDur, \"requiedDur: \", requiredDuration, \"remainingDur: \", remainingDur,);\n        // then the last item needs to be split, and by how much?\n        const spillOver = lastChild.splitAt(newRequiredDur);\n        if (spillOver == null) {\n          throw new Error(\"Spill over cannot be null here\");\n        }\n        if (!this.durationIsMultiplier) {\n          // Our own duration has also now changed\n          this._duration = requiredDuration;\n        } else {\n          if (this._duration.isZero) throw new Error(\"How can this be?\");\n        }\n        spillOver.isContinuation = true;\n        // Add spill over to the target\n        targetGroup.insertAtomsAt(targetGroup.atoms.first, true, spillOver);\n        return targetGroup;\n      }\n      remainingDur = newDuration;\n    }\n    return targetGroup;\n  }\n\n  /**\n   * Gets the total duration of all child atoms.\n   * @returns The sum of durations of all atoms in this group\n   */\n  get totalChildDuration(): Fraction {\n    let out = ZERO;\n    this.atoms.forEach((atom) => (out = out.plus(atom.duration)));\n    return out;\n  }\n\n  /**\n   * Inserts atoms before a given cursor atom.\n   * If the cursor atom is null, the atoms are appended at the end.\n   *\n   * @param beforeAtom The atom before which to insert the new atoms, or null to append\n   * @param adjustDuration Whether to adjust this group's duration based on the new atoms\n   * @param atoms The atoms to insert\n   * @returns This Group instance for method chaining\n   */\n  insertAtomsAt(beforeAtom: TSU.Nullable<Atom>, adjustDuration = false, ...atoms: Atom[]): this {\n    adjustDuration = adjustDuration && !this.durationIsMultiplier;\n    const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;\n    // First form a chain of the given atoms\n    for (const atom of atoms) {\n      if (atom.parentGroup != null) {\n        if (atom.parentGroup != this) {\n          throw new Error(\"Atom belongs to another parent. Remove it first\");\n        }\n        atom.parentGroup.removeAtoms(false, atom);\n      }\n      if (atom.TYPE == AtomType.REST) {\n        const last = this.atoms.last;\n        if (last && last.TYPE != AtomType.GROUP && last.TYPE != AtomType.LABEL) {\n          (last as LeafAtom).beforeRest = true;\n        }\n      } else {\n        atom.parentGroup = this;\n        this.atoms.add(atom, beforeAtom);\n      }\n    }\n    if (adjustDuration) {\n      if (this._duration.isZero) {\n        if (this.durationIsMultiplier) throw new Error(\"How can this be?\");\n        this._duration = this.totalChildDuration;\n      } else {\n        const scaleFactor = this.totalChildDuration.divby(oldChildDuration);\n        this._duration = this._duration.times(scaleFactor, true);\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Adds atoms to the end of this group's atom list.\n   *\n   * @param adjustDuration Whether to adjust this group's duration based on the new atoms\n   * @param atoms The atoms to add\n   * @returns This Group instance for method chaining\n   */\n  addAtoms(adjustDuration = false, ...atoms: Atom[]): this {\n    return this.insertAtomsAt(null, adjustDuration, ...atoms);\n  }\n\n  /**\n   * Removes atoms from this group's child list.\n   *\n   * @param adjustDuration Whether to adjust this group's duration after removing atoms\n   * @param atoms The atoms to remove\n   * @returns This Group instance for method chaining\n   */\n  removeAtoms(adjustDuration = false, ...atoms: Atom[]): this {\n    adjustDuration = adjustDuration && !this.durationIsMultiplier;\n    const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;\n    for (const atom of atoms) {\n      if (atom.parentGroup == this) {\n        this.atoms.remove(atom);\n        atom.parentGroup = null;\n      } else if (atom.parentGroup != null) {\n        throw new Error(\"Atom cannot be removed as it does not belong to this group\");\n      }\n    }\n    if (adjustDuration) {\n      if (this._duration.isZero) {\n        if (this.durationIsMultiplier) throw new Error(\"How can this be?\");\n        this._duration = this.totalChildDuration;\n      } else {\n        const scaleFactor = this.totalChildDuration.divby(oldChildDuration);\n        this._duration = this._duration.times(scaleFactor, true);\n      }\n    }\n    return this;\n  }\n}\n\n/**\n * Represents a line of notation containing multiple roles.\n * A line can have atoms starting before or after the cycle.\n */\nexport class Line extends Entity {\n  readonly TYPE: string = \"Line\";\n\n  /**\n   * Offset tells how many notes before or after the cycle this line's atoms start at.\n   */\n  offset: Fraction = ZERO;\n\n  /**\n   * The roles contained in this line.\n   */\n  roles: Role[] = [];\n\n  /**\n   * Text to be displayed in the margin of the line.\n   * This is a hacky solution to doing left side pre-margin text typically\n   * found in notations - e.g., line X of a pallavi has this. This makes vertical\n   * space less wasteful.\n   *\n   * A better solution is inter-beat annotation but it is very complex for now.\n   */\n  marginText = \"\";\n\n  /**\n   * The LayoutParams associated with this line.\n   */\n  layoutParams: LayoutParams;\n\n  /**\n   * Finds the index of a role with the given name.\n   * @param name The name of the role to find\n   * @returns The index of the role, or -1 if not found\n   */\n  indexOfRole(name: string): number {\n    for (let i = 0; i < this.roles.length; i++) {\n      if (this.roles[i].name == name) return i;\n    }\n    return -1;\n  }\n\n  /**\n   * Checks if this line is empty (has no content in any role).\n   */\n  get isEmpty(): boolean {\n    for (const r of this.roles) if (!r.isEmpty) return false;\n    return true;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Line.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = {\n      ...super.debugValue(),\n      roles: this.roles.map((r) => r.debugValue()),\n    };\n    if (!this.offset.isZero) {\n      out.offset = this.offset.toString();\n    }\n    return out;\n  }\n\n  /**\n   * Copies the properties of this Line to another Line.\n   * @param another The target Line to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.roles = this.roles.map((r) => r.clone());\n  }\n\n  /**\n   * Adds atoms to a role in this line.\n   * @param roleName The name of the role to add atoms to\n   * @param defaultToNotes Whether to default to notes for this role\n   * @param atoms The atoms to add\n   * @returns This Line instance for method chaining\n   */\n  addAtoms(roleName: string, defaultToNotes: boolean, ...atoms: Atom[]): this {\n    const role = this.ensureRole(roleName, defaultToNotes);\n    role.addAtoms(...atoms);\n    return this;\n  }\n\n  /**\n   * Ensures a role with the given name exists in this line, creating it if needed.\n   * @param roleName The name of the role to ensure\n   * @param defaultToNotes Whether to default to notes for this role\n   * @returns The role with the specified name\n   */\n  ensureRole(roleName: string, defaultToNotes: boolean): Role {\n    // Ensure we have this many roles\n    let ri = this.roles.findIndex((r) => r.name == roleName);\n    if (ri < 0) {\n      ri = this.roles.length;\n      const role = new Role(this, roleName);\n      role.defaultToNotes = defaultToNotes;\n      this.roles.push(role);\n    }\n    return this.roles[ri];\n  }\n\n  /**\n   * Gets the maximum duration across all roles in this line.\n   */\n  get duration(): Fraction {\n    let max = ZERO;\n    for (const role of this.roles) {\n      max = TSU.Num.Fraction.max(role.duration, max);\n    }\n    return max;\n  }\n}\n\n/**\n * Represents a specific role or voice in a line of notation.\n * Each role contains a sequence of atoms.\n */\nexport class Role extends Entity {\n  readonly TYPE = \"Role\";\n\n  /**\n   * Whether this role represents notes by default.\n   */\n  defaultToNotes = true;\n\n  /**\n   * The atoms in this role.\n   */\n  atoms: Atom[] = [];\n\n  /**\n   * Creates a new Role with the specified line and name.\n   * @param line The line this role belongs to\n   * @param name The name of the role\n   */\n  constructor(\n    public readonly line: Line,\n    public readonly name: string,\n  ) {\n    super();\n  }\n\n  /**\n   * Checks if this role is empty (has no atoms).\n   */\n  get isEmpty(): boolean {\n    return this.atoms.length == 0;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Role.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { name: this.name, atoms: this.atoms.map((a) => a.debugValue()) };\n  }\n\n  /**\n   * Adds atoms to this role.\n   * @param atoms The atoms to add\n   */\n  addAtoms(...atoms: Atom[]): void {\n    let last: null | Atom = null;\n    for (const atom of atoms) {\n      if (atom.TYPE == AtomType.REST) {\n        if (last && last.TYPE != AtomType.GROUP && last.TYPE != AtomType.LABEL) {\n          (last as LeafAtom).beforeRest = true;\n        }\n      } else {\n        this.atoms.push(atom);\n      }\n      last = atom;\n    }\n  }\n\n  /**\n   * Copies the properties of this Role to another Role.\n   * @param another The target Role to copy properties to\n   */\n  copyTo(another: Role): void {\n    another.addAtoms(...this.atoms);\n  }\n\n  /**\n   * Gets the total duration of all atoms in this role.\n   */\n  get duration(): Fraction {\n    return this.atoms.reduce((a, b) => a.plus(b.duration), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Cycle, CyclePosition, CycleCursor } from \"./cycle\";\n\ntype Fraction = TSU.Num.Fraction;\nconst ZERO = TSU.Num.Fraction.ZERO;\n\n/**\n * Manages layout parameters for arranging beats and notes in the notation.\n * LayoutParams determines how beats are organized into lines and rows based on\n * cycle patterns and line breaks.\n */\nexport class LayoutParams {\n  private static counter = 0;\n  /** Unique identifier for this layout parameters instance */\n  readonly uuid = LayoutParams.counter++;\n\n  /** Duration of a single beat (multiplier for beat lengths) */\n  beatDuration: number;\n\n  /** The cycle pattern to use for this layout */\n  cycle: Cycle;\n\n  /** The pattern of line breaks to apply */\n  protected _lineBreaks: number[];\n\n  /** Cache of row start offsets */\n  private _rowStartOffsets: Fraction[];\n\n  /** Cache of row end offsets */\n  private _rowEndOffsets: Fraction[];\n\n  /** Cache of row durations */\n  private _rowDurations: Fraction[];\n\n  /** Total duration of the layout pattern */\n  private _totalLayoutDuration;\n\n  /** Cached beat layout information */\n  private _beatLayouts: [CyclePosition, Fraction][][];\n\n  /** Total number of beats across all layout lines */\n  private _totalBeats: number;\n\n  /**\n   * Creates a new LayoutParams instance.\n   * @param config Configuration object containing beatDuration, cycle, and lineBreaks\n   */\n  constructor(config?: any) {\n    config = config || {};\n    this.beatDuration = config.beatDuration || 1;\n    if (\"cycle\" in config) this.cycle = config.cycle;\n    if (!this.cycle || this.cycle.duration.isZero) {\n      this.cycle = Cycle.DEFAULT;\n    }\n\n    this._rowStartOffsets = [];\n    this._rowEndOffsets = [];\n    this._rowDurations = [];\n    this._totalLayoutDuration = ZERO;\n    this._totalBeats = 0;\n    this._beatLayouts = [];\n    this.lineBreaks = config.lineBreaks || config.layout || [];\n  }\n\n  /**\n   * Checks if this LayoutParams is equal to another LayoutParams.\n   * @param another The LayoutParams to compare with\n   * @returns True if the LayoutParams are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return (\n      // super.equals(another) &&\n      this.beatDuration == another.beatDuration &&\n      this.cycle.equals(another.cycle) &&\n      this.lineBreaksEqual(another._lineBreaks)\n    );\n  }\n\n  /**\n   * Checks if the line breaks pattern is equal to another pattern.\n   * @param another The line breaks pattern to compare with\n   * @returns True if the patterns are equal, false otherwise\n   */\n  lineBreaksEqual(another: number[]): boolean {\n    return this._lineBreaks.length == another.length && this._lineBreaks.every((x, i) => x == another[i]);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this LayoutParams.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return {\n      // ...super.debugValue(),\n      cycle: this.cycle?.debugValue(),\n      beatDuration: this.beatDuration,\n      lineBreaks: this._lineBreaks,\n    };\n  }\n\n  /**\n   * Returns the \"location\" of a beat within a layout.\n   *\n   * Lines are broken into beats of notes and those beats are aligned as per\n   * the specs in the LayoutParams (breaks). For example if the breaks param\n   * stipulates [5, 5, 4] then we have 5 beats in the first 2 lines and 4 in\n   * the last line.\n   *\n   * @param beat The beat to locate\n   * @returns A tuple containing [layoutLine, layoutColumn, rowOffset]\n   *         - layoutLine: The line in the layout break spec this beat falls in\n   *         - layoutColumn: The column within the layoutLine\n   *         - rowOffset: The offset of the beat from the start of the row/line\n   */\n  getBeatLocation(beat: {\n    index: number;\n    barIndex: number;\n    beatIndex: number;\n    instance: number;\n  }): [number, number, Fraction] {\n    //\n    // If a line contains say 50 beats (B1 - B50), then it is laid out as:\n    //\n    //      C0  C1  C2  C3  C4\n    //    ---------------------\n    // L0 | B1  B2  B3  B4  B5\n    // L1 | B6  B7  B8  B9  B10\n    // L2 | B11 B12 B13 B14\n    // L0 | B15 B16 B17 B18 B19\n    // L1 | B20 B21 B22 B23 B24\n    // L2 | B25 B26 B27 B28\n    // L0 | B29 B30 B31 B32 B33\n    // L1 | B34 B35 B36 B37 B38\n    // L2 | B39 B40 B41 B42\n    // L0 | B43 B44 B45 B46 B47\n    // L1 | B48 B49 B50\n    //\n    // This methods returns the triple: [layoutLine, layoutColumn, rowOffset]\n    // where\n    //\n    //  layoutLine: The particular line in the layout break spec this index falls in.\n    //              *Note*: Since lines can start with negative offsets, we can\n    //              even return a layoutLine that is towards the end and then go\n    //              back to 0, eg 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4 ...\n    //              (eg returns L0 or L1 ... Ln)\n    //  layoutColumn: The column within the layoutLine line where this beat falls.\n    //                (eg C0 - C4 above - or depending on how many columns exist\n    //                in the particular layout line).\n    //  rowOffset: The note offset of the beat from the start of the row/line\n    //             (not from the start of the cycle).\n    //\n    // Note the beatIndex can also be negative so we can return a beat\n    // starting from before the cycle starting point.\n    //\n    //  To calculate the \"real\" line globally simply do:\n    //\n    //    realLine = lineBreaks.length  // Math.floor(beatIndex / this.totalBeats) + layoutLine;\n    //\n    // Some examples here are (using B1-B50 above):\n    const modIndex = beat.index % this.totalBeats;\n    let total = 0;\n    for (let i = 0; i < this._lineBreaks.length; i++) {\n      if (modIndex < total + this._lineBreaks[i]) {\n        // TODO: What is the right offset here?\n        let offset = ZERO;\n        if (modIndex > total) {\n          const cursor = new CycleCursor(this.cycle, beat.barIndex, beat.beatIndex, beat.instance);\n          let [, duration] = cursor.prev;\n          for (let i = total; i < modIndex; i++) {\n            [, duration] = cursor.prev;\n            offset = offset.plus(duration.timesNum(this.beatDuration));\n          }\n        }\n        return [i, modIndex - total, offset];\n      }\n      total += this._lineBreaks[i];\n    }\n    throw new Error(\"Invalid beat index: \" + beat.index);\n    return [-1, -1, ZERO];\n  }\n\n  /**\n   * Gets the line layout pattern - i.e., number of beats in each line - as a\n   * repeating pattern.\n   *\n   * For example 4,2,4 indicates that the notes in our song should be\n   * laid out 4 beats in line 1, 2 beats in line 2, 4 beats in line 3 and\n   * 4 beats in line 4 and so on as long as there are more notes available\n   * in this line.\n   */\n  get lineBreaks(): number[] {\n    if (!this._lineBreaks || this._lineBreaks.length == 0) {\n      // trigger a refresh\n      this.lineBreaks = [this.cycle.beatCount];\n    }\n    return this._lineBreaks;\n  }\n\n  /**\n   * Sets the line layout pattern.\n   */\n  set lineBreaks(val: number[]) {\n    this._lineBreaks = val;\n    this.refreshLayout();\n  }\n\n  /**\n   * Returns the number of beats in each line based on the line layout\n   * after taking beatDuration into account.\n   */\n  get beatLayouts(): ReadonlyArray<ReadonlyArray<[CyclePosition, Fraction]>> {\n    if (!this._beatLayouts || this._beatLayouts.length < this.lineBreaks.length) {\n      this.refreshLayout();\n    }\n    return this._beatLayouts;\n  }\n\n  /**\n   * Gets the total number of beats across all lines in the layout pattern.\n   */\n  get totalBeats(): number {\n    this.beatLayouts;\n    return this._totalBeats;\n  }\n\n  /**\n   * Gets the total duration of all beats across all lines in the layout pattern.\n   */\n  get totalLayoutDuration(): Fraction {\n    this.beatLayouts;\n    return this._totalLayoutDuration;\n  }\n\n  /**\n   * Refreshes the layout calculations based on the current cycle and line breaks.\n   * This rebuilds the beat layouts, row durations, and offset information.\n   */\n  protected refreshLayout(): void {\n    const cycleIter = this.cycle.iterateBeats();\n    const akb = this.beatDuration;\n    this._beatLayouts = this.lineBreaks.map((numBeats, index) => {\n      const beats: [CyclePosition, Fraction][] = [];\n      // see what the beat lengths are here\n      for (let i = 0; i < numBeats; i++) {\n        const nextCP = cycleIter.next().value;\n        nextCP[1] = nextCP[1].timesNum(akb);\n        beats.push(nextCP);\n      }\n      return beats;\n    });\n    this._totalBeats = this.lineBreaks.reduce((a, b) => a + b, 0);\n    this._rowDurations = this._beatLayouts.map((beats) => beats.reduce((x, y) => x.plus(y[1]), ZERO));\n    this._rowDurations.forEach((rd, index) => {\n      this._rowStartOffsets[index] = index == 0 ? ZERO : this._rowStartOffsets[index - 1].plus(rd);\n    });\n    this._rowEndOffsets = this._rowDurations.map((rd, index) => {\n      return this._rowStartOffsets[index].plus(rd);\n    });\n    this._totalLayoutDuration = this._rowDurations.reduce((x, y) => x.plus(y), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n// import * as kiwi from \"@lume/kiwi\";\n\n/**\n * Event emitted when layout changes occur in a GridLayoutGroup.\n * Subscribers can use this to update their views incrementally.\n */\nexport interface LayoutChangeEvent {\n  /** The range of rows affected by the change */\n  affectedRowRange: { start: number; end: number } | null;\n  /** The range of columns affected by the change */\n  affectedColRange: { start: number; end: number } | null;\n  /** Whether column widths changed (requires horizontal re-layout) */\n  columnWidthsChanged: boolean;\n  /** Whether row heights changed (requires vertical re-layout) */\n  rowHeightsChanged: boolean;\n  /** The grid models that were affected */\n  affectedGridModels: GridModel[];\n}\n\n/**\n * Callback type for layout change subscribers.\n */\nexport type LayoutChangeCallback = (event: LayoutChangeEvent) => void;\n\n/**\n * A generic grid layout system for hosting child views (similar to GridBagLayout).\n * This provides a framework for hosting BeatViews in a structured grid arrangement,\n * with support for rows, columns, and alignment.\n *\n * Grid \"cells\" can be referred to by cell indexes. Additionally, grid rows and\n * columns can have names (like in spreadsheets) so that even when rows and columns\n * are inserted, though indexes may change, the \"addresses\" remain fixed and immovable.\n */\nexport class GridModel extends TSU.Events.EventEmitter {\n  private static idCounter = 0;\n  readonly uuid = GridModel.idCounter++;\n  /** Timestamp of the last update to this grid */\n  lastUpdatedAt = 0;\n  // cells = new SparseArray<SparseArray<GridCell>>();\n  /** The rows in this grid */\n  rows: GridRow[] = [];\n  /** Mapping of row indices to row alignment objects */\n  rowAligns = new Map<number, RowAlign>();\n  /** Mapping of column indices to column alignment objects */\n  colAligns = new Map<number, ColAlign>();\n\n  /**\n   * Returns a debug-friendly representation of this GridModel.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    const out = {\n      rows: this.rows.map((r) => r.debugValue()),\n      lastUpdatedAt: this.lastUpdatedAt,\n    } as any;\n    return out;\n  }\n\n  /**\n   * Gets the index of the first non-empty row.\n   * @returns The index of the first row containing cells, or -1 if none\n   */\n  get firstRow(): number {\n    for (const gr of this.rows) {\n      if (gr.numCells > 0) return gr.rowIndex;\n    }\n    return -1;\n  }\n\n  /**\n   * Gets the index of the leftmost column containing cells.\n   * @returns The index of the first column containing cells, or -1 if none\n   */\n  get firstCol(): number {\n    let minCol = -1;\n    for (const gr of this.rows) {\n      const fc = gr.firstCol;\n      if (fc >= 0) {\n        if (minCol < 0 || fc < minCol) {\n          minCol = fc;\n        }\n      }\n    }\n    return minCol;\n  }\n\n  /**\n   * Gets all non-empty cells in a specific row.\n   * @param row The index of the row\n   * @returns An array of cells in the row\n   */\n  cellsInRow(row: number): GridCell[] {\n    const out = [] as GridCell[];\n    const gr = this.rows[row];\n    if (gr) {\n      for (const cell of gr.cells) {\n        if (cell?.value) out.push(cell);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all non-empty cells in a specific column.\n   * @param col The index of the column\n   * @returns An array of cells in the column\n   */\n  cellsInCol(col: number): GridCell[] {\n    const out = [] as GridCell[];\n    for (const gr of this.rows) {\n      const cell = gr.cellAt(col);\n      if (cell?.value) out.push(cell);\n    }\n    return out;\n  }\n\n  /**\n   * Adds a row alignment object to the grid.\n   * @param align The row alignment to add\n   */\n  addRowAlign(align: RowAlign): void {\n    this.rowAligns.set(align.uuid, align);\n  }\n\n  /**\n   * Adds a column alignment object to the grid.\n   * @param align The column alignment to add\n   */\n  addColAlign(align: ColAlign): void {\n    this.colAligns.set(align.uuid, align);\n  }\n\n  /**\n   * Adds rows to the grid.\n   * @param insertBefore The index before which to insert the rows, or -1 to append\n   * @param numRows The number of rows to add\n   * @returns This grid instance for method chaining\n   */\n  addRows(insertBefore = -1, numRows = 1): this {\n    if (insertBefore < 0) {\n      insertBefore = this.rows.length;\n    }\n    let next = this.rows[insertBefore] || null;\n    const prev = this.rows[insertBefore - 1] || null;\n    for (let i = numRows - 1; i >= 0; i--) {\n      const newRow = new GridRow(this, insertBefore + i);\n      this.rows.splice(insertBefore, 0, newRow);\n      if (next != null) {\n        newRow.defaultRowAlign.addSuccessor(next.defaultRowAlign);\n      }\n      if (i == 0 && insertBefore > 0) {\n        prev.defaultRowAlign.addSuccessor(newRow.defaultRowAlign);\n      }\n      next = newRow;\n    }\n    for (let i = insertBefore + numRows; i < this.rows.length; i++) {\n      this.rows[i].rowIndex += numRows;\n    }\n    return this;\n  }\n\n  /**\n   * Gets a row at the specified index, creating it if necessary.\n   * @param row The index of the row to get\n   * @returns The row at the specified index\n   */\n  getRow(row: number): GridRow {\n    if (row >= this.rows.length) {\n      this.addRows(-1, 1 + row - this.rows.length);\n    }\n    return this.rows[row];\n  }\n\n  /**\n   * Sets a value in a cell at the specified row and column.\n   * @param row The row index\n   * @param col The column index\n   * @param value The value to set\n   * @param cellCreator Optional function to create a custom cell\n   * @returns The previous value of the cell\n   */\n  setValue(row: number, col: number, value: any, cellCreator?: (row: GridRow, col: number) => GridCell): any {\n    const grow = this.getRow(row);\n    if (!cellCreator) {\n      cellCreator = (row: GridRow, col: number) => {\n        return new GridCell(row, col);\n      };\n    }\n    if (value == null) {\n      const out = grow.clearCellAt(col);\n      if (out != null) {\n        this.eventHub?.emit(GridCellEvent.CLEARED, this, {\n          loc: out.location,\n        });\n      }\n      return out;\n    } else {\n      const cell = grow.cellAt(col, cellCreator) as GridCell;\n      const oldValue = cell.value;\n      this.eventHub?.emit(GridCellEvent.UPDATED, this, {\n        loc: cell.location,\n        cell: cell,\n        oldValue: cell.value,\n      });\n      cell.value = value;\n      return oldValue;\n    }\n  }\n\n  /**\n   * Handles changes to the event hub.\n   */\n  protected eventHubChanged(): void {\n    console.log(\"Event Hub Changed for GridModel\");\n  }\n}\n\n/**\n * Interface for a view associated with a grid cell.\n * GridCellView defines the contract for views that can be placed in grid cells.\n */\nexport interface GridCellView {\n  /** The grid cell this view is associated with */\n  readonly cell: GridCell;\n  /** X-coordinate of the view */\n  x: number;\n  /** Y-coordinate of the view */\n  y: number;\n  /** Width of the view */\n  width: number;\n  /** Height of the view */\n  height: number;\n\n  /**\n   * Sets the bounds of the view.\n   * @param x New x-coordinate, or null to keep current value\n   * @param y New y-coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @param applyLayout Whether to apply layout immediately\n   * @returns The new bounds values\n   */\n  setBounds(\n    x: number | null,\n    y: number | null,\n    w: number | null,\n    h: number | null,\n    applyLayout: boolean,\n  ): [number | null, number | null, number | null, number | null];\n\n  /** Whether this view needs layout */\n  readonly needsLayout: boolean;\n\n  /** The minimum size this view requires */\n  readonly minSize: TSU.Geom.Size;\n\n  /** The bounding box of this view */\n  readonly bbox: TSU.Geom.Rect;\n}\n\n/**\n * Enum defining the events that can occur on grid cells.\n */\nexport enum GridCellEvent {\n  ADDED = \"CellAdded\",\n  CLEARED = \"CellCleared\",\n  REMOVED = \"CellRemoved\",\n  UPDATED = \"CellUpdated\",\n  MOVED = \"CellMoved\",\n}\n\n/**\n * Represents a cell in the grid.\n * GridCell holds a value and manages alignment with rows and columns.\n */\nexport class GridCell {\n  private static idCounter = 0;\n  readonly uuid = GridCell.idCounter++;\n  /** The view associated with this cell */\n  cellView: GridCellView | null;\n  private _rowAlign: RowAlign;\n  private _colAlign: ColAlign;\n\n  /**\n   * Creates a new GridCell.\n   * @param gridRow The row this cell belongs to\n   * @param colIndex The column index of this cell\n   * @param value Optional initial value for the cell\n   */\n  constructor(\n    public gridRow: GridRow,\n    public colIndex: number,\n    public value: any = null,\n  ) {\n    this.rowAlign = gridRow.defaultRowAlign;\n  }\n\n  /**\n   * Gets the row alignment for this cell.\n   */\n  get rowAlign(): RowAlign {\n    return this._rowAlign;\n  }\n\n  /**\n   * Sets the row alignment for this cell.\n   */\n  set rowAlign(val: RowAlign) {\n    val.addCell(this);\n    this._rowAlign = val;\n  }\n\n  /**\n   * Gets the column alignment for this cell.\n   */\n  get colAlign(): ColAlign {\n    return this._colAlign;\n  }\n\n  /**\n   * Sets the column alignment for this cell.\n   */\n  set colAlign(val: ColAlign) {\n    val.addCell(this);\n    this._colAlign = val;\n  }\n\n  /**\n   * Gets the location string for this cell (rowIndex:colIndex).\n   */\n  get location(): string {\n    return this.gridRow.rowIndex + \":\" + this.colIndex;\n  }\n\n  /**\n   * Gets the grid this cell belongs to.\n   */\n  get grid(): GridModel {\n    return this.gridRow.grid;\n  }\n\n  /**\n   * Gets the row index of this cell.\n   */\n  get rowIndex(): number {\n    return this.gridRow.rowIndex;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this GridCell.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    const out = {\n      r: this.gridRow.rowIndex,\n      c: this.colIndex,\n      value: this.value,\n      y: this.rowAlign.coordOffset,\n      h: this.rowAlign.maxLength,\n    } as any;\n    if (this.colAlign) {\n      out.x = this.colAlign.coordOffset;\n      out.w = this.colAlign.maxLength;\n    }\n    return out;\n  }\n}\n\n/**\n * Represents a row of grid cells in a GridModel.\n */\nexport class GridRow {\n  /** The cells in this row */\n  cells: (null | GridCell)[] = [];\n  /** The default vertical alignment for all cells in this row */\n  defaultRowAlign: RowAlign;\n\n  /**\n   * Creates a new GridRow.\n   * @param grid The grid this row belongs to\n   * @param rowIndex The index of this row\n   */\n  constructor(\n    public grid: GridModel,\n    public rowIndex: number,\n  ) {\n    this.defaultRowAlign = new RowAlign();\n    this.grid.addRowAlign(this.defaultRowAlign);\n  }\n\n  /**\n   * Gets the index of the first non-empty column in this row.\n   */\n  get firstCol() {\n    for (let i = 0; i < this.cells.length; i++) {\n      if (this.cells[i]?.value) {\n        return i;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * Gets the number of columns in this row.\n   */\n  get numCols() {\n    return this.cells.length;\n  }\n\n  /**\n   * Gets the number of cells that contain values.\n   */\n  get numCells() {\n    let i = 0;\n    for (const cell of this.cells) {\n      if (cell != null && cell.value != null) i++;\n    }\n    return i;\n  }\n\n  /**\n   * Gets the cell at the specified column index, optionally creating it if it doesn't exist.\n   * @param col The column index\n   * @param creator Optional function to create the cell if it doesn't exist\n   * @returns The cell at the specified index, or null if it doesn't exist and no creator was provided\n   */\n  cellAt(col: number, creator?: (row: GridRow, col: number) => GridCell): GridCell | null {\n    let out = this.cells[col] || null;\n    if (!out && creator) {\n      this.cells[col] = out = creator(this, col);\n      out.gridRow = this;\n      out.colIndex = col;\n      if (out.rowAlign) {\n        this.grid.addRowAlign(out.rowAlign);\n      }\n      if (out.colAlign) {\n        this.grid.addColAlign(out.colAlign);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Clears the cell at the given column.\n   * Note this is not the same as \"removing\" a cell.\n   * Removing a cell would require all cells to the \"right\" to be shifted left.\n   * @param col The column index\n   * @returns The cell that was cleared, or null if none existed\n   */\n  clearCellAt(col: number): GridCell | null {\n    const out = this.cells[col] || null;\n    if (out) {\n      this.cells[col] = null;\n    }\n    return out;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this GridRow.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    return {\n      r: this.rowIndex,\n      cells: this.cells.filter((c) => c).map((c) => c?.debugValue()),\n    };\n  }\n}\n\n/**\n * Base class for row and column alignment objects.\n * AlignedLine manages the alignment of cells along a line (row or column).\n */\nexport abstract class AlignedLine {\n  private static idCounter = 0;\n  readonly uuid = AlignedLine.idCounter++;\n  /** Whether this line needs layout */\n  needsLayout = false;\n  /** The coordinate offset of this line */\n  protected _coordOffset = 0;\n  /** The maximum length of this line */\n  protected _maxLength = 0;\n  /** Padding before this line */\n  paddingBefore = 5;\n  /** Padding after this line */\n  paddingAfter = 5;\n  /** The cells that belong to this line */\n  cells: GridCell[] = [];\n  /** Function to get a view for a cell value */\n  getCellView: (value: any) => GridCellView;\n\n  /**\n   * Sets the offset of this line.\n   * @param val The new offset value\n   */\n  abstract setOffset(val: number): void;\n\n  /**\n   * Evaluates the maximum length required for this line.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum length\n   */\n  abstract evalMaxLength(changedCells: GridCell[]): number;\n\n  /**\n   * Gets the coordinate offset of this line.\n   */\n  get coordOffset(): number {\n    return this._coordOffset;\n  }\n\n  /**\n   * Gets the maximum length of this line, including padding.\n   */\n  get maxLength(): number {\n    return this._maxLength + this.paddingBefore + this.paddingAfter;\n  }\n\n  /**\n   * Sets the maximum length of this line.\n   * @param length The new maximum length\n   */\n  setMaxLength(length: number) {\n    this._maxLength = length;\n  }\n\n  /**\n   * Sets the padding before and after this line.\n   * @param before Padding before the line\n   * @param after Padding after the line\n   */\n  setPadding(before: number, after: number): void {\n    if (before >= 0) {\n      this.paddingBefore = before;\n    }\n    if (after >= 0) {\n      this.paddingAfter = after;\n    }\n  }\n\n  /**\n   * Adds a cell to this line.\n   * @param cell The cell to add\n   * @returns This line instance for method chaining\n   */\n  addCell(cell: GridCell): this {\n    if (this.beforeAddingCell(cell)) {\n      this.cells.push(cell);\n    }\n    return this;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected abstract beforeAddingCell(cell: GridCell): boolean;\n\n  /**\n   * Removes a cell from this line.\n   * @param cell The cell to remove\n   * @returns This line instance for method chaining\n   */\n  removeCell(cell: GridCell): this {\n    if (this.beforeRemovingCell(cell)) {\n      for (let i = 0; i < this.cells.length; i++) {\n        if (this.cells[i].uuid == cell.uuid) {\n          this.cells.splice(i, 1);\n          break;\n        }\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  protected abstract beforeRemovingCell(cell: GridCell): boolean;\n\n  // The \"neighboring\" lines that depend on this line to be placed\n  // before they are placed\n  /** Lines that must be positioned before this line */\n  prevLines = [] as this[];\n  /** Lines that must be positioned after this line */\n  nextLines = [] as this[];\n\n  /**\n   * Adds a successor line to this line.\n   * @param next The line to add as a successor\n   */\n  addSuccessor(next: this): void {\n    // Set nextCol as a successor of this col\n    // TODO - Ensure no cycles\n    for (const c of this.nextLines) {\n      if (c == next) return;\n    }\n    this.nextLines.push(next);\n    next.prevLines.push(this);\n  }\n\n  /* TODO: Disabling only to improve test coverage as this method is\n   * not used.\n   * When we have mutable grids where we can insert/remove neighbors\n   * we can enable this again.\n   */\n  /*\n  removeSuccessor(next: this): void {\n    // Set nextCol as a successor of this col\n    // TODO - Ensure no cycles\n    for (let i = 0; i < this.nextLines.length; i++) {\n      if (this.nextLines[i] == next) {\n        this.nextLines.splice(i, 1);\n        break;\n      }\n    }\n    for (let i = 0; i < next.prevLines.length; i++) {\n      if (next.prevLines[i] == this) {\n        next.prevLines.splice(i, 1);\n        break;\n      }\n    }\n  }\n  */\n}\n\n/**\n * Manages the alignment of cells in a column.\n */\nexport class ColAlign extends AlignedLine {\n  paddingBefore = 10;\n  /** Padding after this line */\n  paddingAfter = 10;\n\n  /**\n   * Sets the offset of this column and updates all associated cells.\n   * @param val The new offset value\n   */\n  setOffset(val: number): void {\n    this._coordOffset = val;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        if (this._maxLength <= 0) {\n          // this hasnt been evaluated yet so do it!\n          this.evalMaxLength();\n        }\n        cellView.setBounds(val, null, this.maxLength, null, true);\n      }\n    }\n  }\n\n  /**\n   * Evaluates the maximum width required for this column.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum width\n   */\n  evalMaxLength(changedCells: GridCell[] = []): number {\n    this._maxLength = 0;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        this._maxLength = Math.max(cellView.minSize.width, this._maxLength);\n      }\n    }\n    return this._maxLength;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected beforeAddingCell(cell: GridCell): boolean {\n    if (cell.colAlign && cell.colAlign != this) {\n      cell.colAlign.removeCell(cell);\n    }\n    return cell.colAlign != this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  beforeRemovingCell(cell: GridCell): boolean {\n    return cell.colAlign == this;\n  }\n}\n\n/**\n * Manages the alignment of cells in a row.\n */\nexport class RowAlign extends AlignedLine {\n  /**\n   * Sets the Y coordinate of all cells in this row.\n   * @param val The new Y coordinate\n   */\n  setOffset(val: number): void {\n    this._coordOffset = val;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        if (this._maxLength <= 0) {\n          // this hasnt been evaluated yet so do it!\n          this.evalMaxLength();\n        }\n        cellView.setBounds(null, val, null, this.maxLength, true);\n      }\n    }\n  }\n\n  /**\n   * Evaluates the maximum height required for this row.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum height\n   */\n  evalMaxLength(changedCells: GridCell[] = []): number {\n    this._maxLength = 0;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        this._maxLength = Math.max(cellView.minSize.height, this._maxLength);\n      }\n    }\n    return this._maxLength;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected beforeAddingCell(cell: GridCell): boolean {\n    if (cell.rowAlign && cell.rowAlign != this) {\n      cell.rowAlign.removeCell(cell);\n    }\n    return cell.rowAlign != this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  beforeRemovingCell(cell: GridCell): boolean {\n    return cell.rowAlign == this;\n  }\n}\n\n/**\n * The layout manager for a collection of GridViews bound by common alignment objects.\n * Manages the layout of multiple grid models, ensuring proper alignment between them.\n */\nexport class GridLayoutGroup {\n  // rowAligns = new Map<number, RowAlign>();\n  // colAligns = new Map<number, ColAlign>();\n  /** The grid models managed by this layout group */\n  gridModels = [] as GridModel[];\n\n  /** Subscribers to layout change events */\n  private layoutChangeSubscribers = new Set<LayoutChangeCallback>();\n\n  /** Previous column widths by ColAlign uuid - for detecting actual changes */\n  private previousColumnWidths = new Map<number, number>();\n\n  /** Previous row heights by RowAlign uuid - for detecting actual changes */\n  private previousRowHeights = new Map<number, number>();\n\n  /**\n   * Subscribes to layout change events.\n   * @param callback Function to call when layout changes\n   * @returns Unsubscribe function\n   */\n  onLayoutChange(callback: LayoutChangeCallback): () => void {\n    this.layoutChangeSubscribers.add(callback);\n    return () => {\n      this.layoutChangeSubscribers.delete(callback);\n    };\n  }\n\n  /**\n   * Notifies all subscribers of a layout change.\n   * @param event The layout change event\n   */\n  protected notifyLayoutChange(event: LayoutChangeEvent): void {\n    for (const callback of this.layoutChangeSubscribers) {\n      try {\n        callback(event);\n      } catch (e) {\n        console.error(\"Error in layout change callback:\", e);\n      }\n    }\n  }\n\n  /**\n   * Gets the number of layout change subscribers.\n   */\n  get subscriberCount(): number {\n    return this.layoutChangeSubscribers.size;\n  }\n\n  /**\n   * Event handler for processing events from grid models.\n   */\n  private eventHandler = (event: TSU.Events.TEvent) => {\n    this.applyModelEvents(event.payload);\n  };\n\n  /**\n   * Adds a grid model to this layout group.\n   * @param gridModel The grid model to add\n   * @returns True if the model was added successfully\n   */\n  addGridModel(gridModel: GridModel): boolean {\n    gridModel.eventHub?.on(TSU.Events.EventHub.BATCH_EVENTS, this.eventHandler);\n    this.gridModels.push(gridModel);\n    return true;\n  }\n\n  /**\n   * Gets all row alignment objects that have no predecessors.\n   * @returns An array of starting row alignments\n   */\n  startingRowAligns(): RowAlign[] {\n    const out = [] as RowAlign[];\n    const visited = {} as any;\n    for (const gm of this.gridModels) {\n      for (const cell of gm.cellsInRow(gm.firstRow)) {\n        if (cell.rowAlign && !visited[cell.rowAlign.uuid]) {\n          visited[cell.rowAlign.uuid] = true;\n          out.push(cell.rowAlign);\n        }\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all column alignment objects that have no predecessors.\n   * @returns An array of starting column alignments\n   */\n  startingColAligns(): ColAlign[] {\n    const out = [] as ColAlign[];\n    const visited = {} as any;\n    for (const gm of this.gridModels) {\n      for (const cell of gm.cellsInCol(gm.firstCol)) {\n        if (cell.colAlign && !visited[cell.colAlign.uuid]) {\n          visited[cell.colAlign.uuid] = true;\n          out.push(cell.colAlign);\n        }\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Removes a grid model from this layout group.\n   * @param gridModel The grid model to remove\n   */\n  removeGridModel(gridModel: GridModel): void {\n    gridModel.eventHub?.removeOn(TSU.Events.EventHub.BATCH_EVENTS, this.eventHandler);\n  }\n\n  /**\n   * Function to get a view for a cell value.\n   */\n  getCellView: (cell: GridCell) => GridCellView;\n\n  /**\n   * Gets the starting row alignments.\n   */\n  get startingRows(): RowAlign[] {\n    return this.startingRowAligns();\n  }\n\n  /**\n   * Gets the starting column alignments.\n   */\n  get startingCols(): ColAlign[] {\n    return this.startingColAligns();\n  }\n\n  /**\n   * Forces a full refresh of the layout.\n   * This recalculates all row and column sizes and positions.\n   * @param notify Whether to notify subscribers of the change (default: true)\n   */\n  refreshLayout(notify = true): void {\n    const changedRowAligns = {} as any;\n    const changedColAligns = {} as any;\n\n    for (const rowAlign of this.startingRowAligns()) {\n      if (!(rowAlign.uuid in changedRowAligns)) {\n        changedRowAligns[rowAlign.uuid] = {\n          align: rowAlign,\n          cells: [],\n        };\n      }\n    }\n\n    for (const colAlign of this.startingColAligns()) {\n      if (!(colAlign.uuid in changedColAligns)) {\n        changedColAligns[colAlign.uuid] = {\n          align: colAlign,\n          cells: [],\n        };\n      }\n    }\n\n    // Pass the previous dimension maps for O(1) inline change detection\n    const rowHeightsChanged = this.doBfsLayout(this.startingRows, changedRowAligns, this.previousRowHeights);\n    const columnWidthsChanged = this.doBfsLayout(this.startingCols, changedColAligns, this.previousColumnWidths);\n\n    // Notify subscribers of full refresh\n    if (notify && this.layoutChangeSubscribers.size > 0) {\n      this.notifyLayoutChange({\n        affectedRowRange: null, // null means all rows\n        affectedColRange: null, // null means all columns\n        columnWidthsChanged,\n        rowHeightsChanged,\n        affectedGridModels: this.gridModels,\n      });\n    }\n  }\n\n  /**\n   * Applies model events to update the layout.\n   * @param events The events to process\n   */\n  protected applyModelEvents(events: TSU.Events.TEvent[]): void {\n    // As the grid model changes (cell content changed, cleared etc) we need\n    // to refresh our layout based on this.\n    // As a first step the new height and width of all changed cells is\n    // evaluted to see which rows and/or columns are affected (and need to be\n    // resized/repositioned).\n    const [changedRowAligns, changedColAligns, affectedGridModels] = this.changesForEvents(events);\n    const hadRowChanges = Object.keys(changedRowAligns).length > 0;\n    const hadColChanges = Object.keys(changedColAligns).length > 0;\n\n    // Pass the previous dimension maps for O(1) inline change detection\n    const rowHeightsChanged = this.doBfsLayout(this.startingRows, changedRowAligns, this.previousRowHeights);\n    const columnWidthsChanged = this.doBfsLayout(this.startingCols, changedColAligns, this.previousColumnWidths);\n\n    // Notify subscribers of incremental changes\n    if (this.layoutChangeSubscribers.size > 0 && (hadRowChanges || hadColChanges)) {\n      // Calculate affected ranges from the changed alignments\n      const affectedRowRange = this.calculateAffectedRowRange(changedRowAligns);\n      const affectedColRange = this.calculateAffectedColRange(changedColAligns);\n\n      this.notifyLayoutChange({\n        affectedRowRange,\n        affectedColRange,\n        columnWidthsChanged,\n        rowHeightsChanged,\n        affectedGridModels: affectedGridModels,\n      });\n    }\n  }\n\n  /**\n   * Calculates the range of affected rows from changed row alignments.\n   * Returns null if no rows changed or range cannot be determined.\n   */\n  protected calculateAffectedRowRange(changedRowAligns: any): { start: number; end: number } | null {\n    let minRow = Infinity;\n    let maxRow = -Infinity;\n\n    for (const alignId in changedRowAligns) {\n      const { cells } = changedRowAligns[alignId];\n      for (const cell of cells) {\n        const rowIndex = cell.gridRow.rowIndex;\n        minRow = Math.min(minRow, rowIndex);\n        maxRow = Math.max(maxRow, rowIndex);\n      }\n    }\n\n    if (minRow === Infinity) return null;\n    return { start: minRow, end: maxRow };\n  }\n\n  /**\n   * Calculates the range of affected columns from changed column alignments.\n   * Returns null if no columns changed or range cannot be determined.\n   */\n  protected calculateAffectedColRange(changedColAligns: any): { start: number; end: number } | null {\n    let minCol = Infinity;\n    let maxCol = -Infinity;\n\n    for (const alignId in changedColAligns) {\n      const { cells } = changedColAligns[alignId];\n      for (const cell of cells) {\n        const colIndex = cell.colIndex;\n        minCol = Math.min(minCol, colIndex);\n        maxCol = Math.max(maxCol, colIndex);\n      }\n    }\n\n    if (minCol === Infinity) return null;\n    return { start: minCol, end: maxCol };\n  }\n\n  /**\n   * Checks if an alignment's maxLength changed from previous value.\n   * Updates the stored previous value. O(1) cost.\n   * @param align The alignment to check\n   * @param previousMap Map storing previous lengths\n   * @returns true if length changed (or is new)\n   */\n  private checkAndUpdateLength<T extends AlignedLine>(align: T, previousMap: Map<number, number>): boolean {\n    const previous = previousMap.get(align.uuid);\n    const current = align.maxLength;\n    previousMap.set(align.uuid, current);\n    return previous === undefined || previous !== current;\n  }\n\n  /**\n   * Determines which rows and columns need to be updated based on events.\n   * @param events The events to process\n   * @returns A tuple containing the changed row alignments, column alignments, and affected grid models\n   */\n  protected changesForEvents(events: TSU.Events.TEvent[]): [any, any, GridModel[]] {\n    // Step 1 - topologically sort RowAligns of changed cells\n    // Step 2 - topologically sort ColAligns of changed cells\n    // Step 3 -\n    const cellVisited = {} as any;\n    const changedRowAligns = {} as any;\n    const changedColAligns = {} as any;\n    const affectedGridModelsSet = new Set<GridModel>();\n    // Going in reverse means we only get the latest event affecting a cell\n    // instead of going through every change.\n    // Later on we can revisit this if the events are edge triggered instead\n    // of level triggered\n    for (let i = events.length - 1; i >= 0; i--) {\n      const event = events[i];\n      const loc = event.payload.loc;\n      if (cellVisited[loc]) continue;\n      cellVisited[loc] = true;\n      const [row, col] = loc.split(\":\").map((x: string) => parseInt(x));\n      const gridModel = event.source as GridModel;\n      affectedGridModelsSet.add(gridModel);\n      const cell = gridModel.getRow(row).cellAt(col);\n      if (cell) {\n        // TODO - For now we are marking both row and col as having\n        // changed for a cell.  We can optimize this to only row or\n        // col based on whether height or width has changed.\n        if (!(cell.rowAlign.uuid in changedRowAligns)) {\n          changedRowAligns[cell.rowAlign.uuid] = {\n            align: cell.rowAlign,\n            cells: [],\n          };\n        }\n        changedRowAligns[cell.rowAlign.uuid][\"cells\"].push(cell);\n\n        if (!(cell.colAlign.uuid in changedColAligns)) {\n          changedColAligns[cell.colAlign.uuid] = {\n            align: cell.colAlign,\n            cells: [],\n          };\n        }\n        changedColAligns[cell.colAlign.uuid][\"cells\"].push(cell);\n      }\n    }\n    return [changedRowAligns, changedColAligns, Array.from(affectedGridModelsSet)];\n  }\n\n  /**\n   * Ensures that a cell view getter function is available for an alignment.\n   * @param align The alignment to check\n   * @returns The cell view getter function\n   */\n  protected ensureGetCellView(align: AlignedLine) {\n    if (!align.getCellView) {\n      if (!this.getCellView) {\n        return null;\n      }\n      align.getCellView = this.getCellView;\n    }\n    return align.getCellView;\n  }\n\n  /**\n   * Performs a breadth-first layout of aligned lines.\n   * @param startingLines The lines to start from\n   * @param changedAligns Map of alignment IDs to changed alignments\n   * @param previousLengths Map to track previous lengths for change detection\n   * @returns true if any dimension (width/height) actually changed\n   */\n  protected doBfsLayout<T extends AlignedLine>(\n    startingLines: T[],\n    changedAligns: any,\n    previousLengths?: Map<number, number>,\n  ): boolean {\n    // 1. start from the starting lines and do a BF traversal\n    // 2. If a line not visited (ie laid out):\n    //      if it is in the changedAlign list then reval its length (w/h)\n    //      set its offset and length if either width or offset has changed\n    //      offset can be thought of changed if the preceding line's offset has changed\n    // first do above for rows\n    if (!this.getCellView) return false;\n    let anyDimensionChanged = false;\n\n    for (const alignId in changedAligns) {\n      const val = changedAligns[alignId];\n      this.ensureGetCellView(val.align);\n      val.align.evalMaxLength(val.cells);\n\n      // Check if this alignment's length actually changed (O(1))\n      if (previousLengths && this.checkAndUpdateLength(val.align, previousLengths)) {\n        anyDimensionChanged = true;\n      }\n    }\n\n    let lineQueue = [] as [null | T, T][];\n    const visitedLines = {} as any;\n    for (const line of startingLines) lineQueue.push([null, line]);\n    const lineOffsetChanged = {} as any;\n    while (lineQueue.length > 0) {\n      const nextQueue = [] as [null | T, T][];\n      for (let i = 0; i < lineQueue.length; i++) {\n        const [prevLineAlign, lineAlign] = lineQueue[i];\n        visitedLines[lineAlign.uuid] = true;\n        let newOffset = lineAlign.coordOffset;\n        let lineChanged = lineAlign.uuid in changedAligns;\n        if (prevLineAlign) {\n          if (lineOffsetChanged[prevLineAlign.uuid]) {\n            newOffset = prevLineAlign.coordOffset + prevLineAlign.maxLength;\n            lineChanged = true;\n          }\n        }\n        if (lineChanged) {\n          this.ensureGetCellView(lineAlign);\n          lineAlign.setOffset(newOffset);\n          lineOffsetChanged[lineAlign.uuid] = true;\n        }\n\n        // Add next neighbors now\n        for (const next of lineAlign.nextLines) {\n          if (!visitedLines[next.uuid]) {\n            nextQueue.push([lineAlign, next]);\n          }\n        }\n      }\n      lineQueue = nextQueue;\n    }\n\n    return anyDimensionChanged;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { AtomType, Marker, Group, Line, Atom, Space, Role } from \"./\";\nimport { CycleIterator, CyclePosition } from \"./cycle\";\nimport { WindowIterator } from \"./iterators\";\nimport { LayoutParams } from \"./layouts\";\nimport { GridModel, GridRow, GridCell, ColAlign, GridLayoutGroup } from \"./grids\";\nimport { Block, BlockItem, isLine, isBlock } from \"./notation\";\n\ntype Fraction = TSU.Num.Fraction;\nconst ZERO = TSU.Num.Fraction.ZERO;\nconst ONE = TSU.Num.Fraction.ONE;\n\n/**\n * Represents a single beat in the notation.\n * A beat contains one or more atoms and has a specific position in a bar.\n */\nexport class Beat {\n  private static idCounter = 0;\n  readonly uuid = Beat.idCounter++;\n  // Should this be as flat Atoms or should we keep it as atoms and breakdown later?\n\n  /** The atom contained in this beat */\n  atom: Atom;\n  protected atomIsPlaceholder = false;\n\n  /**\n   * Creates a new Beat.\n   * @param index The index of this beat in the sequence\n   * @param role The role this beat belongs to\n   * @param offset The time offset of this beat from the start\n   * @param duration The duration of this beat\n   * @param barIndex The index of the bar containing this beat\n   * @param beatIndex The index of this beat within its bar\n   * @param instance The instance number of this beat\n   * @param prevBeat The previous beat in the sequence, if any\n   * @param nextBeat The next beat in the sequence, if any\n   */\n  constructor(\n    public readonly index: number,\n    public readonly role: Role,\n    public readonly offset: Fraction,\n    public readonly duration: Fraction,\n    public readonly barIndex: number,\n    public readonly beatIndex: number,\n    public readonly instance: number,\n    public readonly prevBeat: null | Beat,\n    public nextBeat: null | Beat,\n  ) {}\n\n  /**\n   * Returns a debug-friendly representation of this Beat.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return {\n      index: this.index,\n      role: this.role.name,\n      offset: this.offset.toString(),\n      duration: this.duration.toString(),\n      barIndex: this.barIndex,\n      beatIndex: this.beatIndex,\n      instance: this.instance,\n      atom: this.atom.debugValue(),\n    };\n  }\n\n  /**\n   * Gets the end offset of this beat (offset + duration).\n   */\n  get endOffset(): Fraction {\n    return this.offset.plus(this.duration);\n  }\n\n  /**\n   * Checks if this beat is filled completely (no remaining space).\n   */\n  get filled(): boolean {\n    return this.remaining.isZero;\n  }\n\n  /**\n   * Gets the remaining duration available in this beat.\n   */\n  get remaining(): Fraction {\n    return this.atom ? this.duration.minus(this.atom.duration, true) : this.duration;\n  }\n\n  /**\n   * Adds an atom to this beat.\n   * @param atom The atom to add\n   * @returns True if the atom was added successfully, false if there's not enough space\n   */\n  add(atom: Atom): boolean {\n    if (this.remaining.cmp(atom.duration) < 0) {\n      return false;\n    }\n    if (!this.atom) {\n      this.atom = atom;\n    } else {\n      if (!this.atomIsPlaceholder) {\n        this.atomIsPlaceholder = true;\n        this.atom = new Group(this.atom).setDuration(ONE, true);\n      }\n      (this.atom as Group).addAtoms(true, atom);\n    }\n    return true;\n  }\n\n  /**\n   * Gets all markers that should be displayed before this beat.\n   * @returns An array of Marker objects\n   */\n  get preMarkers(): Marker[] {\n    const out = [] as Marker[];\n    let curr: Atom | null = this.atom;\n    while (curr != null) {\n      for (const marker of curr.markersBefore || []) {\n        out.push(marker);\n      }\n      if (curr.TYPE == AtomType.GROUP) {\n        curr = (curr as Group).atoms.first;\n      } else {\n        curr = null;\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all markers that should be displayed after this beat.\n   * @returns An array of Marker objects\n   */\n  get postMarkers(): Marker[] {\n    const out = [] as Marker[];\n    let curr: Atom | null = this.atom;\n    while (curr != null) {\n      out.splice(0, 0, ...(curr.markersAfter || []));\n      if (curr.TYPE == AtomType.GROUP) {\n        curr = (curr as Group).atoms.last;\n      } else {\n        curr = null;\n      }\n    }\n    return out;\n  }\n}\n\n/**\n * Builds a sequence of beats from atoms according to layout parameters.\n * Used to convert a flat sequence of atoms into structured beats for display.\n */\nexport class BeatsBuilder {\n  /** All atoms divided into beats */\n  readonly beats: Beat[] = [];\n  readonly startIndex: number;\n  readonly beatOffset: Fraction;\n  cycleIter: CycleIterator;\n  windowIter: WindowIterator;\n\n  /** Callback for when an atom is added to this role */\n  onAtomAdded: (atom: Atom, beat: Beat) => void;\n\n  /** Callback for when a new beat is added */\n  onBeatAdded: (beat: Beat) => void;\n\n  /** Callback for when a beat has been filled */\n  onBeatFilled: (beat: Beat) => void;\n\n  /**\n   * Creates a new BeatsBuilder.\n   * @param role The role containing the atoms\n   * @param layoutParams Layout parameters for structuring beats\n   * @param startOffset The starting offset for the first beat, defaults to ZERO\n   * @param atoms Initial atoms to add to the beats\n   */\n  constructor(\n    public readonly role: Role,\n    public readonly layoutParams: LayoutParams,\n    public readonly startOffset: Fraction = ZERO,\n    ...atoms: Atom[]\n  ) {\n    const [, [bar, beat, instance], beatOffset, index] = layoutParams.cycle.getPosition(startOffset);\n    this.cycleIter = layoutParams.cycle.iterateBeats(bar, beat, instance);\n    this.windowIter = new WindowIterator();\n    this.beatOffset = beatOffset;\n\n    // evaluate the start beatindex - typically it would be 0 if things start\n    // at beginning of a cycle.  But if the start offset is < 0 then the\n    // startIndex should also shift accordingly\n    this.startIndex = index;\n    this.addAtoms(...atoms);\n  }\n\n  /**\n   * Adds atoms to be processed into beats.\n   * @param atoms The atoms to add\n   */\n  addAtoms(...atoms: Atom[]): void {\n    // First add all atoms to the atom Iterator so we can\n    // fetch them as FlatAtoms.  This is needed because atoms\n    // passed here could be unflatted (via groups) or much larger\n    // than what can fit in the given role/bar etc.  So this\n    // flattening and windowing is needed before we add them\n    // to the views - and this is done by the durationIterators.\n    this.windowIter.push(...atoms);\n    while (this.windowIter.hasMore) {\n      // get the last/current row and add a new one if it is full\n      let currBeat = this.beats[this.beats.length - 1];\n\n      // First add a row if last row is filled\n      if (this.beats.length == 0 || currBeat.filled) {\n        // what should be the beatlengths be here?\n        currBeat = this.addBeat();\n      }\n\n      // For this beat get symbols in all roles\n      const [remAtoms, filled] = this.windowIter.get(currBeat.remaining);\n      TSU.assert(remAtoms.length > 0, \"Atleast one element should have been available here\");\n      // render the atoms now\n      for (const atom of remAtoms) {\n        // console.log(\"Adding FA: \", flatAtom.debugValue(), flatAtom.atom);\n        TSU.assert(currBeat.add(atom), \"Should return true as we are already using a duration iterator here\");\n        if (this.onAtomAdded) this.onAtomAdded(atom, currBeat);\n      }\n      if (currBeat.filled) {\n        if (this.onBeatFilled) this.onBeatFilled(currBeat);\n      }\n    }\n  }\n\n  /**\n   * Adds a new beat to the sequence.\n   * @returns The newly created beat\n   */\n  protected addBeat(): Beat {\n    const numBeats = this.beats.length;\n    const lastBeat = numBeats == 0 ? null : this.beats[numBeats - 1];\n    const nextCP: [CyclePosition, Fraction] = this.cycleIter.next().value;\n    const apb = this.layoutParams.beatDuration;\n    const newBeat = new Beat(\n      lastBeat == null ? this.startIndex : lastBeat.index + 1,\n      this.role,\n      lastBeat == null ? this.startOffset.minus(this.beatOffset).timesNum(apb, true) : lastBeat.endOffset,\n      nextCP[1].timesNum(apb),\n      nextCP[0][0],\n      nextCP[0][1],\n      nextCP[0][2],\n      lastBeat,\n      null,\n    );\n    if (lastBeat == null && this.beatOffset.isGT(ZERO)) {\n      // Add spaces to fill up empty beats\n      newBeat.add(new Space(this.beatOffset.timesNum(apb)));\n    }\n    if (lastBeat) lastBeat.nextBeat = newBeat;\n    this.beats.push(newBeat);\n    if (this.onBeatAdded) this.onBeatAdded(newBeat);\n    return newBeat;\n  }\n}\n\n/**\n * Represents a column of beats in a layout grid.\n * Used for aligning beats vertically in the notation.\n */\nexport class BeatColumn extends ColAlign {\n  /** Spacing between atoms in this column */\n  atomSpacing = 5;\n  /** Unique key for this column */\n  readonly key: string;\n\n  /**\n   * Creates a new BeatColumn.\n   * @param offset The starting offset of this column\n   * @param endOffset The ending offset of this column\n   * @param markerType The type of marker for this column (negative: before, positive: after, zero: normal)\n   */\n  constructor(\n    public readonly offset: Fraction,\n    public readonly endOffset: Fraction,\n    public readonly markerType: number,\n  ) {\n    super();\n    offset = offset.factorized;\n    endOffset = endOffset.factorized;\n    this.key = BeatColumn.keyFor(offset, endOffset, markerType);\n  }\n\n  /**\n   * Generates a key for identifying columns with the same offsets and marker type.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker (negative: before, positive: after, zero: normal)\n   * @returns A string key\n   */\n  static keyFor(offset: Fraction, endOffset: Fraction, markerType = 0): string {\n    offset = offset.factorized;\n    endOffset = endOffset.factorized;\n    if (markerType < 0) {\n      // return the column for the marker \"before\" this col\n      // int his case only the \"start offset\" is needed and length doesnt matter\n      return \":\" + offset.toString();\n    } else if (markerType > 0) {\n      // return the column for the marker \"after\" this col\n      // in this case only thd end offset matters\n      return endOffset.toString() + \":\";\n    } else {\n      return offset.toString() + \":\" + endOffset.toString();\n    }\n  }\n}\n\n/**\n * Manages the organization of beats into columns based on their offsets.\n * Used to create a directed acyclic graph (DAG) of beat columns for layout purposes.\n *\n * Grouping of beats by their column based on the layout params.\n * The confusion is we have beats broken up and saved in columns\n * but we are loosing how a line is supposed to access it in its own way\n * we have beatsByRole for getting all beats for a role (in a line)\n * sequentially we have beatColumns for getting all beats in a particular\n * column across all lines and roles globally.\n *\n * What we want here is for a given line get all roles, their beats\n * in zipped way.  eg for a Line with 3 roles and say 10 beats each\n * (with the breaks of 4, 1) we need:\n *\n * R1 B1 R1 B2 R1 B3 R1 B4\n * R2 B1 R2 B2 R2 B3 R2 B4\n * R3 B1 R3 B2 R3 B3 R3 B4\n *\n * R1 B5\n * R2 B5\n * R3 B5\n *\n * R1 B6 R1 B7 R1 B8 R1 B9\n * R2 B6 R2 B7 R2 B8 R2 B9\n * R3 B6 R3 B7 R3 B8 R3 B9\n *\n * R1 B10\n * R2 B10\n * R3 B10\n *\n *\n * Here we have 5 distinct beat columns:\n *\n * 1: R1B1, R2B1, R3B1, R1B6, R2B6, R3B6,\n * 2: R1B2, R2B2, R3B2, R1B7, R2B7, R3B7,\n * 3: R1B3, R2B3, R3B3, R1B8, R2B8, R3B8,\n * 4: R1B4, R2B4, R3B4, R1B9, R2B9, R3B9,\n * 5: R1B5, R2B5, R3B5, R1B10, R2B10, R3B10,\n *\n */\nexport class BeatColDAG {\n  /** Map of column keys to BeatColumn objects */\n  beatColumns = new Map<string, BeatColumn>();\n\n  /**\n   * Creates a new BeatColDAG.\n   * @param layoutGroup The layout group to associate with this DAG\n   */\n  constructor(public readonly layoutGroup: GridLayoutGroup) {\n    //\n  }\n\n  /**\n   * Gets the beat column for a given duration at the specified offset.\n   * Creates a new column if none exists.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker\n   * @returns The BeatColumn for the specified parameters\n   */\n  getBeatColumn(offset: Fraction, endOffset: Fraction, markerType = 0): BeatColumn {\n    const [bcol, newcreated] = this.ensureBeatColumn(offset, endOffset, markerType);\n    if (newcreated) {\n      if (markerType == 0) {\n        const [prevcol] = this.ensureBeatColumn(offset, endOffset, -1);\n        const [nextcol] = this.ensureBeatColumn(offset, endOffset, 1);\n        prevcol.addSuccessor(bcol);\n        bcol.addSuccessor(nextcol);\n        for (const other of this.beatColumns.values()) {\n          // only join the \"marker\" columns\n          if (other.markerType == -1 && endOffset.equals(other.offset)) {\n            // our next col is a preecessor of other\n            nextcol.addSuccessor(other);\n          } else if (other.markerType == 1 && other.endOffset.equals(offset)) {\n            // our prev col is a predecessor of other\n            other.addSuccessor(prevcol);\n          }\n        }\n      }\n    }\n    return bcol;\n  }\n\n  /**\n   * Ensures a beat column exists for the given parameters.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker\n   * @returns A tuple containing the column and whether it was newly created\n   */\n  protected ensureBeatColumn(offset: Fraction, endOffset: Fraction, markerType = 0): [BeatColumn, boolean] {\n    const key = BeatColumn.keyFor(offset, endOffset, markerType);\n    let bcol = this.beatColumns.get(key) || null;\n    const newcreated = bcol == null;\n    if (!bcol) {\n      bcol = new BeatColumn(offset, endOffset, markerType);\n      this.beatColumns.set(key, bcol);\n    }\n    return [bcol, newcreated];\n  }\n}\n\n/** Type alias for line IDs */\ntype LineId = number;\n/** Type alias for layout parameter IDs */\ntype LPID = number;\n\n/**\n * Manages the beat layouts for all lines in a notation.\n * Handles the creation of grid models, positioning of beats, and alignment of beats across lines.\n */\nexport class GlobalBeatLayout {\n  /** Map of line IDs to grid models */\n  gridModelsForLine = new Map<LineId, GridModel>();\n  /** Map of line IDs to arrays of beats for each role */\n  roleBeatsForLine = new Map<LineId, Beat[][]>();\n  /** Map of layout parameter IDs to beat column DAGs */\n  beatColDAGsByLP = new Map<LPID, BeatColDAG>();\n  /** The global layout group for all grid models */\n  readonly gridLayoutGroup: GridLayoutGroup;\n\n  /**\n   * Creates a new GlobalBeatLayout.\n   * @param sharedGridLayoutGroup Optional shared GridLayoutGroup for column alignment across multiple views.\n   *                               If not provided, a new GridLayoutGroup is created internally.\n   */\n  constructor(sharedGridLayoutGroup?: GridLayoutGroup) {\n    this.gridLayoutGroup = sharedGridLayoutGroup ?? new GridLayoutGroup();\n  }\n\n  /**\n   * Gets the GridModel associated with a particular line, creating one if it doesn't exist.\n   * @param lineid The ID of the line\n   * @returns The GridModel for the line\n   */\n  getGridModelForLine(lineid: LineId): GridModel {\n    let out = this.gridModelsForLine.get(lineid) || null;\n    if (!out) {\n      out = new GridModel();\n      this.gridLayoutGroup.addGridModel(out);\n      this.gridModelsForLine.set(lineid, out);\n    }\n    return out;\n  }\n\n  /**\n   * Gets the BeatColDAG for a specific layout parameter ID, creating one if it doesn't exist.\n   * @param lpid The layout parameter ID\n   * @returns The BeatColDAG for the layout parameters\n   */\n  protected beatColDAGForLP(lpid: LPID): BeatColDAG {\n    let out = this.beatColDAGsByLP.get(lpid) || null;\n    if (!out) {\n      out = new BeatColDAG(this.gridLayoutGroup);\n      this.beatColDAGsByLP.set(lpid, out);\n    }\n    return out;\n  }\n\n  /**\n   * Adds a line to the beat layout.\n   * This ensures that a line is broken down into beats and added into a dedicated GridModel.\n   *\n   * A line must also be given the layout params by which the beat breakdown will happen.\n   * This LayoutParams object does not have to be unique per line (this non-constraint allows\n   * beats to be aligned across lines).\n   *\n   * @param line The line to add\n   */\n  addLine(line: Line): void {\n    const gridModel = this.getGridModelForLine(line.uuid) as GridModel;\n    gridModel.eventHub?.startBatchMode();\n    this.lineToRoleBeats(line, gridModel);\n    gridModel.eventHub?.commitBatch();\n  }\n\n  /**\n   * Recursively processes a block and its children to build beat layouts.\n   * Uses block.children() to get expanded children (e.g., RepeatBlock expands to N copies).\n   *\n   * @param block The block to process\n   */\n  processBlock(block: Block): void {\n    for (const child of block.children()) {\n      this.processBlockItem(child);\n    }\n  }\n\n  /**\n   * Processes a single block item (Block, Line, or RawBlock).\n   *\n   * @param item The item to process\n   */\n  protected processBlockItem(item: BlockItem): void {\n    if (isLine(item)) {\n      const line = item as Line;\n      if (!line.isEmpty && line.layoutParams != null) {\n        this.addLine(line);\n      }\n    } else if (isBlock(item)) {\n      this.processBlock(item as Block);\n    }\n    // RawBlocks are ignored (no beat layout for raw content)\n  }\n\n  /**\n   * Converts a line into a series of beats for each role.\n   * @param line The line to convert\n   * @param gridModel The grid model to use\n   * @returns Arrays of beats for each role\n   */\n  protected lineToRoleBeats(line: Line, gridModel: GridModel): Beat[][] {\n    const lp = line.layoutParams;\n    const roleBeats = [] as Beat[][];\n    this.roleBeatsForLine.set(line.uuid, roleBeats);\n    const lineOffset = line.offset.divbyNum(lp.beatDuration);\n    for (const role of line.roles) {\n      const bb = new BeatsBuilder(role, lp, lineOffset, ...role.atoms);\n      roleBeats.push(bb.beats);\n\n      // Add these to the beat layout too\n      for (const beat of bb.beats) {\n        // beat.ensureUniformSpaces(layoutParams.beatDuration);\n        this.addBeat(beat, gridModel);\n      }\n    }\n    return roleBeats;\n  }\n\n  /**\n   * Adds a beat to the layout.\n   * @param beat The beat to add\n   * @param gridModel The grid model to add the beat to\n   * @returns The grid cell containing the beat\n   */\n  protected addBeat(beat: Beat, gridModel: GridModel): GridCell {\n    // Get the beat column at this index (and line) and add to it.\n    const line = beat.role.line;\n    const lp = line.layoutParams;\n    const beatColDAG = this.beatColDAGForLP(lp.uuid);\n    const [layoutLine, layoutColumn, rowOffset] = lp.getBeatLocation(beat);\n    const colEnd = rowOffset.plus(beat.duration, true);\n    const bcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 0);\n\n    // Since a beat's column has a \"pre\" and \"post\" col to, each\n    // beat has 3 columns for it\n    const roleIndex = beat.role.line.indexOfRole(beat.role.name);\n    const nthLine = Math.floor(beat.index / lp.totalBeats);\n    const realLine = lp.lineBreaks.length * nthLine + layoutLine;\n    const realRow = line.roles.length * realLine + roleIndex;\n    // pre marker goes on realCol - 1, post marker goes on realCol + 1\n    const realCol = 1 + layoutColumn * 3;\n    const preMarkers = beat.preMarkers;\n    if (preMarkers.length > 0) {\n      const val = {\n        beat: beat,\n        markers: preMarkers,\n      };\n      const precol = beatColDAG.getBeatColumn(rowOffset, colEnd, -1);\n      gridModel.setValue(realRow, realCol - 1, val, (gridRow: GridRow, col: number) => {\n        const cell = new GridCell(gridRow, col);\n        cell.colAlign = precol;\n        return cell;\n      });\n    }\n    const postMarkers = beat.postMarkers;\n    if (postMarkers.length > 0) {\n      const val = {\n        beat: beat,\n        markers: postMarkers,\n      };\n      const postcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 1);\n      gridModel.setValue(realRow, realCol + 1, val, (gridRow: GridRow, col: number) => {\n        const cell = new GridCell(gridRow, col);\n        cell.colAlign = postcol;\n        return cell;\n      });\n    }\n    return gridModel.setValue(realRow, realCol, beat, (gridRow: GridRow, col: number) => {\n      const cell = new GridCell(gridRow, col);\n      cell.colAlign = bcol;\n      return cell;\n    });\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n\ntype EdgeData = any;\ntype EdgeFunctor<T> = (node: T) => ReadonlyArray<[T, EdgeData]>;\ntype IDFunc<T> = (t: T) => number | string;\n\nexport function allMinimalCycles<T>(\n  nodes: ReadonlyArray<T>,\n  idFunc: IDFunc<T>,\n  edges: EdgeFunctor<T>,\n): ReadonlyArray<[T, EdgeData]> {\n  // Tells which cycle a node is assigned to if any\n  const cycles: [T, EdgeData][] = [];\n  const inACycle = {} as any;\n  nodes.forEach((node) => {\n    // start from node and do a BFS to see what cycle a node appears in\n    if (!(idFunc(node) in inACycle)) {\n      const startNode = node;\n      const visited = {} as any;\n      let queue: [T, [EdgeData, T][]][] = [[node, []]];\n      while (queue.length > 0) {\n        const newQueue: [T, [EdgeData, T][]][] = [];\n        for (let i = 0; i < queue.length; i++) {\n          const [node, c] = queue[i];\n          TSU.assert(node != null);\n          const e = edges(node);\n          let cycle = [...c];\n          for (const [nextNode, edgeData] of e) {\n            if (nextNode == startNode) {\n              // we have a cycle\n              cycle.push([edgeData, nextNode]);\n              cycle.forEach(([e, n], i) => (inACycle[n] = true));\n              cycles.push([startNode, cycle]);\n              cycle = cycle.slice(0, cycle.length - 1);\n            } else if (!(idFunc(nextNode) in visited)) {\n              visited[idFunc(nextNode)] = true;\n              newQueue.push([nextNode, [...cycle, [edgeData, nextNode]]]);\n            }\n          }\n        }\n        queue = newQueue;\n      }\n    }\n  });\n  return cycles;\n}\n\nexport function digraph(): void {\n  //\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Grammar, Sym, Str, Rule } from \"./grammar\";\n\ntype NumMap<T> = TSU.NumMap<T>;\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\nconst defaultKeyFunc = (x: any) => x.key;\n\nexport class Trie<T> {\n  protected keyFunc: (t: T) => string;\n  readonly root: TrieNode<T> = new TrieNode();\n\n  constructor(keyFunc: (t: T) => string) {\n    this.keyFunc = keyFunc;\n  }\n\n  add(values: T[], fromIndex = 0): TrieNode<T> {\n    // we are at the bottom\n    let curr = this.root;\n    for (let i = fromIndex; i < values.length; i++) {\n      const key = this.keyFunc(values[i]);\n      if (curr.children.has(key)) {\n        curr = curr.children.get(key)!;\n      } else {\n        const newNode = new TrieNode<T>();\n        newNode.value = values[i];\n        newNode.parent = curr;\n        curr.children.set(key, newNode);\n        curr = newNode;\n      }\n    }\n    curr.isLeaf = true;\n    return curr;\n  }\n\n  get debugValue(): any {\n    return this.root.debugValue;\n  }\n}\n\nexport class TrieNode<T> {\n  isLeaf = false;\n  value: Nullable<T> = null;\n  parent: Nullable<TrieNode<T>> = null;\n  children = new Map<string, TrieNode<T>>();\n\n  get debugValue(): any {\n    const out = { value: this.value, children: {} as any } as any;\n    if (this.isLeaf) out[\"isLeaf\"] = true;\n    for (const [key, value] of this.children.entries()) {\n      out.children[key] = value.debugValue;\n    }\n    return out;\n  }\n}\n\nexport class IDSet<T extends { id: number }> {\n  protected _entries: T[] = [];\n  protected _entriesByKey: StringMap<T> = {};\n  protected keyFunc: (t: T) => string;\n\n  constructor(keyFunc: (t: T) => string = defaultKeyFunc) {\n    this.keyFunc = keyFunc;\n  }\n\n  clear(): void {\n    this._entries = [];\n    this._entriesByKey = {};\n  }\n\n  /**\n   * Removes all entries that match a predict.\n   */\n  remove(predicate: (t: T) => boolean): boolean {\n    const e2: T[] = [];\n    this._entriesByKey = {};\n    let modified = false;\n    for (let l = 0; l < this._entries.length; l++) {\n      const e = this._entries[l];\n      if (!predicate(e)) {\n        // keep it if predicate failes\n        e.id = e2.length;\n        e2.push(e);\n        this._entriesByKey[this.keyFunc(e)] = e;\n      } else {\n        modified = true;\n      }\n    }\n    this._entries = e2;\n    return modified;\n  }\n\n  get entries(): ReadonlyArray<T> {\n    return this._entries;\n  }\n\n  get(id: number): T {\n    TSU.assert(id >= 0 && id < this._entries.length);\n    return this._entries[id];\n  }\n\n  getByKey(key: string): Nullable<T> {\n    return this._entriesByKey[key] || null;\n  }\n\n  ensure(entry: T, throwIfExists = false): T {\n    // see if this itemset exists\n    if (this.has(entry)) {\n      if (throwIfExists) throw new Error(`Entry ${this.keyFunc(entry)} already exists`);\n      return this._entriesByKey[this.keyFunc(entry)];\n    } else {\n      this._entriesByKey[this.keyFunc(entry)] = entry;\n      entry.id = this._entries.length;\n      this._entries.push(entry);\n      return entry;\n    }\n  }\n\n  has(entry: T): boolean {\n    return this.keyFunc(entry) in this._entriesByKey;\n  }\n\n  get size(): number {\n    return this._entries.length;\n  }\n}\n\nexport class SymbolSet {\n  readonly grammar: Grammar;\n  readonly enforceSymbolType: Nullable<boolean>;\n  entries = new Set<number>();\n  hasNull = false;\n\n  constructor(grammar: Grammar, enforceSymbolType: Nullable<boolean> = true) {\n    this.grammar = grammar;\n    this.enforceSymbolType = enforceSymbolType;\n  }\n\n  get debugString(): string {\n    return \"<\" + this.labels().sort().join(\", \") + \">\";\n  }\n\n  labels(skipAux = false): string[] {\n    const out: string[] = [];\n    for (const i of this.entries) {\n      const exp = this.grammar.getSymById(i);\n      TSU.assert(exp != null);\n      if (!skipAux || !exp.isAuxiliary) out.push(exp.label);\n    }\n    if (this.hasNull) out.push(\"\");\n    return out;\n  }\n\n  addFrom(another: SymbolSet, includeNull = true): number {\n    return another.addTo(this, includeNull);\n  }\n\n  addTo(another: SymbolSet, includeNull = true): number {\n    const before = another.entries.size;\n    for (const termid of this.entries) {\n      another.entries.add(termid);\n    }\n    if (includeNull) {\n      another.hasNull = this.hasNull || another.hasNull;\n    }\n    return another.entries.size - before;\n  }\n\n  has(term: Sym): boolean {\n    return this.entries.has(term.id);\n  }\n\n  add(term: Sym): this {\n    TSU.assert(\n      this.enforceSymbolType == null || this.enforceSymbolType == term.isTerminal,\n      `Terminal types being enforced: ${this.enforceSymbolType}`,\n    );\n    this.entries.add(term.id);\n    return this;\n  }\n\n  delete(term: Sym): boolean {\n    return this.entries.delete(term.id);\n  }\n\n  get size(): number {\n    return this.entries.size + (this.hasNull ? 1 : 0);\n  }\n}\n\n/**\n * Tells which non terminals are nullables.\n */\nexport class NullableSet {\n  readonly grammar: Grammar;\n  entries: Set<number>;\n  private visited: any;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n    this.refresh();\n  }\n\n  get nonterms(): Sym[] {\n    const out: Sym[] = [];\n    this.entries.forEach((id) => {\n      const e = this.grammar.getSymById(id);\n      TSU.assert(e != null && !e.isTerminal);\n      out.push(e);\n    });\n    return out;\n  }\n\n  refresh(): void {\n    // Nuke entries cache.  Will force isNullable to recompute.\n    this.entries = new Set();\n    this.visited = {};\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.entries.size;\n      this.grammar.allNonTerminals.forEach((nt) => this.visit(nt));\n    } while (beforeCount != this.entries.size);\n  }\n\n  protected visit(nt: Sym): void {\n    for (const rule of this.grammar.rulesForNT(nt)) {\n      if (this.isStrNullable(rule.rhs)) {\n        this.add(nt);\n        break;\n      }\n    }\n  }\n\n  isNullable(nt: Sym): boolean {\n    return !nt.isTerminal && this.entries.has(nt.id);\n  }\n\n  isStrNullable(str: Str, fromIndex = 0, toIndex: Nullable<number> = null): boolean {\n    if (toIndex == null) {\n      toIndex = str.length - 1;\n    }\n    for (let i = fromIndex; i <= toIndex; i++) {\n      if (!this.isNullable(str.syms[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  add(nt: Sym): void {\n    TSU.assert(!nt.isTerminal);\n    this.entries.add(nt.id);\n  }\n}\n\nclass SymSymbolSets {\n  readonly grammar: Grammar;\n  entries: NumMap<SymbolSet> = {};\n  private _count = 0;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n  }\n\n  refresh(): void {\n    this.entries = {};\n    this._count = 0;\n  }\n\n  forEachTerm(nt: Sym, visitor: (x: Nullable<Sym>) => boolean | void): void {\n    const entries = this.entriesFor(nt);\n    entries.entries.forEach((x) => {\n      const term = this.grammar.getSymById(x);\n      TSU.assert(term != null && term.isTerminal);\n      visitor(term);\n    });\n    if (entries.hasNull) visitor(null);\n  }\n\n  get debugValue(): any {\n    const out = {} as any;\n    for (const x in this.entries) out[this.grammar.getSymById(x as any)!.label] = this.entries[x].debugString;\n    return out;\n  }\n\n  get count(): number {\n    let c = 0;\n    for (const x in this.entries) c += this.entries[x].size;\n    return c;\n    // TSU.assert(c == this._count, \"Count mismatch\")\n    // return this._count;\n  }\n\n  entriesFor(sym: Sym): SymbolSet {\n    if (sym.id in this.entries) {\n      return this.entries[sym.id];\n    } else {\n      const out = new SymbolSet(this.grammar);\n      this.entries[sym.id] = out;\n      return out;\n    }\n  }\n\n  /**\n   * Add the null symbol into this set of terminals for a given expression.\n   */\n  addNull(nt: Sym): boolean {\n    const entries = this.entriesFor(nt);\n    if (entries.hasNull) return false;\n    entries.hasNull = true;\n    return true;\n  }\n\n  /**\n   * Add a Null, term or another expression to the set of terminals\n   * for a given expression.  If source is an expression then all\n   * of the source expression's terminal symbosl are added to exp's\n   * term set.\n   */\n  add(nt: Sym, source: Sym, includeNull = true): boolean {\n    if (nt.isTerminal) {\n      TSU.assert(false, \"Should not be here\");\n    }\n    const entries = this.entriesFor(nt);\n    if (source.isTerminal) {\n      if (entries.has(source)) return false;\n      // console.log(`Adding Term(${term.label}) to Set of ${exp.id}`);\n      entries.add(source);\n      this._count++;\n    } else {\n      const srcEntries = this.entriesFor(source);\n      const destEntries = this.entriesFor(nt);\n      const count = srcEntries.addTo(destEntries, includeNull);\n      this._count += count;\n    }\n    return true;\n  }\n}\n\n/**\n * For each symbol maps its label to a list of terminals that\n * start that non terminal.\n */\nexport class FirstSets extends SymSymbolSets {\n  readonly nullables: NullableSet;\n\n  constructor(grammar: Grammar, nullables?: NullableSet) {\n    super(grammar);\n    if (!nullables) {\n      nullables = new NullableSet(grammar);\n    }\n    this.nullables = nullables;\n    this.refresh();\n  }\n\n  /**\n   * For a given string return the first(str) starting at a given index.\n   * Including eps if it exists.\n   */\n  forEachTermIn(str: Str, fromIndex = 0, visitor: (term: Nullable<Sym>) => void): void {\n    // This needs to be memoized by exp.id + index\n    const syms = str.syms;\n    const visited = {} as any;\n    let allNullable = true;\n    for (let j = fromIndex; allNullable && j < syms.length; j++) {\n      const symj = syms[j];\n      if (symj.isTerminal) {\n        visitor(symj);\n        allNullable = false;\n      } else {\n        const nt = symj as Sym;\n        this.forEachTerm(nt, (term) => {\n          if (term != null && !(term.id in visited)) {\n            visited[term.id] = true;\n            visitor(term);\n          }\n        });\n        if (!this.nullables.isNullable(symj as Sym)) {\n          allNullable = false;\n        }\n      }\n    }\n    if (allNullable) visitor(null);\n  }\n\n  /**\n   * Reevaluates the first sets of a grammar.\n   * This method assumes that the grammar's nullables are fresh.\n   */\n  refresh(): void {\n    super.refresh();\n    // this.grammar.terminals.forEach((t) => this.add(t, t));\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.count;\n      this.grammar.forEachRule(null, (rule) => {\n        this.processRule(rule);\n      });\n    } while (beforeCount != this.count);\n  }\n\n  processRule(rule: Rule): void {\n    const nullables = this.nullables;\n    let allNullable = true;\n    for (const s of rule.rhs.syms) {\n      // First(s) - null will be in First(nonterm)\n      // Null will onlybe added if all symbols are nullable\n      this.add(rule.nt, s, false);\n      if (s.isTerminal || !nullables.isNullable(s as Sym)) {\n        // since s is not nullable the next rule's first set\n        // cannot affect nonterm's firs set\n        allNullable = false;\n        break;\n      }\n    }\n    if (allNullable) this.addNull(rule.nt);\n  }\n}\n\n/**\n * For each symbol maps its label to a list of terminals that\n * start that non terminal.\n */\nexport class FollowSets extends SymSymbolSets {\n  readonly firstSets: FirstSets;\n\n  constructor(grammar: Grammar, firstSets?: FirstSets) {\n    super(grammar);\n    this.firstSets = firstSets || new FirstSets(grammar);\n    this.refresh();\n  }\n\n  get nullables(): NullableSet {\n    return this.firstSets.nullables;\n  }\n\n  /**\n   * Reevaluates the follow sets of each expression in our grammar.\n   * This method assumes that the grammar's nullables and firstSets are\n   * up-to-date.\n   */\n  refresh(): void {\n    super.refresh();\n    const g = this.grammar;\n    TSU.assert(g.startSymbol != null, \"Select start symbol of the grammar\");\n    this.add(g.startSymbol, g.Eof);\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.count;\n      this.grammar.forEachRule(null, (rule) => this.processRule(rule));\n    } while (beforeCount != this.count);\n  }\n\n  /**\n   * Add Follows[source] into Follows[dest] recursively.\n   */\n  processRule(rule: Rule): void {\n    const syms = rule.rhs.syms;\n    const firstSets = this.firstSets;\n    const nullables = this.firstSets.nullables;\n\n    // Rule 1:\n    //  If A -> aBb1b2b3..bn:\n    //    Follow(B) = Follow(B) U { First(b1b2b3...bn) - eps }\n    for (let i = 0; i < syms.length; i++) {\n      const sym = syms[i];\n      if (sym.isTerminal) continue;\n      firstSets.forEachTermIn(rule.rhs, i + 1, (term) => {\n        if (term != null) this.add(sym, term);\n      });\n    }\n\n    // Rule 2:\n    //  If A -> aBb1b2b3..bn:\n    //    if Nullable(b1b2b3...bn):\n    //      Follow(B) = Follow(B) U Follow(N)\n    for (let i = syms.length - 1; i >= 0; i--) {\n      if (syms[i].isTerminal) continue;\n\n      // This needs to be memoized??\n      let allNullable = true;\n      for (let j = i + 1; j < syms.length; j++) {\n        const symj = syms[j];\n        if (symj.isTerminal || !nullables.isNullable(symj as Sym)) {\n          allNullable = false;\n          break;\n        }\n      }\n      if (allNullable) {\n        this.add(syms[i], rule.nt);\n      }\n    }\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { allMinimalCycles } from \"./graph\";\nimport { IDSet, SymbolSet, FirstSets, FollowSets, NullableSet } from \"./sets\";\n\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\n/**\n * Symbols represent both terminals and non-terminals in our system.\n * Chosing a convention of using a single class to represent both instead\n * of a base class with Term and NonTerm children has the following effects:\n * 1. We can change the type of a literal when doing things like reading\n *    a grammar DSL when we dont konw if a symbol is a term or non-term\n *    until *all* the declarations have been read and parsed.\n * 2. The down side of this we would need more explicit isTerm checks\n *    but we would have done that anyway by calling getTerm and getNT\n *    verions of the getSym method.\n */\nexport class Sym {\n  isAuxiliary = false;\n  auxType: string | null = null;\n  precedence = 1;\n  assocLeft = true;\n\n  private static idCounter = -1;\n\n  /**\n   * An ID assigned to indicate order of \"creation\" of this symbol in the grammar.\n   */\n  creationId = -1;\n\n  /**\n   * ID unique across all expression within the grammar.\n   */\n  id: number;\n\n  /**\n   * Creates a new symbol in the grammar.\n   *\n   * @param   grammar     Grammar this symbol belongs to.\n   * @param   label       Label for the symbol.\n   * @param   isTerminal  Whether the symbol is a terminal or not.\n   * @param   id          ID unique across all expression within the\n   *                      grammar.\n   */\n  constructor(\n    public readonly grammar: Grammar,\n    public readonly label: string,\n    public isTerminal: boolean,\n    id: Nullable<number> = null,\n  ) {\n    this.isTerminal = isTerminal;\n    this.label = label;\n    if (id == null) {\n      this.id = Sym.idCounter--;\n    } else {\n      this.id = id;\n    }\n  }\n\n  compareTo(another: this): number {\n    return this.label.localeCompare(another.label);\n  }\n\n  equals(another: this): boolean {\n    return this.label == another.label;\n  }\n\n  toString(): string {\n    return this.label;\n  }\n}\n\nexport class Str {\n  syms: Sym[];\n\n  constructor(...syms: Sym[]) {\n    this.syms = syms || [];\n  }\n\n  append(...lits: Sym[]): this {\n    for (const l of lits) this.syms.push(l);\n    return this;\n  }\n\n  extend(...strs: Str[]): this {\n    for (const s of strs) this.append(...s.syms);\n    return this;\n  }\n\n  copy(): Str {\n    return new Str(...this.syms);\n  }\n\n  add(lit: Sym): void {\n    this.syms.push(lit);\n  }\n\n  isTerminal(index: number): boolean {\n    return this.syms[index].isTerminal;\n  }\n\n  get length(): number {\n    return this.syms.length;\n  }\n\n  toString(): string {\n    return this.syms.map((s) => s.toString()).join(\" \");\n  }\n\n  slice(startIndex: number, endIndex: number): Str {\n    return new Str(...this.syms.slice(startIndex, endIndex));\n  }\n\n  splice(index: number, numToDelete: number, ...itemsToAdd: Sym[]): Str {\n    this.syms.splice(index, numToDelete, ...itemsToAdd);\n    return this;\n  }\n\n  compareTo(another: this): number {\n    for (let i = 0; i < this.syms.length && i < another.syms.length; i++) {\n      const diff = this.syms[i].compareTo(another.syms[i]);\n      if (diff != 0) return diff;\n    }\n    return this.syms.length - another.syms.length;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  /**\n   * Returns true if another string is a substring within\n   * this string at the given offset.\n   */\n  containsAt(offset: number, another: Str): boolean {\n    let i = 0;\n    for (; i < another.length && offset + i < this.syms.length; i++) {\n      if (!this.syms[offset + i].equals(another.syms[i])) return false;\n      // if (this.cardinalities[i] != another.cardinalities[i]) return false;\n    }\n    return i == another.length;\n  }\n\n  get debugString(): string {\n    return this.syms.map((lit) => lit.label).join(\" \");\n  }\n}\n\nexport class RuleAction {\n  constructor(public value: string | number) {}\n\n  get isFunction(): boolean {\n    return typeof this.value === \"string\";\n  }\n\n  get isChildPosition(): boolean {\n    return typeof this.value === \"number\";\n  }\n}\n\nexport class Rule {\n  id: number;\n  constructor(\n    public nt: Sym,\n    public rhs: Str,\n    public action: RuleAction | null = null,\n  ) {\n    if (nt.isTerminal) {\n      throw new Error(\"Cannot add rules to a terminal\");\n    }\n  }\n\n  get debugString(): string {\n    return `${this.nt.label} -> ${this.rhs.debugString}`;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  compareTo(another: this): number {\n    TSU.assert(!isNaN(this.id));\n    const diff = this.nt.compareTo(another.nt);\n    if (diff == 0) {\n      this.rhs.compareTo(another.rhs);\n    }\n    return diff;\n  }\n}\n\nexport class Grammar {\n  public startSymbol: Nullable<Sym> = null;\n  modified = true;\n  protected symbolSet = new IDSet<Sym>((s) => s.label);\n  protected allRules: Rule[] = [];\n  protected _rulesForNT: Nullable<StringMap<Rule[]>> = null;\n  protected _followSets: Nullable<FollowSets> = null;\n\n  /**\n   * Prefix used for auxiliary symbols.\n   */\n  auxNTPrefix: string;\n\n  readonly Null: Sym;\n  readonly Eof: Sym;\n  private _AugStartRule: Rule;\n  private _hasNull = false;\n\n  /**\n   * A way of creating Grammars with a \"single expresssion\".\n   */\n  static make(callback: (g: Grammar) => void): Grammar {\n    const g = new Grammar();\n    callback(g);\n    return g;\n  }\n\n  constructor(config?: any) {\n    config = config || {};\n    this.auxNTPrefix = config.auxNTPrefix || \"$\";\n    this.Null = this.newTerm(\"\");\n    this.Eof = this.newTerm(\"$end\");\n  }\n\n  rulesForNT(nt: Sym): Rule[] {\n    TSU.assert(!nt.isTerminal);\n    if (this._rulesForNT == null) {\n      this._rulesForNT = {};\n      for (const rule of this.allRules) {\n        if (!(rule.nt.label in this._rulesForNT)) {\n          this._rulesForNT[rule.nt.label] = [];\n        }\n        this._rulesForNT[rule.nt.label].push(rule);\n      }\n    }\n    if (!(nt.label in this._rulesForNT)) {\n      this._rulesForNT[nt.label] = [];\n    }\n    return this._rulesForNT[nt.label];\n  }\n\n  get nullables(): NullableSet {\n    return this.firstSets.nullables;\n  }\n\n  get firstSets(): FirstSets {\n    return this.followSets.firstSets;\n  }\n\n  get followSets(): FollowSets {\n    if (this.modified || this._followSets == null) {\n      this.refresh();\n    }\n    TSU.assert(this._followSets != null);\n    return this._followSets;\n  }\n\n  get augStartRule(): Rule {\n    return this._AugStartRule;\n  }\n\n  augmentStartSymbol(label = \"$accept\"): this {\n    TSU.assert(this._AugStartRule == null, \"Ensure this grammar has not yet been augmented.\");\n    TSU.assert(this.startSymbol != null, \"Start symbol not yet set\");\n    const augSym = this.newNT(label);\n    this._AugStartRule = new Rule(augSym, new Str(this.startSymbol));\n    this.addRule(this._AugStartRule, 0);\n    return this;\n  }\n\n  refresh(): this {\n    this.symbolSet.entries.forEach((s, i) => (s.id = i));\n    this._rulesForNT = null;\n    this.allRules.forEach((rule, i) => {\n      rule.id = i;\n    });\n    this._followSets = new FollowSets(this);\n    this.modified = false;\n    return this;\n  }\n\n  addTerminals(...terminals: string[]): void {\n    for (const t of terminals) {\n      this.newTerm(t);\n    }\n  }\n\n  get terminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => x.isTerminal);\n  }\n\n  get allNonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => !x.isTerminal);\n  }\n\n  get nonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => !x.isTerminal && !x.isAuxiliary);\n  }\n\n  get auxNonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => x.isAuxiliary);\n  }\n\n  get allSymbols(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries;\n  }\n\n  /**\n   * A way to quickly iterate through all non-terminals.\n   */\n  forEachNT(visitor: (nt: Sym) => void | boolean | undefined | null): void {\n    for (const sym of this.symbolSet.entries) {\n      if (sym.isTerminal) continue;\n      if (visitor(sym) == false) return;\n    }\n  }\n\n  /**\n   * A iterator across all the rules for either all non terminals in this grammar\n   * for a single non terminal (if the nt value is non null).\n   *\n   * @param visitor\n   */\n  forEachRule(nt: Nullable<Sym>, visitor: (rule: Rule, index: number) => void | boolean | undefined | null): boolean {\n    const rules = nt == null ? this.allRules : this.rulesForNT(nt) || [];\n    for (let i = 0; i < rules.length; i++) {\n      if (visitor(rules[i], i) == false) return false;\n    }\n    return true;\n  }\n\n  getRule(nt: string | Sym, index: number): Rule {\n    if (typeof nt === \"string\") nt = this.getSym(nt)!;\n    TSU.assert(nt != null);\n    return this.rulesForNT(nt)[index];\n  }\n\n  /**\n   * Return the the index of a rule if it already exists to prevent duplicates.\n   */\n  findRule(nt: Sym, production: Str): number {\n    return this.rulesForNT(nt).findIndex((r) => r.nt == nt && r.rhs.equals(production));\n  }\n\n  /**\n   * Adds a new rule to a particular non terminal of the grammar\n   * Each rule represents a production of the form:\n   *\n   * name -> A B C D;\n   *\n   * Null production can be represented with an empty exps list.\n   */\n  add(nt: string | Sym, production: Str, action: RuleAction | null = null): Rule {\n    let nonterm: Nullable<Sym> = null;\n    if (typeof nt === \"string\") {\n      nonterm = this.getSym(nt);\n      if (nonterm == null) {\n        // create it\n        nonterm = this.newNT(nt);\n      }\n    } else {\n      nonterm = this.ensureSym(nt);\n    }\n    return this.addRule(new Rule(nonterm, production, action));\n  }\n\n  /**\n   * Add a rule directly.\n   */\n  addRule(rule: Rule, index = -1): Rule {\n    if (this.findRule(rule.nt, rule.rhs) >= 0) {\n      throw new Error(\"Duplicate rule: \" + rule.debugString);\n    }\n    rule.id = this.allRules.length;\n    if (rule.rhs.length == 0) this._hasNull = true;\n    if (index < 0) {\n      this.allRules.push(rule);\n    } else {\n      this.allRules.splice(index, 0, rule);\n    }\n    this._rulesForNT = null;\n    // this.rulesForNT(rule.nt).push(rule);\n    this.modified = true;\n    return rule;\n  }\n\n  /**\n   * Removes all rules from the grammar which match the given predicate.\n   */\n  removeRules(pred: (r: Rule) => boolean): boolean {\n    this.allRules = this.allRules.filter((r) => !pred(r));\n    this._rulesForNT = null;\n    this.modified = true;\n    return true;\n  }\n\n  /**\n   * Removes all symbols from the grammar and all of its productions which match\n   * a particular predicate.\n   */\n  removeSymbols(pred: (s: Sym) => boolean): boolean {\n    let modified = false;\n    const newRules: Rule[] = [];\n    this.allRules.forEach((r) => {\n      if (pred(r.nt)) return;\n      // if it was already a null production then leave it\n      if (r.rhs.length == 0) {\n        newRules.push(r);\n      } else {\n        const newRhs = new Str(...r.rhs.syms.filter((s) => !pred(s)));\n        modified = modified || r.rhs.length != newRhs.length;\n        if (newRhs.length > 0) {\n          newRules.push(new Rule(r.nt, newRhs));\n        }\n      }\n    });\n    this.allRules = newRules;\n    modified = this.symbolSet.remove(pred) || modified;\n    this.modified = this.modified || modified;\n    return modified;\n  }\n\n  /**\n   * Gets or creates a terminal with the given label.\n   * The grammar acts as a factory for terminal symbols\n   * so that we can reuse symbols instead of having\n   * users create new symbols each time.\n   *\n   * This also ensures that users are not able mix terminal\n   * and non terminal labels.\n   */\n  getSymById(id: number): Nullable<Sym> {\n    // if (id == Grammar.AUG_SYM_ID) return this._AugStartRule?.nt || null;\n    // else if (id == this.Eof.id) return this.Eof;\n    // else if (id == this.Null.id) return this.Null;\n    return this.symbolSet.get(id);\n  }\n\n  getSym(label: string): Nullable<Sym> {\n    // if (this._AugStartRule && label == this._AugStartRule.nt.label) return this._AugStartRule.nt;\n    return this.symbolSet.getByKey(label);\n  }\n\n  ensureSym(sym: Sym, throwIfExists = false): Sym {\n    const sym2 = this.symbolSet.ensure(sym, throwIfExists);\n    if (sym == sym2) {\n      if (sym2.creationId < 0) {\n        sym2.creationId = this.symbolSet.size;\n      }\n    } else {\n      TSU.assert(!throwIfExists, \"Should have already thrown error\");\n    }\n    return sym2;\n  }\n\n  /**\n   * Ensures that a terminal by a given name exists (creating if\n   * necessary).  If a terminal already exists by this label then\n   * an error is thrown.\n   *\n   * The grammar acts as a factory for terminal and non terminal symbols\n   * so that we can reuse symbols instead of having users create new\n   * symbols each time.  This also ensures that users are not able mix\n   * terminal and non terminal labels.\n   */\n  T(label: string, throwIfExists = false): Sym {\n    let t = this.getSym(label);\n    if (t != null) {\n      if (throwIfExists) throw new Error(`Terminal ${label} is already exists`);\n      if (!t.isTerminal) throw new Error(`Symbol (${label}) already exists as a non-terminal`);\n    } else {\n      t = new Sym(this, label, true);\n      t = this.ensureSym(t, true);\n    }\n    return t;\n  }\n\n  /**\n   * Ensures that a non term by a given name exists (creating if\n   * necessary).  If a terminal already exists by this label then\n   * an error is thrown.\n   *\n   * The grammar acts as a factory for terminal and non terminal symbols\n   * so that we can reuse symbols instead of having users create new\n   * symbols each time.  This also ensures that users are not able mix\n   * terminal and non terminal labels.\n   */\n  NT(label: string, isAuxiliary = false, throwIfExists = false): Sym {\n    let nt = this.getSym(label);\n    if (nt != null) {\n      if (throwIfExists) throw new Error(`Non-terminal ${label} is already exists`);\n      if (nt.isTerminal) throw new Error(`Symbol (${label}) already exists as a terminal`);\n    } else {\n      nt = new Sym(this, label, false);\n      nt.isAuxiliary = isAuxiliary;\n      nt = this.ensureSym(nt, true);\n      if (!isAuxiliary && this.startSymbol == null) {\n        this.startSymbol = nt;\n      }\n    }\n    return nt;\n  }\n\n  /**\n   * Creates a terminal with the given label if one does not\n   * already exist.\n   */\n  newTerm(label: string): Sym {\n    return this.T(label, true);\n  }\n\n  /**\n   * Creates a non terminal with the given label if it does not\n   * already exist.\n   */\n  newNT(label: string, isAuxiliary = false): Sym {\n    return this.NT(label, isAuxiliary, true);\n  }\n\n  /**\n   * Checks if a given label is a terminal.\n   */\n  isTerminal(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && t.isTerminal;\n  }\n\n  /**\n   * Checks if a given label is a non-terminal.\n   */\n  isNT(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && !t.isTerminal && !t.isAuxiliary;\n  }\n\n  /**\n   * Checks if a given label is an auxiliary non-terminal.\n   */\n  isAuxNT(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && !t.isTerminal && t.isAuxiliary;\n  }\n\n  seq(...exps: (Str | string)[]): Str {\n    if (exps.length == 1) {\n      return this.normalizeRule(exps[0]);\n    } else {\n      const out = new Str();\n      for (const e of exps) {\n        const s = this.normalizeRule(e);\n        // insert string here inline\n        // A ( B C D ) => A B C D\n        for (let i = 0; i < s.length; i++) {\n          // out.add(s.syms[i], s.cardinalities[i]);\n          out.add(s.syms[i]);\n        }\n      }\n      return out;\n    }\n  }\n\n  /**\n   * Provides a union rule:\n   *\n   * (A | B | C | D)\n   *\n   * Each of A, B, C or D themselves could be strings or literals.\n   */\n  anyof(...rules: (Str | string)[]): Str {\n    if (rules.length == 1) {\n      return this.normalizeRule(rules[0]);\n    } else {\n      // see if there is already NT with the exact set of rules\n      // reuse if it exists.  That would make this method\n      // Idempotent (which it needs to be).\n      return new Str(this.ensureAuxNT(...rules.map((r) => this.normalizeRule(r))));\n    }\n  }\n\n  opt(exp: Str | string): Str {\n    // convert to aux rule\n    const out = this.anyof(exp, new Str());\n    const nt = out.syms[0];\n    TSU.assert(out.syms.length == 1 && nt.isAuxiliary, \"NT must be an auxiliary symbol\");\n    nt.auxType = \"opt\";\n    return out;\n  }\n\n  atleast0(exp: Str | string, leftRec = true): Str {\n    const s = this.normalizeRule(exp);\n    // We want to find another auxiliary NT that has the following rules:\n    //    X -> exp X | ;    # if leftRec = true\n    //\n    //    X -> X exp | ;    # otherwise:\n    let auxNT = this.findAuxNT((auxNT) => {\n      const rules = this.rulesForNT(auxNT);\n      if (rules.length != 2) return false;\n\n      let which = 0;\n      if (rules[0].rhs.length == 0) {\n        which = 1;\n      } else if (rules[1].rhs.length == 0) {\n        which = 0;\n      } else {\n        return false;\n      }\n\n      const rule = rules[which].rhs;\n      if (rule.length != 1 + exp.length) return false;\n      if (rule.syms[0].equals(auxNT)) {\n        return rule.containsAt(1, s);\n      } else if (rule.syms[rule.length - 1].equals(auxNT)) {\n        return rule.containsAt(0, s);\n      }\n      return false;\n    });\n    if (auxNT == null) {\n      auxNT = this.newAuxNT();\n      auxNT.auxType = leftRec ? \"atleast0:left\" : \"atleast0\";\n      this.add(auxNT, new Str());\n      if (leftRec) {\n        this.add(auxNT, new Str(auxNT).extend(s));\n      } else {\n        this.add(auxNT, s.copy().append(auxNT));\n      }\n    }\n    return new Str(auxNT);\n  }\n\n  atleast1(exp: Str | string, leftRec = true): Str {\n    const s = this.normalizeRule(exp);\n    // We want to find another auxiliary NT that has the following rules:\n    //    X -> exp X | exp ;    # if leftRec = true\n    //\n    //    X -> X exp | exp ;    # otherwise:\n    let auxNT = this.findAuxNT((auxNT) => {\n      const rules = this.rulesForNT(auxNT);\n      if (rules.length != 2) return false;\n\n      let which = 0;\n      if (rules[0].rhs.equals(s)) {\n        which = 1;\n      } else if (rules[1].rhs.equals(s)) {\n        which = 0;\n      } else {\n        return false;\n      }\n\n      const rule = rules[which].rhs;\n      if (rule.length != 1 + exp.length) return false;\n      if (rule.syms[0].equals(auxNT)) {\n        return rule.containsAt(1, s);\n      } else if (rule.syms[rule.length - 1].equals(auxNT)) {\n        return rule.containsAt(0, s);\n      }\n      return false;\n    });\n    if (auxNT == null) {\n      auxNT = this.newAuxNT();\n      auxNT.auxType = leftRec ? \"atleast1:left\" : \"atleast1\";\n      this.add(auxNT, s);\n      if (leftRec) {\n        this.add(auxNT, new Str(auxNT).extend(s));\n      } else {\n        this.add(auxNT, s.copy().append(auxNT));\n      }\n    }\n    return new Str(auxNT);\n  }\n\n  normalizeRule(exp: Str | string): Str {\n    if (typeof exp === \"string\") {\n      const lit = this.getSym(exp);\n      if (lit == null) throw new Error(`Invalid symbol: '${exp}'`);\n      return new Str(lit);\n    } else {\n      // We have an expression that needs to be fronted by an\n      // auxiliarry non-terminal\n      return exp;\n    }\n  }\n\n  // Override this to have a different\n  protected auxNTCount = 0;\n  protected newAuxNTName(): string {\n    return this.auxNTPrefix + this.auxNTCount++;\n  }\n\n  newAuxNT(name = \"\"): Sym {\n    if (name == \"\") name = this.newAuxNTName();\n    return this.newNT(name, true);\n  }\n\n  ensureAuxNT(...rules: Str[]): Sym {\n    let nt = this.findAuxNTByRules(...rules);\n    if (nt == null) {\n      nt = this.newAuxNT();\n      nt.auxType = \"anyof\";\n      for (const rule of rules) this.add(nt, rule);\n    }\n    return nt;\n  }\n\n  /**\n   * Find an auxiliary rule that has the same rules as the ones here.\n   * This can be used to ensure duplicate rules are not created for\n   * union expressions.\n   */\n  findAuxNT(filter: (nt: Sym) => boolean): Nullable<Sym> {\n    for (const auxNT of this.symbolSet.entries) {\n      if (!auxNT.isAuxiliary) continue;\n      if (filter(auxNT)) return auxNT;\n    }\n    return null;\n  }\n\n  findAuxNTByRules(...rules: Str[]): Nullable<Sym> {\n    return this.findAuxNT((auxNT) => {\n      const ntRules = this.rulesForNT(auxNT);\n      if (ntRules.length != rules.length) return false;\n      for (let i = 0; i < ntRules.length; i++) {\n        if (!ntRules[i].rhs.equals(rules[i])) return false;\n      }\n      return true;\n    });\n  }\n\n  print(options: any = null): string[] {\n    options = options || {};\n    const ruleSep = options.ruleSep || \"->\";\n    const includeSemiColon = options.includeSemiColon || false;\n    const lambdaSymbol = options.lambdaSymbol || \"\";\n    const out: string[] = [];\n    this.forEachRule(null, (rule: Rule, index: number) => {\n      let r = `${rule.nt.label} ${ruleSep} `;\n      if (rule.rhs.length > 0) r += rule.rhs.debugString;\n      else r += lambdaSymbol;\n      if (includeSemiColon) r += \" ;\";\n      out.push(r);\n    });\n    return out;\n  }\n\n  /**\n   * Returns a flat list of all productions in a single list.\n   */\n  get debugValue(): string[] {\n    const out: string[] = [];\n    this.forEachRule(null, (rule: Rule, index: number) => {\n      out.push(`${rule.nt.label} -> ${rule.rhs.debugString}`);\n    });\n    return out;\n  }\n\n  /**\n   * Returns all non terminals that can derive terminals.\n   */\n  get terminalDerivingSymbols(): SymbolSet {\n    const out = new SymbolSet(this, null);\n    let nadded = -1;\n    let allDerive = true;\n    while (nadded != 0) {\n      nadded = 0;\n      for (const rule of this.allRules) {\n        allDerive = true;\n        for (const sym of rule.rhs.syms) {\n          if (!out.has(sym)) {\n            if (sym.isTerminal) {\n              out.add(sym);\n              nadded++;\n            } else {\n              allDerive = false;\n            }\n          }\n        }\n        if (allDerive && !out.has(rule.nt)) {\n          out.add(rule.nt);\n          nadded++;\n        }\n      }\n    }\n    return out;\n  }\n\n  /*\n   * Returns all non terminal that are reachable from a given symbol.\n   * If the FROM symbol is omitted then the start symbol is used.\n   */\n  reachableSymbols(fromSymbol: Nullable<Sym> = null): SymbolSet {\n    if (fromSymbol == null) {\n      fromSymbol = this._AugStartRule ? this._AugStartRule.nt : this.startSymbol;\n    }\n    TSU.assert(fromSymbol != null, \"Start symbol does not exist\");\n    const reachable = new SymbolSet(this, false).add(fromSymbol);\n    let queue: Sym[] = [fromSymbol];\n    while (queue.length > 0) {\n      const newQueue: Sym[] = [];\n      for (const curr of queue) {\n        for (const rule of this.rulesForNT(curr)) {\n          for (const sym of rule.rhs.syms) {\n            if (!sym.isTerminal && !reachable.has(sym)) {\n              newQueue.push(sym);\n              reachable.add(sym);\n            }\n          }\n        }\n      }\n      queue = newQueue;\n    }\n    return reachable;\n  }\n\n  /**\n   * Returns all cycles in this grammar.\n   */\n  get cycles(): ReadonlyArray<[Sym, any]> {\n    /*\n     * Returns the edge of the given nonterm\n     * For a nt such that:\n     *             S -> alpha1 X1 beta1 |\n     *                  alpha2 X2 beta2 |\n     *                  ...\n     *                  alphaN XN betaN |\n     *\n     * S's neighbouring nodes would be Xk if all of alphak is optional\n     * AND all of betak is optional\n     */\n    const edgeFunctor = (node: Sym): [Sym, any][] => {\n      const out: [Sym, any][] = [];\n      this.forEachRule(node, (rule, ruleIndex) => {\n        rule.rhs.syms.forEach((s, j) => {\n          if (s.isTerminal) return;\n          if (this.nullables.isStrNullable(rule.rhs, 0, j - 1) && this.nullables.isStrNullable(rule.rhs, j + 1)) {\n            out.push([s, [node, ruleIndex]]);\n          }\n        });\n      });\n      return out;\n    };\n    return allMinimalCycles(this.allNonTerminals, (val: Sym) => val.label, edgeFunctor);\n  }\n\n  /**\n   * Returns a set of \"Starting\" non terminals which have atleast\n   * one production containing left recursion.\n   */\n  get leftRecursion(): any {\n    const edgeFunctor = (node: Sym): [Sym, any][] => {\n      const out: [Sym, any][] = [];\n      this.forEachRule(node, (rule, ruleIndex) => {\n        rule.rhs.syms.forEach((s, j) => {\n          if (s.isTerminal) return;\n          out.push([s, ruleIndex]);\n          // If this is symbol is not nullable then we can stop here\n          return this.nullables.isNullable(s);\n        });\n      });\n      return out;\n    };\n    return allMinimalCycles(this.allNonTerminals, (val: Sym) => val.id, edgeFunctor);\n  }\n}\n","export enum CharClassType {\n  WORD_CHAR,\n  DIGITS,\n  SPACES,\n}\n\nconst ZERO = \"0\".charCodeAt(0);\nconst NINE = \"9\".charCodeAt(0);\nconst lA = \"a\".charCodeAt(0);\nconst lZ = \"z\".charCodeAt(0);\nconst uA = \"A\".charCodeAt(0);\nconst uZ = \"Z\".charCodeAt(0);\nconst USCORE = \"_\".charCodeAt(0);\n\n/**\n * An abstract class to be implemented for enabling different types of char classes.\n * Char classes are a form of \"short codes\" to identify characters.  eg SPACES, DIGITS etc.\n * Char classes are only shortcuts.  One can get away without using them and instead explicitly\n * construct the underlying state machine or regex (eg DIGIT could be replaced with [0-9]).\n */\nexport abstract class CharClassHelper {\n  matches(charCode: number, neg: boolean): boolean {\n    const res = this.match(charCode);\n    return neg ? !res : res;\n  }\n  protected abstract match(charCode: number): boolean;\n  abstract reString(neg: boolean): string;\n}\n\nconst spaceChars = \" \\f\\n\\r\\t\\v\\u00a0\\u1680\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff\";\n\n/**\n * Spaces - \\s => [ \\b\\c\\u00a0\\t\\r\\n\\u2028\\u2029<BOM><USP>]\n * BOM = \\uFEFF\n * USP = Other unicode space separator\n */\nexport class Spaces extends CharClassHelper {\n  match(charCode: number): boolean {\n    // if (charCode == 0x180e) return true;\n    if (charCode >= 0x2000 && charCode <= 0x200a) return true;\n    for (let i = 0; i < spaceChars.length; i++) {\n      if (spaceChars.charCodeAt(i) == charCode) return true;\n    }\n    return false;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\S\" : \"\\\\s\";\n  }\n}\n\n/**\n * Char class for denoting a digit - [0-9].\n */\nexport class Digit extends CharClassHelper {\n  match(charCode: number): boolean {\n    return charCode >= ZERO && charCode <= NINE;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\D\" : \"\\\\d\";\n  }\n}\n\n/**\n * Char class for denoting \"\\\\w\" - ie any WordChar\n */\nexport class WordChar extends CharClassHelper {\n  match(charCode: number): boolean {\n    return (\n      charCode == USCORE ||\n      (charCode >= ZERO && charCode <= NINE) ||\n      (charCode >= lA && charCode <= lZ) ||\n      (charCode >= uA && charCode <= uZ)\n    );\n    return true;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\W\" : \"\\\\w\";\n  }\n}\n\nexport const CharClassHelpers: ReadonlyArray<CharClassHelper> = [new WordChar(), new Digit(), new Spaces()];\n","export enum PropertyName {\n  // Binary Property Names\n  gc,\n  General_Category = gc,\n  sc,\n  Script = sc,\n  scx,\n  Script_Extension = scx,\n\n  // Non binary property names\n  Any,\n  ASCII,\n  AHex,\n  ASCII_Hex_Digit = AHex,\n  Alpha,\n  Alphabetic = Alpha,\n  Bidi_M,\n  Bidi_Mirrored = Bidi_M,\n  Bidi_C,\n  Bidi_Control = Bidi_C,\n  CI,\n  Case_Ignorable = CI,\n  Cased,\n  CWCF,\n  Changes_When_Casefolded = CWCF,\n  CWCM,\n  Changes_When_Casemapped = CWCM,\n  CWL,\n  Changes_When_Lowercased = CWL,\n  CWKCF,\n  Changes_When_NFKC_Casefolded = CWKCF,\n  CWT,\n  Changes_When_Titlecased = CWT,\n  CWU,\n  Changes_When_Uppercased = CWU,\n  Dash,\n  DI,\n  Default_Ignorable_Code_Point = DI,\n  Dep,\n  Deprecated = Dep,\n  Dia,\n  Diacritic = Dia,\n  Emoji,\n  Emoji_Component,\n  Emoji_Modifier,\n  Emoji_Modifier_Base,\n  Emoji_Presentation,\n  Ext,\n  Extender = Ext,\n  Gr_Base,\n  Grapheme_Base = Gr_Base,\n  Gr_Ext,\n  Grapheme_Extend = Gr_Ext,\n  Hex,\n  Hex_Digit = Hex,\n  IDSB,\n  IDS_Binary_Operator = IDSB,\n  IDST,\n  IDS_Trinary_Operator = IDST,\n  IDC,\n  ID_Continue = IDC,\n  IDS,\n  ID_Start = IDS,\n  Ideo,\n  Ideographic = Ideo,\n  Join_C,\n  Join_Control = Join_C,\n  LOE,\n  Logical_Order_Exception = LOE,\n  Lower,\n  Lowercase = Lower,\n  Math,\n  NChar,\n  Noncharacter_Code_Point = NChar,\n  Pat_Syn,\n  Pattern_Syntax = Pat_Syn,\n  Pat_WS,\n  Pattern_White_Space = Pat_WS,\n  QMark,\n  Quotation_Mark = QMark,\n  Radical,\n  RI,\n  Regional_Indicator = RI,\n  STerm,\n  Sentence_Terminal = STerm,\n  SD,\n  Soft_Dotted = SD,\n  Term,\n  Terminal_Punctuation = Term,\n  UIdeo,\n  Unified_Ideograph = UIdeo,\n  Upper,\n  Uppercase = Upper,\n  VS,\n  Variation_Selector = VS,\n  space,\n  White_Space = space,\n  XIDC,\n  XID_Continue = XIDC,\n  XIDS,\n  XID_Start = XIDS,\n}\n\nexport enum PropertyValue {\n  // General Category proeprty values\n  LC,\n  Cased_Letter = LC,\n  Pe,\n  Close_Punctuation = Pe,\n  Pc,\n  Connector_Punctuation = Pc,\n  Cc,\n  cntrl = Cc,\n  Control = Cc,\n  Sc,\n  Currency_Symbol = Sc,\n  Pd,\n  Dash_Punctuation = Pd,\n  Nd,\n  digit = Nd,\n  Decimal_Number = digit,\n  Me,\n  Enclosing_Mark = Me,\n  Pf,\n  Final_Punctuation = Pf,\n  Cf,\n  Format = Cf,\n  Pi,\n  Initial_Punctuation = Pi,\n  L,\n  Letter = L,\n  Nl,\n  Letter_Number = Nl,\n  Zl,\n  Line_Separator = Zl,\n  Ll,\n  Lowercase_Letter = Ll,\n  M,\n  Combining_Mark = M,\n  Mark,\n  Sm,\n  Math_Symbol = Sm,\n  Lm,\n  Modifier_Letter = Lm,\n  Sk,\n  Modifier_Symbol = Sk,\n  Mn,\n  Nonspacing_Mark = Mn,\n  N,\n  Number = N,\n  Ps,\n  Open_Punctuation = Ps,\n  C,\n  Other = C,\n  Lo,\n  Other_Letter = Lo,\n  No,\n  Other_Number = No,\n  Po,\n  Other_Punctuation = Po,\n  So,\n  Other_Symbol = So,\n  Zp,\n  Paragraph_Separator = Zp,\n  Co,\n  Private_Use = Co,\n  P,\n  punct = P,\n  Punctuation = P,\n  Z,\n  Separator = Z,\n  Zs,\n  Space_Separator = Zs,\n  Mc,\n  Spacing_Mark = Mc,\n  Cs,\n  Surrogate = Cs,\n  S,\n  Symbol = S,\n  Lt,\n  Titlecase_Letter = Lt,\n  Cn,\n  Unassigned = Cn,\n  Lu,\n  Uppercase_Letter = Lu,\n  // Script and Script Extension proeprty values\n}\n\nexport function propertyNameFor(value: string): PropertyName {\n  value = value.trim();\n  if (!(value in PropertyName)) {\n    throw new SyntaxError(\"Invalid property name: \" + value);\n  }\n  return (PropertyName as any)[value];\n}\n\nexport function propertyValueFor(value: string): PropertyValue {\n  value = value.trim();\n  if (!(value in PropertyValue)) {\n    throw new SyntaxError(\"Invalid property value: \" + value);\n  }\n  return (PropertyValue as any)[value];\n}\n\nexport function propertyNameString(value: number): string {\n  if (!(value in PropertyName)) {\n    throw new Error(\"Invalid property name: \" + value);\n  }\n  return PropertyName[value];\n}\n\nexport function propertyValueString(value: number): string {\n  if (!(value in PropertyValue)) {\n    throw new Error(\"Invalid property value: \" + value);\n  }\n  return PropertyValue[value];\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport { Char } from \"./core\";\n\nfunction isNewLineChar(ch: string): boolean {\n  return ch == \"\\r\" || ch == \"\\n\" || ch == \"\\u2028\" || ch == \"\\u2029\";\n}\n\nexport class Match {\n  groups: [number, number][] = [];\n  positions: number[] = [];\n  constructor(public priority = 10, public matchIndex = -1, public start = -1, public end = -1) {}\n}\n\nexport enum OpCode {\n  // Any character\n  Any,\n  // Any character not including a new line\n  AnyNonNL,\n  // Char and CI Chars\n  Char,\n  CIChar,\n  // NegChar,\n  // NegCIChar,\n\n  // Non char opcodes\n  Match,\n  Noop,\n  Save,\n  Split,\n  Jump,\n  Begin, // Forward lookahead matches\n  RBegin, // Reverse lookahead matches\n  End,\n\n  // Look ahead and Look back matchers\n  // ^ and $ that are not activated on newlines\n  StartingChar,\n  EndingChar,\n  // ^ and $ that are activated on newlines as well\n  MLStartingChar,\n  MLEndingChar,\n  StartOfWord,\n  EndOfWord,\n  GroupStart,\n  GroupEnd,\n\n  // Stops the thread if state does not match\n  EnsureState,\n}\n\nexport class Prog {\n  instrs: Instr[] = [];\n  stateMapping: Map<string, number>;\n\n  constructor(public readonly startCondition = \"INITIAL\", public readonly scIsInclusive = true) {\n    this.stateMapping = new Map<string, number>();\n    this.registerState(\"INITIAL\");\n    this.registerState(startCondition);\n  }\n\n  get length(): number {\n    return this.instrs.length;\n  }\n\n  /**\n   * Adds a state to our program and returns the state's index.\n   */\n  registerState(state: string): number {\n    if (!this.stateMapping.has(state)) {\n      this.stateMapping.set(state, this.stateMapping.size);\n    }\n    return this.stateMapping.get(state) || -1;\n  }\n\n  add(opcode: any, char: null | Char = null, ...args: number[]): Instr {\n    const out = new Instr(opcode, char).add(...args);\n    out.offset = this.instrs.length;\n    this.instrs.push(out);\n    return out;\n  }\n\n  static with(initializer: (prog: Prog) => void): Prog {\n    const out = new Prog();\n    initializer(out);\n    return out;\n  }\n\n  debugValue(instrDebugValue: (instr: Instr) => string = InstrDebugValue): any {\n    if (instrDebugValue) {\n      return this.instrs.map((instr, index) => {\n        if (instr.comment.trim().length > 0) return `L${index}: ${instrDebugValue(instr)}     # ${instr.comment}`;\n        else return `L${index}: ${instrDebugValue(instr)}`;\n      });\n    } else {\n      return this.instrs.map((instr, index) => `L${index}: ${instr.debugValue}`);\n    }\n  }\n}\n\nexport class Instr {\n  offset = 0;\n  comment = \"\";\n  args: number[] = [];\n  // used for char match instructions - if opcode == Char or CIChar\n  constructor(public readonly opcode: any, public char: null | Char = null) {\n    this.char = char;\n  }\n\n  add(...args: number[]): this {\n    this.args.push(...args);\n    return this;\n  }\n\n  get debugValue(): any {\n    let c = this.comment.trim();\n    if (c.length > 0) c = \"    # \" + c;\n    return `${this.opcode} ${this.args.join(\" \")}    ${this.char || \"\"}   ${c}`;\n  }\n}\n\n/**\n * A thread that is performing an execution of the regex VM.\n */\nexport class Thread {\n  parentId = -1;\n  id = 0;\n  priority = 0;\n  /**\n   * Saved positions into the input stream for the purpose of\n   * partial and custom matches.\n   */\n  groups: [number, number][] = [];\n  positions: number[] = [];\n  registers: TSU.NumMap<number> = {};\n\n  /**\n   * Create a thread at the given offset\n   */\n  constructor(public readonly offset: number = 0, public readonly gen: number = 0) {}\n\n  regIncr(regId: number): void {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    this.registers[regId]++;\n  }\n\n  regAcquire(regId: number): void {\n    if (regId in this.registers) {\n      throw new Error(`Register at offset ${regId} already acquired.  Release it first`);\n    }\n    this.registers[regId] = 0;\n  }\n\n  regRelease(regId: number): void {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    delete this.registers[regId];\n  }\n\n  regValue(regId: number): number {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    return this.registers[regId];\n  }\n}\n\nexport interface VMTracer {\n  threadDequeued(thread: Thread, tapeIndex: number): void;\n  threadStepped(thread: Thread, tapeIndex: number, gen: number): void;\n  threadQueued(thread: Thread, tapeIndex: number): void;\n}\n\nexport class VM {\n  // TODO - To prevent excessive heap activity and GC\n  // create a pool of threads and just have a cap on\n  // match sizes\n  // To eve simplify each Thread could just be something like:\n  // number[] where\n  //  number[0] == offset\n  //  number[1-2*MaxSubs] = Substitutions\n  //  number[2*MaxSubs - 2*MaxSubs + M] = Registers\n  //      where M = Max number of NewReg instructions\n  protected threadCounter = 0;\n  protected currThreads: Thread[] = [];\n  protected nextThreads: Thread[] = [];\n  protected startPos = 0; // Where the match is beginning from - this will be set to tape.index when match is called\n  // Initial state is always 0\n  protected currState = 0;\n\n  /**\n   * Get the current lexer state (for incremental lexing support).\n   * State is used to track context-sensitive lexing (e.g., inside string, comment).\n   */\n  getState(): number {\n    return this.currState;\n  }\n\n  /**\n   * Set the lexer state (for incremental lexing support).\n   * Allows restarting lexing from a saved state.\n   */\n  setState(state: number): void {\n    this.currState = state;\n  }\n\n  protected gen = 0;\n  // Records which \"generation\" of the match a particular\n  // offset is in.  If a thread is added at a particular\n  // offset the generation number is used to see if the\n  // thread is a duplicate (and avoided if so).  This\n  // ensures that are linearly bounded on the number of\n  // number threads as we match.\n  protected genForOffset: TSU.NumMap<number> = {};\n\n  tracer: VMTracer;\n  constructor(\n    public readonly prog: Prog,\n    public readonly start = 0,\n    public readonly end = -1,\n    public readonly forward = true,\n    configs: any = {},\n  ) {\n    if (end < 0) {\n      end = prog.length - 1;\n    }\n    this.end = end;\n  }\n\n  savePosition(thread: Thread, pos: number, tapeIndex: number): void {\n    while (thread.positions.length <= pos) thread.positions.push(-1);\n    thread.positions[pos] = tapeIndex;\n  }\n\n  jumpBy(thread: Thread, delta = 1): Thread {\n    return this.jumpTo(thread, thread.offset + delta);\n  }\n\n  jumpTo(thread: Thread, newOffset: number): Thread {\n    // TODO - Why create new thread here - investigate if we can\n    // return the same thread with the offset updated?\n    // if we really want a \"history\" we could jsut keep prev offsets\n    // in a list so we can keep a trace\n    const out = new Thread(newOffset, this.gen);\n    out.id = thread.id;\n    out.parentId = thread.parentId;\n    out.priority = thread.priority;\n    out.positions = thread.positions;\n    out.groups = thread.groups;\n    out.registers = thread.registers;\n    return out;\n  }\n\n  forkTo(thread: Thread, newOffset: number): Thread {\n    const out = new Thread(newOffset, this.gen);\n    out.id = ++this.threadCounter;\n    out.parentId = thread.id;\n    out.priority = thread.priority;\n    out.positions = [...thread.positions];\n    out.groups = [...thread.groups];\n    out.registers = { ...thread.registers };\n    return out;\n  }\n\n  startGroup(thread: Thread, groupIndex: number, tapeIndex: number): Thread {\n    const newThread = this.forkTo(thread, thread.offset + 1);\n    newThread.groups.push([groupIndex, tapeIndex]);\n    return newThread;\n  }\n\n  endGroup(thread: Thread, groupIndex: number, tapeIndex: number): Thread {\n    const newThread = this.forkTo(thread, thread.offset + 1);\n    newThread.groups.push([-groupIndex, tapeIndex]);\n    return newThread;\n  }\n\n  addThread(thread: Thread, list: Thread[], tape: Tape, delta = 0): void {\n    if (\n      thread.offset < this.start ||\n      thread.offset > this.end ||\n      this.genForOffset[thread.offset - this.start] == this.gen\n    ) {\n      // duplicate\n      return;\n    }\n    this.genForOffset[thread.offset - this.start] = this.gen;\n    const instr = this.prog.instrs[thread.offset];\n    let nextCh: string;\n    let lastCh: string;\n    let newThread: Thread;\n    // if (this.tracer) this.tracer.threadStepped(thread, tape.index, this.gen);\n    const opcode = instr.opcode;\n    switch (opcode) {\n      case OpCode.Jump:\n        newThread = this.jumpTo(thread, instr.args[0]);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.Split:\n        for (let j = 0; j < instr.args.length; j++) {\n          const newOff = instr.args[j];\n          // TODO - only fork on position/group write instead of always forking on a split\n          const newThread = j == 0 ? this.jumpTo(thread, newOff) : this.forkTo(thread, newOff);\n          this.addThread(newThread, list, tape, delta);\n        }\n        break;\n      case OpCode.Save:\n        newThread = this.jumpTo(thread, thread.offset + 1);\n        this.savePosition(newThread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.GroupStart:\n        newThread = this.startGroup(thread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.GroupEnd:\n        newThread = this.endGroup(thread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.StartingChar:\n      case OpCode.MLStartingChar:\n        // only proceed further if prev was a newline or start\n        lastCh = this.prevCh(tape);\n        if (tape.index == 0 || (opcode == OpCode.MLStartingChar && isNewLineChar(lastCh))) {\n          // have a match so can go forwrd but dont advance tape on\n          // the same generation\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n        break;\n      case OpCode.EndingChar:\n      case OpCode.MLEndingChar:\n        // On end of input we dont advance tape but thread moves on\n        // if at end of line boundary\n        // check if next is end of input\n        nextCh = this.nextCh(tape);\n        if (nextCh == \"\" || (opcode == OpCode.MLEndingChar && isNewLineChar(nextCh))) {\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n        break;\n      case OpCode.StartOfWord:\n        // only proceed further if prev was a newline or start\n        /*\n        lastCh = this.prevCh(tape);\n        if (tape.index == 0 || (this.multiline && (isNewLineChar(lastCh) || isSpaceChar(lastCh)))) {\n          // have a match so can go forwrd but dont advance tape on\n          // the same generation\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n       */\n        break;\n      case OpCode.EndOfWord:\n        // On end of input we dont advance tape but thread moves on\n        // if at end of line boundary\n        // check if next is end of input\n        /*\n        nextCh = this.nextCh(tape);\n        if (nextCh == \"\" || (this.multiline && (isNewLineChar(nextCh) || isSpaceChar(nextCh)))) {\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n       */\n        break;\n      case OpCode.RBegin:\n        {\n          const [groupIndex, negate, end] = instr.args;\n          const pos = (1 + groupIndex) * 2;\n          const groupStart = thread.positions[pos];\n          const [matchSuccess, matchEnd] = this.recurseMatch(\n            tape,\n            groupStart - 1,\n            instr.offset + 1,\n            end,\n            false,\n            negate == 1,\n          );\n          if (matchSuccess) {\n            // TODO - Consider using a DFA for this case so we can mitigate\n            // pathological cases with an exponential blowup on a success\n            this.addThread(this.jumpTo(thread, end + 1), list, tape, delta);\n          }\n        }\n        break;\n      case OpCode.Begin:\n        // This results in a new VM being created for this sub program and\n        // kicking off a backtracking execution - Making these as explicit\n        // constructs for the user to use means the user can make this choice\n        // on their own voilition\n        const [consume, negate, end] = instr.args;\n        if (consume == 1) {\n          // since this results in the consumption of a character (similar to \"Char\")\n          // defer this to the list\n          if (this.tracer) this.tracer.threadQueued(thread, tape.index);\n          list.push(thread);\n        } else {\n          const [matchSuccess, matchEnd] = this.recurseMatch(\n            tape,\n            tape.index + 1,\n            instr.offset + 1,\n            end,\n            true,\n            negate == 1,\n          );\n          if (matchSuccess) {\n            // TODO - Consider using a DFA for this case so we can mitigate\n            // pathological cases with an exponential blowup on a success\n            this.addThread(this.jumpTo(thread, end + 1), list, tape, delta);\n          }\n        }\n        break;\n      case OpCode.EnsureState:\n        const states = instr.args;\n        for (const state of states) {\n          if (this.currState == state) {\n            this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n            break;\n          }\n        }\n        break;\n      default:\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index);\n        list.push(thread);\n        break;\n    }\n  }\n\n  matchCurrPos(tape: Tape, char: Char, ignoreCase = false): boolean {\n    if (ignoreCase) {\n      return char.match(tape.currChCodeLower) || char.match(tape.currChCodeUpper);\n    } else {\n      return char.match(tape.currChCode);\n    }\n  }\n\n  protected hasMore(tape: Tape): boolean {\n    return this.forward ? tape.hasMore : tape.index >= 0;\n  }\n\n  protected nextCh(tape: Tape): string {\n    const next = tape.index + (this.forward ? 1 : -1);\n    return tape.charAt(next);\n    // if (next < 0 || next >= tape.input.length) return \"\";\n    // return tape.input[next];\n  }\n\n  protected prevCh(tape: Tape): string {\n    return tape.charAt(tape.index - (this.forward ? 1 : -1));\n    // return tape.input[tape.index - (this.forward ? 1 : -1)];\n  }\n\n  /**\n   * Runs the given instructions and returns a triple:\n   * [matchId, matchStart, matchEnd]\n   */\n  match(tape: Tape): Match | null {\n    // this.gen = 0; this.genForOffset = {};\n    if (this.end < this.start) return null;\n    this.startMatching(tape);\n    let bestMatch: TSU.Nullable<Match> = null;\n    while (this.currThreads.length > 0) {\n      bestMatch = this.stepChar(tape, bestMatch);\n    }\n    // ensure tape is rewound to end of last match\n    if (bestMatch != null) tape.index = bestMatch.end;\n    return bestMatch;\n  }\n\n  recurseMatch(\n    tape: Tape,\n    tapeIndex: number,\n    startOffset: number,\n    endOffset: number,\n    forward = true,\n    negate = false,\n  ): [boolean, number] {\n    const savedPos = tape.index;\n    if (!tape.canAdvance(forward ? 1 : -1)) return [negate, -1];\n    tape.index = tapeIndex;\n    // tape.advance(forward ? 1 : -1);\n    const vm = new VM(this.prog, startOffset, endOffset, forward);\n    const match = vm.match(tape);\n    const newPos = tape.index;\n    tape.index = savedPos; // always restore it first and let caller use it\n    return [(match != null && !negate) || (match == null && negate), newPos];\n  }\n\n  startMatching(tape: Tape): void {\n    this.currThreads = [];\n    this.nextThreads = [];\n    this.gen++;\n    this.addThread(new Thread(this.start, this.gen), this.currThreads, tape);\n    // let largestMatchEnd = -1;\n    // let lastMatchIndex = -1;\n    this.startPos = tape.index;\n  }\n\n  stepChar(tape: Tape, currMatch: TSU.Nullable<Match> = null): TSU.Nullable<Match> {\n    // At this point all our threads are point to the next \"transition\" or \"match\" action.\n    this.gen++;\n    // console.log(`Ch (@${tape.index}): ${tape.currChCode}, Gen (${this.gen})`);\n    for (let i = 0; i < this.currThreads.length; i++) {\n      const thread = this.currThreads[i];\n      // console.log(`   Thread (${i}): ${thread.offset}(${thread.gen})`);\n      const nextMatch = this.stepThread(tape, thread);\n      if (nextMatch != null) {\n        if (\n          currMatch == null ||\n          nextMatch.priority > currMatch.priority ||\n          (nextMatch.priority == currMatch.priority && nextMatch.end > currMatch.end)\n        ) {\n          currMatch = nextMatch;\n          break;\n        } else if (currMatch != nextMatch) {\n          // Since we kill of lower priority matches becuase of matchedInGen\n          // we should not be here\n          // TSU.assert(false, \"Should not be here\");\n        }\n      }\n    }\n    if (this.hasMore(tape)) {\n      tape.advance(this.forward ? 1 : -1);\n    }\n    this.currThreads = this.nextThreads;\n    this.nextThreads = [];\n    return currMatch;\n  }\n\n  stepThread(tape: Tape, thread: Thread): TSU.Nullable<Match> {\n    if (this.tracer) this.tracer.threadStepped(thread, tape.index, this.gen);\n    let currMatch: TSU.Nullable<Match> = null;\n    const instrs = this.prog.instrs;\n    const instr = instrs[thread.offset];\n    const opcode = instr.opcode;\n    const args = instr.args;\n    const delta = this.forward ? 1 : -1;\n    // Do char match based actions\n    let advanceTape = false;\n    let ch: number;\n    switch (opcode) {\n      case OpCode.RBegin:\n        throw new Error(\"Invalid state.  Reverse matches must be handled in addThread\");\n        break;\n      case OpCode.Begin:\n        const [consume, negate, end] = instr.args;\n        TSU.assert(consume == 1, \"Plain lookahead cannot be here\");\n        const [matchSuccess, matchEnd] = this.recurseMatch(tape, tape.index, instr.offset + 1, end, true, negate == 1);\n        if (matchSuccess) {\n          // TODO - Consider using a DFA for this case so we can mitigate\n          // pathological cases with an exponential blowup\n          // on a success we have a few options\n          this.addThread(this.jumpTo(thread, end + 1), this.nextThreads, tape);\n        }\n        break;\n      case OpCode.End:\n        // Return back to calling VM - very similar to a match\n        const out = new Match(-1, -1, this.startPos, tape.index);\n        out.groups = thread.groups;\n        out.positions = thread.positions;\n        return out;\n        break;\n      case OpCode.Match:\n        // we have a match on this thread so return it\n        // Update the match if we are a higher prioirty or longer match\n        // than what was already found (if any)\n        if (tape.index > this.startPos) {\n          const currPriority = instr.args[0];\n          const matchIndex = instr.args[1];\n          currMatch = new Match();\n          currMatch.start = this.startPos;\n          currMatch.end = tape.index;\n          currMatch.priority = currPriority;\n          currMatch.matchIndex = matchIndex;\n          currMatch.groups = thread.groups;\n          currMatch.positions = thread.positions;\n        }\n        break;\n      case OpCode.Char:\n      case OpCode.CIChar:\n        if (this.hasMore(tape)) {\n          advanceTape = this.matchCurrPos(tape, instr.char!, opcode == OpCode.CIChar);\n        }\n        break;\n      /*\n      case OpCode.NegChar:\n      case OpCode.NegCIChar:\n        if (this.hasMore(tape)) {\n          advanceTape = !this.matchCurrPos(tape, args, opcode == OpCode.NegCIChar);\n        }\n        break;\n      */\n      case OpCode.AnyNonNL:\n      case OpCode.Any:\n        if (this.hasMore(tape)) {\n          advanceTape = opcode == OpCode.Any || !isNewLineChar(tape.currCh);\n        }\n        break;\n    }\n    if (advanceTape /* && this.hasMore(tape) */) {\n      this.addThread(this.jumpBy(thread, 1), this.nextThreads, tape, delta);\n    }\n    return currMatch;\n  }\n}\n\nexport function InstrDebugValue(instr: Instr): string {\n  switch (instr.opcode) {\n    case OpCode.Match:\n      return `Match ${instr.args[0]} ${instr.args[1]}`;\n    // case OpCode.NegChar:\n    // case OpCode.NegCIChar:\n    case OpCode.Char:\n    case OpCode.CIChar: {\n      let out = `${OpCode[instr.opcode].toString()} `;\n      // out += `${CharType[instr.args[0]]}`;\n      // for (let i = 1; i < instr.args.length; i++) out += \" \" + instr.args[i];\n      out += `${instr.char!.debugValue()}`;\n      return out;\n    }\n    case OpCode.Any:\n      return \".\";\n    case OpCode.AnyNonNL:\n      return \"NL.\";\n    case OpCode.StartingChar:\n      return \"^\";\n    case OpCode.MLStartingChar:\n      return \"NL^\";\n    case OpCode.EndingChar:\n      return \"$NL\";\n    case OpCode.MLEndingChar:\n      return \"$NL_MultiLine\";\n    case OpCode.Save:\n      return `Save ${instr.args[0]}`;\n    case OpCode.GroupStart:\n      return `GroupStart ${instr.args[0]}`;\n    case OpCode.GroupEnd:\n      return `GroupEnd ${instr.args[0]}`;\n    case OpCode.Split:\n      return `Split ${instr.args.join(\", \")}`;\n    case OpCode.Jump:\n      return `Jump ${instr.args[0]}`;\n    case OpCode.Begin:\n      return `Begin ${instr.args.join(\" \")}`;\n    case OpCode.RBegin:\n      return `RBegin ${instr.args.join(\" \")}`;\n    case OpCode.End:\n      return `End ${instr.args.join(\" \")}`;\n    case OpCode.EnsureState:\n      return `EnsureState ${instr.args.join(\" \")}`;\n    default:\n      throw new Error(\"Invalid Opcode: \" + instr.opcode);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n\nimport {\n  Rule,\n  RegexType,\n  Quant,\n  Regex,\n  Cat,\n  Char,\n  CharType,\n  Var,\n  BackNumRef,\n  BackNamedRef,\n  LookAhead,\n  LookBack,\n  Union,\n} from \"./core\";\nimport { OpCode, Prog, Instr } from \"./vm\";\n\nexport type RegexResolver = (name: string) => Regex;\nexport type CompilerListener = (expr: Regex, prog: Prog, start: number, length: number) => void;\n\n/**\n * The regex Compiler compiles a parsed regular expression tree into bytecode that is\n * executed by the VM.\n */\nexport class Compiler {\n  emitGroups = false;\n  emitPosition = true;\n  constructor(\n    public regexResolver: TSU.Nullable<RegexResolver>,\n    public listener: TSU.Nullable<CompilerListener> = null,\n  ) {}\n\n  compile(rules: Rule[]): Prog {\n    // Split across each of our expressions\n    const out = new Prog();\n    // only add the split instruction if we have more than one rule\n    const split: Instr = rules.length <= 1 ? new Instr(OpCode.Split) : out.add(OpCode.Split, null);\n    rules.forEach((rule, i) => {\n      split.add(out.instrs.length);\n      const ignoreCase = rule.expr.ignoreCase == null ? false : rule.expr.ignoreCase;\n      const dotAll = rule.expr.dotAll == null ? true : rule.expr.dotAll;\n      const multiline = rule.expr.multiline == null ? true : rule.expr.multiline;\n      if (rule.needsSpecificStates && rule.activeStates != null) {\n        const ensureInstr = out.add(OpCode.EnsureState, null);\n        rule.activeStates.forEach((state) => {\n          const ind = out.registerState(state);\n          ensureInstr.add(ind);\n        });\n      }\n      this.compileExpr(rule.expr, out, ignoreCase, dotAll, multiline);\n      out.add(OpCode.Match, null).add(rule.priority, rule.matchIndex >= 0 ? rule.matchIndex : i);\n    });\n    return out;\n  }\n\n  /**\n   * Compile a given expression into a set of instructions.\n   */\n  protected compileExpr(expr: Regex, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): number {\n    const start = prog.length;\n    const currOffset = prog.length;\n    if (expr.groupIndex >= 0) {\n      if (this.emitPosition) prog.add(OpCode.Save).add((1 + expr.groupIndex) * 2);\n      if (this.emitGroups) prog.add(OpCode.GroupStart).add(1 + expr.groupIndex);\n    }\n    if (expr.tag == RegexType.CHAR) {\n      this.compileChar(expr as Char, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.START_OF_INPUT) {\n      const ml = expr.multiline == null ? multiline : expr.multiline;\n      prog.add(ml ? OpCode.MLStartingChar : OpCode.StartingChar);\n    } else if (expr.tag == RegexType.END_OF_INPUT) {\n      const ml = expr.multiline == null ? multiline : expr.multiline;\n      prog.add(ml ? OpCode.MLEndingChar : OpCode.EndingChar);\n    } else if (expr.tag == RegexType.START_OF_WORD) {\n      prog.add(OpCode.StartOfWord);\n    } else if (expr.tag == RegexType.END_OF_WORD) {\n      prog.add(OpCode.EndOfWord);\n    } else if (expr.tag == RegexType.CAT) {\n      this.compileCat(expr as Cat, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.UNION) {\n      this.compileUnion(expr as Union, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.QUANT) {\n      this.compileQuant(expr as Quant, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.VAR) {\n      this.compileVar(expr as Var, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.BACK_NAMED_REF) {\n      this.compileBackNamedRef(expr as BackNamedRef, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.BACK_NUM_REF) {\n      this.compileBackNumRef(expr as BackNumRef, prog, ignoreCase, dotAll, multiline);\n      // } else if (expr.tag == RegexType.NEG) { this.compileNeg(expr as Neg, prog);\n    } else if (expr.tag == RegexType.LOOK_AHEAD) {\n      this.compileLookAhead(expr as LookAhead, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.LOOK_BACK) {\n      this.compileLookBack(expr as LookBack, prog, ignoreCase, dotAll, multiline);\n    } else {\n      throw new Error(\"Regex Type not yet supported: \" + expr.tag);\n    }\n    if (expr.groupIndex >= 0) {\n      if (this.emitGroups) prog.add(OpCode.GroupEnd).add(1 + expr.groupIndex);\n      if (this.emitPosition) prog.add(OpCode.Save).add((1 + expr.groupIndex) * 2 + 1);\n    }\n    if (this.listener && prog.length > currOffset) {\n      this.listener(expr, prog, currOffset, prog.length - currOffset);\n    }\n    return prog.length - start;\n  }\n\n  protected compileChar(char: Char, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    if (char.op == CharType.AnyChar) {\n      // TODO - Should neg be ignored?\n      prog.add(dotAll ? OpCode.Any : OpCode.AnyNonNL);\n    } else {\n      const instr = prog.add(ignoreCase ? OpCode.CIChar : OpCode.Char);\n      instr.char = char;\n      /*\n      // We have Neg or not, CI or not\n      const instr = prog.add(\n        ignoreCase ? (char.neg ? OpCode.NegCIChar : OpCode.CIChar) : char.neg ? OpCode.NegChar : OpCode.Char,\n      );\n      instr.add(char.op);\n\n      // And now the arguments\n      for (const arg of char.args) instr.add(arg);\n      */\n    }\n  }\n\n  protected compileCat(cat: Cat, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    for (const child of cat.children) {\n      this.compileExpr(child, prog, ignoreCase, dotAll, multiline);\n    }\n  }\n\n  protected compileBackNumRef(\n    ne: BackNumRef,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // TODO - This may need a resolution at \"runtime\" so the instruction\n    // should reflect as such?\n    // See compiler.spec.ts - \"Test Back Named Groups\"\n    throw new Error(\"BackNumRef Not Implemented\");\n  }\n\n  protected compileBackNamedRef(\n    ne: BackNamedRef,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // TODO - This may need a resolution at \"runtime\" so the instruction\n    // should reflect as such?\n    // See compiler.spec.ts - \"Test Back Named Groups\"\n    throw new Error(\"BackNameRef Not Implemented\");\n  }\n\n  protected compileVar(v: Var, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    const name = v.name.trim();\n    const expr = this.regexResolver ? this.regexResolver(name) : null;\n    if (expr == null) {\n      throw new Error(`Cannot find expression: ${name}`);\n    }\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n  }\n\n  protected compileUnion(union: Union, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    const split = prog.add(OpCode.Split);\n    const jumps: Instr[] = [];\n\n    for (let i = 0; i < union.options.length; i++) {\n      split.add(prog.length);\n      this.compileExpr(union.options[i], prog, ignoreCase, dotAll, multiline);\n      if (i < union.options.length - 1) {\n        jumps.push(prog.add(OpCode.Jump));\n      }\n    }\n    for (const jmp of jumps) {\n      jmp.add(prog.length);\n    }\n  }\n\n  /**\n   * Compiles a repetition (with quantifiers) into its instructions.  This explicitly expands\n   * a rule of the form x\\{a,b\\} to xx... (a) times followed by x? (b - a) times\n   */\n  protected compileQuant(quant: Quant, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    // optimize the special cases of *, ? and +\n    if (quant.minCount == 0 && quant.maxCount == TSU.Constants.MAX_INT) {\n      // *\n      this.compileAtleast0(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else if (quant.minCount == 1 && quant.maxCount == TSU.Constants.MAX_INT) {\n      // +\n      this.compileAtleast1(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else if (quant.minCount == 0 && quant.maxCount == 1) {\n      // ?\n      this.compileOptional(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else {\n      // general case - Currently going with Option 1\n      //\n      // - convert x{a,b} to xxxxxx (a) times followed by x? b - a times\n      for (let i = 0; i < quant.minCount; i++) {\n        this.compileExpr(quant.expr, prog, ignoreCase, dotAll, multiline);\n      }\n      // generate x? b - a times\n      if (quant.isUnlimited) {\n        // then generate a a* here\n        this.compileAtleast0(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n      } else {\n        for (let i = quant.minCount; i < quant.maxCount; i++) {\n          this.compileOptional(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n        }\n      }\n    }\n  }\n\n  protected compileAtleast1(\n    expr: Regex,\n    prog: Prog,\n    greedy = true,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const l1 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    const split = prog.add(OpCode.Split);\n    const l3 = prog.length;\n    if (greedy) {\n      split.add(l1, l3);\n    } else {\n      split.add(l3, l1);\n    }\n  }\n\n  protected compileAtleast0(\n    expr: Regex,\n    prog: Prog,\n    greedy: boolean,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const split = prog.add(OpCode.Split);\n    const l1 = split.offset;\n    const l2 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    prog.add(OpCode.Jump).add(l1);\n    const l3 = prog.length;\n    if (greedy) {\n      split.add(l2, l3);\n    } else {\n      split.add(l3, l2);\n    }\n  }\n\n  protected compileOptional(\n    expr: Regex,\n    prog: Prog,\n    greedy: boolean,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const split = prog.add(OpCode.Split);\n    const l1 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    const l2 = prog.length;\n    if (greedy) {\n      split.add(l1, l2);\n    } else {\n      split.add(l2, l1);\n    }\n  }\n\n  /**\n   * Compiles lookahead assertions\n   */\n  protected compileLookAhead(\n    la: LookAhead,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // how should this work?\n    // Ensure that assertion matches first before continuing with the expression\n    this.compileExpr(la.expr, prog, ignoreCase, dotAll, multiline);\n    const begin = prog.add(OpCode.Begin).add(0, la.negate ? 1 : 0); // negate if needed\n    this.compileExpr(la.cond, prog, ignoreCase, dotAll, multiline);\n    const end = prog.add(OpCode.End).add(begin.offset);\n    begin.add(end.offset);\n  }\n\n  /**\n   * Compiles lookback assertions\n   */\n  protected compileLookBack(lb: LookBack, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    // Ensure that assertion matches first before continuing with the expression\n    this.compileExpr(lb.expr, prog, ignoreCase, dotAll, multiline);\n    TSU.assert(lb.expr.groupIndex >= 0, \"LookBack Assertion requires expression to have a group Index\");\n    const begin = prog.add(OpCode.RBegin).add(lb.expr.groupIndex, lb.negate ? 1 : 0); // negate if needed\n    this.compileExpr(lb.cond.reverse(), prog, ignoreCase, dotAll, multiline);\n    const end = prog.add(OpCode.End).add(begin.offset);\n    begin.add(end.offset);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Token } from \"./token\";\n\nexport class TokenizerError extends Error {\n  readonly name: string = \"TokenizerError\";\n\n  constructor(\n    message: string,\n    public offset: number,\n    public length: number,\n    public type: string,\n    public value: any = null,\n  ) {\n    super(message);\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\nexport class UnexpectedTokenError extends Error {\n  readonly name: string = \"UnexpectedTokenError\";\n  expectedTokens: Token[];\n\n  constructor(public foundToken: TSU.Nullable<Token>, ...expectedTokens: Token[]) {\n    super(\n      `Found Token: ${foundToken?.tag || \"EOF\"} (${foundToken?.value || \"\"}), Expected: ${expectedTokens.join(\", \")}`,\n    );\n    this.expectedTokens = expectedTokens;\n  }\n}\n","export abstract class TapeInterface {\n  index = 0;\n  abstract charAt(index: number): string;\n  abstract hasIndex(index: number): boolean;\n  abstract substring(startIndex: number, endIndex: number): string;\n\n  constructor(public forward = true) {}\n\n  advance(delta = 1): boolean {\n    const next = this.forward ? this.index + delta : this.index - delta;\n    // if (!this.hasIndex(next)) return false;\n    this.index = next;\n    return true;\n  }\n\n  canAdvance(delta = 1): boolean {\n    const next = this.forward ? this.index + delta : this.index - delta;\n    return this.hasIndex(next);\n  }\n\n  get hasMore(): boolean {\n    const next = this.forward ? this.index : this.index - 1;\n    return this.hasIndex(next);\n    // return this.forward ? this.index < this.input.length : this.index > 0;\n  }\n\n  get currCh(): string {\n    return this.charAt(this.index);\n  }\n\n  get prevCh(): string {\n    return this.charAt(this.index - (this.forward ? 1 : -1));\n  }\n\n  get nextCh(): string {\n    const next = this.index + (this.forward ? 1 : -1);\n    return this.charAt(next);\n  }\n\n  get currChCode(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.charCodeAt(0);\n    // return this.input.charCodeAt(this.index);\n  }\n\n  get currChCodeLower(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.toLowerCase().charCodeAt(0);\n  }\n\n  get currChCodeUpper(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.toUpperCase().charCodeAt(0);\n  }\n\n  charCodeAt(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).charCodeAt(0);\n  }\n\n  charCodeAtLower(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).toLowerCase().charCodeAt(0);\n  }\n\n  charCodeAtUpper(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).toUpperCase().charCodeAt(0);\n  }\n}\n\n/**\n * A Tape of characters we would read with some extra helpers like rewinding\n * forwarding and prefix checking that is fed into the different tokenizers\n * used by the scannerless parsers.\n */\nexport class Tape extends TapeInterface {\n  protected _rawInput: string;\n  readonly input: string[];\n\n  constructor(input: string, public forward = true) {\n    super(forward);\n    this._rawInput = input;\n    this.input = [...input];\n  }\n\n  push(content: string): void {\n    this._rawInput += content;\n    this.input.push(...content);\n  }\n\n  substring(startIndex: number, endIndex: number): string {\n    return this._rawInput.substring(startIndex, endIndex);\n    // return this.input.slice(startIndex, endIndex).join(\"\");\n  }\n\n  hasIndex(index: number): boolean {\n    return index >= 0 && index < this.input.length;\n  }\n\n  charAt(index: number): string {\n    if (index < 0 || index >= this.input.length) return \"\";\n    return this.input[index];\n  }\n}\n\nexport class TapeHelper {\n  /**\n   * Advances the tape to the end of the first occurence of\n   * the given pattern.\n   */\n  static advanceAfter(tape: TapeInterface, pattern: string, ensureNoPrefixSlash = true): number {\n    let pos = TapeHelper.advanceTo(tape, pattern, ensureNoPrefixSlash);\n    if (pos >= 0) {\n      pos += pattern.length;\n      tape.index = pos;\n    }\n    return pos;\n  }\n\n  /**\n   * Advances the tape till the start of a given pattern.\n   * This is not the most optimal implementation and just does a brute\n   * force search at each index.  Instead using the Regex interface\n   * directly will be faster.\n   */\n  static advanceTo(tape: TapeInterface, pattern: string, ensureNoPrefixSlash = true): number {\n    const lastIndex = tape.index;\n    while (tape.hasMore) {\n      const currStart = tape.index;\n      if (TapeHelper.matches(tape, pattern)) {\n        const endIndex = tape.index;\n        tape.index = currStart;\n        let numSlashes = 0;\n        if (ensureNoPrefixSlash) {\n          for (let i = endIndex - 1; i >= 0; i--) {\n            if (tape.charAt(i) == \"\\\\\") numSlashes++;\n            else break;\n          }\n        }\n        if (numSlashes % 2 == 0) {\n          return tape.index;\n        }\n      }\n      tape.advance(1);\n    }\n    tape.index = lastIndex;\n    throw new Error(`Unexpected end of input before (${pattern})`);\n    return -1;\n  }\n\n  /**\n   * Tells if the given prefix is matche at the current position of the tokenizer.\n   */\n  static matches(tape: TapeInterface, prefix: string, advance = true): boolean {\n    const lastIndex = tape.index;\n    let i = 0;\n    let success = true;\n    for (; i < prefix.length; i++) {\n      if (prefix[i] != tape.currCh) {\n        success = false;\n        break;\n      }\n      tape.advance(1);\n    }\n    // Reset pointers if we are only peeking or match failed\n    if (!advance || !success) {\n      tape.index = lastIndex;\n    }\n    return success;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport { TokenizerError, UnexpectedTokenError } from \"./errors\";\n\nexport type TokenType = number | string;\n\nexport class Token {\n  private static idCounter = 0;\n  // ID for uniquely identifying tokens if needed for shallow equality\n  id = Token.idCounter++;\n  value: any = null;\n  groups: TSU.NumMap<number[]> = {};\n  positions: TSU.NumMap<[number, number]> = {};\n\n  // Incremental lexing support fields\n  /**\n   * Lexer state when this token was constructed.\n   * 0 = INITIAL state. Higher numbers represent other states (e.g., inside string, comment).\n   * Used for incremental lexing to restart from a token boundary.\n   */\n  state = 0;\n\n  /**\n   * Number of characters read beyond this token's lexeme to determine it.\n   * Most tokens need 1 char lookahead to know they're complete (e.g., identifier ends on non-alnum).\n   * Used for incremental lexing dependency tracking.\n   */\n  lookahead = 1;\n\n  /**\n   * Number of preceding tokens whose lookahead reaches this token.\n   * Default 1 means the previous token's lookahead extends into this token.\n   * Used for incremental lexing to find affected region on edit.\n   */\n  lookback = 1;\n\n  constructor(public tag: TokenType, public readonly matchIndex: number, public start: number, public end: number) {}\n\n  isOneOf(...expected: any[]): boolean {\n    for (const tok of expected) {\n      if (this.tag == tok) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n\nexport type NextTokenFunc = (tape: Tape, owner: any) => Token | null;\n\n/**\n * A wrapper on a tokenizer for providing features like k-lookahead, token\n * insertion, rewinding, expectation enforcement etc.\n */\nexport class TokenBuffer {\n  buffer: Token[] = [];\n\n  constructor(public readonly nextToken: NextTokenFunc, public tokenizerContext: any) {}\n\n  next(tape: Tape): Token | null {\n    const out = this.peek(tape);\n    if (out != null) {\n      this.consume();\n    }\n    return out;\n  }\n\n  /**\n   * Peek at the nth token in the token stream.\n   */\n  peek(tape: Tape, nth = 0): Token | null {\n    while (this.buffer.length <= nth) {\n      const tok = this.nextToken(tape, this.tokenizerContext);\n      if (tok == null) return null;\n      this.buffer.push(tok);\n    }\n    return this.buffer[nth];\n  }\n\n  match(\n    tape: Tape,\n    matchFunc: (token: Token) => boolean,\n    ensure = false,\n    consume = true,\n    nextAction?: (token: Token) => boolean | undefined,\n  ): Token | null {\n    const token = this.peek(tape);\n    if (token != null) {\n      if (matchFunc(token)) {\n        if (nextAction && nextAction != null) {\n          nextAction(token);\n        }\n        if (consume) {\n          this.consume();\n        }\n      } else if (ensure) {\n        // Should we throw an error?\n        throw new UnexpectedTokenError(token);\n      } else {\n        return null;\n      }\n    } else if (ensure) {\n      throw new TokenizerError(\"Unexpected end of input\", -1, 0, \"UnexpectedEndOfInput\");\n    }\n    return token;\n  }\n\n  consume(): void {\n    this.buffer.splice(0, 1);\n  }\n\n  consumeIf(tape: Tape, ...expected: TokenType[]): Token | null {\n    return this.match(tape, (t) => t.isOneOf(...expected));\n  }\n\n  expectToken(tape: Tape, ...expected: TokenType[]): Token {\n    return this.match(tape, (t) => t.isOneOf(...expected), true, true) as Token;\n  }\n\n  ensureToken(tape: Tape, ...expected: TokenType[]): Token {\n    return this.match(tape, (t) => t.isOneOf(...expected), true, false) as Token;\n  }\n\n  nextMatches(tape: Tape, ...expected: TokenType[]): Token | null {\n    const token = this.peek(tape);\n    if (token == null) return null;\n    for (const tok of expected) {\n      if (token.tag == tok) return token;\n    }\n    return null;\n  }\n}\n","export class GroupCounter {\n  value = -1;\n  next(): number {\n    return ++this.value;\n  }\n  get current(): number {\n    return this.value;\n  }\n}\n\nexport function isSpace(ch: string): boolean {\n  return ch == \" \" || ch == \"\\t\" || ch == \"\\n\" || ch == \"\\r\";\n}\n\n// function isSpaceChar(ch: string): boolean { return ch == \" \" || ch == \"\\t\"; }\n","import * as TSU from \"@panyam/tsutils\";\nimport {\n  Quant,\n  RegexType,\n  StartOfInput,\n  EndOfInput,\n  Regex,\n  Cat,\n  Char,\n  LeafChar,\n  CharGroup,\n  CharType,\n  Var,\n  BackNamedRef,\n  BackNumRef,\n  LookAhead,\n  LookBack,\n  Union,\n} from \"./core\";\nimport { CharClassType } from \"./charclasses\";\nimport { GroupCounter } from \"./utils\";\n\n/**\n * A RegexParser for parsing regex strings in JS RegExp format.\n * This class will seldom have to be used directly.  Instead use one of the methods in {@link Builder}\n */\nexport class RegexParser {\n  protected unicode: boolean;\n  protected counter: GroupCounter;\n  /**\n   * @param pattern The pattern string being parsed.\n   * @param config  Configs for the regex to include whether parsing is unicode or plain ASCII.\n   */\n  constructor(public readonly pattern: string, config?: { unicode?: boolean }) {\n    this.counter = new GroupCounter();\n    this.unicode = config?.unicode || false;\n  }\n\n  protected reduceLeft(stack: Regex[]): Regex {\n    const r = stack.length == 1 ? stack[0] : new Cat(...stack);\n    // remove all elements on stack\n    stack.splice(0);\n    return r;\n  }\n\n  protected throwError(msg: string): void {\n    throw new SyntaxError(`Error in JS RE '${this.pattern}': ${msg}`);\n  }\n\n  /**\n   * Creates a regex tree given a string\n   */\n  parse(curr = 0, end = -1): Regex {\n    const pattern = this.pattern;\n    const stack: Regex[] = [];\n    if (end < 0) end = pattern.length - 1;\n    while (curr <= end) {\n      const currCh = pattern[curr];\n      // see if we have groups so they get highest preference\n      if (currCh == \".\") {\n        stack.push(LeafChar.Any());\n        curr++;\n      } else if (currCh == \"\\\\\" && pattern[curr + 1] >= \"1\" && pattern[curr + 1] <= \"9\") {\n        // Numeric references\n        curr++;\n        let num = \"\";\n        while (curr <= end && pattern[curr] >= \"0\" && pattern[curr] <= \"9\") {\n          num = num + pattern[curr++];\n        }\n        const refNum = parseInt(num);\n        if (refNum > this.counter.current + 1) {\n          this.throwError(\"Invalid reference: \" + refNum);\n        }\n        stack.push(new BackNumRef(refNum));\n      } else if (currCh == \"\\\\\" && pattern[curr + 1] == \"k\" && pattern[curr + 2] == \"<\") {\n        // Named references\n        curr += 3;\n        let gtPos = curr;\n        while (gtPos <= end && pattern[gtPos] != \">\") gtPos++;\n        if (gtPos > end) this.throwError(\"Expected '>' found EOI\");\n        const name = pattern.substring(curr, gtPos);\n        if (name.trim() == \"\") {\n          this.throwError(\"Expected name\");\n        }\n        stack.push(new BackNamedRef(name));\n        curr = gtPos + 1;\n      } else if (currCh == \"[\") {\n        // character ranges\n        let clPos = curr + 1;\n        while (clPos <= end && pattern[clPos] != \"]\") {\n          if (pattern[clPos] == \"\\\\\") clPos++;\n          clPos++;\n        }\n        if (clPos > end) this.throwError(\"Expected ']' found EOI\");\n        stack.push(this.parseCharGroup(curr + 1, clPos - 1));\n        curr = clPos + 1;\n      } else if (currCh == \"^\") {\n        stack.push(new StartOfInput());\n        curr++;\n      } else if (currCh == \"$\") {\n        stack.push(new EndOfInput());\n        curr++;\n      } else if (currCh == \"|\") {\n        if (curr + 1 <= end) {\n          // reduce everything \"until now\" and THEN apply\n          const prev = this.reduceLeft(stack);\n          // this.parse everything to the right\n          const rest = this.parse(curr + 1, end);\n          return new Union(prev, rest);\n        }\n        curr = end + 1;\n      } else if (currCh == \"(\") {\n        curr = this.parseGroup(stack, curr, end);\n      } else if (currCh == \")\" || currCh == \"]\" || currCh == \"}\") {\n        this.throwError(`Unmatched ${currCh}.  Try using \\\\${currCh}`);\n      } else if (pattern[curr] == \"*\" || pattern[curr] == \"?\" || pattern[curr] == \"+\" || pattern[curr] == \"{\") {\n        curr = this.parseQuant(stack, curr, end);\n      } else {\n        // plain old alphabets\n        const [result, nchars] = this.parseChar(curr, end);\n        stack.push(result);\n        curr += nchars;\n      }\n    }\n    if (stack.length <= 0) {\n      // this.throwError(`Invalid Regex (${curr} - ${end}): ${pattern}`);\n    }\n    if (stack.length == 1) return stack[0];\n    return new Cat(...stack);\n  }\n\n  protected parseGroup(stack: Regex[], curr: number, end: number): number {\n    // we have a grouping or an assertion\n    let clPos = curr + 1;\n    let depth = 0;\n    const pattern = this.pattern;\n    while (clPos <= end && (pattern[clPos] != \")\" || depth > 0)) {\n      if (pattern[clPos] == \"(\") depth++;\n      else if (pattern[clPos] == \")\") depth--;\n      if (pattern[clPos] == \"\\\\\") clPos++;\n      clPos++;\n    }\n    if (clPos > end) this.throwError(\"Expected ')' found EOI\");\n\n    curr++;\n    if (pattern[curr] == \"?\") {\n      // assertions\n      curr++; // skip the \"?\"\n      if (pattern[curr] == \":\") {\n        // A non capturing\n        stack.push(this.parse(curr + 1, clPos - 1));\n      } else if (pattern[curr] == \"<\" && pattern[curr + 1] != \"!\" && pattern[curr + 1] != \"=\") {\n        // Named capture group\n        const groupIndex = this.counter.next();\n        let groupName = \"\";\n        // get name of this group\n        let gtPos = curr + 1;\n        while (gtPos <= end && pattern[gtPos] != \">\") {\n          groupName += pattern[gtPos];\n          gtPos++;\n        }\n        const subExpr = this.parse(gtPos + 1, clPos - 1);\n        subExpr.groupIndex = groupIndex;\n        if (groupName.length > 0) subExpr.groupName = groupName;\n      } else {\n        // We have lookback/ahead assertions\n        let after = true;\n        if (pattern[curr] == \"<\") {\n          curr++;\n          after = false;\n        }\n        const neg = pattern[curr++] == \"!\";\n        const cond = this.parse(curr, clPos - 1);\n        if (after) {\n          // reduce everything \"until now\" and THEN apply\n          if (stack.length == 0) {\n            // this.throwError(\"LookAhead condition cannot be before empty rule\");\n          }\n          // const endIndex = stack.length - 1;\n          // stack[endIndex] = new LookAhead(stack[endIndex], cond, neg);\n          const expr = new LookAhead(this.reduceLeft(stack), cond, neg);\n          stack.push(expr);\n        } else {\n          // Lookbacks are interesting, we have something like:\n          // (?<!...)abcde\n          // clPos points to \")\" We need abcde also parsed\n          // and then lookback applied to it\n          const rest = this.parse(clPos + 1, end);\n          if (rest.groupIndex < 0) {\n            rest.groupIndex = this.counter.next();\n            rest.groupIsSilent = true;\n          }\n          stack.push(new LookBack(rest, cond, neg));\n          return end + 1;\n        }\n      }\n    } else {\n      // plain old grouping of the form (xyz)\n      const groupIndex = this.counter.next();\n      let neg = false;\n      if (pattern[curr] == \"^\") {\n        neg = true;\n        curr++;\n      }\n      let subExpr = this.parse(curr, clPos - 1);\n      // if (neg) subExpr = new Neg(subExpr);\n      // Do the next before the previous call if we want group\n      // index to match outer brackets first\n      if (subExpr.groupIndex >= 0) {\n        // Already set so create cat\n        subExpr = new Cat(subExpr);\n      }\n      subExpr.groupIndex = groupIndex;\n      stack.push(subExpr);\n    }\n    return clPos + 1;\n  }\n\n  protected parseCharGroup(curr: number, end: number): Char {\n    const out: Char[] = [];\n    // first see which characters are in this (until the end)\n    let i = curr;\n    let neg = false;\n    const pattern = this.pattern;\n    if (pattern[i] == \"^\") {\n      neg = true;\n      i++;\n    }\n    for (; i <= end; ) {\n      const [currch, nchars] = this.parseChar(i, end);\n      i += nchars;\n      if (i < pattern.length && pattern[i] == \"-\") {\n        i++;\n        // TODO - Should this be for all such \"operator\" charactors?\n        if (pattern[i] == \"]\" || pattern[i] == \"[\") {\n          // Special case for something like:\n          // [....x-] or [.....x-[:alpha:]]\n          out.push(currch);\n          out.push(LeafChar.Single(\"-\"));\n        } else if (i <= end) {\n          const [endch, nchars] = this.parseChar(i, end);\n          if (currch.op != CharType.SingleChar || endch.op != CharType.SingleChar) {\n            this.throwError(\"Char range cannot start or end in a char class\");\n          }\n          if (endch.args[0] < currch.args[0]) {\n            this.throwError(\"End cannot be less than start\");\n          }\n          out.push(CharGroup.Range(currch, endch));\n          i += nchars;\n        } else {\n          this.throwError(\"Unterminated char class\");\n        }\n      } else {\n        out.push(currch);\n      }\n    }\n    return CharGroup.Union(neg, out);\n  }\n\n  protected parseChar(index = 0, end = 0): [LeafChar, number] {\n    if (this.pattern[index] == \"\\\\\") {\n      return this.parseEscapeChar(index, end);\n    } else {\n      return this.parseSingleChar(index, end);\n    }\n  }\n\n  protected parseSingleChar(index = 0, end = 0): [LeafChar, number] {\n    // single char\n    const ch = this.pattern.charCodeAt(index);\n    return [LeafChar.Single(ch), 1];\n  }\n\n  protected parsePropertyEscape(index = 0, end = 0): [LeafChar, number] {\n    const pattern = this.pattern;\n    if (pattern[index] + 1 != \"{\") {\n      this.throwError(\"Invalid property escape\");\n    }\n    index += 2;\n    let clEnd = index;\n    let eqPos = -1;\n    while (clEnd <= end && pattern[clEnd] != \"}\") {\n      if (pattern[clEnd] == \"=\") eqPos = clEnd;\n      clEnd++;\n    }\n    if (clEnd > end) {\n      this.throwError(\"Invalid property escape\");\n    }\n    // see if this is a lone property escape\n    const propStr = pattern.substring(index, clEnd);\n    let propName = \"General_Category\";\n    let propValue = propStr;\n    if (eqPos >= 0) {\n      const parts = propStr.split(\"=\");\n      if (parts.length != 2) this.throwError(\"Invalid property escape\");\n      propName = parts[0].trim();\n      propValue = parts[1].trim();\n    }\n    return [LeafChar.PropertyEscape(propName, propValue), 2 + clEnd + 1 - index];\n  }\n\n  protected parseEscapeChar(index = 0, end = 0): [LeafChar, number] {\n    const pattern = this.pattern;\n    TSU.assert(pattern[index] == \"\\\\\", \"Expected '\\\\'\");\n    // escape char\n    index++;\n    if (index > end) {\n      this.throwError(\"Encounted unexpected end of input after \\\\\");\n    }\n    const ch = pattern[index];\n    if ((this.unicode && ch == \"p\") || ch == \"P\") {\n      // property escapes\n      return this.parsePropertyEscape(index, end);\n    }\n    switch (ch) {\n      // char classes\n      case \"w\":\n        return [LeafChar.Class(CharClassType.WORD_CHAR), 2];\n      case \"W\":\n        return [LeafChar.Class(CharClassType.WORD_CHAR, true), 2];\n      case \"d\":\n        return [LeafChar.Class(CharClassType.DIGITS), 2];\n      case \"D\":\n        return [LeafChar.Class(CharClassType.DIGITS, true), 2];\n      case \"s\":\n        return [LeafChar.Class(CharClassType.SPACES), 2];\n      case \"S\":\n        return [LeafChar.Class(CharClassType.SPACES, true), 2];\n      case \"0\":\n        if (pattern[index + 1] >= \"0\" && pattern[index + 1] <= \"9\" && this.unicode) {\n          this.throwError(\"Invalid decimal escape\");\n        }\n        return [LeafChar.Single(\"\\0\"), 2];\n      case \"r\":\n        return [LeafChar.Single(\"\\r\"), 2];\n      case \"n\":\n        return [LeafChar.Single(\"\\n\"), 2];\n      case \"f\":\n        return [LeafChar.Single(\"\\f\"), 2];\n      case \"b\":\n        return [LeafChar.Single(\"\\b\"), 2];\n      case \"v\":\n        return [LeafChar.Single(\"\\v\"), 2];\n      case \"t\":\n        return [LeafChar.Single(\"\\t\"), 2];\n      case \"c\":\n        // ControlEscape:\n        // https://262.ecma-international.org/5.1/#sec-15.10.2.10\n        if (this.unicode || index >= end) {\n          this.throwError(`Invalid char sequence at ${index}, ${end}`);\n        }\n        const next = pattern.charCodeAt(index + 1) % 32;\n        return [LeafChar.Single(next), 3];\n      case \"x\":\n        // 2 digit hex digits\n        index++;\n        if (index >= end) {\n          this.throwError(`Invalid hex sequence at ${index}, ${end}`);\n        }\n        const hexSeq = pattern.substring(index, index + 2);\n        const hexVal = parseInt(hexSeq, 16);\n        TSU.assert(!isNaN(hexVal), `Invalid hex sequence: '${hexSeq}'`);\n        return [LeafChar.Single(hexVal), 4];\n      case \"u\": // this could \\uABCD or \\u{ABCDEF}\n        index++;\n        // 4 digit hex digits for unicode\n        if (index > end - 3) {\n          this.throwError(`Invalid unicode sequence at ${index}`);\n        }\n        const ucodeSeq = pattern.substring(index, index + 4);\n        const ucodeVal = parseInt(ucodeSeq, 16);\n        if (isNaN(ucodeVal)) {\n          this.throwError(`Invalid unicode sequence: '${ucodeSeq}'`);\n        }\n        return [LeafChar.Single(ucodeVal), 6];\n      case \"^\": // List of special operators that need to be escaped\n      case \"$\":\n      case \".\":\n      case \"*\":\n      case \"+\":\n      case \"?\":\n      case \"\\\\\":\n      case \"'\":\n      case '\"':\n      case \"(\":\n      case \")\":\n      case \"[\":\n      case \"]\":\n      case \"{\":\n      case \"}\":\n      case \"|\":\n      case \"/\":\n        return [LeafChar.Single(ch), 2];\n      default:\n        if (this.unicode) this.throwError(\"Invalid escape character: \" + ch);\n        return [LeafChar.Single(ch), 2];\n    }\n  }\n\n  protected parseQuant(stack: Regex[], curr: number, end: number): number {\n    const pattern = this.pattern;\n    const lastCh = pattern[curr - 1];\n    let minCount = 1,\n      maxCount = 1;\n    if (pattern[curr] == \"*\") {\n      minCount = 0;\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (pattern[curr] == \"+\") {\n      minCount = Math.min(minCount, 1);\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (pattern[curr] == \"?\") {\n      minCount = 0;\n      maxCount = Math.max(maxCount, 1);\n    } else if (pattern[curr] == \"{\") {\n      // find the next \"}\"\n      const clPos = pattern.indexOf(\"}\", curr + 1);\n      if (clPos <= curr || clPos > end) {\n        this.throwError(\"Unexpected end of input while looking for '}'\");\n      }\n      const sub = pattern.substring(curr + 1, clPos).trim();\n      const parts = sub.split(\",\").map((x) => parseInt(x.trim()));\n      curr = clPos;\n      if (parts.length == 1) {\n        if (isNaN(parts[0])) {\n          if (sub.trim().length > 0) {\n            stack.push(new Var(sub.trim()));\n            return curr + 1;\n          } else {\n            this.throwError(`Invalid quantifier: /${sub}/`);\n          }\n        }\n        minCount = maxCount = parts[0];\n      } else if (parts.length == 2) {\n        minCount = isNaN(parts[0]) ? 0 : parts[0];\n        maxCount = isNaN(parts[1]) ? TSU.Constants.MAX_INT : parts[1];\n        if (minCount > maxCount) {\n          this.throwError(`Invalid Quant /${sub}/: Min must be <= Max`);\n        }\n      } else if (parts.length > 2) {\n        this.throwError(`Invalid quantifier spec: \"{${sub}}\"`);\n      }\n    } else {\n      throw new Error(\"Here?\");\n    }\n    // Quantifiers\n    if (stack.length <= 0) {\n      this.throwError(\"Quantifier cannot appear before an expression\");\n    }\n    // no optimizations - convert the last one into a Quantifier\n    // and we will start to fill in the quantities and greediness\n    const last = stack[stack.length - 1];\n    if (last.tag == RegexType.QUANT && (lastCh == \"*\" || lastCh == \"?\" || lastCh == \"+\" || lastCh == \"}\")) {\n      this.throwError(\"Nothing to repeat\");\n    }\n    if (this.unicode && (last.tag == RegexType.LOOK_AHEAD || last.tag == RegexType.LOOK_BACK)) {\n      this.throwError(\"Cannot have quantifier on assertion in unicode mode\");\n    }\n    const quant = (stack[stack.length - 1] = new Quant(last));\n    quant.minCount = minCount;\n    quant.maxCount = maxCount;\n    // check if there is an extra lazy quantifier\n    curr++;\n    if (curr <= end && pattern[curr] == \"?\" && quant.greedy) {\n      curr++;\n      quant.greedy = false;\n    }\n    return curr;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport {\n  LookAhead,\n  Quant,\n  RegexType,\n  StartOfInput,\n  EndOfInput,\n  Regex,\n  Cat,\n  CharType,\n  Char,\n  LeafChar,\n  CharGroup,\n  Var,\n  Union,\n} from \"./core\";\nimport { CharClassType } from \"./charclasses\";\nimport { GroupCounter, isSpace } from \"./utils\";\n\nfunction advanceIf(tape: Tape, ch: string): boolean {\n  const pos = tape.index;\n  for (let i = 0; i < ch.length; i++) {\n    if (tape.currCh != ch.charAt(i)) {\n      tape.index = pos;\n      return false;\n    }\n    tape.advance(1);\n  }\n  return true;\n}\n\n/**\n * A RegexParser for parsing regex strings in Flex RE format.\n * This class will seldom have to be used directly.  Instead use one of the methods in {@link Builder}\n */\nexport class RegexParser {\n  protected counter: GroupCounter = new GroupCounter();\n\n  parse(pattern: Tape, ignoreSpaces = false, obCount = 0): Regex {\n    const stack: Regex[] = [];\n\n    while (pattern.hasMore) {\n      const currCh = pattern.currCh;\n      // see if we have groups so they get highest preference\n      if (advanceIf(pattern, \".\")) {\n        stack.push(LeafChar.Any());\n      } else if (advanceIf(pattern, \"^\")) {\n        const x = new StartOfInput();\n        x.multiline = true;\n        stack.push(x);\n      } else if (advanceIf(pattern, \"$\")) {\n        const x = new EndOfInput();\n        x.multiline = true;\n        stack.push(x);\n      } else if (advanceIf(pattern, \"|\")) {\n        // reduce everything \"until now\" and THEN apply\n        const prev = this.reduceLeft(stack);\n        // this.parse everything to the right\n        const rest = this.parse(pattern, ignoreSpaces, obCount);\n        return new Union(prev, rest);\n      } else if (currCh == \"[\") {\n        stack.push(this.parseCharGroup(pattern));\n      } else if (currCh == \"*\" || currCh == \"?\" || currCh == \"+\" || currCh == \"{\") {\n        this.parseQuant(pattern, stack);\n      } else if (ignoreSpaces && isSpace(currCh)) {\n        // do nothing\n        pattern.advance(1);\n      } else if (ignoreSpaces && advanceIf(pattern, \"/*\")) {\n        // Read everything until a */\n        while (pattern.currCh != \"*\" || pattern.nextCh != \"/\") {\n          if (!pattern.hasMore) {\n            this.throwError(pattern, \"Unterminated comment\");\n          }\n          pattern.advance(1);\n        }\n        pattern.advance(2);\n        // now do nothing\n      } else if (advanceIf(pattern, \"{-}\")) {\n        // char class intersection\n        throw new Error(\"Intersection Not yet supported\");\n      } else if (advanceIf(pattern, \"{+}\")) {\n        // char class union\n        throw new Error(\"Union Not yet supported\");\n      } else if (advanceIf(pattern, \"(\")) {\n        if (advanceIf(pattern, \"?\")) {\n          if (advanceIf(pattern, \"#\")) {\n            while (pattern.hasMore && pattern.currCh != \")\") pattern.advance(1);\n            TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n          } else {\n            // pattern of the form (?r-s:pattern)\n            let ignoreCase = false;\n            let dotAll = false;\n            let ignoreSpaces2 = ignoreSpaces as boolean;\n            let neg = false;\n            while (pattern.hasMore && pattern.currCh != \":\") {\n              if (pattern.currCh == \"i\") {\n                ignoreCase = neg ? false : true;\n              } else if (pattern.currCh == \"s\") {\n                dotAll = neg ? false : true;\n              } else if (pattern.currCh == \"x\") {\n                ignoreSpaces2 = neg ? false : true;\n              } else if (pattern.currCh == \"-\") {\n                neg = true;\n              }\n              pattern.advance(1);\n            }\n            TSU.assert(advanceIf(pattern, \":\"), \"Expected ':'\");\n            const groupIndex = this.counter.next();\n            let subExpr = this.parse(pattern, ignoreSpaces2, obCount + 1);\n            if (subExpr.groupIndex >= 0) {\n              // Already set so create cat\n              subExpr = new Cat(subExpr);\n            }\n            subExpr.dotAll = dotAll;\n            subExpr.ignoreCase = ignoreCase;\n            subExpr.groupIndex = groupIndex;\n            stack.push(subExpr);\n            TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n          }\n        } else {\n          // parse the subgroup and give it a group number\n          const groupIndex = this.counter.next();\n          let subExpr = this.parse(pattern, ignoreSpaces, obCount + 1);\n          if (subExpr.groupIndex >= 0) {\n            // Already set so create cat\n            subExpr = new Cat(subExpr);\n          }\n          subExpr.groupIndex = groupIndex;\n          stack.push(subExpr);\n          TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n        }\n      } else if (currCh == \")\") {\n        if (obCount == 0) {\n          this.throwError(pattern, `Unmatched ${currCh}.  Try using \\\\${currCh}`);\n        }\n        // stop here so we can recurse up\n        break;\n      } else if (currCh == \"]\" || currCh == \"}\") {\n        this.throwError(pattern, `Unmatched ${currCh}.  Try using \\\\${currCh}`);\n      } else if (advanceIf(pattern, \"/\")) {\n        // LookAheads\n        const prev = this.reduceLeft(stack);\n        // this.parse everything to the right\n        const rest = this.parse(pattern, ignoreSpaces, obCount);\n        return new LookAhead(prev, rest, false);\n      } else if (advanceIf(pattern, '\"')) {\n        // raw string\n        while (pattern.currCh != '\"') {\n          if (!pattern.hasMore) {\n            this.throwError(pattern, \"Unterminated string\");\n          }\n          stack.push(this.parseChar(pattern));\n        }\n        pattern.advance(1);\n      } else {\n        // plain old alphabets\n        stack.push(this.parseChar(pattern));\n      }\n    }\n    if (stack.length == 1) return stack[0];\n    return new Cat(...stack);\n  }\n\n  protected parseQuant(pattern: Tape, stack: Regex[]): void {\n    let minCount = 1,\n      maxCount = 1;\n    if (advanceIf(pattern, \"*\")) {\n      minCount = 0;\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (advanceIf(pattern, \"+\")) {\n      minCount = Math.min(minCount, 1);\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (advanceIf(pattern, \"?\")) {\n      minCount = 0;\n      maxCount = Math.max(maxCount, 1);\n    } else if (advanceIf(pattern, \"{\")) {\n      let foundComma = false;\n      let p1 = \"\";\n      let p2 = \"\";\n      while (pattern.hasMore && pattern.currCh != \"}\") {\n        if (pattern.currCh == \",\") foundComma = true;\n        else {\n          if (!foundComma) p1 += pattern.currCh;\n          else p2 += pattern.currCh;\n        }\n        pattern.advance(1);\n      }\n      if (!pattern.hasMore) {\n        this.throwError(pattern, \"Invalid property escape\");\n      }\n      // see if this is a lone property escape\n      p1 = p1.trim();\n      p2 = p2.trim();\n      // advance over the \"}\"\n      pattern.advance(1);\n\n      const part1 = parseInt(p1);\n      const part2 = parseInt(p2);\n      if (foundComma) {\n        minCount = isNaN(part1) ? 0 : part1;\n        maxCount = isNaN(part2) ? TSU.Constants.MAX_INT : part2;\n        if (minCount > maxCount) {\n          this.throwError(pattern, `Invalid Quant /${p1},${p2}/: Min must be <= Max`);\n        }\n      } else {\n        if (isNaN(part1)) {\n          if (p1.length > 0) {\n            stack.push(new Var(p1));\n            // nothing more\n            return;\n          } else {\n            this.throwError(pattern, `Invalid quantifier: /${p1}/`);\n          }\n          minCount = maxCount = 1;\n        } else {\n          minCount = maxCount = part1;\n        }\n      }\n    } else {\n      this.throwError(pattern, \"Expected '{', '*', '?' or '+', Found: \" + pattern.currCh);\n    }\n    // Quantifiers\n    if (stack.length <= 0) {\n      this.throwError(pattern, \"Quantifier cannot appear before an expression\");\n    }\n    // no optimizations - convert the last one into a Quantifier\n    // and we will start to fill in the quantities and greediness\n    const last = stack[stack.length - 1];\n    let quant: Quant;\n    if (last.tag == RegexType.QUANT && last.groupIndex < 0) {\n      // Fold repeated quants unless they are not in a group\n      quant = last as Quant;\n      quant.minCount = Math.min(minCount, quant.minCount);\n      quant.maxCount = Math.max(maxCount, quant.maxCount);\n    } else {\n      quant = stack[stack.length - 1] = new Quant(last);\n      quant.minCount = minCount;\n      quant.maxCount = maxCount;\n    }\n    // check if there is an extra lazy quantifier\n    if (quant.greedy && advanceIf(pattern, \"?\")) {\n      quant.greedy = false;\n    }\n  }\n\n  protected parseCharGroup(pattern: Tape): Char {\n    const out: Char[] = [];\n    TSU.assert(advanceIf(pattern, \"[\"), \"Expected '['\");\n    // first see which characters are in this (until the end)\n    const neg = advanceIf(pattern, \"^\");\n    while (pattern.currCh != \"]\") {\n      const currch = this.parseChar(pattern);\n      if (advanceIf(pattern, \"-\")) {\n        if (pattern.hasMore) {\n          // TODO - Should this be for all such \"operator\" charactors?\n          if (pattern.currCh == \"]\" || pattern.currCh == \"[\") {\n            // Special case for something like:\n            // [....x-] or [.....x-[:alpha:]]\n            out.push(currch);\n            out.push(LeafChar.Single(\"-\"));\n          } else {\n            const endch = this.parseChar(pattern);\n            if (currch.op != CharType.SingleChar || endch.op != CharType.SingleChar) {\n              this.throwError(pattern, \"Char range cannot start or end in a char class\");\n            }\n            if (endch.args[0] < currch.args[0]) {\n              this.throwError(pattern, \"End cannot be less than start\");\n            }\n            // currch.end = endch.start;\n            out.push(CharGroup.Range(currch, endch));\n          }\n        } else {\n          this.throwError(pattern, \"Unterminated char class\");\n        }\n      } else {\n        out.push(currch);\n      }\n    }\n    TSU.assert(advanceIf(pattern, \"]\"), \"']' expected\");\n    return CharGroup.Union(neg, out);\n  }\n\n  protected parseChar(pattern: Tape): LeafChar {\n    if (pattern.currCh == \"\\\\\") {\n      return this.parseEscapeChar(pattern);\n    } else {\n      return this.parseSingleChar(pattern);\n    }\n  }\n\n  protected parseSingleChar(pattern: Tape): LeafChar {\n    // single char\n    const ch = pattern.currCh;\n    pattern.advance(1);\n    return LeafChar.Single(ch);\n  }\n\n  protected parsePropertyEscape(pattern: Tape): LeafChar {\n    TSU.assert(advanceIf(pattern, \"\\\\{\"), \"Invalid property escape\");\n    pattern.advance(2);\n    let foundEq = false;\n    let propName = \"\";\n    let propValue = \"\";\n    while (pattern.hasMore && pattern.currCh != \"}\") {\n      if (pattern.currCh == \"=\") foundEq = true;\n      else {\n        if (!foundEq) propName += pattern.currCh;\n        else propValue += pattern.currCh;\n      }\n      pattern.advance(1);\n    }\n    if (!pattern.hasMore) {\n      this.throwError(pattern, \"Invalid property escape\");\n    }\n    // see if this is a lone property escape\n    propName = propName.trim();\n    propValue = propValue.trim();\n    if (!foundEq) {\n      propValue = propName;\n      propName = \"General_Category\";\n    }\n    // advance over the \"}\"\n    pattern.advance(1);\n    return LeafChar.PropertyEscape(propName, propValue);\n  }\n\n  protected parseEscapeChar(pattern: Tape): LeafChar {\n    TSU.assert(advanceIf(pattern, \"\\\\\"), \"Expected '\\\\'\");\n    // escape char\n    if (!pattern.hasMore) {\n      this.throwError(pattern, \"Encounted unexpected end of input after \\\\\");\n    }\n    if (advanceIf(pattern, \"w\")) {\n      return LeafChar.Class(CharClassType.WORD_CHAR);\n    } else if (advanceIf(pattern, \"W\")) {\n      return LeafChar.Class(CharClassType.WORD_CHAR, true);\n    } else if (advanceIf(pattern, \"d\")) {\n      return LeafChar.Class(CharClassType.DIGITS);\n    } else if (advanceIf(pattern, \"D\")) {\n      return LeafChar.Class(CharClassType.DIGITS, true);\n    } else if (advanceIf(pattern, \"s\")) {\n      return LeafChar.Class(CharClassType.SPACES);\n    } else if (advanceIf(pattern, \"S\")) {\n      return LeafChar.Class(CharClassType.SPACES, true);\n    } else if (advanceIf(pattern, \"0\")) {\n      return LeafChar.Single(\"\\0\");\n    } else if (advanceIf(pattern, \"r\")) {\n      return LeafChar.Single(\"\\r\");\n    } else if (advanceIf(pattern, \"n\")) {\n      return LeafChar.Single(\"\\n\");\n    } else if (advanceIf(pattern, \"f\")) {\n      return LeafChar.Single(\"\\f\");\n    } else if (advanceIf(pattern, \"b\")) {\n      return LeafChar.Single(\"\\b\");\n    } else if (advanceIf(pattern, \"v\")) {\n      return LeafChar.Single(\"\\v\");\n    } else if (advanceIf(pattern, \"t\")) {\n      return LeafChar.Single(\"\\t\");\n    } else if (advanceIf(pattern, \"\\\\\")) {\n      return LeafChar.Single(\"\\\\\");\n    } else if (advanceIf(pattern, \"'\")) {\n      return LeafChar.Single(\"'\");\n    } else if (advanceIf(pattern, '\"')) {\n      return LeafChar.Single('\"');\n    } else if (advanceIf(pattern, \"x\")) {\n      // 2 digit hex digits\n      if (!pattern.hasMore) {\n        this.throwError(pattern, `Invalid hex sequence at ${pattern.index}`);\n      }\n      const hexSeq = pattern.currCh + pattern.nextCh;\n      const hexVal = parseInt(hexSeq, 16);\n      TSU.assert(!isNaN(hexVal), `Invalid hex sequence: '${hexSeq}'`);\n      pattern.advance(2);\n      return LeafChar.Single(hexVal);\n    } else if (advanceIf(pattern, \"u\")) {\n      // 4 digit hex digits for unicode\n      if (!pattern.canAdvance(3)) {\n        // index >= pattern.input.length - 3) {\n        this.throwError(pattern, `Invalid unicode sequence at ${pattern.index}`);\n      }\n      const ucodeSeq = pattern.substring(pattern.index, pattern.index + 4);\n      const ucodeVal = parseInt(ucodeSeq, 16);\n      if (isNaN(ucodeVal)) {\n        this.throwError(pattern, `Invalid unicode sequence: '${ucodeSeq}'`);\n      }\n      pattern.advance(4);\n      return LeafChar.Single(ucodeVal);\n    }\n    // default\n    const ch = pattern.currCh;\n    pattern.advance(1);\n    return LeafChar.Single(ch);\n  }\n\n  protected reduceLeft(stack: Regex[]): Regex {\n    const r = stack.length == 1 ? stack[0] : new Cat(...stack);\n    // remove all elements on stack\n    stack.splice(0);\n    return r;\n  }\n\n  protected throwError(pattern: Tape, msg: string): void {\n    throw new Error(msg);\n    // this.throwError(pattern, `Error in Flex RE '${pattern.input}': ${msg}`);\n  }\n}\n","import { Rule, Regex, REPatternType } from \"./core\";\nimport { RegexParser as JSREParser } from \"./jsparser\";\nimport { RegexParser as FlexREParser } from \"./flexparser\";\nimport { Tape } from \"./tape\";\n\n/**\n * Uber method to build a Regex given either a regex string or a JS regex.\n *\n * @param pattern   Either a regex pattern, a JS RegExp object, or an already parsed Regex object.\n * @param config    TBD\n *\n * @return A {@link Rule} object that contains the pattern as well as its normalized regex tree.\n */\nexport function build(pattern: string | RegExp | Regex, config?: any): Rule {\n  if (typeof pattern === \"string\") {\n    const rule = new Rule(exprFromJSRE(pattern, config), config);\n    rule.pattern = pattern;\n    return rule;\n  } else if (pattern.constructor.name == \"RegExp\") {\n    const rule = new Rule(exprFromJSRE(pattern as RegExp, config), config);\n    rule.pattern = (pattern as RegExp).source;\n    return rule;\n  } else {\n    // Already compiled expression\n    return new Rule(pattern as Regex, config);\n  }\n}\n\n/*\nexport function fromRE(pattern: string, config?: any): Rule {\n  const expr = new JSREParser(pattern, config).parse();\n  const rule = new Rule(expr, config);\n  rule.pattern = pattern;\n  return rule;\n}\n\nexport function fromJSRE(re: RegExp, config?: any): Rule {\n  const expr = exprFromJSRE(re);\n  const rule = new Rule(expr, config);\n  rule.pattern = re.source;\n  return rule;\n}\n\nexport function fromFlexRE(re: string, config?: any): Rule {\n  const expr = exprFromFlexRE(re);\n  const rule = new Rule(expr, config);\n  rule.pattern = re;\n  return rule;\n}\n*/\n\n/**\n * \"Flattens\" either a single REPatternType or a list of REPatternTypes into a flat list of all\n * REPatternTypes at the leaf levels.\n */\nexport function flatten(re: REPatternType | REPatternType[], index = 0, rules?: Rule[]): Rule[] {\n  rules = rules || [];\n  if (typeof re === \"string\") {\n    rules.push(build(re, { tag: index }));\n  } else if (re.constructor == RegExp) {\n    rules.push(build(re, { tag: index }));\n  } else if (re.constructor == Rule) {\n    rules.push(re as Rule);\n  } else if (re.constructor == Regex) {\n    rules.push(new Rule(re as Regex));\n  } else {\n    const res = re as (RegExp | Rule | string)[];\n    for (let i = 0; i < res.length; i++) {\n      flatten(res[i], i, rules);\n    }\n  }\n  return rules;\n}\n\n/**\n * Takes a string assumed to be in Flex RE format and parses the Regex expression out of it.\n */\nexport function exprFromFlexRE(pattern: string): Regex {\n  const parser = new FlexREParser();\n  try {\n    const expr = parser.parse(new Tape(pattern));\n    // if not specified default to false\n    if (expr.dotAll == null) expr.dotAll = false;\n    if (expr.multiline == null) expr.multiline = false;\n    return expr;\n  } catch (error) {\n    console.log(\"Error in FLEX RE: \", pattern);\n    throw error;\n  }\n}\n\n/**\n * Takes a string assumed to be in JS RE format and parses the Regex expression out of it.\n */\nexport function exprFromJSRE(re: string | RegExp, config?: any): Regex {\n  config = config || {};\n  const isRegExp = typeof re !== \"string\";\n  const pattern = typeof re === \"string\" ? re : re.source;\n  if (isRegExp) config.unicode = (re as RegExp).unicode;\n  const expr = new JSREParser(pattern, config).parse();\n  if (typeof re !== \"string\") {\n    expr.dotAll = re.dotAll;\n    expr.ignoreCase = re.ignoreCase;\n    expr.multiline = re.multiline;\n  }\n  return expr;\n}\n\n/**\n * A way to build a JS RE from a string literal, eg: jsRE`a*b+`\n */\nexport function jsRE(strings: TemplateStringsArray, ...keys: any[]): Regex {\n  // what we have is the raw value of this template and this can be parsed by our parser\n  const merged = String.raw(strings, ...keys);\n  return exprFromJSRE(merged);\n}\n\n/**\n * A way to build a Flex RE from a string literal, eg: flexRE`a*b+`\n */\nexport function flexRE(strings: TemplateStringsArray, ...keys: any[]): Regex {\n  const merged = String.raw(strings, ...keys);\n  return exprFromFlexRE(merged);\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Regex, Union, Rule, RuleConfig } from \"./core\";\nimport { Prog, Match, VM } from \"./vm\";\nimport { Compiler } from \"./compiler\";\nimport { TapeInterface as Tape, Tape as DefaultTape } from \"./tape\";\nimport { TokenizerError } from \"./errors\";\nimport * as Builder from \"./builder\";\nimport { Token, TokenType } from \"./token\";\n\nexport type RuleMatchHandler = (rule: Rule, tape: Tape, token: Token, owner: any) => any;\nexport type TokenizerErrorHandler = (error: Error, tape: Tape, startIndex: number) => Error | null;\n\nexport function toToken(tag: TokenType, m: Match, tape: Tape | null): Token {\n  const out = new Token(tag, m.matchIndex, m.start, m.end);\n  for (let i = 0; i < m.positions.length; i += 2) {\n    if (m.positions[i] >= 0) {\n      out.positions[Math.floor(i / 2)] = [m.positions[i], m.positions[i + 1]];\n    }\n  }\n  for (const [groupIndex, tapeIndex] of m.groups) {\n    const gi = Math.abs(groupIndex);\n    if (!(gi in out.groups)) {\n      out.groups[gi] = [];\n    }\n    out.groups[gi].push(tapeIndex);\n  }\n  if (tape != null) out.value = tape.substring(m.start, m.end);\n  return out;\n}\n\nexport class BaseTokenizer {\n  protected _prog: Prog | null = null;\n  protected _vm: VM | null = null;\n\n  /**\n   * Error handler called when an invalid character or lexeme is encountered.\n   * If this method returns back an error then the tokenization stops otherwise\n   * (if a null is returned) then tokenization continues.\n   *\n   * @param error       The error currently caught and being handled.\n   * @param tape        The tape currently being tokenized.\n   * @param startIndex  The start index when the tokenization began resulting in the error.\n   */\n  onError: TokenizerErrorHandler | null = null;\n\n  // Stores named rules\n  // Rules are a \"regex\", whether literal or not\n  allRules: Rule[] = [];\n  onMatchHandlers: (RuleMatchHandler | null)[] = [];\n  matchHandlersByValue: any = {};\n  variables = new Map<string, Regex>();\n  compiler: Compiler = new Compiler((name) => {\n    let out = this.variables.get(name) || null;\n    if (out == null) out = this.findRuleByValue(name)?.expr || null;\n    if (out == null) throw new Error(`Invalid regex reference: ${name}`);\n    return out;\n  });\n\n  getVar(name: string): Regex | null {\n    return this.variables.get(name) || null;\n  }\n\n  addVar(name: string, regex: Regex): this {\n    let currValue = this.variables.get(name) || null;\n    if (currValue == null) {\n      currValue = regex;\n    } else {\n      currValue = new Union(currValue, regex);\n    }\n    this.variables.set(name, regex);\n    return this;\n  }\n\n  findRuleByValue(value: any): Rule | null {\n    return this.allRules.find((r) => r.tag == value) || null;\n  }\n\n  /**\n   * Helper method over the addRule method that converts the pattern to its normalized expression form\n   * and adds a rule to the tokenizer.\n   *\n   * @param pattern     A raw string or a JS RegExp, or parsed Regex expression\n   *                    (either from JS or Flex RE syntax).\n   * @param config      Rule configs to control priority and other aspects of rules to be used during\n   *                    the match stage.\n   * @param onMatch     A callback method called when the rule is matched.\n   */\n  add(\n    pattern: string | RegExp | Regex,\n    config?: RuleConfig | RuleMatchHandler | null,\n    onMatch: RuleMatchHandler | null = null,\n  ): this {\n    if (typeof config === \"function\") {\n      onMatch = config;\n      config = null;\n    }\n    return this.addRule(Builder.build(pattern, config), onMatch);\n  }\n\n  /**\n   * Helper method over the addRule method that converts the pattern to its normalized expression form\n   * and adds a rule to the tokenizer.\n   *\n   * @param rule        A normalized Rule object that contains both the pattern as well as rule configs\n   *                    to be used during the match and afterwards (if successfully matched).\n   * @param onMatch     A callback method called when the rule is matched.\n   */\n  addRule(rule: Rule, onMatch: null | RuleMatchHandler = null): this {\n    rule.matchIndex = this.allRules.length;\n    this.allRules.push(rule);\n    this.onMatchHandlers.push(onMatch);\n    this._prog = null;\n    this._vm = null;\n    return this;\n  }\n\n  /**\n   * Add a token match callback by value.\n   */\n  on(tag: any, onMatch: RuleMatchHandler): this {\n    this.matchHandlersByValue[tag] = onMatch;\n    return this;\n  }\n\n  get prog(): Prog {\n    if (this._prog == null) {\n      const sortedRules = this.sortRules();\n      this._prog = this.compiler.compile(sortedRules);\n    }\n    return this._prog;\n  }\n\n  get vm(): VM {\n    if (this._vm == null) {\n      this._vm = new VM(this.prog);\n    }\n    return this._vm;\n  }\n\n  protected sortRules(): Rule[] {\n    // Sort rules so high priority ones appear first\n    const sortedRules: Rule[] = this.allRules.map((rule) => rule);\n    sortedRules.sort((r1, r2) => {\n      if (r1.priority != r2.priority) return r2.priority - r1.priority;\n      return r1.matchIndex - r2.matchIndex;\n    });\n    return sortedRules;\n  }\n}\n\n/**\n * A batch tokenizer.\n */\nexport class Tokenizer extends BaseTokenizer {\n  idCounter = 0;\n\n  /**\n   * Get the current lexer state (for incremental lexing support).\n   * State is used to track context-sensitive lexing modes.\n   */\n  getState(): number {\n    return this.vm.getState();\n  }\n\n  /**\n   * Set the lexer state (for incremental lexing support).\n   * Allows restarting lexing from a saved state.\n   */\n  setState(state: number): void {\n    this.vm.setState(state);\n  }\n\n  /**\n   * Reset the tokenizer state. Useful for incremental lexing\n   * when restarting from a different position.\n   */\n  reset(): void {\n    this.idCounter = 0;\n    // Reset VM state to initial\n    if (this._vm) {\n      this._vm.setState(0);\n    }\n  }\n\n  next(tape: Tape, owner: any): Token | null {\n    if (!tape.hasMore) {\n      return null;\n    }\n    const startIndex = tape.index;\n    const startChar = tape.currCh;\n    const m = this.vm.match(tape);\n    if (m == null) {\n      // no match so we have an error\n      let err: Error | null = null;\n      if (tape.index == startIndex + 1) {\n        err = new TokenizerError(`Unexpected Character: ${startChar}`, startIndex, 1, \"UnexpectedCharacter\", startChar);\n      } else {\n        err = new TokenizerError(\n          `Unexpected Symbol: ${tape.substring(startIndex, tape.index)}`,\n          startIndex,\n          tape.index - startIndex,\n          \"UnexpectedLexeme\",\n        );\n      }\n      if (this.onError) {\n        err = this.onError(err, tape, startIndex);\n      }\n      if (err != null) {\n        throw err;\n      } else {\n        // err has been ocnsumed so we can restart tokenizer at the current position\n        return this.next(tape, owner);\n      }\n    }\n    const rule = this.allRules[m.matchIndex];\n    let token = toToken(rule.tag, m, tape);\n    token.id = this.idCounter++;\n    let onMatch = this.onMatchHandlers[m.matchIndex];\n    if (!onMatch) {\n      onMatch = this.matchHandlersByValue[rule.tag];\n    }\n    if (onMatch) {\n      token = onMatch(rule, tape, token, owner);\n      if (token == null) {\n        // null is returned by onMatch to skip tokens\n        return this.next(tape, owner);\n      }\n    } else if (rule.skip) {\n      return this.next(tape, owner);\n    }\n    return token;\n  }\n\n  tokenize(tape: string | Tape, owner: any = null): Token[] {\n    const tokens = [] as Token[];\n    if (typeof tape === \"string\") {\n      tape = new DefaultTape(tape);\n    }\n    let next = this.next(tape, owner);\n    while (next) {\n      tokens.push(next);\n      try {\n        next = this.next(tape, owner);\n      } catch (err: any) {\n        tokens.push({\n          tag: \"ERROR\",\n          start: err.offset,\n          end: err.offset + err.length,\n          value: err.message,\n        } as Token);\n        break;\n      }\n    }\n    return tokens;\n  }\n}\n","import { flexRE } from \"./builder\";\n\nexport const SINGLE_QUOTE_STRING = flexRE`[\"]([^\"\\\\\\n]|\\\\.|\\\\\\n)*[\"]`;\nexport const DOUBLE_QUOTE_STRING = flexRE`[']([^'\\\\\\n]|\\\\.|\\\\\\n)*[']`;\nexport const SIMPLE_JS_STRING = '\"(.*?(?<!\\\\\\\\))\"';\nexport const JS_REGEX_WITHOUT_LB = String.raw`/([^\\\\/]|\\\\.)*/([imus]*)`;\nexport const JS_REGEX = String.raw`/(.+?(?<!\\\\))/([imus]*)`;\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Str, Rule, RuleAction } from \"./grammar\";\n\ntype Tape = TLEX.TapeInterface;\n\nconst str2regex = (s: string | number): string => {\n  if (typeof s === \"number\") return \"\" + s;\n  return s.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n};\n\nexport enum TokenType {\n  STRING = \"STRING\",\n  REGEX = \"REGEX\",\n  NUMBER = \"NUMBER\",\n  SPACES = \"SPACES\",\n  IDENT = \"IDENT\",\n  PCT_IDENT = \"PCT_IDENT\",\n  STAR = \"STAR\",\n  PLUS = \"PLUS\",\n  QMARK = \"QMARK\",\n  PIPE = \"PIPE\",\n  DOLLAR_NUM = \"DOLLAR_NUM\",\n  DOLLAR_IDENT = \"DOLLAR_IDENT\",\n  OPEN_PAREN = \"OPEN_PAREN\",\n  CLOSE_PAREN = \"CLOSE_PAREN\",\n  OPEN_BRACE = \"OPEN_BRACE\",\n  CLOSE_BRACE = \"CLOSE_BRACE\",\n  OPEN_SQ = \"OPEN_SQ\",\n  CLOSE_SQ = \"CLOSE_SQ\",\n  COMMENT = \"COMMENT\",\n  ARROW = \"ARROW\",\n  COLCOLHYPHEN = \"COLCOLHYPHEN\",\n  COLON = \"COLON\",\n  SEMI_COLON = \"SEMI_COLON\",\n}\n\nexport type NewSymbolCallback = TSU.Nullable<(label: string, assumedTerminal: boolean) => Sym | void>;\nexport type TokenHandler = (token: TLEX.Token, tape: TLEX.TapeInterface, owner: any) => TLEX.Token | null;\n\nexport interface LoaderConfig {\n  grammar?: Grammar;\n  leftRecursive?: boolean;\n  newSymbolCallback?: NewSymbolCallback;\n  tokenHandlers: TSU.StringMap<TokenHandler>;\n  debug?: string;\n}\n\n/**\n * Entry point in loading a grammar from a DSL spec.\n */\nexport function load(input: string, params?: LoaderConfig): [Grammar, null | TLEX.NextTokenFunc] {\n  params = params || ({} as LoaderConfig);\n  const g = new Grammar(params.grammar || {});\n  const eparser = new Loader(input, { ...params, grammar: g });\n  // g.augmentStartSymbol();\n  const tokenFunc = eparser.generatedTokenizer.next.bind(eparser.generatedTokenizer);\n  const debug = params.debug || \"\";\n  if (debug.split(\"|\").findIndex((p: string) => p == \"all\" || p == \"lexer\") >= 0) {\n    console.log(\"Prog: \\n\", `${eparser.generatedTokenizer.vm.prog.debugValue().join(\"\\n\")}`);\n  }\n  return [g, tokenFunc];\n}\n\n/**\n * The SemanticHandler is the bridge between the DSL, the Grammar, the Parser\n * and the caller of the parser.\n * In the DSL semantic actions can be added to tokenizer and grammar specs.\n * However the problem how to invoke them during runtime.\n *\n * For example in the grammar:\n *\n * E -> E + E { add($1, $3) }\n *\n * declares that when this rule is reduced the \"add\" function (in user land) is\n * invoked with the results of the right hand side values.\n *\n * This parsing however is done by the DSL loader and at this time the \"add\" method\n * is not declared anywhere.   In fact the the declaration is only  used by the parser\n * driver (after the parse tables have been constructed and parsing is started on\n * a real input).   The parser here needs to supply the definition for \"add\" method.\n * Note only this only the parser can call what is needed to kick off the \"add\" method\n * to be invoked.\n *\n * So the parser will need something like:\n *\n * while (input) {\n *    ....\n *    reduceRule(Nt, E1, E2, E3 ..., \"action\")\n * }\n *\n * the \"action\" will be part of the SemanticHandler\n *\n * reduceRule(Nt...., \"action\") {\n *  Nt.value = semanticHandler.getAction(\"action\").apply(E1, E2...., En);\n * }\n *\n * Similarly the caller of the \"parse\" method could populate the actions, eg:\n *\n * semanticHandler.register(\"action\", (a, b, c) => {\n *    return ....;\n * });\n *\n * The DSL loader in turn returns a semanticHandler instance just the way it\n * creates a tokenizer.\n *\n * There are a couple of options here.\n *\n * 1. Keep actions simple and store action IDs and let the caller do all the work, eg:\n *\n * E -> E + E { add $1 $3 }\n *\n * 2. Provide a stronger expression syntax:\n *\n * Or we could add a slightly more functional syntax so that a proper interpreter like setup is possible, eg:\n *\n * E -> E + E { add(halve($1), double($3)) }\n *\n * Here instead of calling an action \"add\" we could actually store expression trees and call an interpreter\n * with attribute value bindings.\n *\n * For now we will go with (1) as it is simpler and we can always build up (2) if doing (1) alone is too verbose.\n *\n * With (1), syntax for semantic actions is:\n *\n *  SemAction -> \"{\" ActionSpec \"}\" ;\n *\n *  ActionSpec -> DOLLAR_NUM\n *              | IDENT ( IDENT | DOLLAR_NUM | NUM | STRING | BOOLEAN | NULL ) *\n *              ;\n *\n * 3. There is an evern simpler third option.  Instead of the parser trying to martial parameters etc it could just\n * let the handler do the work of martialling/extracting parameters from children.  This is effective and easy\n *\n * In this mode all child nodes are passed as is to the handler and it is upto the handler to return the semantic\n * value of the production.\n */\n\nexport function Tokenizer(): TLEX.Tokenizer {\n  const lexer = new TLEX.Tokenizer();\n  lexer.add(/->/, { tag: TokenType.ARROW });\n  lexer.add(/\\[/, { tag: TokenType.OPEN_SQ });\n  lexer.add(/\\]/, { tag: TokenType.CLOSE_SQ });\n  lexer.add(/\\(/, { tag: TokenType.OPEN_PAREN });\n  lexer.add(/\\)/, { tag: TokenType.CLOSE_PAREN });\n  lexer.add(/\\{/, { tag: TokenType.OPEN_BRACE });\n  lexer.add(/\\}/, { tag: TokenType.CLOSE_BRACE });\n  lexer.add(/\\*/, { tag: TokenType.STAR });\n  lexer.add(/\\+/, { tag: TokenType.PLUS });\n  lexer.add(/\\?/, { tag: TokenType.QMARK });\n  lexer.add(/;/, { tag: TokenType.SEMI_COLON });\n  lexer.add(/:/, { tag: TokenType.COLON });\n  lexer.add(/\\|/, { tag: TokenType.PIPE });\n  lexer.add(/\\s+/m, { tag: TokenType.SPACES }, () => null);\n  lexer.add(/\\/\\*.*?\\*\\//s, { tag: TokenType.COMMENT }, () => null);\n  lexer.add(/\\/\\/.*$/m, { tag: TokenType.COMMENT }, () => null);\n  lexer.add(TLEX.Samples.DOUBLE_QUOTE_STRING, { tag: TokenType.STRING }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end - 1);\n    return token;\n  });\n  lexer.add(TLEX.Samples.SINGLE_QUOTE_STRING, { tag: TokenType.STRING }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end - 1);\n    return token;\n  });\n  lexer.add(TLEX.Samples.JS_REGEX, { tag: TokenType.REGEX }, (rule, tape, token) => {\n    const pattern = tape.substring(token.positions[1][0], token.positions[1][1]);\n    const flags = tape.substring(token.positions[3][0], token.positions[3][1]);\n    token.value = [pattern, flags];\n    return token;\n  });\n  lexer.add(/\\d+/, { tag: TokenType.NUMBER }, (rule, tape, token) => {\n    token.value = parseInt(tape.substring(token.start, token.end));\n    return token;\n  });\n  lexer.add(/%([\\w][\\w\\d_]*)/, { tag: TokenType.PCT_IDENT }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end);\n    return token;\n  });\n  lexer.add(/\\$\\d+/, { tag: TokenType.DOLLAR_NUM }, (rule, tape, token) => {\n    token.value = parseInt(tape.substring(token.start + 1, token.end));\n    return token;\n  });\n  lexer.add(/\\$([\\w][\\w\\d_]*)/, { tag: TokenType.DOLLAR_IDENT }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end);\n    return token;\n  });\n  lexer.add(/[\\w][\\w\\d_]*/, { tag: TokenType.IDENT });\n  return lexer;\n}\n\nexport enum NodeType {\n  GRAMMAR = \"GRAMMAR\",\n  DECL = \"DECL\",\n  RULE = \"RULE\",\n  PROD_NULL = \"PROD_NULL\",\n  PROD_STR = \"PROD_STR\",\n  PROD_UNION = \"PROD_UNION\",\n  PROD_NAME = \"PROD_NAME\",\n  PROD_STRING = \"PROD_STRING\",\n  PROD_NUM = \"PROD_NUM\",\n  PROD_IDENT = \"PROD_IDENT\",\n  PROD_STAR = \"PROD_STAR\",\n  PROD_PLUS = \"PROD_PLUS\",\n  PROD_OPTIONAL = \"PROD_OPTIONAL\",\n  IDENT = \"IDENT\",\n  ERROR = \"ERROR\",\n  COMMENT = \"COMMENT\",\n}\n\n/**\n * EBNF Grammar:\n *\n * grammar -> rules;\n *\n * decl -> rule ;\n *\n * rules -> rule | rule rules ;\n *\n * rule -> IDENT \"->\" top_productions \";\" ;\n *\n * top_productions -> ( actionSpec ) ?\n *                |   prod ( actionSpec ) ? top_productions\n *                ;\n *\n * productions ->\n *              | prod  \"|\" productions\n *              ;\n *\n * prod -> ( prod_group | optional_prod | IDENT ( \":\" name ) ? | STRING ) ( \"*\" | \"+\" | \"?\" ) ?\n *      ;\n *\n * prod_group -> \"(\" productions \")\"  ;\n *\n * optional_prod -> \"[\" productions \"]\"  ;\n *\n * actionSpec := \"{\" IDENT \"(\" IDENT ( \",\" IDENT ) * \")\" \"}\"\n */\nexport class Loader {\n  readonly grammar: Grammar;\n  private tokenizer: TLEX.TokenBuffer;\n  private leftRecursive = false;\n  readonly generatedTokenizer: TLEX.Tokenizer = new TLEX.Tokenizer();\n  tokenHandlers: TSU.StringMap<TokenHandler>;\n\n  /*\n   * The newSymbol callback provided to the contructor is a way for the client to\n   * be given a chance to create a symbol given a new label that is encountered.\n   * The client can either return a null to let this parser define the Symbol\n   * or return a Symbol which will be associated with the given label going\n   * forward.\n   *\n   * The newSymbol callback will ONLY be called once for each new label\n   * encountered by the parser.   If the client returns a duplicte symbol\n   * then parsing fails.\n   */\n  private newSymbolCallback: NewSymbolCallback;\n  private symbolsByLabel: TSU.StringMap<Sym>;\n\n  /**\n   * Allowed regex syntaxes - js or flex\n   */\n  private regexSyntax = \"js\";\n\n  constructor(input: string, config?: LoaderConfig) {\n    config = config || ({} as LoaderConfig);\n    this.symbolsByLabel = {};\n    this.grammar = config.grammar || new Grammar();\n    this.leftRecursive = \"leftRecursive\" in config ? config.leftRecursive || false : true;\n    this.newSymbolCallback = config.newSymbolCallback || null;\n    this.tokenHandlers = config.tokenHandlers || {};\n    this.parse(input);\n  }\n\n  /**\n   * As the parser creates encounters a new literal or an identifier (hinting at\n   * either a terminal or a non terminal), it needs to know which symbol to associate\n   * with this lit/ident going forward.\n   *\n   * All symbols created for the grammar, since they are either created\n   * by this parser or by the client (invokved by this parser), are\n   * stored locally to be returned in this method.\n   */\n  symbolForLabel(label: string): TSU.Nullable<Sym> {\n    return this.symbolsByLabel[label] || null;\n  }\n\n  /**\n   * Registers a symbol for a given label.\n   */\n  registerSymbol(label: string, sym: Sym): void {\n    TSU.assert(!(label in this.symbolsByLabel), `${label} is already registered`);\n    this.symbolsByLabel[label] = sym;\n  }\n\n  /**\n   * Ensures that a symbol exists for a given label (as found in the parser spec)\n   * to be used through out the grammar.\n   */\n  ensureSymbol(label: string, assumedTerminal: boolean): Sym {\n    let currSym = this.symbolForLabel(label);\n\n    if (currSym != null) return currSym;\n    else if (this.newSymbolCallback) {\n      // then give the user a chance to create a symbol for this\n      currSym = this.newSymbolCallback(label, assumedTerminal) || null;\n    }\n    if (currSym == null) {\n      if (assumedTerminal) {\n        currSym = this.grammar.newTerm(label);\n      } else {\n        currSym = this.grammar.newNT(label);\n      }\n    }\n    // then register it so it is used going forward\n    this.registerSymbol(label, currSym);\n    return currSym;\n  }\n\n  parse(input: string): void {\n    const et = Tokenizer();\n    const ntFunc = (tape: Tape, owner: any) => {\n      const out = et.next(tape, this);\n      return out;\n    };\n    this.tokenizer = new TLEX.TokenBuffer(ntFunc, this);\n    this.parseGrammar(new TLEX.Tape(input));\n  }\n\n  parseRegex(tape: TLEX.TapeInterface, tag?: string, priority = 0, syntax = \"\"): TLEX.Rule {\n    if (syntax == \"\") syntax = this.regexSyntax;\n    if (syntax == \"js\") {\n      const tokPattern = this.tokenizer.expectToken(tape, TokenType.STRING, TokenType.NUMBER, TokenType.REGEX);\n      let rule: TLEX.Rule;\n      if (!tag || tag.length == 0) {\n        tag = \"/\" + tokPattern.value[0] + \"/\" + tokPattern.value[1];\n      }\n      if (tokPattern.tag == TokenType.STRING || tokPattern.tag == TokenType.NUMBER) {\n        const pattern = str2regex(tokPattern.value);\n        rule = TLEX.Builder.build(pattern, { tag: tag, priority: priority + 20 });\n      } else if (tokPattern.tag == TokenType.REGEX) {\n        let re = tokPattern.value[0];\n        if (tokPattern.value[1].length > 0) {\n          // Flags given so create\n          re = new RegExp(tokPattern.value[0], tokPattern.value[1]);\n        }\n        rule = TLEX.Builder.build(re, { tag: tag, priority: priority + 10 });\n      } else {\n        throw new TLEX.UnexpectedTokenError(tokPattern);\n      }\n      return rule;\n    } else {\n      // Flex style RE - no delimiters - just read until end of line and strip spaces\n      let patternStr = \"\";\n      while (tape.hasMore && tape.currCh != \"\\n\") {\n        patternStr += tape.currCh;\n        tape.advance();\n      }\n      patternStr = patternStr.trim();\n      if (!tag || tag.length == 0) {\n        tag = \"/\" + patternStr + \"/\";\n      }\n      return new TLEX.Rule(TLEX.Builder.exprFromFlexRE(patternStr), { tag: tag, priority: priority });\n    }\n  }\n\n  parseGrammar(tape: TLEX.Tape): void {\n    let peeked = this.tokenizer.peek(tape);\n    while (peeked != null) {\n      if (peeked.tag == TokenType.IDENT) {\n        // declaration\n        this.parseDecl(tape);\n      } else if (peeked.tag == TokenType.PCT_IDENT) {\n        this.tokenizer.next(tape);\n        this.parseDirective(tape, peeked.value);\n      } else {\n        throw new SyntaxError(`Declaration must start with IDENT or PCT_IDENT.  Found: '${peeked.value}' instead.`);\n      }\n      peeked = this.tokenizer.peek(tape);\n    }\n  }\n\n  parseDirective(tape: TLEX.TapeInterface, directive: string): void {\n    if (directive == \"start\") {\n      // override start directive\n      const next = this.tokenizer.expectToken(tape, TokenType.IDENT);\n      this.grammar.startSymbol = this.ensureSymbol(next.value as string, false);\n    } else if (directive == \"resyntax\") {\n      // override start directive\n      const next = this.tokenizer.expectToken(tape, TokenType.IDENT);\n      if (next.value != \"js\" && next.value != \"flex\") {\n        throw new SyntaxError(\"Invalid regex syntax: \" + next.value);\n      }\n      this.regexSyntax = next.value;\n    } else if (directive.startsWith(\"skip\")) {\n      const rule = this.parseRegex(tape, \"\", 30, directive.endsWith(\"flex\") ? \"flex\" : \"\");\n      const tokenHandler = this.parseTokenHandler(tape);\n      if (tokenHandler) {\n        this.generatedTokenizer.addRule(rule, (rule, tape, token) => {\n          tokenHandler(rule, tape, token, this);\n          return null;\n        });\n      } else {\n        this.generatedTokenizer.addRule(rule, () => null);\n      }\n    } else if (directive.startsWith(\"token\") || directive.startsWith(\"define\")) {\n      const isDef = directive.startsWith(\"define\");\n      const tokName = this.tokenizer.expectToken(tape, TokenType.IDENT, TokenType.STRING);\n      let label = tokName.value as string;\n      if (tokName.tag == TokenType.STRING || tokName.tag == TokenType.NUMBER) {\n        label = `\"${tokName.value}\"`;\n      }\n      const rule = this.parseRegex(tape, label, 0, directive.endsWith(\"flex\") ? \"flex\" : \"\");\n      if (isDef) {\n        // Define a \"reusable\" regex that is not a token on its own\n        this.generatedTokenizer.addVar(label, rule.expr);\n      } else {\n        const tokenHandler = this.parseTokenHandler(tape);\n        // see if we have a handler function here\n        this.generatedTokenizer.addRule(rule, tokenHandler);\n        // register it\n        this.ensureSymbol(label, true);\n      }\n    } else {\n      throw new Error(\"Invalid directive: \" + directive);\n    }\n  }\n\n  parseTokenHandler(tape: Tape): TLEX.RuleMatchHandler | null {\n    if (!this.tokenizer.consumeIf(tape, TokenType.OPEN_BRACE)) {\n      return null;\n    }\n\n    const funcName = this.tokenizer.expectToken(tape, TokenType.IDENT);\n\n    // how do we use the funcName to\n    const out = (rule: TLEX.Rule, tape: Tape, token: any, owner: any) => {\n      const handler = this.tokenHandlers[funcName.value];\n      if (!handler) throw new Error(\"Handler method not found: \" + funcName.value);\n      token = handler(token, tape, owner);\n      return token;\n    };\n\n    this.tokenizer.expectToken(tape, TokenType.CLOSE_BRACE);\n    return out;\n  }\n\n  parseDecl(tape: Tape): void {\n    const ident = this.tokenizer.expectToken(tape, TokenType.IDENT);\n    if (this.tokenizer.consumeIf(tape, TokenType.ARROW, TokenType.COLON)) {\n      const nt = this.ensureSymbol(ident.value as string, false);\n      if (nt.isTerminal) {\n        // it is a terminal so mark it as a non-term now that we\n        // know there is a declaration for it.\n        nt.isTerminal = false;\n      } else if (nt.isAuxiliary) {\n        throw new Error(\"NT is already auxiliary and cannot be reused.\");\n      }\n      for (const [rhs, action] of this.parseProductions(tape, this.grammar, nt)) {\n        const rule = this.grammar.add(nt, rhs, action);\n      }\n      this.tokenizer.expectToken(tape, TokenType.SEMI_COLON);\n    }\n  }\n\n  parseProductions(tape: Tape, grammar: Grammar, nt: TSU.Nullable<Sym>): [Str, RuleAction | null][] {\n    const out: [Str, RuleAction | null][] = [];\n    while (this.tokenizer.peek(tape) != null) {\n      const rule = this.parseProd(tape, grammar);\n      out.push(rule);\n      if (this.tokenizer.consumeIf(tape, TokenType.PIPE)) {\n        continue;\n      } else if (this.tokenizer.nextMatches(tape, TokenType.CLOSE_SQ, TokenType.CLOSE_PAREN, TokenType.SEMI_COLON)) {\n        break;\n      }\n    }\n    return out;\n  }\n\n  parseProd(tape: Tape, grammar: Grammar): [Str, null | RuleAction] {\n    const out = new Str();\n    while (true) {\n      // if we are starting with a FOLLOW symbol then return as it marks\n      // the end of this production\n      if (\n        this.tokenizer.nextMatches(\n          tape,\n          TokenType.CLOSE_PAREN,\n          TokenType.CLOSE_SQ,\n          TokenType.SEMI_COLON,\n          TokenType.PIPE,\n          TokenType.OPEN_BRACE,\n        )\n      ) {\n        break;\n        // return [out, null];\n      }\n\n      let curr: TSU.Nullable<Str> = null;\n      if (this.tokenizer.consumeIf(tape, TokenType.OPEN_PAREN)) {\n        const rules = this.parseProductions(tape, grammar, null);\n        if (rules.length == 0) {\n          // nothing\n        } else if (rules.length == 1) {\n          // TODO: Consider actions in non top level rules\n          curr = rules[0][0];\n        } else {\n          // create a new NT over this\n          // TODO: Consider actions in non top level rules\n          curr = grammar.anyof(...rules.map((r) => r[0]));\n        }\n        this.tokenizer.expectToken(tape, TokenType.CLOSE_PAREN);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.OPEN_SQ)) {\n        const rules = this.parseProductions(tape, grammar, null);\n        if (rules.length == 0) {\n          // nothing\n        } else if (rules.length == 1) {\n          // TODO: Consider actions in non top level rules\n          curr = grammar.opt(rules[0][0]);\n        } else {\n          // create a new NT over this\n          // TODO: Consider actions in non top level rules\n          curr = grammar.opt(grammar.anyof(...rules.map((r) => r[0])));\n        }\n        this.tokenizer.expectToken(tape, TokenType.CLOSE_SQ);\n      } else if (\n        this.tokenizer.nextMatches(tape, TokenType.IDENT, TokenType.STRING, TokenType.NUMBER, TokenType.REGEX)\n      ) {\n        const token = this.tokenizer.next(tape) as TLEX.Token;\n        let label = token.value as string;\n        if (token.tag == TokenType.STRING || token.tag == TokenType.NUMBER) {\n          label = `\"${token.value}\"`;\n          const pattern = str2regex(token.value);\n          const rule = TLEX.Builder.build(pattern, { tag: label, priority: 20 });\n          this.generatedTokenizer.addRule(rule);\n        } else if (token.tag == TokenType.REGEX) {\n          label = \"/\" + token.value[0] + \"/\" + token.value[1];\n          let re = token.value[0];\n          if (token.value[1].length > 0) {\n            // Flags given so create\n            re = new RegExp(token.value[0], token.value[1]);\n          }\n          const rule = TLEX.Builder.build(re, { tag: label, priority: 10 });\n          this.generatedTokenizer.addRule(rule);\n        } else {\n          // Normal\n        }\n        // See if this symbol is already registered\n        const currSym = this.ensureSymbol(label, true);\n        curr = new Str(currSym);\n      } else {\n        throw new TLEX.UnexpectedTokenError(this.tokenizer.peek(tape));\n      }\n\n      if (curr == null) {\n        throw new Error(\"Could not determine node\");\n      }\n\n      if (this.tokenizer.consumeIf(tape, TokenType.STAR)) {\n        curr = grammar.atleast0(curr, this.leftRecursive);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.PLUS)) {\n        curr = grammar.atleast1(curr, this.leftRecursive);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.QMARK)) {\n        curr = grammar.opt(curr);\n      }\n      out.extend(curr);\n    }\n    let action: RuleAction | null = null;\n    if (this.tokenizer.consumeIf(tape, TokenType.OPEN_BRACE)) {\n      const next = this.tokenizer.expectToken(tape, TokenType.DOLLAR_NUM, TokenType.IDENT);\n      action = new RuleAction(next.value);\n      this.tokenizer.expectToken(tape, TokenType.CLOSE_BRACE);\n    }\n    return [out, action];\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport {\n  PTNode,\n  SimpleParser as ParserBase,\n  BeforeAddingChildCallback,\n  RuleReductionCallback,\n  NextTokenCallback,\n} from \"./parser\";\nimport { ParseError } from \"./errors\";\n\ntype Nullable<T> = TSU.Nullable<T>;\ntype NumMap<T> = TSU.NumMap<T>;\ntype StringMap<T> = TSU.StringMap<T>;\n\nexport enum LRActionType {\n  ACCEPT,\n  SHIFT,\n  REDUCE,\n  GOTO, // can *ONLY* be valid for non-terms\n}\n\nexport class LRAction {\n  // Type of action\n  tag: LRActionType;\n\n  // Next state to go to after performing the action (if valid).\n  gotoState: Nullable<number> = null;\n\n  // The rule to be used for a reduce action\n  rule: Nullable<Rule> = null;\n\n  toString(): string {\n    if (this.tag == LRActionType.ACCEPT) return \"Acc\";\n    else if (this.tag == LRActionType.SHIFT) {\n      return \"S\" + this.gotoState!;\n    } else if (this.tag == LRActionType.REDUCE) {\n      return \"R \" + this.rule!.id;\n    } else {\n      return \"\" + this.gotoState!;\n    }\n  }\n\n  equals(another: LRAction): boolean {\n    return this.tag == another.tag && this.gotoState == another.gotoState && this.rule == another.rule;\n  }\n\n  static Shift(goto: number): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.SHIFT;\n    out.gotoState = goto;\n    return out;\n  }\n\n  static Reduce(rule: Rule): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.REDUCE;\n    out.rule = rule;\n    return out;\n  }\n\n  static Goto(gotoState: number): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.GOTO;\n    out.gotoState = gotoState;\n    return out;\n  }\n\n  static Accept(): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.ACCEPT;\n    return out;\n  }\n}\n\n/**\n * A parsing table for LR parsers.\n */\nexport class ParseTable {\n  // Records which actions have conflicts\n  conflictActions: NumMap<StringMap<boolean>> = {};\n\n  /**\n   * Maps symbol (by id) to the action;\n   */\n  actions: NumMap<NumMap<LRAction[]>> = {};\n\n  constructor(public readonly grammar: Grammar) {}\n\n  get hasConflicts(): boolean {\n    return Object.keys(this.conflictActions).length > 0;\n  }\n\n  /**\n   * Gets the action for a given sym from a given state.\n   */\n  getActions(stateId: number, next: Sym, ensure = false): LRAction[] {\n    let l1: NumMap<LRAction[]>;\n    if (stateId in this.actions) {\n      l1 = this.actions[stateId];\n    } else if (ensure) {\n      l1 = this.actions[stateId] = {};\n    } else {\n      return [];\n    }\n\n    if (next.id in l1) {\n      return l1[next.id];\n    } else if (ensure) {\n      return (l1[next.id] = []);\n    }\n    return [];\n  }\n\n  addAction(stateId: number, next: Sym, action: LRAction): this {\n    const actions = this.getActions(stateId, next, true);\n    if (actions.findIndex((ac) => ac.equals(action)) < 0) {\n      actions.push(action);\n    }\n    if (actions.length > 1) {\n      this.conflictActions[stateId] = this.conflictActions[stateId] || {};\n      this.conflictActions[stateId][next.label] = true;\n    }\n    return this;\n  }\n\n  get debugValue(): any {\n    const out: any = {};\n    for (const fromId in this.actions) {\n      out[fromId] = {};\n      for (const symId in this.actions[fromId]) {\n        const sym = this.grammar.getSymById(symId as any)!;\n        const actions = this.actions[fromId][sym.id] || [];\n        if (actions.length > 0) {\n          out[fromId][sym.label] = actions.map((a) => a.toString());\n        }\n      }\n    }\n    return out;\n  }\n}\n\nexport class ParseStack {\n  // A way of marking the kind of item that is on the stack\n  // true => isStateId\n  // false => isSymbolId\n  readonly stateStack: number[] = [];\n  readonly nodeStack: PTNode[] = [];\n\n  push(state: number, node: PTNode): void {\n    this.stateStack.push(state);\n    this.nodeStack.push(node);\n  }\n\n  /**\n   * Gets the nth item from the top of the stack.\n   */\n  top(nth = 0): [number, PTNode] {\n    return [this.stateStack[this.stateStack.length - 1 - nth], this.nodeStack[this.nodeStack.length - 1 - nth]];\n  }\n\n  pop(): [number, PTNode] {\n    const out = this.top();\n    this.stateStack.pop();\n    this.nodeStack.pop();\n    return out;\n  }\n\n  /**\n   * Pop N items from the stack.\n   */\n  popN(n = 1): void {\n    const L = this.stateStack.length;\n    this.stateStack.splice(L - n, n);\n    this.nodeStack.splice(L - n, n);\n  }\n\n  get isEmpty(): boolean {\n    return this.stateStack.length == 0 || this.nodeStack.length == 0;\n  }\n}\n\nexport type ActionResolverCallback = (\n  actions: LRAction[],\n  stack: ParseStack,\n  tokenbuffer: TLEX.TokenBuffer,\n) => LRAction;\n\nexport type RuleActionHandler = (rule: Rule, parent: PTNode, ...children: PTNode[]) => any;\n\nexport type TokenErrorCallback = (err: TLEX.TokenizerError, input: TLEX.Tape) => boolean;\n\nexport interface ParserContext {\n  buildParseTree?: boolean;\n  copySingleChild?: boolean;\n  ruleHandlers: TSU.StringMap<RuleActionHandler>;\n  beforeAddingChildNode?: BeforeAddingChildCallback;\n  onReduction?: RuleReductionCallback;\n  onNextToken?: NextTokenCallback;\n  actionResolver?: ActionResolverCallback;\n  onTokenError?: TokenErrorCallback;\n  // The owner used for tokenizer to get an insight into the context\n  // (to allow context sensitive scanning - aka \"scanner hacks\").\n  tokenizerContext: any;\n}\n\nexport class Parser extends ParserBase {\n  constructor(\n    public readonly parseTable: ParseTable,\n    config: any = {},\n  ) {\n    super();\n  }\n\n  get grammar(): Grammar {\n    return this.parseTable.grammar;\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected parseInput(input: TLEX.Tape, context?: ParserContext): Nullable<PTNode> {\n    context = context || ({} as ParserContext);\n    // Set default values for missing values\n    this.tokenbuffer.tokenizerContext = context.tokenizerContext;\n    if (context.buildParseTree != false) context.buildParseTree = true;\n    if (context.copySingleChild != false) context.copySingleChild = true;\n    let idCounter = 0;\n    const stack = new ParseStack();\n    stack.push(0, new PTNode(idCounter++, this.grammar.augStartRule.nt, null));\n    const tokenbuffer = this.tokenbuffer;\n    const g = this.grammar;\n    let output: Nullable<PTNode> = null;\n\n    /**\n     * Pick an action among several actions based on several factors (eg\n     * curr parse stack, tokenbuffer etc).\n     */\n    function resolveActions(actions: LRAction[]): LRAction {\n      if (context?.actionResolver) {\n        return context.actionResolver(actions, stack, tokenbuffer);\n      } else {\n        if (actions.length > 1) {\n          throw new Error(\"Multiple actions found.\");\n        }\n        return actions[0];\n      }\n    }\n\n    function nextToken(): TLEX.Token | null {\n      try {\n        return tokenbuffer.peek(input);\n      } catch (err /* InvalidCharacterException */) {\n        if (!context?.onTokenError || !context?.onTokenError(err as TLEX.TokenizerError, input)) {\n          // no handler or handler could do nothing so throw it up again\n          throw err;\n        }\n\n        // Handler managed to do \"something\" so retry again\n        // TODO - Check offsets were modified?\n        return nextToken();\n      }\n    }\n\n    while (true) {\n      // while (tokenbuffer.peek(input) != null || !stack.isEmpty) {\n      let token = nextToken();\n      if (token == null) {\n        if (stack.isEmpty) {\n          // no more to do\n          break;\n        }\n      } else if (context.onNextToken) {\n        token = context.onNextToken(token);\n      }\n      const nextSym = token == null ? g.Eof : this.getSym(token);\n      const nextValue = token == null ? null : token.value;\n      let [topState, topNode] = stack.top();\n      const actions = this.parseTable.getActions(topState, nextSym);\n      if (actions == null || actions.length == 0) {\n        // TODO - use a error handler here\n        throw new ParseError(`Unexpected Token: '${nextSym.label}'`, \"UnexpectedToken\", {\n          state: topState,\n          token: token,\n          nextSym: nextSym,\n        });\n      }\n\n      const action = resolveActions(actions);\n      if (action.tag == LRActionType.ACCEPT) {\n        break;\n      } else if (action.tag == LRActionType.SHIFT) {\n        tokenbuffer.next(input);\n        const newNode = new PTNode(idCounter++, nextSym, nextValue);\n        stack.push(action.gotoState!, newNode);\n      } else {\n        // reduce\n        TSU.assert(action.rule != null, \"Nonterm and ruleindex must be provided for a reduction action\");\n        const ruleLen = action.rule.rhs.length;\n\n        // here see if a rule handler exists - if it does use it\n        let newNode = new PTNode(idCounter++, action.rule.nt, null);\n        // Begin the reduction here. We are breaking the reduction into\n        // two parts:\n        //\n        // 1. Adding child nodes into the parent (reduced) node. Here\n        // the beforeAddingChildNode callback is used to modify children\n        // being added.\n        // 2. After all children have been added to give the caller a chance\n        // to handle/post-process the reduction - eg to build the semantic value.\n        //\n        // Our onReduction is a catch all to perform semantic actions.  Instead\n        // we could do rule specific ones by using the rule.action (if it exists)\n        // and only invoke the onReduction if a rule specific action does not exist.\n        //\n        // Are these \"double steps\" needed?  Can we just build parse tree, filter out\n        // child nodes and eval semantic value with a single action?\n        //\n        // Can semanticHandler do this?\n        //\n        // eg with\n        //\n        // E -> E + E { add }\n        //\n        // we could have our stack looking like;\n        //\n        // .... s1 E s2 E\n        //\n        // to be reduced and add could be called with:\n        //\n        // add(E1, E2) - as the child nodes themselves.\n        //\n        // the add handler could now do a few things:\n        //\n        // 1. Ensure all nodes are added to E as is (resulting in 3 nodes - \"E\", \"+\", \"E\")\n        // 2. Not add any nodes\n        // 3. Computing the value of E and E and the sum of those and put it in the parent E.\n        // 4. or all of the above.\n        //\n        // Doing filtering seems like a very premature usecase.  In the case of incremental\n        // parsing we may need all nodes to exist and filtering out can get in the way of that.\n        //\n        // But let us leave it for now and make any semantic handling happen *after* parse tree\n        // child node filter/transformation\n        if (context.buildParseTree) {\n          for (let i = ruleLen - 1; i >= 0; i--) {\n            const childNode: TSU.Nullable<PTNode> = stack.top(i)[1];\n            if (context.beforeAddingChildNode) {\n              for (const node of context.beforeAddingChildNode(newNode, childNode)) {\n                newNode.add(node);\n              }\n            } else if (childNode != null) {\n              newNode.add(childNode);\n            }\n          }\n        }\n        // Now apply the semantic handler if it exists\n        if (action.rule.action) {\n          // call it\n          if (action.rule.action.isFunction) {\n            // find the function associated with\n            const handlerName = action.rule.action.value;\n            const handler = context.ruleHandlers![handlerName];\n            if (!handler) throw new Error(\"Action handler not found: \" + handlerName);\n            // TODO - Replace the handler signature to take an\n            // interface that returns the nth child node (directly from\n            // the parse stack) instead of all children - this way we\n            // can even avoid building a parse tree if need be and\n            // decouple semantic actions from parse tree building\n            newNode.value = handler(action.rule, newNode, ...newNode.children);\n          } else {\n            // setting value as a child's value, eg $1, $2 etc\n            newNode.value = newNode.children[(action.rule.action.value as number) - 1].value;\n          }\n        } else if (context.onReduction) {\n          // fallback to default reduction handler\n          newNode = context.onReduction(newNode, action.rule);\n        } else if (newNode.children.length == 1 && context.copySingleChild) {\n          // If we have only 1 child set the semantic value to be child's value\n          // ie values \"bubble up\"\n          newNode.value = newNode.children[0].value;\n        }\n\n        // Perform the action reduction by popping ruleLen number of items off the stack\n        // and replace the top with our newNode\n        stack.popN(ruleLen);\n        [topState, topNode] = stack.top();\n        const newAction = resolveActions(this.parseTable.getActions(topState, action.rule.nt));\n        TSU.assert(newAction != null && newAction.gotoState != null, \"Top item does not have an action.\");\n        stack.push(newAction.gotoState, newNode);\n        output = newNode;\n      }\n    }\n    // It is possible that here no reductions have been done!\n    return output;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\n\ntype Nullable<T> = TSU.Nullable<T>;\n\n/**\n * As the parse tree is built, nodes are created and added to parents bottom up.\n * This method is called before a child node is added to its parent.  The\n * node's left-most siblings have already been added this point.\n *\n * This method is an opportunity to filter or transfor the node or even adding\n * other nodes to the parent's child list.  Note that at this point the parent\n * has *NOT* been added to its parent.\n *\n * In order to filter out the node, return null.  Otherwise return a\n * PTNode instance for the actual node to be added to the parent.\n */\nexport type BeforeAddingChildCallback = (parent: PTNode, child: PTNode) => PTNode[];\n\n/**\n * This method is called when after a rule has been reduced.  At this time\n * all the children have already been reduced (and called with this method).\n * Now is the opportunity for the parent node reduction to perform custom\n * actions.  Note that this method cannot modify the stack.  It can only be\n * used to perform things like AST building or logging etc.\n */\nexport type RuleReductionCallback = (node: PTNode, rule: Rule) => PTNode;\n\n/**\n * This method is called as soon as the next token is received from the tokenizer.\n * This allows one to filter out tokens or even transform them based on any other\n * context being maintained.\n */\nexport type NextTokenCallback = (token: TLEX.Token) => TSU.Nullable<TLEX.Token>;\n\nexport class PFNode {\n  children: this[] = [];\n  constructor(\n    public readonly id: number,\n    public readonly sym: Sym,\n    public value: any,\n    ...children: PFNode[]\n  ) {\n    this.children = (children as this[]) || [];\n  }\n\n  get childCount(): number {\n    return this.children.length;\n  }\n\n  childAt(index: number): this {\n    if (index < 0) return this.children[this.children.length + index] as this;\n    return this.children[index] as this;\n  }\n\n  get isTerminal(): boolean {\n    return this.sym.isTerminal;\n  }\n\n  add(node: this, index = -1): this {\n    if (this.isTerminal) {\n      throw new Error(`Cannot add children (${node.sym.label}) to a terminal node: ${this.sym.label}`);\n    }\n    if (index < 0) {\n      this.children.push(node);\n    } else {\n      this.children.splice(index, 0, node);\n    }\n    return this;\n  }\n\n  splice(index: number, numToDelete: number, ...nodes: this[]): this {\n    this.children.splice(index, numToDelete, ...nodes);\n    return this;\n  }\n\n  get reprString(): string {\n    /*\n    let out = `Node(${this.sym.label}, {this.value}`;\n    if (this.children.length > 0) out += \", \" + this.children.map((c) => c.reprString).join(\", \");\n    out += \")\";\n    return out;\n    */\n    return this.debugValue(false).join(\"\\n\");\n  }\n\n  debugValue(raw = true): any {\n    if (raw) {\n      const out: any = [this.sym.label];\n      if (this.value) out.push(this.value);\n      if (this.children.length > 0) out.push(this.children.map((c) => c.debugValue(raw)));\n      return out;\n    } else {\n      const out: any[] = [];\n      const value = this.value;\n      out.push(this.value == null ? this.sym.label : this.sym.label + \" - \" + this.value);\n      this.children.forEach((node) => (node.debugValue(raw) as string[]).forEach((l) => out.push(\"  \" + l)));\n      return out;\n    }\n  }\n}\n\nexport class PTNode extends PFNode {\n  parent: Nullable<PTNode> = null;\n\n  add(node: this, index = -1): this {\n    super.add(node, index);\n    node.parent = this;\n    return this;\n  }\n\n  splice(index: number, numToDelete: number, ...nodes: this[]): this {\n    for (const node of nodes) node.parent = this;\n    return super.splice(index, numToDelete, ...nodes);\n  }\n}\n\nexport abstract class ParserBase {\n  tokenbuffer: TLEX.TokenBuffer;\n\n  setTokenizer(tokenizer: TLEX.NextTokenFunc): this {\n    this.tokenbuffer = new TLEX.TokenBuffer(tokenizer, null);\n    return this;\n  }\n\n  abstract get grammar(): Grammar;\n\n  /**\n   * Converts the token to a Terminal based on the tag value.\n   */\n  getSym(token: TLEX.Token): Sym {\n    const out = this.grammar.getSym(token.tag as string);\n    if (out == null) {\n      throw new Error(\"Invalid token tag: \" + token.tag + \", Value: \" + token.value);\n    }\n    return out;\n  }\n}\n\nexport abstract class SimpleParser extends ParserBase {\n  parse(input: string | TLEX.Tape, delegate: any = null): Nullable<PTNode> {\n    if (typeof input === \"string\") {\n      input = new TLEX.Tape(input);\n    }\n    return this.parseInput(input, delegate);\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected abstract parseInput(input: TLEX.Tape, delegate: any): Nullable<PTNode>;\n}\n\nexport abstract class ParallelParser extends ParserBase {\n  parse(input: string | TLEX.Tape, delegate: any = null): PFNode[] {\n    if (typeof input === \"string\") {\n      input = new TLEX.Tape(input);\n    }\n    return this.parseInput(input, delegate);\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected abstract parseInput(input: TLEX.Tape, delegate: any): PFNode[];\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport { IDSet } from \"./sets\";\n\ntype Nullable<T> = TSU.Nullable<T>;\ntype NumMap<T> = TSU.NumMap<T>;\n\nexport class LRItem {\n  id = 0;\n  readonly rule: Rule;\n  readonly position: number;\n  constructor(rule: Rule, position = 0) {\n    this.rule = rule;\n    this.position = position;\n  }\n\n  advance(): LRItem {\n    TSU.assert(this.position < this.rule.rhs.length);\n    return new LRItem(this.rule, this.position + 1);\n  }\n\n  copy(): LRItem {\n    return new LRItem(this.rule, this.position);\n  }\n\n  /**\n   * TODO - Instead of using strings as keys, can we use a unique ID?\n   * If we assume a max limit on number of non terminals in our grammar\n   * and a max limit on the number of rules per non terminal and a\n   * max limit on the size of each rule then we can uniquely identify\n   * a rule and position for a non-terminal by a single (64 bit) number\n   *\n   * We can use the following bitpacking to nominate this:\n   *\n   * <padding 16 bits><nt id 16 bits><ruleIndex 16 bits><position 16 bits>\n   */\n  get key(): string {\n    TSU.assert(!isNaN(this.rule.id), \"Rule's ID is not yet set.\");\n    return this.rule.id + \":\" + this.position;\n  }\n\n  compareTo(another: this): number {\n    let diff = this.rule.id - another.rule.id;\n    if (diff == 0) diff = this.position - another.position;\n    return diff;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  get debugString(): string {\n    const rule = this.rule;\n    const pos = this.position;\n    const pre = rule.rhs.syms.slice(0, pos).join(\" \");\n    const post = rule.rhs.syms.slice(pos).join(\" \");\n    return `${rule.id}  -  ${rule.nt} -> ${pre} • ${post}`;\n  }\n}\n\nexport class LRItemSet {\n  id = 0;\n  readonly itemGraph: LRItemGraph;\n  protected _key: Nullable<string> = null;\n  readonly values: number[];\n  protected _lookaheads: NumMap<Sym[]> = {};\n  protected _hasLookAheads = false;\n\n  constructor(ig: LRItemGraph, ...entries: number[]) {\n    this.itemGraph = ig;\n    this.values = entries;\n  }\n\n  copy(): LRItemSet {\n    const out = new LRItemSet(this.itemGraph, ...this.values);\n    out._lookaheads = { ...this._lookaheads };\n    out._hasLookAheads = this._hasLookAheads;\n    return out;\n  }\n\n  /**\n   * Adds a new look ahead symbol for a given item.\n   */\n  addLookAhead(item: LRItem, sym: Sym): boolean {\n    if (!(item.id in this._lookaheads)) {\n      this._lookaheads[item.id] = [];\n    }\n    for (const s of this._lookaheads[item.id]) if (s == sym) return false;\n    this._hasLookAheads = true;\n    this._key = null;\n    this._lookaheads[item.id].push(sym);\n    this._lookaheads[item.id].sort((s1, s2) => s1.id - s2.id);\n    return true;\n  }\n\n  /**\n   * Clears all lookaheads from this itemset.\n   */\n  clearLookAheads(): void {\n    this._lookaheads = {};\n  }\n\n  /**\n   * Gets the lookahead symbols for a given item.\n   */\n  getLookAheads(item: LRItem): ReadonlyArray<Sym> {\n    return this._lookaheads[item.id] || [];\n  }\n\n  // A way to cache the key of this item set.\n  // Keys help make the comparison of two sets easy.\n  get key(): string {\n    if (this._key == null) {\n      this._key = this.revalKey();\n    }\n    return this._key;\n  }\n\n  protected revalKey(): string {\n    if (this.hasLookAheads) {\n      this.values.sort();\n      return this.values\n        .map((itemId) => {\n          const la = this._lookaheads[itemId] || [];\n          return itemId + \"[\" + la.map((s) => s.id).join(\",\") + \"]\";\n        })\n        .join(\"/\");\n    } else {\n      this.values.sort();\n      return this.values.join(\"/\");\n    }\n  }\n\n  has(itemId: number): boolean {\n    return this.values.indexOf(itemId) >= 0;\n  }\n\n  equals(another: LRItemSet): boolean {\n    return this.key == another.key;\n  }\n\n  add(itemId: number): this {\n    if (!this.has(itemId)) {\n      this.values.push(itemId);\n      this._key = null;\n    }\n    return this;\n  }\n\n  get size(): number {\n    return this.values.length;\n  }\n\n  get debugString(): string {\n    return this.debugValue.join(\"\\n\");\n  }\n\n  get hasLookAheads(): boolean {\n    return this._hasLookAheads;\n  }\n\n  get debugValue(): any {\n    if (this.hasLookAheads) {\n      const items = this.values.map((v: number) => this.itemGraph.items.get(v));\n      // sort them by rule\n      items.sort((i1, i2) => i1.compareTo(i2));\n      // then append the look aheads\n      return items.map((item) => {\n        const las = this.getLookAheads(item)\n          .map((s) => s.label)\n          .sort((s1, s2) => s1.localeCompare(s2))\n          .join(\", \");\n        return las.length > 0 ? `${item.debugString} / ( ${las} )` : item.debugString;\n      });\n    } else {\n      const items = this.values.map((v: number) => this.itemGraph.items.get(v));\n      // sort them by rule\n      items.sort((i1, i2) => i1.compareTo(i2));\n      return items.map((i) => i.debugString);\n    }\n  }\n}\n\nexport abstract class LRItemGraph {\n  // List of all unique LRItems that can be used in this item graph.\n  // Note that since the same Item can reside in multiple sets only\n  // one is created via the newItem method and it is referred\n  // everwhere it is needed.\n\n  /**\n   * Using IDed sets of Items and ItemSets.\n   * This ensures that only one copy of an item exists\n   * \"by value\".\n   */\n  items: IDSet<LRItem>;\n  itemSets: IDSet<LRItemSet>;\n\n  // Goto sets for a set and a given transition out of it\n  gotoSets: NumMap<NumMap<LRItemSet>> = {};\n\n  abstract closure(itemSet: LRItemSet): LRItemSet;\n  abstract startSet(): LRItemSet;\n\n  constructor(public readonly grammar: Grammar) {\n    this.items = new IDSet();\n    this.itemSets = new IDSet();\n  }\n\n  protected startItem(): LRItem {\n    const startSymbol = this.grammar.startSymbol;\n    TSU.assert(startSymbol != null, \"Start symbol must be set\");\n    TSU.assert((this.grammar.augStartRule || null) != null, \"Grammar is not augmented\");\n    return this.items.ensure(new LRItem(this.grammar.augStartRule));\n  }\n\n  reset(): void {\n    this.grammar.refresh();\n    this.gotoSets = {};\n    this.items.clear();\n    this.itemSets.clear();\n    this.startSet();\n  }\n\n  refresh(): this {\n    this.reset();\n    this.grammar.refresh();\n    this.evalGotoSets();\n    return this;\n  }\n\n  /**\n   * Computes all the goto sets used to create the graph of items.\n   */\n  protected evalGotoSets(): void {\n    const out = this.itemSets;\n    for (let i = 0; i < out.size; i++) {\n      const currSet = out.get(i);\n      // This will also include the null symbol since Grammar\n      // adds Null and Eof symbols automatically\n      for (const sym of this.grammar.allSymbols) {\n        if (sym != this.grammar.Null) {\n          const gotoSet = this.goto(currSet, sym);\n          if (gotoSet.size > 0) {\n            this.setGoto(currSet, sym, gotoSet);\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Computes the GOTO set of this ItemSet for a particular symbol transitioning\n   * out of this item set.\n   */\n  goto(itemSet: LRItemSet, sym: Sym): LRItemSet {\n    const out = this.newItemSet();\n    for (const itemId of itemSet.values) {\n      const item = this.items.get(itemId);\n      // see if item.position points to \"sym\" in its rule\n      const rule = item.rule;\n      if (item.position < rule.rhs.length) {\n        if (rule.rhs.syms[item.position] == sym) {\n          // advance the item and add it\n          this.advanceItemAndAdd(item, itemSet, out);\n        }\n      }\n    }\n    // compute the closure of the new set\n    return this.closure(out);\n  }\n\n  protected advanceItemAndAdd(itemToAdvance: LRItem, fromItemSet: LRItemSet, toItemSet: LRItemSet): void {\n    const newItem = this.items.ensure(itemToAdvance.advance());\n    toItemSet.add(newItem.id);\n    // copy over the look aheads\n    for (const laSym of fromItemSet.getLookAheads(itemToAdvance)) {\n      toItemSet.addLookAhead(newItem, laSym);\n    }\n  }\n\n  protected newItemSet(...items: LRItem[]): LRItemSet {\n    return new LRItemSet(this, ...items.map((item) => item.id));\n  }\n\n  get size(): number {\n    return this.itemSets.size;\n  }\n\n  protected ensureGotoSet(fromSet: LRItemSet): NumMap<LRItemSet> {\n    if (!(fromSet.id in this.gotoSets)) {\n      this.gotoSets[fromSet.id] = {};\n    }\n    return this.gotoSets[fromSet.id];\n  }\n\n  setGoto(fromSet: LRItemSet, sym: Sym, toSet: LRItemSet): void {\n    const entries = this.ensureGotoSet(fromSet);\n    entries[sym.id] = toSet;\n  }\n\n  getGoto(fromSet: LRItemSet, sym: Sym): Nullable<LRItemSet> {\n    return (this.gotoSets[fromSet.id] || {})[sym.id] || null;\n  }\n\n  forEachGoto(itemSet: LRItemSet, visitor: (sym: Sym, nextSet: LRItemSet) => boolean | void): void {\n    const gotoSet = this.gotoSets[itemSet.id] || {};\n    for (const symid in gotoSet) {\n      const sym = this.grammar.getSymById(symid as any) as Sym;\n      const next = gotoSet[symid];\n      if (visitor(sym, next) == false) break;\n    }\n  }\n\n  gotoSetFor(itemSet: LRItemSet): NumMap<LRItemSet> {\n    return this.gotoSets[itemSet.id] || {};\n  }\n\n  get debugValue(): any {\n    const out = {} as any;\n    this.itemSets.entries.forEach((iset) => {\n      out[iset.id] = { items: [], goto: {} };\n      out[iset.id][\"items\"] = iset.debugValue;\n      const g = this.gotoSets[iset.id];\n      for (const symid in g) {\n        const sym = this.grammar.getSymById(symid as any)!;\n        out[iset.id][\"goto\"] = out[iset.id][\"goto\"] || {};\n        out[iset.id][\"goto\"][sym.label] = g[symid].id;\n      }\n    });\n    return out;\n  }\n}\n\nexport class LR0ItemGraph extends LRItemGraph {\n  /**\n   * Creates the set for the grammar.  This is done by creating an\n   * augmented rule of the form S' -> S (where S is the start symbol of\n   * the grammar) and creating the closure of this starting rule, ie:\n   *\n   * StartSet = closure({S' -> . S})\n   */\n  startSet(): LRItemSet {\n    const startItem = this.startItem();\n    const newset = this.newItemSet(startItem);\n    return this.closure(newset);\n  }\n\n  /**\n   * Computes the closure of a given item set and returns a new\n   * item set.\n   */\n  closure(itemSet: LRItemSet): LRItemSet {\n    const out = new LRItemSet(this, ...itemSet.values);\n    for (let i = 0; i < out.values.length; i++) {\n      const itemId = out.values[i];\n      const item = this.items.get(itemId)!;\n      const rule = item.rule;\n      // Evaluate the closure\n      // Cannot do anything past the end\n      if (item.position < rule.rhs.length) {\n        const sym = rule.rhs.syms[item.position];\n        if (!sym.isTerminal) {\n          for (const rule of this.grammar.rulesForNT(sym)) {\n            const newItem = this.items.ensure(new LRItem(rule, 0));\n            out.add(newItem.id);\n          }\n        }\n      }\n    }\n    return out.size == 0 ? out : this.itemSets.ensure(out);\n  }\n}\n\nexport class LR1ItemGraph extends LRItemGraph {\n  /**\n   * Overridden to include the EOF marker as the lookahead for the start state\n   *\n   * StartSet = closure({S' -> . S, $})\n   */\n  startSet(): LRItemSet {\n    const startItem = this.startItem();\n    const newset = this.newItemSet(startItem);\n    newset.addLookAhead(startItem, this.grammar.Eof);\n    return this.closure(newset);\n  }\n\n  /**\n   * Computes the closure of this item set and returns a new\n   * item set.\n   */\n  closure(itemSet: LRItemSet): LRItemSet {\n    const out = itemSet.copy();\n    for (let i = 0; i < out.values.length; i++) {\n      const itemId = out.values[i];\n      const item = this.items.get(itemId) as LRItem;\n      // Evaluate the closure\n      // Cannot do anything past the end\n      if (item.position >= item.rule.rhs.length) continue;\n      const rhs = item.rule.rhs;\n      const B = rhs.syms[item.position];\n      if (B.isTerminal) continue;\n\n      for (const lookahead of out.getLookAheads(item)) {\n        const suffix = rhs.copy().append(lookahead);\n        this.grammar.firstSets.forEachTermIn(suffix, item.position + 1, (term) => {\n          if (term != null) {\n            // For each rule [ B -> beta, term ] add it to\n            // our list of items if it doesnt already exist\n            const bRules = this.grammar.rulesForNT(B);\n            for (const br of bRules) {\n              const newItem = this.items.ensure(new LRItem(br, 0));\n              out.add(newItem.id);\n              out.addLookAhead(newItem, term);\n            }\n          }\n        });\n      }\n    }\n    return out.size == 0 ? out : this.itemSets.ensure(out);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Grammar, Str, Sym, Rule } from \"./grammar\";\nimport { LRAction, ParseTable } from \"./lr\";\nimport { LRItem, LRItemSet, LRItemGraph, LR0ItemGraph, LR1ItemGraph } from \"./lritems\";\nimport { Goto } from \"./tests/utils\";\n\nexport function makeParseTable(g: Grammar, type = \"lr1\"): [ParseTable, LRItemGraph] {\n  switch (type) {\n    case \"lr1\":\n      return makeLRParseTable(g);\n    case \"lalr\":\n      return makeLALRParseTable(g);\n  }\n  return makeSLRParseTable(g);\n}\n\n/**\n * A SLR parse table maker.\n */\nexport function makeSLRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  const ig = makeSLRAutomaton(grammar);\n  return [makeParseTableFromLA(ig, grammar), ig];\n}\n\nexport function makeSLRAutomaton(grammar: Grammar): LRItemGraph {\n  const ig = new LR0ItemGraph(grammar).refresh();\n  for (const itemSet of ig.itemSets.entries) {\n    evalLASetsForSLRItem(grammar, ig, itemSet);\n  }\n  return ig;\n}\n\n/**\n * For a given LR(0) Item in the LR0 automaton evaluates the lookahead set\n * for an SLR1 parse table.\n *\n * The SLR lookahead is:\n *\n *    SLRLA(q, A -> w) = Follow(A)\n *\n * @param grammar\n * @param ig\n * @param itemSet\n */\nexport function evalLASetsForSLRItem(grammar: Grammar, ig: LRItemGraph, itemSet: LRItemSet): void {\n  // Look for transitions from this set\n  for (const itemId of itemSet.values) {\n    const item = ig.items.get(itemId);\n    const rule = item.rule;\n    if (item.position >= rule.rhs.length) {\n      // if sym is in follows(nt) then add the rule\n      // Reduce nt -> rule for all sym in follows(nt)\n      grammar.followSets.forEachTerm(rule.nt, (term) => {\n        if (term != null) {\n          TSU.assert(term.isTerminal);\n          itemSet.addLookAhead(item, term);\n        }\n      });\n    }\n  }\n}\n\n/**\n * A canonical LR1 parse table maker.\n */\nexport function makeLRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  const ig = new LR1ItemGraph(grammar).refresh();\n  const parseTable = makeParseTableFromLA(ig, grammar);\n  return [parseTable, ig];\n}\n\n/**\n * A LALR(1) parse table maker using Bermudez and Logothetis' (1989)\n *  \"Simple computation of LALR(1) lookahead sets\" method.\n */\nexport function makeLALRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  // const [parseTable, ig] = makeSLRParseTable(grammar);\n  const [parseTable, ig] = makeSLRParseTable(grammar);\n\n  if (!parseTable.hasConflicts) {\n    return [parseTable, ig];\n  }\n\n  // This is a really simple method compared to DeRemer and Penello's method\n  // (based on relations).\n  //\n  // 1. First transform the grammar G into G' that is based on around the LR0\n  // item graph\n  const g2 = grammarFromLR0ItemGraph(ig, grammar);\n\n  // Reverse of goto sets in the LR automaton to track predecessor states.\n  const prevSets: TSU.NumMap<TSU.NumMap<Set<number>>> = {};\n\n  for (const startState in ig.gotoSets) {\n    for (const symId in ig.gotoSets[startState]) {\n      const nextSet = ig.gotoSets[startState][symId];\n      if (!(nextSet.id in prevSets)) {\n        prevSets[nextSet.id] = {};\n      }\n      if (!(symId in prevSets[nextSet.id])) {\n        prevSets[nextSet.id][symId] = new Set();\n      }\n      prevSets[nextSet.id][symId].add(startState as any as number);\n    }\n  }\n\n  // For conflict states upgrade lookahead sets based on union of follow\n  // sets of G2 for the corresponding sets\n  // LALRLA(q, A -> w) =\n  for (const startState in parseTable.conflictActions) {\n    // So here we have a startState where a symbol was extraneously added\n    // into the look ahead set.   So here recompute the lookahead set\n    // for this state\n    const itemSet = ig.itemSets.get(startState as any as number);\n    evalLASetsForLALRItem(grammar, g2, ig, itemSet, prevSets);\n  }\n\n  // Now that all look aheads have been recomputed - recreate\n  // the parse table\n  return [makeParseTableFromLA(ig, grammar), ig];\n}\n\n/**\n * Shared parse table creator for SLR/LR/LALR grammars that have lookahead\n * in the LR0 automaton.\n */\nexport function makeParseTableFromLA(ig: LRItemGraph, grammar: Grammar): ParseTable {\n  const parseTable = new ParseTable(grammar);\n  for (const itemSet of ig.itemSets.entries) {\n    // Look for transitions from this set\n    for (const itemId of itemSet.values) {\n      const item = ig.items.get(itemId);\n      const rule = item.rule;\n      if (item.position < rule.rhs.length) {\n        // possibilities of shift\n        const sym = rule.rhs.syms[item.position];\n        if (sym.isTerminal) {\n          const nextSet = ig.getGoto(itemSet, sym);\n          if (nextSet) {\n            parseTable.addAction(itemSet.id, sym, LRAction.Shift(nextSet.id));\n          }\n        }\n      } else if (!rule.nt.equals(grammar.augStartRule.nt)) {\n        // We have nt -> rule DOT / t\n        // AND nt != S'\n        // Reduce nt -> rule for t\n        const lookaheads = itemSet.getLookAheads(item);\n        for (const lookahead of lookaheads) {\n          parseTable.addAction(itemSet.id, lookahead, LRAction.Reduce(rule));\n        }\n      }\n    }\n\n    // Now create GOTO entries for (State,X) where X is a non-term\n    ig.forEachGoto(itemSet, (sym, next) => {\n      if (sym != null && !sym.isTerminal) {\n        parseTable.addAction(itemSet.id, sym, LRAction.Goto(next.id));\n      }\n    });\n\n    // If this state contains the augmented item, S' -> S . / $\n    // then add accept\n    const lr1Item = ig.items.ensure(new LRItem(grammar.augStartRule, 1));\n    itemSet.addLookAhead(lr1Item, grammar.Eof);\n    if (itemSet.has(lr1Item.id)) {\n      parseTable.addAction(itemSet.id, grammar.Eof, LRAction.Accept());\n    }\n  }\n  return parseTable;\n}\n\n/**\n * For a given LR(0) Item in the LR0 automaton evaluates the lookahead set\n * for an LALR1 parse table.\n *\n * The LALR lookahead is:\n *\n *    LALRLA(q, A -> w) = {t | [r:t] in Follow[p: A], Go[p: w] = q }\n *\n * Here [r: t] refers to a state in the augmented grammar transformed from the original\n * grammar where the nonterminals and terminals are based on the transitions in the\n * LR(0) automaton.  This augmented grammar is also passed in as a parameter.\n *\n * @param grammar     - Original grammar\n * @param augGrammar  - Augmented grammar\n * @param ig          - LR0 Automaton\n * @param itemSet     - The item set in the automaton (ie a particular state)\n *                      for which lookahead sets are to be computed.\n * @param prevSets    - A mapping where prevSets[stateI][symId] is a list of\n *                      states X1,X2...Xn where where the transition\n *                      X1[symId] = stateI, X2[symId] = stateI ...\n *                      Xn[symId] = stateI\n */\nexport function evalLASetsForLALRItem(\n  grammar: Grammar,\n  augGrammar: Grammar,\n  ig: LRItemGraph,\n  itemSet: LRItemSet,\n  prevSets: TSU.NumMap<TSU.NumMap<Set<number>>>,\n): void {\n  // find p going backwards from q spelling w\n  function findP(rule: Rule, i: number, currState: number, states: Set<number>): void {\n    if (i < 0) {\n      // we have reached the end - currState is P\n      // Ensure there is a transition from currState on rule.nt\n      const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[currState];\n      TSU.assert((transitions[rule.nt.id] || null) != null, \"Transition on rule.nt missing from start state\");\n      states.add(currState);\n    } else {\n      const sym = rule.rhs.syms[i];\n      const prevStates = prevSets[currState][sym.id] || null;\n      TSU.assert(prevStates != null, \"Prev set should not be null\");\n      prevStates.forEach((nextState) => findP(rule, i - 1, nextState, states));\n    }\n  }\n\n  itemSet.clearLookAheads();\n  // Look for transitions from this set\n  for (const itemId of itemSet.values) {\n    const item = ig.items.get(itemId);\n    const rule = item.rule;\n    if (item.position >= rule.rhs.length) {\n      // Here we have rule of the form A -> w in state q\n      //\n      // For this state we compute LALR lookaheads as:\n      //\n      // LALRLA(q, A -> w) = {t | [r:t] in Follow[p: A], Go[p: w] = q }\n      const pSet = new Set<number>();\n      findP(rule, rule.rhs.length - 1, itemSet.id, pSet);\n      pSet.forEach((p) => {\n        // Now find the NT [p: A] in the augmented grammar\n        const pALabel = `[${p}:${rule.nt.label}]`;\n        const pA = augGrammar.getSym(pALabel);\n        TSU.assert(pA != null, \"Augmented grammar symbol [p:A] not found\");\n        augGrammar.followSets.forEachTerm(pA, (term) => {\n          if (term != null && term != augGrammar.Eof) {\n            TSU.assert(term.isTerminal);\n            // This term is in the form [r: T] in the augmented grammar.\n            // Get the T from this and add to the look ahead set\n            const label = term.label.substring(term.label.indexOf(\":\") + 1, term.label.length - 1).trim();\n            const T = grammar.getSym(label);\n            TSU.assert(T != null, `T (${label}) in [r:T] cannot be null`);\n            itemSet.addLookAhead(item, T);\n          }\n        });\n      });\n    }\n  }\n}\n\n/**\n * For a grammar G and its LR0 ItemGraph, IG, returns a transformed grammar G'\n * that is based along the transitions of IG.\n *\n * For this new Grammar G' we have:\n *\n * NonTerminals N' =  { [p: A] | if Go[p: A] is defined },\n * Terminals T' =  { [p: t] | if Go[p: t] is defined },\n * Start Symbol S' = [ Start : S ]\n * Productions P' =  { [p1 : A ] -> [p1 : X1][p2 : X2]...[pn : Xn], if\n *                            [p1 : A] is in N'         AND\n *                            [pi : Xi] is in N' U T'   AND\n *                            A -> X1 X2 .. An is in P (of original grammar G)\n */\nexport function grammarFromLR0ItemGraph(ig: LR0ItemGraph, g: Grammar): Grammar {\n  const g2 = new Grammar();\n\n  function ensureG2Sym(pi: number, sym: Sym): Sym {\n    const newSymLabel = `[${pi}:${sym.label}]`;\n    const newSym = g2.ensureSym(new Sym(g2, newSymLabel, sym.isTerminal), false);\n    if (pi == 0 && g.startSymbol == sym && g.startSymbol != newSym && !sym.isTerminal) {\n      g2.startSymbol = newSym;\n    }\n    return newSym;\n  }\n\n  // Create N', T' and S'\n  for (const startState in ig.gotoSets) {\n    // transitions is a Map of symId -> ItemSet\n    const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[startState];\n    for (const symId in transitions) {\n      const sym = g.getSymById(symId as any as number)!;\n      ensureG2Sym(startState as any as number, sym);\n    }\n  }\n\n  function buildRuleFrom(startSet: number, A: Sym, rule: Rule): Str {\n    // Str to be built up for the production in the transformed grammar\n    //    -   [P1:X1][P2:X2]...[Pn:Xn]\n    let pi = startSet;\n    const newSyms = rule.rhs.syms.map((xi, index) => {\n      const nextSym = ensureG2Sym(pi, xi);\n      const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[pi];\n      const nextSet = transitions[xi.id] || null;\n      TSU.assert(nextSet != null, \"Next set transition *must* be valid\");\n      pi = nextSet.id;\n      return nextSym;\n    });\n    return new Str(...newSyms);\n  }\n\n  for (const startState in ig.gotoSets) {\n    // from P1 - for every transition that is a non terminal A\n    // find an equivalent chain of transition starting from P1 where we have\n    // [P1:X1][P2:X2]...[Pn:Xn]\n    // for All A -> X1X2...Xn in G\n    const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[startState];\n    for (const symId in transitions) {\n      const startSym = g.getSymById(symId as any as number)!;\n      const p1 = startState as any as number;\n      if (!startSym.isTerminal) {\n        const newA = ensureG2Sym(p1, startSym);\n        g.forEachRule(startSym, (rule, index) => {\n          const newRHS = buildRuleFrom(p1, startSym, rule);\n          const newRule = new Rule(newA, newRHS);\n          g2.addRule(newRule);\n        });\n      }\n    }\n  }\n  // Do another pass to evaluate P'\n  return g2;\n}\n","const ALIAS = Symbol.for('yaml.alias');\nconst DOC = Symbol.for('yaml.document');\nconst MAP = Symbol.for('yaml.map');\nconst PAIR = Symbol.for('yaml.pair');\nconst SCALAR = Symbol.for('yaml.scalar');\nconst SEQ = Symbol.for('yaml.seq');\nconst NODE_TYPE = Symbol.for('yaml.node.type');\nconst isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;\nconst isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;\nconst isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;\nconst isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;\nconst isScalar = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR;\nconst isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;\nfunction isCollection(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case MAP:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nfunction isNode(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case ALIAS:\n            case MAP:\n            case SCALAR:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nconst hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;\n\nexport { ALIAS, DOC, MAP, NODE_TYPE, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };\n","import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from './nodes/identity.js';\n\nconst BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove node');\n/**\n * Apply a visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nfunction visit(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        visit_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisit.SKIP = SKIP;\n/** Remove the current node */\nvisit.REMOVE = REMOVE;\nfunction visit_(key, node, visitor, path) {\n    const ctrl = callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visit_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = visit_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = visit_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = visit_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\n/**\n * Apply an async visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `Promise`: Must resolve to one of the following values\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nasync function visitAsync(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        await visitAsync_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisitAsync.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisitAsync.SKIP = SKIP;\n/** Remove the current node */\nvisitAsync.REMOVE = REMOVE;\nasync function visitAsync_(key, node, visitor, path) {\n    const ctrl = await callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visitAsync_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = await visitAsync_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = await visitAsync_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = await visitAsync_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\nfunction initVisitor(visitor) {\n    if (typeof visitor === 'object' &&\n        (visitor.Collection || visitor.Node || visitor.Value)) {\n        return Object.assign({\n            Alias: visitor.Node,\n            Map: visitor.Node,\n            Scalar: visitor.Node,\n            Seq: visitor.Node\n        }, visitor.Value && {\n            Map: visitor.Value,\n            Scalar: visitor.Value,\n            Seq: visitor.Value\n        }, visitor.Collection && {\n            Map: visitor.Collection,\n            Seq: visitor.Collection\n        }, visitor);\n    }\n    return visitor;\n}\nfunction callVisitor(key, node, visitor, path) {\n    if (typeof visitor === 'function')\n        return visitor(key, node, path);\n    if (isMap(node))\n        return visitor.Map?.(key, node, path);\n    if (isSeq(node))\n        return visitor.Seq?.(key, node, path);\n    if (isPair(node))\n        return visitor.Pair?.(key, node, path);\n    if (isScalar(node))\n        return visitor.Scalar?.(key, node, path);\n    if (isAlias(node))\n        return visitor.Alias?.(key, node, path);\n    return undefined;\n}\nfunction replaceNode(key, path, node) {\n    const parent = path[path.length - 1];\n    if (isCollection(parent)) {\n        parent.items[key] = node;\n    }\n    else if (isPair(parent)) {\n        if (key === 'key')\n            parent.key = node;\n        else\n            parent.value = node;\n    }\n    else if (isDocument(parent)) {\n        parent.contents = node;\n    }\n    else {\n        const pt = isAlias(parent) ? 'alias' : 'scalar';\n        throw new Error(`Cannot replace node with ${pt} parent`);\n    }\n}\n\nexport { visit, visitAsync };\n","import { isNode } from '../nodes/identity.js';\nimport { visit } from '../visit.js';\n\nconst escapeChars = {\n    '!': '%21',\n    ',': '%2C',\n    '[': '%5B',\n    ']': '%5D',\n    '{': '%7B',\n    '}': '%7D'\n};\nconst escapeTagName = (tn) => tn.replace(/[!,[\\]{}]/g, ch => escapeChars[ch]);\nclass Directives {\n    constructor(yaml, tags) {\n        /**\n         * The directives-end/doc-start marker `---`. If `null`, a marker may still be\n         * included in the document's stringified representation.\n         */\n        this.docStart = null;\n        /** The doc-end marker `...`.  */\n        this.docEnd = false;\n        this.yaml = Object.assign({}, Directives.defaultYaml, yaml);\n        this.tags = Object.assign({}, Directives.defaultTags, tags);\n    }\n    clone() {\n        const copy = new Directives(this.yaml, this.tags);\n        copy.docStart = this.docStart;\n        return copy;\n    }\n    /**\n     * During parsing, get a Directives instance for the current document and\n     * update the stream state according to the current version's spec.\n     */\n    atDocument() {\n        const res = new Directives(this.yaml, this.tags);\n        switch (this.yaml.version) {\n            case '1.1':\n                this.atNextDocument = true;\n                break;\n            case '1.2':\n                this.atNextDocument = false;\n                this.yaml = {\n                    explicit: Directives.defaultYaml.explicit,\n                    version: '1.2'\n                };\n                this.tags = Object.assign({}, Directives.defaultTags);\n                break;\n        }\n        return res;\n    }\n    /**\n     * @param onError - May be called even if the action was successful\n     * @returns `true` on success\n     */\n    add(line, onError) {\n        if (this.atNextDocument) {\n            this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' };\n            this.tags = Object.assign({}, Directives.defaultTags);\n            this.atNextDocument = false;\n        }\n        const parts = line.trim().split(/[ \\t]+/);\n        const name = parts.shift();\n        switch (name) {\n            case '%TAG': {\n                if (parts.length !== 2) {\n                    onError(0, '%TAG directive should contain exactly two parts');\n                    if (parts.length < 2)\n                        return false;\n                }\n                const [handle, prefix] = parts;\n                this.tags[handle] = prefix;\n                return true;\n            }\n            case '%YAML': {\n                this.yaml.explicit = true;\n                if (parts.length !== 1) {\n                    onError(0, '%YAML directive should contain exactly one part');\n                    return false;\n                }\n                const [version] = parts;\n                if (version === '1.1' || version === '1.2') {\n                    this.yaml.version = version;\n                    return true;\n                }\n                else {\n                    const isValid = /^\\d+\\.\\d+$/.test(version);\n                    onError(6, `Unsupported YAML version ${version}`, isValid);\n                    return false;\n                }\n            }\n            default:\n                onError(0, `Unknown directive ${name}`, true);\n                return false;\n        }\n    }\n    /**\n     * Resolves a tag, matching handles to those defined in %TAG directives.\n     *\n     * @returns Resolved tag, which may also be the non-specific tag `'!'` or a\n     *   `'!local'` tag, or `null` if unresolvable.\n     */\n    tagName(source, onError) {\n        if (source === '!')\n            return '!'; // non-specific tag\n        if (source[0] !== '!') {\n            onError(`Not a valid tag: ${source}`);\n            return null;\n        }\n        if (source[1] === '<') {\n            const verbatim = source.slice(2, -1);\n            if (verbatim === '!' || verbatim === '!!') {\n                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);\n                return null;\n            }\n            if (source[source.length - 1] !== '>')\n                onError('Verbatim tags must end with a >');\n            return verbatim;\n        }\n        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);\n        if (!suffix)\n            onError(`The ${source} tag has no suffix`);\n        const prefix = this.tags[handle];\n        if (prefix) {\n            try {\n                return prefix + decodeURIComponent(suffix);\n            }\n            catch (error) {\n                onError(String(error));\n                return null;\n            }\n        }\n        if (handle === '!')\n            return source; // local tag\n        onError(`Could not resolve tag: ${source}`);\n        return null;\n    }\n    /**\n     * Given a fully resolved tag, returns its printable string form,\n     * taking into account current tag prefixes and defaults.\n     */\n    tagString(tag) {\n        for (const [handle, prefix] of Object.entries(this.tags)) {\n            if (tag.startsWith(prefix))\n                return handle + escapeTagName(tag.substring(prefix.length));\n        }\n        return tag[0] === '!' ? tag : `!<${tag}>`;\n    }\n    toString(doc) {\n        const lines = this.yaml.explicit\n            ? [`%YAML ${this.yaml.version || '1.2'}`]\n            : [];\n        const tagEntries = Object.entries(this.tags);\n        let tagNames;\n        if (doc && tagEntries.length > 0 && isNode(doc.contents)) {\n            const tags = {};\n            visit(doc.contents, (_key, node) => {\n                if (isNode(node) && node.tag)\n                    tags[node.tag] = true;\n            });\n            tagNames = Object.keys(tags);\n        }\n        else\n            tagNames = [];\n        for (const [handle, prefix] of tagEntries) {\n            if (handle === '!!' && prefix === 'tag:yaml.org,2002:')\n                continue;\n            if (!doc || tagNames.some(tn => tn.startsWith(prefix)))\n                lines.push(`%TAG ${handle} ${prefix}`);\n        }\n        return lines.join('\\n');\n    }\n}\nDirectives.defaultYaml = { explicit: false, version: '1.2' };\nDirectives.defaultTags = { '!!': 'tag:yaml.org,2002:' };\n\nexport { Directives };\n","import { isScalar, isCollection } from '../nodes/identity.js';\nimport { visit } from '../visit.js';\n\n/**\n * Verify that the input string is a valid anchor.\n *\n * Will throw on errors.\n */\nfunction anchorIsValid(anchor) {\n    if (/[\\x00-\\x19\\s,[\\]{}]/.test(anchor)) {\n        const sa = JSON.stringify(anchor);\n        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;\n        throw new Error(msg);\n    }\n    return true;\n}\nfunction anchorNames(root) {\n    const anchors = new Set();\n    visit(root, {\n        Value(_key, node) {\n            if (node.anchor)\n                anchors.add(node.anchor);\n        }\n    });\n    return anchors;\n}\n/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */\nfunction findNewAnchor(prefix, exclude) {\n    for (let i = 1; true; ++i) {\n        const name = `${prefix}${i}`;\n        if (!exclude.has(name))\n            return name;\n    }\n}\nfunction createNodeAnchors(doc, prefix) {\n    const aliasObjects = [];\n    const sourceObjects = new Map();\n    let prevAnchors = null;\n    return {\n        onAnchor: (source) => {\n            aliasObjects.push(source);\n            prevAnchors ?? (prevAnchors = anchorNames(doc));\n            const anchor = findNewAnchor(prefix, prevAnchors);\n            prevAnchors.add(anchor);\n            return anchor;\n        },\n        /**\n         * With circular references, the source node is only resolved after all\n         * of its child nodes are. This is why anchors are set only after all of\n         * the nodes have been created.\n         */\n        setAnchors: () => {\n            for (const source of aliasObjects) {\n                const ref = sourceObjects.get(source);\n                if (typeof ref === 'object' &&\n                    ref.anchor &&\n                    (isScalar(ref.node) || isCollection(ref.node))) {\n                    ref.node.anchor = ref.anchor;\n                }\n                else {\n                    const error = new Error('Failed to resolve repeated object (this should not happen)');\n                    error.source = source;\n                    throw error;\n                }\n            }\n        },\n        sourceObjects\n    };\n}\n\nexport { anchorIsValid, anchorNames, createNodeAnchors, findNewAnchor };\n","/**\n * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,\n * in section 24.5.1.1 \"Runtime Semantics: InternalizeJSONProperty\" of the\n * 2021 edition: https://tc39.es/ecma262/#sec-json.parse\n *\n * Includes extensions for handling Map and Set objects.\n */\nfunction applyReviver(reviver, obj, key, val) {\n    if (val && typeof val === 'object') {\n        if (Array.isArray(val)) {\n            for (let i = 0, len = val.length; i < len; ++i) {\n                const v0 = val[i];\n                const v1 = applyReviver(reviver, val, String(i), v0);\n                // eslint-disable-next-line @typescript-eslint/no-array-delete\n                if (v1 === undefined)\n                    delete val[i];\n                else if (v1 !== v0)\n                    val[i] = v1;\n            }\n        }\n        else if (val instanceof Map) {\n            for (const k of Array.from(val.keys())) {\n                const v0 = val.get(k);\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    val.delete(k);\n                else if (v1 !== v0)\n                    val.set(k, v1);\n            }\n        }\n        else if (val instanceof Set) {\n            for (const v0 of Array.from(val)) {\n                const v1 = applyReviver(reviver, val, v0, v0);\n                if (v1 === undefined)\n                    val.delete(v0);\n                else if (v1 !== v0) {\n                    val.delete(v0);\n                    val.add(v1);\n                }\n            }\n        }\n        else {\n            for (const [k, v0] of Object.entries(val)) {\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    delete val[k];\n                else if (v1 !== v0)\n                    val[k] = v1;\n            }\n        }\n    }\n    return reviver.call(obj, key, val);\n}\n\nexport { applyReviver };\n","import { hasAnchor } from './identity.js';\n\n/**\n * Recursively convert any node or its contents to native JavaScript\n *\n * @param value - The input value\n * @param arg - If `value` defines a `toJSON()` method, use this\n *   as its first argument\n * @param ctx - Conversion context, originally set in Document#toJS(). If\n *   `{ keep: true }` is not set, output should be suitable for JSON\n *   stringification.\n */\nfunction toJS(value, arg, ctx) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    if (Array.isArray(value))\n        return value.map((v, i) => toJS(v, String(i), ctx));\n    if (value && typeof value.toJSON === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        if (!ctx || !hasAnchor(value))\n            return value.toJSON(arg, ctx);\n        const data = { aliasCount: 0, count: 1, res: undefined };\n        ctx.anchors.set(value, data);\n        ctx.onCreate = res => {\n            data.res = res;\n            delete ctx.onCreate;\n        };\n        const res = value.toJSON(arg, ctx);\n        if (ctx.onCreate)\n            ctx.onCreate(res);\n        return res;\n    }\n    if (typeof value === 'bigint' && !ctx?.keep)\n        return Number(value);\n    return value;\n}\n\nexport { toJS };\n","import { applyReviver } from '../doc/applyReviver.js';\nimport { NODE_TYPE, isDocument } from './identity.js';\nimport { toJS } from './toJS.js';\n\nclass NodeBase {\n    constructor(type) {\n        Object.defineProperty(this, NODE_TYPE, { value: type });\n    }\n    /** Create a copy of this node.  */\n    clone() {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /** A plain JavaScript representation of this node. */\n    toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {\n        if (!isDocument(doc))\n            throw new TypeError('A document argument is required');\n        const ctx = {\n            anchors: new Map(),\n            doc,\n            keep: true,\n            mapAsMap: mapAsMap === true,\n            mapKeyWarned: false,\n            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100\n        };\n        const res = toJS(this, '', ctx);\n        if (typeof onAnchor === 'function')\n            for (const { count, res } of ctx.anchors.values())\n                onAnchor(res, count);\n        return typeof reviver === 'function'\n            ? applyReviver(reviver, { '': res }, '', res)\n            : res;\n    }\n}\n\nexport { NodeBase };\n","import { anchorIsValid } from '../doc/anchors.js';\nimport { visit } from '../visit.js';\nimport { ALIAS, isAlias, isCollection, isPair, hasAnchor } from './identity.js';\nimport { NodeBase } from './Node.js';\nimport { toJS } from './toJS.js';\n\nclass Alias extends NodeBase {\n    constructor(source) {\n        super(ALIAS);\n        this.source = source;\n        Object.defineProperty(this, 'tag', {\n            set() {\n                throw new Error('Alias nodes cannot have tags');\n            }\n        });\n    }\n    /**\n     * Resolve the value of this alias within `doc`, finding the last\n     * instance of the `source` anchor before this node.\n     */\n    resolve(doc, ctx) {\n        let nodes;\n        if (ctx?.aliasResolveCache) {\n            nodes = ctx.aliasResolveCache;\n        }\n        else {\n            nodes = [];\n            visit(doc, {\n                Node: (_key, node) => {\n                    if (isAlias(node) || hasAnchor(node))\n                        nodes.push(node);\n                }\n            });\n            if (ctx)\n                ctx.aliasResolveCache = nodes;\n        }\n        let found = undefined;\n        for (const node of nodes) {\n            if (node === this)\n                break;\n            if (node.anchor === this.source)\n                found = node;\n        }\n        return found;\n    }\n    toJSON(_arg, ctx) {\n        if (!ctx)\n            return { source: this.source };\n        const { anchors, doc, maxAliasCount } = ctx;\n        const source = this.resolve(doc, ctx);\n        if (!source) {\n            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n            throw new ReferenceError(msg);\n        }\n        let data = anchors.get(source);\n        if (!data) {\n            // Resolve anchors for Node.prototype.toJS()\n            toJS(source, null, ctx);\n            data = anchors.get(source);\n        }\n        /* istanbul ignore if */\n        if (data?.res === undefined) {\n            const msg = 'This should not happen: Alias anchor was not resolved?';\n            throw new ReferenceError(msg);\n        }\n        if (maxAliasCount >= 0) {\n            data.count += 1;\n            if (data.aliasCount === 0)\n                data.aliasCount = getAliasCount(doc, source, anchors);\n            if (data.count * data.aliasCount > maxAliasCount) {\n                const msg = 'Excessive alias count indicates a resource exhaustion attack';\n                throw new ReferenceError(msg);\n            }\n        }\n        return data.res;\n    }\n    toString(ctx, _onComment, _onChompKeep) {\n        const src = `*${this.source}`;\n        if (ctx) {\n            anchorIsValid(this.source);\n            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {\n                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n                throw new Error(msg);\n            }\n            if (ctx.implicitKey)\n                return `${src} `;\n        }\n        return src;\n    }\n}\nfunction getAliasCount(doc, node, anchors) {\n    if (isAlias(node)) {\n        const source = node.resolve(doc);\n        const anchor = anchors && source && anchors.get(source);\n        return anchor ? anchor.count * anchor.aliasCount : 0;\n    }\n    else if (isCollection(node)) {\n        let count = 0;\n        for (const item of node.items) {\n            const c = getAliasCount(doc, item, anchors);\n            if (c > count)\n                count = c;\n        }\n        return count;\n    }\n    else if (isPair(node)) {\n        const kc = getAliasCount(doc, node.key, anchors);\n        const vc = getAliasCount(doc, node.value, anchors);\n        return Math.max(kc, vc);\n    }\n    return 1;\n}\n\nexport { Alias };\n","import { SCALAR } from './identity.js';\nimport { NodeBase } from './Node.js';\nimport { toJS } from './toJS.js';\n\nconst isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');\nclass Scalar extends NodeBase {\n    constructor(value) {\n        super(SCALAR);\n        this.value = value;\n    }\n    toJSON(arg, ctx) {\n        return ctx?.keep ? this.value : toJS(this.value, arg, ctx);\n    }\n    toString() {\n        return String(this.value);\n    }\n}\nScalar.BLOCK_FOLDED = 'BLOCK_FOLDED';\nScalar.BLOCK_LITERAL = 'BLOCK_LITERAL';\nScalar.PLAIN = 'PLAIN';\nScalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';\nScalar.QUOTE_SINGLE = 'QUOTE_SINGLE';\n\nexport { Scalar, isScalarValue };\n","import { Alias } from '../nodes/Alias.js';\nimport { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/identity.js';\nimport { Scalar } from '../nodes/Scalar.js';\n\nconst defaultTagPrefix = 'tag:yaml.org,2002:';\nfunction findTagObject(value, tagName, tags) {\n    if (tagName) {\n        const match = tags.filter(t => t.tag === tagName);\n        const tagObj = match.find(t => !t.format) ?? match[0];\n        if (!tagObj)\n            throw new Error(`Tag ${tagName} not found`);\n        return tagObj;\n    }\n    return tags.find(t => t.identify?.(value) && !t.format);\n}\nfunction createNode(value, tagName, ctx) {\n    if (isDocument(value))\n        value = value.contents;\n    if (isNode(value))\n        return value;\n    if (isPair(value)) {\n        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);\n        map.items.push(value);\n        return map;\n    }\n    if (value instanceof String ||\n        value instanceof Number ||\n        value instanceof Boolean ||\n        (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere\n    ) {\n        // https://tc39.es/ecma262/#sec-serializejsonproperty\n        value = value.valueOf();\n    }\n    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;\n    // Detect duplicate references to the same object & use Alias nodes for all\n    // after first. The `ref` wrapper allows for circular references to resolve.\n    let ref = undefined;\n    if (aliasDuplicateObjects && value && typeof value === 'object') {\n        ref = sourceObjects.get(value);\n        if (ref) {\n            ref.anchor ?? (ref.anchor = onAnchor(value));\n            return new Alias(ref.anchor);\n        }\n        else {\n            ref = { anchor: null, node: null };\n            sourceObjects.set(value, ref);\n        }\n    }\n    if (tagName?.startsWith('!!'))\n        tagName = defaultTagPrefix + tagName.slice(2);\n    let tagObj = findTagObject(value, tagName, schema.tags);\n    if (!tagObj) {\n        if (value && typeof value.toJSON === 'function') {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n            value = value.toJSON();\n        }\n        if (!value || typeof value !== 'object') {\n            const node = new Scalar(value);\n            if (ref)\n                ref.node = node;\n            return node;\n        }\n        tagObj =\n            value instanceof Map\n                ? schema[MAP]\n                : Symbol.iterator in Object(value)\n                    ? schema[SEQ]\n                    : schema[MAP];\n    }\n    if (onTagObj) {\n        onTagObj(tagObj);\n        delete ctx.onTagObj;\n    }\n    const node = tagObj?.createNode\n        ? tagObj.createNode(ctx.schema, value, ctx)\n        : typeof tagObj?.nodeClass?.from === 'function'\n            ? tagObj.nodeClass.from(ctx.schema, value, ctx)\n            : new Scalar(value);\n    if (tagName)\n        node.tag = tagName;\n    else if (!tagObj.default)\n        node.tag = tagObj.tag;\n    if (ref)\n        ref.node = node;\n    return node;\n}\n\nexport { createNode };\n","import { createNode } from '../doc/createNode.js';\nimport { isNode, isPair, isCollection, isScalar } from './identity.js';\nimport { NodeBase } from './Node.js';\n\nfunction collectionFromPath(schema, path, value) {\n    let v = value;\n    for (let i = path.length - 1; i >= 0; --i) {\n        const k = path[i];\n        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {\n            const a = [];\n            a[k] = v;\n            v = a;\n        }\n        else {\n            v = new Map([[k, v]]);\n        }\n    }\n    return createNode(v, undefined, {\n        aliasDuplicateObjects: false,\n        keepUndefined: false,\n        onAnchor: () => {\n            throw new Error('This should not happen, please report a bug.');\n        },\n        schema,\n        sourceObjects: new Map()\n    });\n}\n// Type guard is intentionally a little wrong so as to be more useful,\n// as it does not cover untypable empty non-string iterables (e.g. []).\nconst isEmptyPath = (path) => path == null ||\n    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);\nclass Collection extends NodeBase {\n    constructor(type, schema) {\n        super(type);\n        Object.defineProperty(this, 'schema', {\n            value: schema,\n            configurable: true,\n            enumerable: false,\n            writable: true\n        });\n    }\n    /**\n     * Create a copy of this collection.\n     *\n     * @param schema - If defined, overwrites the original's schema\n     */\n    clone(schema) {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (schema)\n            copy.schema = schema;\n        copy.items = copy.items.map(it => isNode(it) || isPair(it) ? it.clone(schema) : it);\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /**\n     * Adds a value to the collection. For `!!map` and `!!omap` the value must\n     * be a Pair instance or a `{ key, value }` object, which may not have a key\n     * that already exists in the map.\n     */\n    addIn(path, value) {\n        if (isEmptyPath(path))\n            this.add(value);\n        else {\n            const [key, ...rest] = path;\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.addIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n    /**\n     * Removes a value from the collection.\n     * @returns `true` if the item was found and removed.\n     */\n    deleteIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.delete(key);\n        const node = this.get(key, true);\n        if (isCollection(node))\n            return node.deleteIn(rest);\n        else\n            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n    }\n    /**\n     * Returns item at `key`, or `undefined` if not found. By default unwraps\n     * scalar values from their surrounding node; to disable set `keepScalar` to\n     * `true` (collections are always returned intact).\n     */\n    getIn(path, keepScalar) {\n        const [key, ...rest] = path;\n        const node = this.get(key, true);\n        if (rest.length === 0)\n            return !keepScalar && isScalar(node) ? node.value : node;\n        else\n            return isCollection(node) ? node.getIn(rest, keepScalar) : undefined;\n    }\n    hasAllNullValues(allowScalar) {\n        return this.items.every(node => {\n            if (!isPair(node))\n                return false;\n            const n = node.value;\n            return (n == null ||\n                (allowScalar &&\n                    isScalar(n) &&\n                    n.value == null &&\n                    !n.commentBefore &&\n                    !n.comment &&\n                    !n.tag));\n        });\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     */\n    hasIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.has(key);\n        const node = this.get(key, true);\n        return isCollection(node) ? node.hasIn(rest) : false;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     */\n    setIn(path, value) {\n        const [key, ...rest] = path;\n        if (rest.length === 0) {\n            this.set(key, value);\n        }\n        else {\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.setIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n}\n\nexport { Collection, collectionFromPath, isEmptyPath };\n","/**\n * Stringifies a comment.\n *\n * Empty comment lines are left empty,\n * lines consisting of a single space are replaced by `#`,\n * and all other lines are prefixed with a `#`.\n */\nconst stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');\nfunction indentComment(comment, indent) {\n    if (/^\\n+$/.test(comment))\n        return comment.substring(1);\n    return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;\n}\nconst lineComment = (str, indent, comment) => str.endsWith('\\n')\n    ? indentComment(comment, indent)\n    : comment.includes('\\n')\n        ? '\\n' + indentComment(comment, indent)\n        : (str.endsWith(' ') ? '' : ' ') + comment;\n\nexport { indentComment, lineComment, stringifyComment };\n","const FOLD_FLOW = 'flow';\nconst FOLD_BLOCK = 'block';\nconst FOLD_QUOTED = 'quoted';\n/**\n * Tries to keep input at up to `lineWidth` characters, splitting only on spaces\n * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are\n * terminated with `\\n` and started with `indent`.\n */\nfunction foldFlowLines(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {\n    if (!lineWidth || lineWidth < 0)\n        return text;\n    if (lineWidth < minContentWidth)\n        minContentWidth = 0;\n    const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);\n    if (text.length <= endStep)\n        return text;\n    const folds = [];\n    const escapedFolds = {};\n    let end = lineWidth - indent.length;\n    if (typeof indentAtStart === 'number') {\n        if (indentAtStart > lineWidth - Math.max(2, minContentWidth))\n            folds.push(0);\n        else\n            end = lineWidth - indentAtStart;\n    }\n    let split = undefined;\n    let prev = undefined;\n    let overflow = false;\n    let i = -1;\n    let escStart = -1;\n    let escEnd = -1;\n    if (mode === FOLD_BLOCK) {\n        i = consumeMoreIndentedLines(text, i, indent.length);\n        if (i !== -1)\n            end = i + endStep;\n    }\n    for (let ch; (ch = text[(i += 1)]);) {\n        if (mode === FOLD_QUOTED && ch === '\\\\') {\n            escStart = i;\n            switch (text[i + 1]) {\n                case 'x':\n                    i += 3;\n                    break;\n                case 'u':\n                    i += 5;\n                    break;\n                case 'U':\n                    i += 9;\n                    break;\n                default:\n                    i += 1;\n            }\n            escEnd = i;\n        }\n        if (ch === '\\n') {\n            if (mode === FOLD_BLOCK)\n                i = consumeMoreIndentedLines(text, i, indent.length);\n            end = i + indent.length + endStep;\n            split = undefined;\n        }\n        else {\n            if (ch === ' ' &&\n                prev &&\n                prev !== ' ' &&\n                prev !== '\\n' &&\n                prev !== '\\t') {\n                // space surrounded by non-space can be replaced with newline + indent\n                const next = text[i + 1];\n                if (next && next !== ' ' && next !== '\\n' && next !== '\\t')\n                    split = i;\n            }\n            if (i >= end) {\n                if (split) {\n                    folds.push(split);\n                    end = split + endStep;\n                    split = undefined;\n                }\n                else if (mode === FOLD_QUOTED) {\n                    // white-space collected at end may stretch past lineWidth\n                    while (prev === ' ' || prev === '\\t') {\n                        prev = ch;\n                        ch = text[(i += 1)];\n                        overflow = true;\n                    }\n                    // Account for newline escape, but don't break preceding escape\n                    const j = i > escEnd + 1 ? i - 2 : escStart - 1;\n                    // Bail out if lineWidth & minContentWidth are shorter than an escape string\n                    if (escapedFolds[j])\n                        return text;\n                    folds.push(j);\n                    escapedFolds[j] = true;\n                    end = j + endStep;\n                    split = undefined;\n                }\n                else {\n                    overflow = true;\n                }\n            }\n        }\n        prev = ch;\n    }\n    if (overflow && onOverflow)\n        onOverflow();\n    if (folds.length === 0)\n        return text;\n    if (onFold)\n        onFold();\n    let res = text.slice(0, folds[0]);\n    for (let i = 0; i < folds.length; ++i) {\n        const fold = folds[i];\n        const end = folds[i + 1] || text.length;\n        if (fold === 0)\n            res = `\\n${indent}${text.slice(0, end)}`;\n        else {\n            if (mode === FOLD_QUOTED && escapedFolds[fold])\n                res += `${text[fold]}\\\\`;\n            res += `\\n${indent}${text.slice(fold + 1, end)}`;\n        }\n    }\n    return res;\n}\n/**\n * Presumes `i + 1` is at the start of a line\n * @returns index of last newline in more-indented block\n */\nfunction consumeMoreIndentedLines(text, i, indent) {\n    let end = i;\n    let start = i + 1;\n    let ch = text[start];\n    while (ch === ' ' || ch === '\\t') {\n        if (i < start + indent) {\n            ch = text[++i];\n        }\n        else {\n            do {\n                ch = text[++i];\n            } while (ch && ch !== '\\n');\n            end = i;\n            start = i + 1;\n            ch = text[start];\n        }\n    }\n    return end;\n}\n\nexport { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED, foldFlowLines };\n","import { Scalar } from '../nodes/Scalar.js';\nimport { foldFlowLines, FOLD_FLOW, FOLD_QUOTED, FOLD_BLOCK } from './foldFlowLines.js';\n\nconst getFoldOptions = (ctx, isBlock) => ({\n    indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,\n    lineWidth: ctx.options.lineWidth,\n    minContentWidth: ctx.options.minContentWidth\n});\n// Also checks for lines starting with %, as parsing the output as YAML 1.1 will\n// presume that's starting a new document.\nconst containsDocumentMarker = (str) => /^(%|---|\\.\\.\\.)/m.test(str);\nfunction lineLengthOverLimit(str, lineWidth, indentLength) {\n    if (!lineWidth || lineWidth < 0)\n        return false;\n    const limit = lineWidth - indentLength;\n    const strLen = str.length;\n    if (strLen <= limit)\n        return false;\n    for (let i = 0, start = 0; i < strLen; ++i) {\n        if (str[i] === '\\n') {\n            if (i - start > limit)\n                return true;\n            start = i + 1;\n            if (strLen - start <= limit)\n                return false;\n        }\n    }\n    return true;\n}\nfunction doubleQuotedString(value, ctx) {\n    const json = JSON.stringify(value);\n    if (ctx.options.doubleQuotedAsJSON)\n        return json;\n    const { implicitKey } = ctx;\n    const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    let str = '';\n    let start = 0;\n    for (let i = 0, ch = json[i]; ch; ch = json[++i]) {\n        if (ch === ' ' && json[i + 1] === '\\\\' && json[i + 2] === 'n') {\n            // space before newline needs to be escaped to not be folded\n            str += json.slice(start, i) + '\\\\ ';\n            i += 1;\n            start = i;\n            ch = '\\\\';\n        }\n        if (ch === '\\\\')\n            switch (json[i + 1]) {\n                case 'u':\n                    {\n                        str += json.slice(start, i);\n                        const code = json.substr(i + 2, 4);\n                        switch (code) {\n                            case '0000':\n                                str += '\\\\0';\n                                break;\n                            case '0007':\n                                str += '\\\\a';\n                                break;\n                            case '000b':\n                                str += '\\\\v';\n                                break;\n                            case '001b':\n                                str += '\\\\e';\n                                break;\n                            case '0085':\n                                str += '\\\\N';\n                                break;\n                            case '00a0':\n                                str += '\\\\_';\n                                break;\n                            case '2028':\n                                str += '\\\\L';\n                                break;\n                            case '2029':\n                                str += '\\\\P';\n                                break;\n                            default:\n                                if (code.substr(0, 2) === '00')\n                                    str += '\\\\x' + code.substr(2);\n                                else\n                                    str += json.substr(i, 6);\n                        }\n                        i += 5;\n                        start = i + 1;\n                    }\n                    break;\n                case 'n':\n                    if (implicitKey ||\n                        json[i + 2] === '\"' ||\n                        json.length < minMultiLineLength) {\n                        i += 1;\n                    }\n                    else {\n                        // folding will eat first newline\n                        str += json.slice(start, i) + '\\n\\n';\n                        while (json[i + 2] === '\\\\' &&\n                            json[i + 3] === 'n' &&\n                            json[i + 4] !== '\"') {\n                            str += '\\n';\n                            i += 2;\n                        }\n                        str += indent;\n                        // space after newline needs to be escaped to not be folded\n                        if (json[i + 2] === ' ')\n                            str += '\\\\';\n                        i += 1;\n                        start = i + 1;\n                    }\n                    break;\n                default:\n                    i += 1;\n            }\n    }\n    str = start ? str + json.slice(start) : json;\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));\n}\nfunction singleQuotedString(value, ctx) {\n    if (ctx.options.singleQuote === false ||\n        (ctx.implicitKey && value.includes('\\n')) ||\n        /[ \\t]\\n|\\n[ \\t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline\n    )\n        return doubleQuotedString(value, ctx);\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    const res = \"'\" + value.replace(/'/g, \"''\").replace(/\\n+/g, `$&\\n${indent}`) + \"'\";\n    return ctx.implicitKey\n        ? res\n        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));\n}\nfunction quotedString(value, ctx) {\n    const { singleQuote } = ctx.options;\n    let qs;\n    if (singleQuote === false)\n        qs = doubleQuotedString;\n    else {\n        const hasDouble = value.includes('\"');\n        const hasSingle = value.includes(\"'\");\n        if (hasDouble && !hasSingle)\n            qs = singleQuotedString;\n        else if (hasSingle && !hasDouble)\n            qs = doubleQuotedString;\n        else\n            qs = singleQuote ? singleQuotedString : doubleQuotedString;\n    }\n    return qs(value, ctx);\n}\n// The negative lookbehind avoids a polynomial search,\n// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind\nlet blockEndNewlines;\ntry {\n    blockEndNewlines = new RegExp('(^|(?<!\\n))\\n+(?!\\n|$)', 'g');\n}\ncatch {\n    blockEndNewlines = /\\n+(?!\\n|$)/g;\n}\nfunction blockString({ comment, type, value }, ctx, onComment, onChompKeep) {\n    const { blockQuote, commentString, lineWidth } = ctx.options;\n    // 1. Block can't end in whitespace unless the last line is non-empty.\n    // 2. Strings consisting of only whitespace are best rendered explicitly.\n    if (!blockQuote || /\\n[\\t ]+$/.test(value)) {\n        return quotedString(value, ctx);\n    }\n    const indent = ctx.indent ||\n        (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');\n    const literal = blockQuote === 'literal'\n        ? true\n        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED\n            ? false\n            : type === Scalar.BLOCK_LITERAL\n                ? true\n                : !lineLengthOverLimit(value, lineWidth, indent.length);\n    if (!value)\n        return literal ? '|\\n' : '>\\n';\n    // determine chomping from whitespace at value end\n    let chomp;\n    let endStart;\n    for (endStart = value.length; endStart > 0; --endStart) {\n        const ch = value[endStart - 1];\n        if (ch !== '\\n' && ch !== '\\t' && ch !== ' ')\n            break;\n    }\n    let end = value.substring(endStart);\n    const endNlPos = end.indexOf('\\n');\n    if (endNlPos === -1) {\n        chomp = '-'; // strip\n    }\n    else if (value === end || endNlPos !== end.length - 1) {\n        chomp = '+'; // keep\n        if (onChompKeep)\n            onChompKeep();\n    }\n    else {\n        chomp = ''; // clip\n    }\n    if (end) {\n        value = value.slice(0, -end.length);\n        if (end[end.length - 1] === '\\n')\n            end = end.slice(0, -1);\n        end = end.replace(blockEndNewlines, `$&${indent}`);\n    }\n    // determine indent indicator from whitespace at value start\n    let startWithSpace = false;\n    let startEnd;\n    let startNlPos = -1;\n    for (startEnd = 0; startEnd < value.length; ++startEnd) {\n        const ch = value[startEnd];\n        if (ch === ' ')\n            startWithSpace = true;\n        else if (ch === '\\n')\n            startNlPos = startEnd;\n        else\n            break;\n    }\n    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);\n    if (start) {\n        value = value.substring(start.length);\n        start = start.replace(/\\n+/g, `$&${indent}`);\n    }\n    const indentSize = indent ? '2' : '1'; // root is at -1\n    // Leading | or > is added later\n    let header = (startWithSpace ? indentSize : '') + chomp;\n    if (comment) {\n        header += ' ' + commentString(comment.replace(/ ?[\\r\\n]+/g, ' '));\n        if (onComment)\n            onComment();\n    }\n    if (!literal) {\n        const foldedValue = value\n            .replace(/\\n+/g, '\\n$&')\n            .replace(/(?:^|\\n)([\\t ].*)(?:([\\n\\t ]*)\\n(?![\\n\\t ]))?/g, '$1$2') // more-indented lines aren't folded\n            //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent\n            .replace(/\\n+/g, `$&${indent}`);\n        let literalFallback = false;\n        const foldOptions = getFoldOptions(ctx, true);\n        if (blockQuote !== 'folded' && type !== Scalar.BLOCK_FOLDED) {\n            foldOptions.onOverflow = () => {\n                literalFallback = true;\n            };\n        }\n        const body = foldFlowLines(`${start}${foldedValue}${end}`, indent, FOLD_BLOCK, foldOptions);\n        if (!literalFallback)\n            return `>${header}\\n${indent}${body}`;\n    }\n    value = value.replace(/\\n+/g, `$&${indent}`);\n    return `|${header}\\n${indent}${start}${value}${end}`;\n}\nfunction plainString(item, ctx, onComment, onChompKeep) {\n    const { type, value } = item;\n    const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;\n    if ((implicitKey && value.includes('\\n')) ||\n        (inFlow && /[[\\]{},]/.test(value))) {\n        return quotedString(value, ctx);\n    }\n    if (/^[\\n\\t ,[\\]{}#&*!|>'\"%@`]|^[?-]$|^[?-][ \\t]|[\\n:][ \\t]|[ \\t]\\n|[\\n\\t ]#|[\\n\\t :]$/.test(value)) {\n        // not allowed:\n        // - '-' or '?'\n        // - start with an indicator character (except [?:-]) or /[?-] /\n        // - '\\n ', ': ' or ' \\n' anywhere\n        // - '#' not preceded by a non-space char\n        // - end with ' ' or ':'\n        return implicitKey || inFlow || !value.includes('\\n')\n            ? quotedString(value, ctx)\n            : blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (!implicitKey &&\n        !inFlow &&\n        type !== Scalar.PLAIN &&\n        value.includes('\\n')) {\n        // Where allowed & type not set explicitly, prefer block style for multiline strings\n        return blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (containsDocumentMarker(value)) {\n        if (indent === '') {\n            ctx.forceBlockIndent = true;\n            return blockString(item, ctx, onComment, onChompKeep);\n        }\n        else if (implicitKey && indent === indentStep) {\n            return quotedString(value, ctx);\n        }\n    }\n    const str = value.replace(/\\n+/g, `$&\\n${indent}`);\n    // Verify that output will be parsed as a string, as e.g. plain numbers and\n    // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),\n    // and others in v1.1.\n    if (actualString) {\n        const test = (tag) => tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str);\n        const { compat, tags } = ctx.doc.schema;\n        if (tags.some(test) || compat?.some(test))\n            return quotedString(value, ctx);\n    }\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));\n}\nfunction stringifyString(item, ctx, onComment, onChompKeep) {\n    const { implicitKey, inFlow } = ctx;\n    const ss = typeof item.value === 'string'\n        ? item\n        : Object.assign({}, item, { value: String(item.value) });\n    let { type } = item;\n    if (type !== Scalar.QUOTE_DOUBLE) {\n        // force double quotes on control characters & unpaired surrogates\n        if (/[\\x00-\\x08\\x0b-\\x1f\\x7f-\\x9f\\u{D800}-\\u{DFFF}]/u.test(ss.value))\n            type = Scalar.QUOTE_DOUBLE;\n    }\n    const _stringify = (_type) => {\n        switch (_type) {\n            case Scalar.BLOCK_FOLDED:\n            case Scalar.BLOCK_LITERAL:\n                return implicitKey || inFlow\n                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers\n                    : blockString(ss, ctx, onComment, onChompKeep);\n            case Scalar.QUOTE_DOUBLE:\n                return doubleQuotedString(ss.value, ctx);\n            case Scalar.QUOTE_SINGLE:\n                return singleQuotedString(ss.value, ctx);\n            case Scalar.PLAIN:\n                return plainString(ss, ctx, onComment, onChompKeep);\n            default:\n                return null;\n        }\n    };\n    let res = _stringify(type);\n    if (res === null) {\n        const { defaultKeyType, defaultStringType } = ctx.options;\n        const t = (implicitKey && defaultKeyType) || defaultStringType;\n        res = _stringify(t);\n        if (res === null)\n            throw new Error(`Unsupported default string type ${t}`);\n    }\n    return res;\n}\n\nexport { stringifyString };\n","import { anchorIsValid } from '../doc/anchors.js';\nimport { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/identity.js';\nimport { stringifyComment } from './stringifyComment.js';\nimport { stringifyString } from './stringifyString.js';\n\nfunction createStringifyContext(doc, options) {\n    const opt = Object.assign({\n        blockQuote: true,\n        commentString: stringifyComment,\n        defaultKeyType: null,\n        defaultStringType: 'PLAIN',\n        directives: null,\n        doubleQuotedAsJSON: false,\n        doubleQuotedMinMultiLineLength: 40,\n        falseStr: 'false',\n        flowCollectionPadding: true,\n        indentSeq: true,\n        lineWidth: 80,\n        minContentWidth: 20,\n        nullStr: 'null',\n        simpleKeys: false,\n        singleQuote: null,\n        trueStr: 'true',\n        verifyAliasOrder: true\n    }, doc.schema.toStringOptions, options);\n    let inFlow;\n    switch (opt.collectionStyle) {\n        case 'block':\n            inFlow = false;\n            break;\n        case 'flow':\n            inFlow = true;\n            break;\n        default:\n            inFlow = null;\n    }\n    return {\n        anchors: new Set(),\n        doc,\n        flowCollectionPadding: opt.flowCollectionPadding ? ' ' : '',\n        indent: '',\n        indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',\n        inFlow,\n        options: opt\n    };\n}\nfunction getTagObject(tags, item) {\n    if (item.tag) {\n        const match = tags.filter(t => t.tag === item.tag);\n        if (match.length > 0)\n            return match.find(t => t.format === item.format) ?? match[0];\n    }\n    let tagObj = undefined;\n    let obj;\n    if (isScalar(item)) {\n        obj = item.value;\n        let match = tags.filter(t => t.identify?.(obj));\n        if (match.length > 1) {\n            const testMatch = match.filter(t => t.test);\n            if (testMatch.length > 0)\n                match = testMatch;\n        }\n        tagObj =\n            match.find(t => t.format === item.format) ?? match.find(t => !t.format);\n    }\n    else {\n        obj = item;\n        tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);\n    }\n    if (!tagObj) {\n        const name = obj?.constructor?.name ?? (obj === null ? 'null' : typeof obj);\n        throw new Error(`Tag not resolved for ${name} value`);\n    }\n    return tagObj;\n}\n// needs to be called before value stringifier to allow for circular anchor refs\nfunction stringifyProps(node, tagObj, { anchors, doc }) {\n    if (!doc.directives)\n        return '';\n    const props = [];\n    const anchor = (isScalar(node) || isCollection(node)) && node.anchor;\n    if (anchor && anchorIsValid(anchor)) {\n        anchors.add(anchor);\n        props.push(`&${anchor}`);\n    }\n    const tag = node.tag ?? (tagObj.default ? null : tagObj.tag);\n    if (tag)\n        props.push(doc.directives.tagString(tag));\n    return props.join(' ');\n}\nfunction stringify(item, ctx, onComment, onChompKeep) {\n    if (isPair(item))\n        return item.toString(ctx, onComment, onChompKeep);\n    if (isAlias(item)) {\n        if (ctx.doc.directives)\n            return item.toString(ctx);\n        if (ctx.resolvedAliases?.has(item)) {\n            throw new TypeError(`Cannot stringify circular structure without alias nodes`);\n        }\n        else {\n            if (ctx.resolvedAliases)\n                ctx.resolvedAliases.add(item);\n            else\n                ctx.resolvedAliases = new Set([item]);\n            item = item.resolve(ctx.doc);\n        }\n    }\n    let tagObj = undefined;\n    const node = isNode(item)\n        ? item\n        : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });\n    tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node));\n    const props = stringifyProps(node, tagObj, ctx);\n    if (props.length > 0)\n        ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;\n    const str = typeof tagObj.stringify === 'function'\n        ? tagObj.stringify(node, ctx, onComment, onChompKeep)\n        : isScalar(node)\n            ? stringifyString(node, ctx, onComment, onChompKeep)\n            : node.toString(ctx, onComment, onChompKeep);\n    if (!props)\n        return str;\n    return isScalar(node) || str[0] === '{' || str[0] === '['\n        ? `${props} ${str}`\n        : `${props}\\n${ctx.indent}${str}`;\n}\n\nexport { createStringifyContext, stringify };\n","import { isScalar, isAlias, isSeq, isMap } from '../../nodes/identity.js';\nimport { Scalar } from '../../nodes/Scalar.js';\n\n// If the value associated with a merge key is a single mapping node, each of\n// its key/value pairs is inserted into the current mapping, unless the key\n// already exists in it. If the value associated with the merge key is a\n// sequence, then this sequence is expected to contain mapping nodes and each\n// of these nodes is merged in turn according to its order in the sequence.\n// Keys in mapping nodes earlier in the sequence override keys specified in\n// later mapping nodes. -- http://yaml.org/type/merge.html\nconst MERGE_KEY = '<<';\nconst merge = {\n    identify: value => value === MERGE_KEY ||\n        (typeof value === 'symbol' && value.description === MERGE_KEY),\n    default: 'key',\n    tag: 'tag:yaml.org,2002:merge',\n    test: /^<<$/,\n    resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), {\n        addToJSMap: addMergeToJSMap\n    }),\n    stringify: () => MERGE_KEY\n};\nconst isMergeKey = (ctx, key) => (merge.identify(key) ||\n    (isScalar(key) &&\n        (!key.type || key.type === Scalar.PLAIN) &&\n        merge.identify(key.value))) &&\n    ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default);\nfunction addMergeToJSMap(ctx, map, value) {\n    value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (isSeq(value))\n        for (const it of value.items)\n            mergeValue(ctx, map, it);\n    else if (Array.isArray(value))\n        for (const it of value)\n            mergeValue(ctx, map, it);\n    else\n        mergeValue(ctx, map, value);\n}\nfunction mergeValue(ctx, map, value) {\n    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (!isMap(source))\n        throw new Error('Merge sources must be maps or map aliases');\n    const srcMap = source.toJSON(null, ctx, Map);\n    for (const [key, value] of srcMap) {\n        if (map instanceof Map) {\n            if (!map.has(key))\n                map.set(key, value);\n        }\n        else if (map instanceof Set) {\n            map.add(key);\n        }\n        else if (!Object.prototype.hasOwnProperty.call(map, key)) {\n            Object.defineProperty(map, key, {\n                value,\n                writable: true,\n                enumerable: true,\n                configurable: true\n            });\n        }\n    }\n    return map;\n}\n\nexport { addMergeToJSMap, isMergeKey, merge };\n","import { warn } from '../log.js';\nimport { isMergeKey, addMergeToJSMap } from '../schema/yaml-1.1/merge.js';\nimport { createStringifyContext } from '../stringify/stringify.js';\nimport { isNode } from './identity.js';\nimport { toJS } from './toJS.js';\n\nfunction addPairToJSMap(ctx, map, { key, value }) {\n    if (isNode(key) && key.addToJSMap)\n        key.addToJSMap(ctx, map, value);\n    // TODO: Should drop this special case for bare << handling\n    else if (isMergeKey(ctx, key))\n        addMergeToJSMap(ctx, map, value);\n    else {\n        const jsKey = toJS(key, '', ctx);\n        if (map instanceof Map) {\n            map.set(jsKey, toJS(value, jsKey, ctx));\n        }\n        else if (map instanceof Set) {\n            map.add(jsKey);\n        }\n        else {\n            const stringKey = stringifyKey(key, jsKey, ctx);\n            const jsValue = toJS(value, stringKey, ctx);\n            if (stringKey in map)\n                Object.defineProperty(map, stringKey, {\n                    value: jsValue,\n                    writable: true,\n                    enumerable: true,\n                    configurable: true\n                });\n            else\n                map[stringKey] = jsValue;\n        }\n    }\n    return map;\n}\nfunction stringifyKey(key, jsKey, ctx) {\n    if (jsKey === null)\n        return '';\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\n    if (typeof jsKey !== 'object')\n        return String(jsKey);\n    if (isNode(key) && ctx?.doc) {\n        const strCtx = createStringifyContext(ctx.doc, {});\n        strCtx.anchors = new Set();\n        for (const node of ctx.anchors.keys())\n            strCtx.anchors.add(node.anchor);\n        strCtx.inFlow = true;\n        strCtx.inStringifyKey = true;\n        const strKey = key.toString(strCtx);\n        if (!ctx.mapKeyWarned) {\n            let jsonStr = JSON.stringify(strKey);\n            if (jsonStr.length > 40)\n                jsonStr = jsonStr.substring(0, 36) + '...\"';\n            warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);\n            ctx.mapKeyWarned = true;\n        }\n        return strKey;\n    }\n    return JSON.stringify(jsKey);\n}\n\nexport { addPairToJSMap };\n","function debug(logLevel, ...messages) {\n    if (logLevel === 'debug')\n        console.log(...messages);\n}\nfunction warn(logLevel, warning) {\n    if (logLevel === 'debug' || logLevel === 'warn') {\n        console.warn(warning);\n    }\n}\n\nexport { debug, warn };\n","import { createNode } from '../doc/createNode.js';\nimport { stringifyPair } from '../stringify/stringifyPair.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { NODE_TYPE, PAIR, isNode } from './identity.js';\n\nfunction createPair(key, value, ctx) {\n    const k = createNode(key, undefined, ctx);\n    const v = createNode(value, undefined, ctx);\n    return new Pair(k, v);\n}\nclass Pair {\n    constructor(key, value = null) {\n        Object.defineProperty(this, NODE_TYPE, { value: PAIR });\n        this.key = key;\n        this.value = value;\n    }\n    clone(schema) {\n        let { key, value } = this;\n        if (isNode(key))\n            key = key.clone(schema);\n        if (isNode(value))\n            value = value.clone(schema);\n        return new Pair(key, value);\n    }\n    toJSON(_, ctx) {\n        const pair = ctx?.mapAsMap ? new Map() : {};\n        return addPairToJSMap(ctx, pair, this);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        return ctx?.doc\n            ? stringifyPair(this, ctx, onComment, onChompKeep)\n            : JSON.stringify(this);\n    }\n}\n\nexport { Pair, createPair };\n","import { isCollection, isNode, isScalar, isSeq } from '../nodes/identity.js';\nimport { Scalar } from '../nodes/Scalar.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyPair({ key, value }, ctx, onComment, onChompKeep) {\n    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;\n    let keyComment = (isNode(key) && key.comment) || null;\n    if (simpleKeys) {\n        if (keyComment) {\n            throw new Error('With simple keys, key nodes cannot have comments');\n        }\n        if (isCollection(key) || (!isNode(key) && typeof key === 'object')) {\n            const msg = 'With simple keys, collection cannot be used as a key value';\n            throw new Error(msg);\n        }\n    }\n    let explicitKey = !simpleKeys &&\n        (!key ||\n            (keyComment && value == null && !ctx.inFlow) ||\n            isCollection(key) ||\n            (isScalar(key)\n                ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL\n                : typeof key === 'object'));\n    ctx = Object.assign({}, ctx, {\n        allNullValues: false,\n        implicitKey: !explicitKey && (simpleKeys || !allNullValues),\n        indent: indent + indentStep\n    });\n    let keyCommentDone = false;\n    let chompKeep = false;\n    let str = stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));\n    if (!explicitKey && !ctx.inFlow && str.length > 1024) {\n        if (simpleKeys)\n            throw new Error('With simple keys, single line scalar must not span more than 1024 characters');\n        explicitKey = true;\n    }\n    if (ctx.inFlow) {\n        if (allNullValues || value == null) {\n            if (keyCommentDone && onComment)\n                onComment();\n            return str === '' ? '?' : explicitKey ? `? ${str}` : str;\n        }\n    }\n    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {\n        str = `? ${str}`;\n        if (keyComment && !keyCommentDone) {\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        }\n        else if (chompKeep && onChompKeep)\n            onChompKeep();\n        return str;\n    }\n    if (keyCommentDone)\n        keyComment = null;\n    if (explicitKey) {\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        str = `? ${str}\\n${indent}:`;\n    }\n    else {\n        str = `${str}:`;\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n    }\n    let vsb, vcb, valueComment;\n    if (isNode(value)) {\n        vsb = !!value.spaceBefore;\n        vcb = value.commentBefore;\n        valueComment = value.comment;\n    }\n    else {\n        vsb = false;\n        vcb = null;\n        valueComment = null;\n        if (value && typeof value === 'object')\n            value = doc.createNode(value);\n    }\n    ctx.implicitKey = false;\n    if (!explicitKey && !keyComment && isScalar(value))\n        ctx.indentAtStart = str.length + 1;\n    chompKeep = false;\n    if (!indentSeq &&\n        indentStep.length >= 2 &&\n        !ctx.inFlow &&\n        !explicitKey &&\n        isSeq(value) &&\n        !value.flow &&\n        !value.tag &&\n        !value.anchor) {\n        // If indentSeq === false, consider '- ' as part of indentation where possible\n        ctx.indent = ctx.indent.substring(2);\n    }\n    let valueCommentDone = false;\n    const valueStr = stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));\n    let ws = ' ';\n    if (keyComment || vsb || vcb) {\n        ws = vsb ? '\\n' : '';\n        if (vcb) {\n            const cs = commentString(vcb);\n            ws += `\\n${indentComment(cs, ctx.indent)}`;\n        }\n        if (valueStr === '' && !ctx.inFlow) {\n            if (ws === '\\n' && valueComment)\n                ws = '\\n\\n';\n        }\n        else {\n            ws += `\\n${ctx.indent}`;\n        }\n    }\n    else if (!explicitKey && isCollection(value)) {\n        const vs0 = valueStr[0];\n        const nl0 = valueStr.indexOf('\\n');\n        const hasNewline = nl0 !== -1;\n        const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;\n        if (hasNewline || !flow) {\n            let hasPropsLine = false;\n            if (hasNewline && (vs0 === '&' || vs0 === '!')) {\n                let sp0 = valueStr.indexOf(' ');\n                if (vs0 === '&' &&\n                    sp0 !== -1 &&\n                    sp0 < nl0 &&\n                    valueStr[sp0 + 1] === '!') {\n                    sp0 = valueStr.indexOf(' ', sp0 + 1);\n                }\n                if (sp0 === -1 || nl0 < sp0)\n                    hasPropsLine = true;\n            }\n            if (!hasPropsLine)\n                ws = `\\n${ctx.indent}`;\n        }\n    }\n    else if (valueStr === '' || valueStr[0] === '\\n') {\n        ws = '';\n    }\n    str += ws + valueStr;\n    if (ctx.inFlow) {\n        if (valueCommentDone && onComment)\n            onComment();\n    }\n    else if (valueComment && !valueCommentDone) {\n        str += lineComment(str, ctx.indent, commentString(valueComment));\n    }\n    else if (chompKeep && onChompKeep) {\n        onChompKeep();\n    }\n    return str;\n}\n\nexport { stringifyPair };\n","import { isNode, isPair } from '../nodes/identity.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyCollection(collection, ctx, options) {\n    const flow = ctx.inFlow ?? collection.flow;\n    const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;\n    return stringify(collection, ctx, options);\n}\nfunction stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {\n    const { indent, options: { commentString } } = ctx;\n    const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null });\n    let chompKeep = false; // flag for the preceding node's status\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (!chompKeep && item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (!chompKeep && ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);\n            }\n        }\n        chompKeep = false;\n        let str = stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (chompKeep && comment)\n            chompKeep = false;\n        lines.push(blockItemPrefix + str);\n    }\n    let str;\n    if (lines.length === 0) {\n        str = flowChars.start + flowChars.end;\n    }\n    else {\n        str = lines[0];\n        for (let i = 1; i < lines.length; ++i) {\n            const line = lines[i];\n            str += line ? `\\n${indent}${line}` : '\\n';\n        }\n    }\n    if (comment) {\n        str += '\\n' + indentComment(commentString(comment), indent);\n        if (onComment)\n            onComment();\n    }\n    else if (chompKeep && onChompKeep)\n        onChompKeep();\n    return str;\n}\nfunction stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {\n    const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;\n    itemIndent += indentStep;\n    const itemCtx = Object.assign({}, ctx, {\n        indent: itemIndent,\n        inFlow: true,\n        type: null\n    });\n    let reqNewline = false;\n    let linesAtValue = 0;\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, false);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, false);\n                if (ik.comment)\n                    reqNewline = true;\n            }\n            const iv = isNode(item.value) ? item.value : null;\n            if (iv) {\n                if (iv.comment)\n                    comment = iv.comment;\n                if (iv.commentBefore)\n                    reqNewline = true;\n            }\n            else if (item.value == null && ik?.comment) {\n                comment = ik.comment;\n            }\n        }\n        if (comment)\n            reqNewline = true;\n        let str = stringify(item, itemCtx, () => (comment = null));\n        if (i < items.length - 1)\n            str += ',';\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (!reqNewline && (lines.length > linesAtValue || str.includes('\\n')))\n            reqNewline = true;\n        lines.push(str);\n        linesAtValue = lines.length;\n    }\n    const { start, end } = flowChars;\n    if (lines.length === 0) {\n        return start + end;\n    }\n    else {\n        if (!reqNewline) {\n            const len = lines.reduce((sum, line) => sum + line.length + 2, 2);\n            reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;\n        }\n        if (reqNewline) {\n            let str = start;\n            for (const line of lines)\n                str += line ? `\\n${indentStep}${indent}${line}` : '\\n';\n            return `${str}\\n${indent}${end}`;\n        }\n        else {\n            return `${start}${fcPadding}${lines.join(' ')}${fcPadding}${end}`;\n        }\n    }\n}\nfunction addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {\n    if (comment && chompKeep)\n        comment = comment.replace(/^\\n+/, '');\n    if (comment) {\n        const ic = indentComment(commentString(comment), indent);\n        lines.push(ic.trimStart()); // Avoid double indent on first line\n    }\n}\n\nexport { stringifyCollection };\n","import { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { Collection } from './Collection.js';\nimport { MAP, isPair, isScalar } from './identity.js';\nimport { Pair, createPair } from './Pair.js';\nimport { isScalarValue } from './Scalar.js';\n\nfunction findPair(items, key) {\n    const k = isScalar(key) ? key.value : key;\n    for (const it of items) {\n        if (isPair(it)) {\n            if (it.key === key || it.key === k)\n                return it;\n            if (isScalar(it.key) && it.key.value === k)\n                return it;\n        }\n    }\n    return undefined;\n}\nclass YAMLMap extends Collection {\n    static get tagName() {\n        return 'tag:yaml.org,2002:map';\n    }\n    constructor(schema) {\n        super(MAP, schema);\n        this.items = [];\n    }\n    /**\n     * A generic collection parsing method that can be extended\n     * to other node classes that inherit from YAMLMap\n     */\n    static from(schema, obj, ctx) {\n        const { keepUndefined, replacer } = ctx;\n        const map = new this(schema);\n        const add = (key, value) => {\n            if (typeof replacer === 'function')\n                value = replacer.call(obj, key, value);\n            else if (Array.isArray(replacer) && !replacer.includes(key))\n                return;\n            if (value !== undefined || keepUndefined)\n                map.items.push(createPair(key, value, ctx));\n        };\n        if (obj instanceof Map) {\n            for (const [key, value] of obj)\n                add(key, value);\n        }\n        else if (obj && typeof obj === 'object') {\n            for (const key of Object.keys(obj))\n                add(key, obj[key]);\n        }\n        if (typeof schema.sortMapEntries === 'function') {\n            map.items.sort(schema.sortMapEntries);\n        }\n        return map;\n    }\n    /**\n     * Adds a value to the collection.\n     *\n     * @param overwrite - If not set `true`, using a key that is already in the\n     *   collection will throw. Otherwise, overwrites the previous value.\n     */\n    add(pair, overwrite) {\n        let _pair;\n        if (isPair(pair))\n            _pair = pair;\n        else if (!pair || typeof pair !== 'object' || !('key' in pair)) {\n            // In TypeScript, this never happens.\n            _pair = new Pair(pair, pair?.value);\n        }\n        else\n            _pair = new Pair(pair.key, pair.value);\n        const prev = findPair(this.items, _pair.key);\n        const sortEntries = this.schema?.sortMapEntries;\n        if (prev) {\n            if (!overwrite)\n                throw new Error(`Key ${_pair.key} already set`);\n            // For scalars, keep the old node & its comments and anchors\n            if (isScalar(prev.value) && isScalarValue(_pair.value))\n                prev.value.value = _pair.value;\n            else\n                prev.value = _pair.value;\n        }\n        else if (sortEntries) {\n            const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);\n            if (i === -1)\n                this.items.push(_pair);\n            else\n                this.items.splice(i, 0, _pair);\n        }\n        else {\n            this.items.push(_pair);\n        }\n    }\n    delete(key) {\n        const it = findPair(this.items, key);\n        if (!it)\n            return false;\n        const del = this.items.splice(this.items.indexOf(it), 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const it = findPair(this.items, key);\n        const node = it?.value;\n        return (!keepScalar && isScalar(node) ? node.value : node) ?? undefined;\n    }\n    has(key) {\n        return !!findPair(this.items, key);\n    }\n    set(key, value) {\n        this.add(new Pair(key, value), true);\n    }\n    /**\n     * @param ctx - Conversion context, originally set in Document#toJS()\n     * @param {Class} Type - If set, forces the returned collection type\n     * @returns Instance of Type, Map, or Object\n     */\n    toJSON(_, ctx, Type) {\n        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const item of this.items)\n            addPairToJSMap(ctx, map, item);\n        return map;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        for (const item of this.items) {\n            if (!isPair(item))\n                throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);\n        }\n        if (!ctx.allNullValues && this.hasAllNullValues(false))\n            ctx = Object.assign({}, ctx, { allNullValues: true });\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '',\n            flowChars: { start: '{', end: '}' },\n            itemIndent: ctx.indent || '',\n            onChompKeep,\n            onComment\n        });\n    }\n}\n\nexport { YAMLMap, findPair };\n","import { isMap } from '../../nodes/identity.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\n\nconst map = {\n    collection: 'map',\n    default: true,\n    nodeClass: YAMLMap,\n    tag: 'tag:yaml.org,2002:map',\n    resolve(map, onError) {\n        if (!isMap(map))\n            onError('Expected a mapping for this tag');\n        return map;\n    },\n    createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)\n};\n\nexport { map };\n","import { createNode } from '../doc/createNode.js';\nimport { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { Collection } from './Collection.js';\nimport { SEQ, isScalar } from './identity.js';\nimport { isScalarValue } from './Scalar.js';\nimport { toJS } from './toJS.js';\n\nclass YAMLSeq extends Collection {\n    static get tagName() {\n        return 'tag:yaml.org,2002:seq';\n    }\n    constructor(schema) {\n        super(SEQ, schema);\n        this.items = [];\n    }\n    add(value) {\n        this.items.push(value);\n    }\n    /**\n     * Removes a value from the collection.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     *\n     * @returns `true` if the item was found and removed.\n     */\n    delete(key) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return false;\n        const del = this.items.splice(idx, 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return undefined;\n        const it = this.items[idx];\n        return !keepScalar && isScalar(it) ? it.value : it;\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     */\n    has(key) {\n        const idx = asItemIndex(key);\n        return typeof idx === 'number' && idx < this.items.length;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     *\n     * If `key` does not contain a representation of an integer, this will throw.\n     * It may be wrapped in a `Scalar`.\n     */\n    set(key, value) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            throw new Error(`Expected a valid index, not ${key}.`);\n        const prev = this.items[idx];\n        if (isScalar(prev) && isScalarValue(value))\n            prev.value = value;\n        else\n            this.items[idx] = value;\n    }\n    toJSON(_, ctx) {\n        const seq = [];\n        if (ctx?.onCreate)\n            ctx.onCreate(seq);\n        let i = 0;\n        for (const item of this.items)\n            seq.push(toJS(item, String(i++), ctx));\n        return seq;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '- ',\n            flowChars: { start: '[', end: ']' },\n            itemIndent: (ctx.indent || '') + '  ',\n            onChompKeep,\n            onComment\n        });\n    }\n    static from(schema, obj, ctx) {\n        const { replacer } = ctx;\n        const seq = new this(schema);\n        if (obj && Symbol.iterator in Object(obj)) {\n            let i = 0;\n            for (let it of obj) {\n                if (typeof replacer === 'function') {\n                    const key = obj instanceof Set ? it : String(i++);\n                    it = replacer.call(obj, key, it);\n                }\n                seq.items.push(createNode(it, undefined, ctx));\n            }\n        }\n        return seq;\n    }\n}\nfunction asItemIndex(key) {\n    let idx = isScalar(key) ? key.value : key;\n    if (idx && typeof idx === 'string')\n        idx = Number(idx);\n    return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0\n        ? idx\n        : null;\n}\n\nexport { YAMLSeq };\n","import { isSeq } from '../../nodes/identity.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nconst seq = {\n    collection: 'seq',\n    default: true,\n    nodeClass: YAMLSeq,\n    tag: 'tag:yaml.org,2002:seq',\n    resolve(seq, onError) {\n        if (!isSeq(seq))\n            onError('Expected a sequence for this tag');\n        return seq;\n    },\n    createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)\n};\n\nexport { seq };\n","import { stringifyString } from '../../stringify/stringifyString.js';\n\nconst string = {\n    identify: value => typeof value === 'string',\n    default: true,\n    tag: 'tag:yaml.org,2002:str',\n    resolve: str => str,\n    stringify(item, ctx, onComment, onChompKeep) {\n        ctx = Object.assign({ actualString: true }, ctx);\n        return stringifyString(item, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { string };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nconst nullTag = {\n    identify: value => value == null,\n    createNode: () => new Scalar(null),\n    default: true,\n    tag: 'tag:yaml.org,2002:null',\n    test: /^(?:~|[Nn]ull|NULL)?$/,\n    resolve: () => new Scalar(null),\n    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)\n        ? source\n        : ctx.options.nullStr\n};\n\nexport { nullTag };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nconst boolTag = {\n    identify: value => typeof value === 'boolean',\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,\n    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),\n    stringify({ source, value }, ctx) {\n        if (source && boolTag.test.test(source)) {\n            const sv = source[0] === 't' || source[0] === 'T';\n            if (value === sv)\n                return source;\n        }\n        return value ? ctx.options.trueStr : ctx.options.falseStr;\n    }\n};\n\nexport { boolTag };\n","function stringifyNumber({ format, minFractionDigits, tag, value }) {\n    if (typeof value === 'bigint')\n        return String(value);\n    const num = typeof value === 'number' ? value : Number(value);\n    if (!isFinite(num))\n        return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf';\n    let n = Object.is(value, -0) ? '-0' : JSON.stringify(value);\n    if (!format &&\n        minFractionDigits &&\n        (!tag || tag === 'tag:yaml.org,2002:float') &&\n        /^\\d/.test(n)) {\n        let i = n.indexOf('.');\n        if (i < 0) {\n            i = n.length;\n            n += '.';\n        }\n        let d = minFractionDigits - (n.length - i - 1);\n        while (d-- > 0)\n            n += '0';\n    }\n    return n;\n}\n\nexport { stringifyNumber };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF)|\\.nan|\\.NaN|\\.NAN)$/,\n    resolve: str => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+(?:\\.[0-9]*)?)[eE][-+]?[0-9]+$/,\n    resolve: str => parseFloat(str),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+\\.[0-9]*)$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str));\n        const dot = str.indexOf('.');\n        if (dot !== -1 && str[str.length - 1] === '0')\n            node.minFractionDigits = str.length - dot - 1;\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nconst intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value) && value >= 0)\n        return prefix + value.toString(radix);\n    return stringifyNumber(node);\n}\nconst intOct = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^0o[0-7]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),\n    stringify: node => intStringify(node, 8, '0o')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^0x[0-9a-fA-F]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intHex, intOct };\n","import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { boolTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intOct, int, intHex } from './int.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    boolTag,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float\n];\n\nexport { schema };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { map } from '../common/map.js';\nimport { seq } from '../common/seq.js';\n\nfunction intIdentify(value) {\n    return typeof value === 'bigint' || Number.isInteger(value);\n}\nconst stringifyJSON = ({ value }) => JSON.stringify(value);\nconst jsonScalars = [\n    {\n        identify: value => typeof value === 'string',\n        default: true,\n        tag: 'tag:yaml.org,2002:str',\n        resolve: str => str,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => value == null,\n        createNode: () => new Scalar(null),\n        default: true,\n        tag: 'tag:yaml.org,2002:null',\n        test: /^null$/,\n        resolve: () => null,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => typeof value === 'boolean',\n        default: true,\n        tag: 'tag:yaml.org,2002:bool',\n        test: /^true$|^false$/,\n        resolve: str => str === 'true',\n        stringify: stringifyJSON\n    },\n    {\n        identify: intIdentify,\n        default: true,\n        tag: 'tag:yaml.org,2002:int',\n        test: /^-?(?:0|[1-9][0-9]*)$/,\n        resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),\n        stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)\n    },\n    {\n        identify: value => typeof value === 'number',\n        default: true,\n        tag: 'tag:yaml.org,2002:float',\n        test: /^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,\n        resolve: str => parseFloat(str),\n        stringify: stringifyJSON\n    }\n];\nconst jsonError = {\n    default: true,\n    tag: '',\n    test: /^/,\n    resolve(str, onError) {\n        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);\n        return str;\n    }\n};\nconst schema = [map, seq].concat(jsonScalars, jsonError);\n\nexport { schema };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyString } from '../../stringify/stringifyString.js';\n\nconst binary = {\n    identify: value => value instanceof Uint8Array, // Buffer inherits from Uint8Array\n    default: false,\n    tag: 'tag:yaml.org,2002:binary',\n    /**\n     * Returns a Buffer in node and an Uint8Array in browsers\n     *\n     * To use the resulting buffer as an image, you'll want to do something like:\n     *\n     *   const blob = new Blob([buffer], { type: 'image/jpeg' })\n     *   document.querySelector('#photo').src = URL.createObjectURL(blob)\n     */\n    resolve(src, onError) {\n        if (typeof atob === 'function') {\n            // On IE 11, atob() can't handle newlines\n            const str = atob(src.replace(/[\\n\\r]/g, ''));\n            const buffer = new Uint8Array(str.length);\n            for (let i = 0; i < str.length; ++i)\n                buffer[i] = str.charCodeAt(i);\n            return buffer;\n        }\n        else {\n            onError('This environment does not support reading binary tags; either Buffer or atob is required');\n            return src;\n        }\n    },\n    stringify({ comment, type, value }, ctx, onComment, onChompKeep) {\n        if (!value)\n            return '';\n        const buf = value; // checked earlier by binary.identify()\n        let str;\n        if (typeof btoa === 'function') {\n            let s = '';\n            for (let i = 0; i < buf.length; ++i)\n                s += String.fromCharCode(buf[i]);\n            str = btoa(s);\n        }\n        else {\n            throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');\n        }\n        type ?? (type = Scalar.BLOCK_LITERAL);\n        if (type !== Scalar.QUOTE_DOUBLE) {\n            const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);\n            const n = Math.ceil(str.length / lineWidth);\n            const lines = new Array(n);\n            for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {\n                lines[i] = str.substr(o, lineWidth);\n            }\n            str = lines.join(type === Scalar.BLOCK_LITERAL ? '\\n' : ' ');\n        }\n        return stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { binary };\n","import { isSeq, isPair, isMap } from '../../nodes/identity.js';\nimport { createPair, Pair } from '../../nodes/Pair.js';\nimport { Scalar } from '../../nodes/Scalar.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nfunction resolvePairs(seq, onError) {\n    if (isSeq(seq)) {\n        for (let i = 0; i < seq.items.length; ++i) {\n            let item = seq.items[i];\n            if (isPair(item))\n                continue;\n            else if (isMap(item)) {\n                if (item.items.length > 1)\n                    onError('Each pair must have its own sequence indicator');\n                const pair = item.items[0] || new Pair(new Scalar(null));\n                if (item.commentBefore)\n                    pair.key.commentBefore = pair.key.commentBefore\n                        ? `${item.commentBefore}\\n${pair.key.commentBefore}`\n                        : item.commentBefore;\n                if (item.comment) {\n                    const cn = pair.value ?? pair.key;\n                    cn.comment = cn.comment\n                        ? `${item.comment}\\n${cn.comment}`\n                        : item.comment;\n                }\n                item = pair;\n            }\n            seq.items[i] = isPair(item) ? item : new Pair(item);\n        }\n    }\n    else\n        onError('Expected a sequence for this tag');\n    return seq;\n}\nfunction createPairs(schema, iterable, ctx) {\n    const { replacer } = ctx;\n    const pairs = new YAMLSeq(schema);\n    pairs.tag = 'tag:yaml.org,2002:pairs';\n    let i = 0;\n    if (iterable && Symbol.iterator in Object(iterable))\n        for (let it of iterable) {\n            if (typeof replacer === 'function')\n                it = replacer.call(iterable, String(i++), it);\n            let key, value;\n            if (Array.isArray(it)) {\n                if (it.length === 2) {\n                    key = it[0];\n                    value = it[1];\n                }\n                else\n                    throw new TypeError(`Expected [key, value] tuple: ${it}`);\n            }\n            else if (it && it instanceof Object) {\n                const keys = Object.keys(it);\n                if (keys.length === 1) {\n                    key = keys[0];\n                    value = it[key];\n                }\n                else {\n                    throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);\n                }\n            }\n            else {\n                key = it;\n            }\n            pairs.items.push(createPair(key, value, ctx));\n        }\n    return pairs;\n}\nconst pairs = {\n    collection: 'seq',\n    default: false,\n    tag: 'tag:yaml.org,2002:pairs',\n    resolve: resolvePairs,\n    createNode: createPairs\n};\n\nexport { createPairs, pairs, resolvePairs };\n","import { isScalar, isPair } from '../../nodes/identity.js';\nimport { toJS } from '../../nodes/toJS.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\nimport { resolvePairs, createPairs } from './pairs.js';\n\nclass YAMLOMap extends YAMLSeq {\n    constructor() {\n        super();\n        this.add = YAMLMap.prototype.add.bind(this);\n        this.delete = YAMLMap.prototype.delete.bind(this);\n        this.get = YAMLMap.prototype.get.bind(this);\n        this.has = YAMLMap.prototype.has.bind(this);\n        this.set = YAMLMap.prototype.set.bind(this);\n        this.tag = YAMLOMap.tag;\n    }\n    /**\n     * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,\n     * but TypeScript won't allow widening the signature of a child method.\n     */\n    toJSON(_, ctx) {\n        if (!ctx)\n            return super.toJSON(_);\n        const map = new Map();\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const pair of this.items) {\n            let key, value;\n            if (isPair(pair)) {\n                key = toJS(pair.key, '', ctx);\n                value = toJS(pair.value, key, ctx);\n            }\n            else {\n                key = toJS(pair, '', ctx);\n            }\n            if (map.has(key))\n                throw new Error('Ordered maps must not include duplicate keys');\n            map.set(key, value);\n        }\n        return map;\n    }\n    static from(schema, iterable, ctx) {\n        const pairs = createPairs(schema, iterable, ctx);\n        const omap = new this();\n        omap.items = pairs.items;\n        return omap;\n    }\n}\nYAMLOMap.tag = 'tag:yaml.org,2002:omap';\nconst omap = {\n    collection: 'seq',\n    identify: value => value instanceof Map,\n    nodeClass: YAMLOMap,\n    default: false,\n    tag: 'tag:yaml.org,2002:omap',\n    resolve(seq, onError) {\n        const pairs = resolvePairs(seq, onError);\n        const seenKeys = [];\n        for (const { key } of pairs.items) {\n            if (isScalar(key)) {\n                if (seenKeys.includes(key.value)) {\n                    onError(`Ordered maps must not include duplicate keys: ${key.value}`);\n                }\n                else {\n                    seenKeys.push(key.value);\n                }\n            }\n        }\n        return Object.assign(new YAMLOMap(), pairs);\n    },\n    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)\n};\n\nexport { YAMLOMap, omap };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nfunction boolStringify({ value, source }, ctx) {\n    const boolObj = value ? trueTag : falseTag;\n    if (source && boolObj.test.test(source))\n        return source;\n    return value ? ctx.options.trueStr : ctx.options.falseStr;\n}\nconst trueTag = {\n    identify: value => value === true,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,\n    resolve: () => new Scalar(true),\n    stringify: boolStringify\n};\nconst falseTag = {\n    identify: value => value === false,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,\n    resolve: () => new Scalar(false),\n    stringify: boolStringify\n};\n\nexport { falseTag, trueTag };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF)|\\.nan|\\.NaN|\\.NAN)$/,\n    resolve: (str) => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\\.[0-9_]*)?[eE][-+]?[0-9]+$/,\n    resolve: (str) => parseFloat(str.replace(/_/g, '')),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:[0-9][0-9_]*)?\\.[0-9_]*$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str.replace(/_/g, '')));\n        const dot = str.indexOf('.');\n        if (dot !== -1) {\n            const f = str.substring(dot + 1).replace(/_/g, '');\n            if (f[f.length - 1] === '0')\n                node.minFractionDigits = f.length;\n        }\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nfunction intResolve(str, offset, radix, { intAsBigInt }) {\n    const sign = str[0];\n    if (sign === '-' || sign === '+')\n        offset += 1;\n    str = str.substring(offset).replace(/_/g, '');\n    if (intAsBigInt) {\n        switch (radix) {\n            case 2:\n                str = `0b${str}`;\n                break;\n            case 8:\n                str = `0o${str}`;\n                break;\n            case 16:\n                str = `0x${str}`;\n                break;\n        }\n        const n = BigInt(str);\n        return sign === '-' ? BigInt(-1) * n : n;\n    }\n    const n = parseInt(str, radix);\n    return sign === '-' ? -1 * n : n;\n}\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value)) {\n        const str = value.toString(radix);\n        return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;\n    }\n    return stringifyNumber(node);\n}\nconst intBin = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'BIN',\n    test: /^[-+]?0b[0-1_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),\n    stringify: node => intStringify(node, 2, '0b')\n};\nconst intOct = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^[-+]?0[0-7_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),\n    stringify: node => intStringify(node, 8, '0')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9][0-9_]*$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^[-+]?0x[0-9a-fA-F_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intBin, intHex, intOct };\n","import { isMap, isPair, isScalar } from '../../nodes/identity.js';\nimport { Pair, createPair } from '../../nodes/Pair.js';\nimport { YAMLMap, findPair } from '../../nodes/YAMLMap.js';\n\nclass YAMLSet extends YAMLMap {\n    constructor(schema) {\n        super(schema);\n        this.tag = YAMLSet.tag;\n    }\n    add(key) {\n        let pair;\n        if (isPair(key))\n            pair = key;\n        else if (key &&\n            typeof key === 'object' &&\n            'key' in key &&\n            'value' in key &&\n            key.value === null)\n            pair = new Pair(key.key, null);\n        else\n            pair = new Pair(key, null);\n        const prev = findPair(this.items, pair.key);\n        if (!prev)\n            this.items.push(pair);\n    }\n    /**\n     * If `keepPair` is `true`, returns the Pair matching `key`.\n     * Otherwise, returns the value of that Pair's key.\n     */\n    get(key, keepPair) {\n        const pair = findPair(this.items, key);\n        return !keepPair && isPair(pair)\n            ? isScalar(pair.key)\n                ? pair.key.value\n                : pair.key\n            : pair;\n    }\n    set(key, value) {\n        if (typeof value !== 'boolean')\n            throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);\n        const prev = findPair(this.items, key);\n        if (prev && !value) {\n            this.items.splice(this.items.indexOf(prev), 1);\n        }\n        else if (!prev && value) {\n            this.items.push(new Pair(key));\n        }\n    }\n    toJSON(_, ctx) {\n        return super.toJSON(_, ctx, Set);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        if (this.hasAllNullValues(true))\n            return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);\n        else\n            throw new Error('Set items must all have null values');\n    }\n    static from(schema, iterable, ctx) {\n        const { replacer } = ctx;\n        const set = new this(schema);\n        if (iterable && Symbol.iterator in Object(iterable))\n            for (let value of iterable) {\n                if (typeof replacer === 'function')\n                    value = replacer.call(iterable, value, value);\n                set.items.push(createPair(value, null, ctx));\n            }\n        return set;\n    }\n}\nYAMLSet.tag = 'tag:yaml.org,2002:set';\nconst set = {\n    collection: 'map',\n    identify: value => value instanceof Set,\n    nodeClass: YAMLSet,\n    default: false,\n    tag: 'tag:yaml.org,2002:set',\n    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),\n    resolve(map, onError) {\n        if (isMap(map)) {\n            if (map.hasAllNullValues(true))\n                return Object.assign(new YAMLSet(), map);\n            else\n                onError('Set items must all have null values');\n        }\n        else\n            onError('Expected a mapping for this tag');\n        return map;\n    }\n};\n\nexport { YAMLSet, set };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\n/** Internal types handle bigint as number, because TS can't figure it out. */\nfunction parseSexagesimal(str, asBigInt) {\n    const sign = str[0];\n    const parts = sign === '-' || sign === '+' ? str.substring(1) : str;\n    const num = (n) => asBigInt ? BigInt(n) : Number(n);\n    const res = parts\n        .replace(/_/g, '')\n        .split(':')\n        .reduce((res, p) => res * num(60) + num(p), num(0));\n    return (sign === '-' ? num(-1) * res : res);\n}\n/**\n * hhhh:mm:ss.sss\n *\n * Internal types handle bigint as number, because TS can't figure it out.\n */\nfunction stringifySexagesimal(node) {\n    let { value } = node;\n    let num = (n) => n;\n    if (typeof value === 'bigint')\n        num = n => BigInt(n);\n    else if (isNaN(value) || !isFinite(value))\n        return stringifyNumber(node);\n    let sign = '';\n    if (value < 0) {\n        sign = '-';\n        value *= num(-1);\n    }\n    const _60 = num(60);\n    const parts = [value % _60]; // seconds, including ms\n    if (value < 60) {\n        parts.unshift(0); // at least one : is required\n    }\n    else {\n        value = (value - parts[0]) / _60;\n        parts.unshift(value % _60); // minutes\n        if (value >= 60) {\n            value = (value - parts[0]) / _60;\n            parts.unshift(value); // hours\n        }\n    }\n    return (sign +\n        parts\n            .map(n => String(n).padStart(2, '0'))\n            .join(':')\n            .replace(/000000\\d*$/, '') // % 60 may introduce error\n    );\n}\nconst intTime = {\n    identify: value => typeof value === 'bigint' || Number.isInteger(value),\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,\n    resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),\n    stringify: stringifySexagesimal\n};\nconst floatTime = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*$/,\n    resolve: str => parseSexagesimal(str, false),\n    stringify: stringifySexagesimal\n};\nconst timestamp = {\n    identify: value => value instanceof Date,\n    default: true,\n    tag: 'tag:yaml.org,2002:timestamp',\n    // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part\n    // may be omitted altogether, resulting in a date format. In such a case, the time part is\n    // assumed to be 00:00:00Z (start of day, UTC).\n    test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd\n        '(?:' + // time is optional\n        '(?:t|T|[ \\\\t]+)' + // t | T | whitespace\n        '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)?\n        '(?:[ \\\\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30\n        ')?$'),\n    resolve(str) {\n        const match = str.match(timestamp.test);\n        if (!match)\n            throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd');\n        const [, year, month, day, hour, minute, second] = match.map(Number);\n        const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0;\n        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);\n        const tz = match[8];\n        if (tz && tz !== 'Z') {\n            let d = parseSexagesimal(tz, false);\n            if (Math.abs(d) < 30)\n                d *= 60;\n            date -= 60000 * d;\n        }\n        return new Date(date);\n    },\n    stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\\.000Z$/, '') ?? ''\n};\n\nexport { floatTime, intTime, timestamp };\n","import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { binary } from './binary.js';\nimport { trueTag, falseTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intBin, intOct, int, intHex } from './int.js';\nimport { merge } from './merge.js';\nimport { omap } from './omap.js';\nimport { pairs } from './pairs.js';\nimport { set } from './set.js';\nimport { intTime, floatTime, timestamp } from './timestamp.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    trueTag,\n    falseTag,\n    intBin,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float,\n    binary,\n    merge,\n    omap,\n    pairs,\n    set,\n    intTime,\n    floatTime,\n    timestamp\n];\n\nexport { schema };\n","import { map } from './common/map.js';\nimport { nullTag } from './common/null.js';\nimport { seq } from './common/seq.js';\nimport { string } from './common/string.js';\nimport { boolTag } from './core/bool.js';\nimport { floatNaN, floatExp, float } from './core/float.js';\nimport { intOct, intHex, int } from './core/int.js';\nimport { schema } from './core/schema.js';\nimport { schema as schema$1 } from './json/schema.js';\nimport { binary } from './yaml-1.1/binary.js';\nimport { merge } from './yaml-1.1/merge.js';\nimport { omap } from './yaml-1.1/omap.js';\nimport { pairs } from './yaml-1.1/pairs.js';\nimport { schema as schema$2 } from './yaml-1.1/schema.js';\nimport { set } from './yaml-1.1/set.js';\nimport { timestamp, intTime, floatTime } from './yaml-1.1/timestamp.js';\n\nconst schemas = new Map([\n    ['core', schema],\n    ['failsafe', [map, seq, string]],\n    ['json', schema$1],\n    ['yaml11', schema$2],\n    ['yaml-1.1', schema$2]\n]);\nconst tagsByName = {\n    binary,\n    bool: boolTag,\n    float,\n    floatExp,\n    floatNaN,\n    floatTime,\n    int,\n    intHex,\n    intOct,\n    intTime,\n    map,\n    merge,\n    null: nullTag,\n    omap,\n    pairs,\n    seq,\n    set,\n    timestamp\n};\nconst coreKnownTags = {\n    'tag:yaml.org,2002:binary': binary,\n    'tag:yaml.org,2002:merge': merge,\n    'tag:yaml.org,2002:omap': omap,\n    'tag:yaml.org,2002:pairs': pairs,\n    'tag:yaml.org,2002:set': set,\n    'tag:yaml.org,2002:timestamp': timestamp\n};\nfunction getTags(customTags, schemaName, addMergeTag) {\n    const schemaTags = schemas.get(schemaName);\n    if (schemaTags && !customTags) {\n        return addMergeTag && !schemaTags.includes(merge)\n            ? schemaTags.concat(merge)\n            : schemaTags.slice();\n    }\n    let tags = schemaTags;\n    if (!tags) {\n        if (Array.isArray(customTags))\n            tags = [];\n        else {\n            const keys = Array.from(schemas.keys())\n                .filter(key => key !== 'yaml11')\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown schema \"${schemaName}\"; use one of ${keys} or define customTags array`);\n        }\n    }\n    if (Array.isArray(customTags)) {\n        for (const tag of customTags)\n            tags = tags.concat(tag);\n    }\n    else if (typeof customTags === 'function') {\n        tags = customTags(tags.slice());\n    }\n    if (addMergeTag)\n        tags = tags.concat(merge);\n    return tags.reduce((tags, tag) => {\n        const tagObj = typeof tag === 'string' ? tagsByName[tag] : tag;\n        if (!tagObj) {\n            const tagName = JSON.stringify(tag);\n            const keys = Object.keys(tagsByName)\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);\n        }\n        if (!tags.includes(tagObj))\n            tags.push(tagObj);\n        return tags;\n    }, []);\n}\n\nexport { coreKnownTags, getTags };\n","class YAMLError extends Error {\n    constructor(name, pos, code, message) {\n        super();\n        this.name = name;\n        this.code = code;\n        this.message = message;\n        this.pos = pos;\n    }\n}\nclass YAMLParseError extends YAMLError {\n    constructor(pos, code, message) {\n        super('YAMLParseError', pos, code, message);\n    }\n}\nclass YAMLWarning extends YAMLError {\n    constructor(pos, code, message) {\n        super('YAMLWarning', pos, code, message);\n    }\n}\nconst prettifyError = (src, lc) => (error) => {\n    if (error.pos[0] === -1)\n        return;\n    error.linePos = error.pos.map(pos => lc.linePos(pos));\n    const { line, col } = error.linePos[0];\n    error.message += ` at line ${line}, column ${col}`;\n    let ci = col - 1;\n    let lineStr = src\n        .substring(lc.lineStarts[line - 1], lc.lineStarts[line])\n        .replace(/[\\n\\r]+$/, '');\n    // Trim to max 80 chars, keeping col position near the middle\n    if (ci >= 60 && lineStr.length > 80) {\n        const trimStart = Math.min(ci - 39, lineStr.length - 79);\n        lineStr = '…' + lineStr.substring(trimStart);\n        ci -= trimStart - 1;\n    }\n    if (lineStr.length > 80)\n        lineStr = lineStr.substring(0, 79) + '…';\n    // Include previous line in context if pointing at line start\n    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {\n        // Regexp won't match if start is trimmed\n        let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);\n        if (prev.length > 80)\n            prev = prev.substring(0, 79) + '…\\n';\n        lineStr = prev + lineStr;\n    }\n    if (/[^ ]/.test(lineStr)) {\n        let count = 1;\n        const end = error.linePos[1];\n        if (end?.line === line && end.col > col) {\n            count = Math.max(1, Math.min(end.col - col, 80 - ci));\n        }\n        const pointer = ' '.repeat(ci) + '^'.repeat(count);\n        error.message += `:\\n\\n${lineStr}\\n${pointer}\\n`;\n    }\n};\n\nexport { YAMLError, YAMLParseError, YAMLWarning, prettifyError };\n","const BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove item');\n/**\n * Apply a visitor to a CST document or item.\n *\n * Walks through the tree (depth-first) starting from the root, calling a\n * `visitor` function with two arguments when entering each item:\n *   - `item`: The current item, which included the following members:\n *     - `start: SourceToken[]` – Source tokens before the key or value,\n *       possibly including its anchor or tag.\n *     - `key?: Token | null` – Set for pair values. May then be `null`, if\n *       the key before the `:` separator is empty.\n *     - `sep?: SourceToken[]` – Source tokens between the key and the value,\n *       which should include the `:` map value indicator if `value` is set.\n *     - `value?: Token` – The value of a sequence item, or of a map pair.\n *   - `path`: The steps from the root to the current node, as an array of\n *     `['key' | 'value', number]` tuples.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this token, continue with\n *      next sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current item, then continue with the next one\n *   - `number`: Set the index of the next step. This is useful especially if\n *     the index of the current token has changed.\n *   - `function`: Define the next visitor for this item. After the original\n *     visitor is called on item entry, next visitors are called after handling\n *     a non-empty `key` and when exiting the item.\n */\nfunction visit(cst, visitor) {\n    if ('type' in cst && cst.type === 'document')\n        cst = { start: cst.start, value: cst.value };\n    _visit(Object.freeze([]), cst, visitor);\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current item */\nvisit.SKIP = SKIP;\n/** Remove the current item */\nvisit.REMOVE = REMOVE;\n/** Find the item at `path` from `cst` as the root */\nvisit.itemAtPath = (cst, path) => {\n    let item = cst;\n    for (const [field, index] of path) {\n        const tok = item?.[field];\n        if (tok && 'items' in tok) {\n            item = tok.items[index];\n        }\n        else\n            return undefined;\n    }\n    return item;\n};\n/**\n * Get the immediate parent collection of the item at `path` from `cst` as the root.\n *\n * Throws an error if the collection is not found, which should never happen if the item itself exists.\n */\nvisit.parentCollection = (cst, path) => {\n    const parent = visit.itemAtPath(cst, path.slice(0, -1));\n    const field = path[path.length - 1][0];\n    const coll = parent?.[field];\n    if (coll && 'items' in coll)\n        return coll;\n    throw new Error('Parent collection not found');\n};\nfunction _visit(path, item, visitor) {\n    let ctrl = visitor(item, path);\n    if (typeof ctrl === 'symbol')\n        return ctrl;\n    for (const field of ['key', 'value']) {\n        const token = item[field];\n        if (token && 'items' in token) {\n            for (let i = 0; i < token.items.length; ++i) {\n                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    token.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n            if (typeof ctrl === 'function' && field === 'key')\n                ctrl = ctrl(item, path);\n        }\n    }\n    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;\n}\n\nexport { visit };\n","import { Note } from \"../core\";\n\nexport enum GamakaType {\n  // Kampitam (~)\n  // The oscilation between 2 notes - eg p , S..n S..n S..n\n  Kampitham = \"Kampitham\",\n\n  // Nokku (w)\n  Nokku = \"Nokku\",\n\n  // Spuritham (∴ / u+2234) - Stress on the second note of a jantai\n  Spuritham = \"Spuritham\",\n\n  // Prathyagatham (∵ / u+2235) - Similar to reverse of Spuritham (in descending order)\n  Prathyagatham = \"Prathyagatham\",\n\n  // Raavi (^)\n  Aahaatam_Raavi = \"Raavi\",\n\n  // Kandippu (✓)\n  // eg - Shankarabharanam's S. ,,, n , P ,,,  - where the n is subtle\n  Aahaatam_Kandippu = \"Kandippu\",\n\n  // Vali (⌒ - U+2312)\n  Vaali = \"Vaali\",\n\n  // Odukkal (x):\n  // A veena gamakam where the note itself is stretched more to get the next\n  // note effect (instead of plucking the next note itself).\n  // Not possible where plucking of strings is not possible.\n  // On voice etc it just will sound like an Eetra Jaaru.\n  Odukkal = \"Odukkal\",\n\n  // (/) Ascension from one note to another - eg S / P\n  Jaaru_Eetra = \"EetraJaaru\",\n\n  // (\\) Descending from one note to another - eg P \\ S\n  Jaaru_Irakka = \"IrakkaJaaru\",\n\n  // Orikkai (γ)\n  // eg S~~ RN N~~S.D  D~~~NP\n  Orikkai = \"Orikkai\",\n}\n\nexport class Gamaka {\n  constructor(public readonly type: GamakaType) {}\n  debugValue(): any {\n    return { type: this.type };\n  }\n}\n\nexport class JaaruGamaka extends Gamaka {\n  constructor(\n    public readonly ascending = true,\n    public readonly startingNote: null | Note = null,\n  ) {\n    super(ascending ? GamakaType.Jaaru_Eetra : GamakaType.Jaaru_Irakka);\n  }\n\n  debugValue(): any {\n    const out = { ...super.debugValue(), ascending: this.ascending };\n    if (this.startingNote) out[\"startingNote\"] = this.startingNote.debugValue();\n    return out;\n  }\n}\n\nexport function parseEmbelishment(value: string): [any, boolean] {\n  value = value.substring(1);\n  if (value == \"\") {\n    return [new Gamaka(GamakaType.Kampitham), true];\n  } else if (value == \"^\") {\n    return [new Gamaka(GamakaType.Aahaatam_Raavi), true];\n  } else if (value == \"~\") {\n    return [new Gamaka(GamakaType.Vaali), true];\n  } else if (value == \"w\" || value == \"W\") {\n    return [new Gamaka(GamakaType.Nokku), true];\n  } else if (value == \"∴\" || value == \":-\") {\n    return [new Gamaka(GamakaType.Spuritham), true];\n  } else if (value == \"∵\" || value == \"-:\") {\n    return [new Gamaka(GamakaType.Prathyagatham), true];\n  } else if (value == \"✓\" || value == \"./\" || value == \".\\\\\") {\n    return [new Gamaka(GamakaType.Aahaatam_Kandippu), true];\n  } else if (value.endsWith(\"/\")) {\n    value = value.substring(0, value.length - 1).trim();\n    return [new JaaruGamaka(true, value.length > 0 ? new Note(value) : null), true];\n  } else if (value.endsWith(\"\\\\\")) {\n    value = value.substring(0, value.length - 1);\n    return [new JaaruGamaka(false, value.length > 0 ? new Note(value) : null), true];\n  } else if (value == \"x\") {\n    return [new Gamaka(GamakaType.Odukkal), true];\n  } else if (value == \"γ\" || value == \"Y\") {\n    return [new Gamaka(GamakaType.Orikkai), true];\n  }\n  // throw new Error(\"Invalid carnatic embelishment: \" + value);\n  return [null, false];\n}\n","import { BOM, DOCUMENT, FLOW_END, SCALAR } from './cst.js';\n\n/*\nSTART -> stream\n\nstream\n  directive -> line-end -> stream\n  indent + line-end -> stream\n  [else] -> line-start\n\nline-end\n  comment -> line-end\n  newline -> .\n  input-end -> END\n\nline-start\n  doc-start -> doc\n  doc-end -> stream\n  [else] -> indent -> block-start\n\nblock-start\n  seq-item-start -> block-start\n  explicit-key-start -> block-start\n  map-value-start -> block-start\n  [else] -> doc\n\ndoc\n  line-end -> line-start\n  spaces -> doc\n  anchor -> doc\n  tag -> doc\n  flow-start -> flow -> doc\n  flow-end -> error -> doc\n  seq-item-start -> error -> doc\n  explicit-key-start -> error -> doc\n  map-value-start -> doc\n  alias -> doc\n  quote-start -> quoted-scalar -> doc\n  block-scalar-header -> line-end -> block-scalar(min) -> line-start\n  [else] -> plain-scalar(false, min) -> doc\n\nflow\n  line-end -> flow\n  spaces -> flow\n  anchor -> flow\n  tag -> flow\n  flow-start -> flow -> flow\n  flow-end -> .\n  seq-item-start -> error -> flow\n  explicit-key-start -> flow\n  map-value-start -> flow\n  alias -> flow\n  quote-start -> quoted-scalar -> flow\n  comma -> flow\n  [else] -> plain-scalar(true, 0) -> flow\n\nquoted-scalar\n  quote-end -> .\n  [else] -> quoted-scalar\n\nblock-scalar(min)\n  newline + peek(indent < min) -> .\n  [else] -> block-scalar(min)\n\nplain-scalar(is-flow, min)\n  scalar-end(is-flow) -> .\n  peek(newline + (indent < min)) -> .\n  [else] -> plain-scalar(min)\n*/\nfunction isEmpty(ch) {\n    switch (ch) {\n        case undefined:\n        case ' ':\n        case '\\n':\n        case '\\r':\n        case '\\t':\n            return true;\n        default:\n            return false;\n    }\n}\nconst hexDigits = new Set('0123456789ABCDEFabcdef');\nconst tagChars = new Set(\"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()\");\nconst flowIndicatorChars = new Set(',[]{}');\nconst invalidAnchorChars = new Set(' ,[]{}\\n\\r\\t');\nconst isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);\n/**\n * Splits an input string into lexical tokens, i.e. smaller strings that are\n * easily identifiable by `tokens.tokenType()`.\n *\n * Lexing starts always in a \"stream\" context. Incomplete input may be buffered\n * until a complete token can be emitted.\n *\n * In addition to slices of the original input, the following control characters\n * may also be emitted:\n *\n * - `\\x02` (Start of Text): A document starts with the next token\n * - `\\x18` (Cancel): Unexpected end of flow-mode (indicates an error)\n * - `\\x1f` (Unit Separator): Next token is a scalar value\n * - `\\u{FEFF}` (Byte order mark): Emitted separately outside documents\n */\nclass Lexer {\n    constructor() {\n        /**\n         * Flag indicating whether the end of the current buffer marks the end of\n         * all input\n         */\n        this.atEnd = false;\n        /**\n         * Explicit indent set in block scalar header, as an offset from the current\n         * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not\n         * explicitly set.\n         */\n        this.blockScalarIndent = -1;\n        /**\n         * Block scalars that include a + (keep) chomping indicator in their header\n         * include trailing empty lines, which are otherwise excluded from the\n         * scalar's contents.\n         */\n        this.blockScalarKeep = false;\n        /** Current input */\n        this.buffer = '';\n        /**\n         * Flag noting whether the map value indicator : can immediately follow this\n         * node within a flow context.\n         */\n        this.flowKey = false;\n        /** Count of surrounding flow collection levels. */\n        this.flowLevel = 0;\n        /**\n         * Minimum level of indentation required for next lines to be parsed as a\n         * part of the current scalar value.\n         */\n        this.indentNext = 0;\n        /** Indentation level of the current line. */\n        this.indentValue = 0;\n        /** Position of the next \\n character. */\n        this.lineEndPos = null;\n        /** Stores the state of the lexer if reaching the end of incpomplete input */\n        this.next = null;\n        /** A pointer to `buffer`; the current position of the lexer. */\n        this.pos = 0;\n    }\n    /**\n     * Generate YAML tokens from the `source` string. If `incomplete`,\n     * a part of the last line may be left as a buffer for the next call.\n     *\n     * @returns A generator of lexical tokens\n     */\n    *lex(source, incomplete = false) {\n        if (source) {\n            if (typeof source !== 'string')\n                throw TypeError('source is not a string');\n            this.buffer = this.buffer ? this.buffer + source : source;\n            this.lineEndPos = null;\n        }\n        this.atEnd = !incomplete;\n        let next = this.next ?? 'stream';\n        while (next && (incomplete || this.hasChars(1)))\n            next = yield* this.parseNext(next);\n    }\n    atLineEnd() {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (ch === ' ' || ch === '\\t')\n            ch = this.buffer[++i];\n        if (!ch || ch === '#' || ch === '\\n')\n            return true;\n        if (ch === '\\r')\n            return this.buffer[i + 1] === '\\n';\n        return false;\n    }\n    charAt(n) {\n        return this.buffer[this.pos + n];\n    }\n    continueScalar(offset) {\n        let ch = this.buffer[offset];\n        if (this.indentNext > 0) {\n            let indent = 0;\n            while (ch === ' ')\n                ch = this.buffer[++indent + offset];\n            if (ch === '\\r') {\n                const next = this.buffer[indent + offset + 1];\n                if (next === '\\n' || (!next && !this.atEnd))\n                    return offset + indent + 1;\n            }\n            return ch === '\\n' || indent >= this.indentNext || (!ch && !this.atEnd)\n                ? offset + indent\n                : -1;\n        }\n        if (ch === '-' || ch === '.') {\n            const dt = this.buffer.substr(offset, 3);\n            if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3]))\n                return -1;\n        }\n        return offset;\n    }\n    getLine() {\n        let end = this.lineEndPos;\n        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {\n            end = this.buffer.indexOf('\\n', this.pos);\n            this.lineEndPos = end;\n        }\n        if (end === -1)\n            return this.atEnd ? this.buffer.substring(this.pos) : null;\n        if (this.buffer[end - 1] === '\\r')\n            end -= 1;\n        return this.buffer.substring(this.pos, end);\n    }\n    hasChars(n) {\n        return this.pos + n <= this.buffer.length;\n    }\n    setNext(state) {\n        this.buffer = this.buffer.substring(this.pos);\n        this.pos = 0;\n        this.lineEndPos = null;\n        this.next = state;\n        return null;\n    }\n    peek(n) {\n        return this.buffer.substr(this.pos, n);\n    }\n    *parseNext(next) {\n        switch (next) {\n            case 'stream':\n                return yield* this.parseStream();\n            case 'line-start':\n                return yield* this.parseLineStart();\n            case 'block-start':\n                return yield* this.parseBlockStart();\n            case 'doc':\n                return yield* this.parseDocument();\n            case 'flow':\n                return yield* this.parseFlowCollection();\n            case 'quoted-scalar':\n                return yield* this.parseQuotedScalar();\n            case 'block-scalar':\n                return yield* this.parseBlockScalar();\n            case 'plain-scalar':\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseStream() {\n        let line = this.getLine();\n        if (line === null)\n            return this.setNext('stream');\n        if (line[0] === BOM) {\n            yield* this.pushCount(1);\n            line = line.substring(1);\n        }\n        if (line[0] === '%') {\n            let dirEnd = line.length;\n            let cs = line.indexOf('#');\n            while (cs !== -1) {\n                const ch = line[cs - 1];\n                if (ch === ' ' || ch === '\\t') {\n                    dirEnd = cs - 1;\n                    break;\n                }\n                else {\n                    cs = line.indexOf('#', cs + 1);\n                }\n            }\n            while (true) {\n                const ch = line[dirEnd - 1];\n                if (ch === ' ' || ch === '\\t')\n                    dirEnd -= 1;\n                else\n                    break;\n            }\n            const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));\n            yield* this.pushCount(line.length - n); // possible comment\n            this.pushNewline();\n            return 'stream';\n        }\n        if (this.atLineEnd()) {\n            const sp = yield* this.pushSpaces(true);\n            yield* this.pushCount(line.length - sp);\n            yield* this.pushNewline();\n            return 'stream';\n        }\n        yield DOCUMENT;\n        return yield* this.parseLineStart();\n    }\n    *parseLineStart() {\n        const ch = this.charAt(0);\n        if (!ch && !this.atEnd)\n            return this.setNext('line-start');\n        if (ch === '-' || ch === '.') {\n            if (!this.atEnd && !this.hasChars(4))\n                return this.setNext('line-start');\n            const s = this.peek(3);\n            if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {\n                yield* this.pushCount(3);\n                this.indentValue = 0;\n                this.indentNext = 0;\n                return s === '---' ? 'doc' : 'stream';\n            }\n        }\n        this.indentValue = yield* this.pushSpaces(false);\n        if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))\n            this.indentNext = this.indentValue;\n        return yield* this.parseBlockStart();\n    }\n    *parseBlockStart() {\n        const [ch0, ch1] = this.peek(2);\n        if (!ch1 && !this.atEnd)\n            return this.setNext('block-start');\n        if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) {\n            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));\n            this.indentNext = this.indentValue + 1;\n            this.indentValue += n;\n            return yield* this.parseBlockStart();\n        }\n        return 'doc';\n    }\n    *parseDocument() {\n        yield* this.pushSpaces(true);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('doc');\n        let n = yield* this.pushIndicators();\n        switch (line[n]) {\n            case '#':\n                yield* this.pushCount(line.length - n);\n            // fallthrough\n            case undefined:\n                yield* this.pushNewline();\n                return yield* this.parseLineStart();\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel = 1;\n                return 'flow';\n            case '}':\n            case ']':\n                // this is an error\n                yield* this.pushCount(1);\n                return 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'doc';\n            case '\"':\n            case \"'\":\n                return yield* this.parseQuotedScalar();\n            case '|':\n            case '>':\n                n += yield* this.parseBlockScalarHeader();\n                n += yield* this.pushSpaces(true);\n                yield* this.pushCount(line.length - n);\n                yield* this.pushNewline();\n                return yield* this.parseBlockScalar();\n            default:\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseFlowCollection() {\n        let nl, sp;\n        let indent = -1;\n        do {\n            nl = yield* this.pushNewline();\n            if (nl > 0) {\n                sp = yield* this.pushSpaces(false);\n                this.indentValue = indent = sp;\n            }\n            else {\n                sp = 0;\n            }\n            sp += yield* this.pushSpaces(true);\n        } while (nl + sp > 0);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('flow');\n        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||\n            (indent === 0 &&\n                (line.startsWith('---') || line.startsWith('...')) &&\n                isEmpty(line[3]))) {\n            // Allowing for the terminal ] or } at the same (rather than greater)\n            // indent level as the initial [ or { is technically invalid, but\n            // failing here would be surprising to users.\n            const atFlowEndMarker = indent === this.indentNext - 1 &&\n                this.flowLevel === 1 &&\n                (line[0] === ']' || line[0] === '}');\n            if (!atFlowEndMarker) {\n                // this is an error\n                this.flowLevel = 0;\n                yield FLOW_END;\n                return yield* this.parseLineStart();\n            }\n        }\n        let n = 0;\n        while (line[n] === ',') {\n            n += yield* this.pushCount(1);\n            n += yield* this.pushSpaces(true);\n            this.flowKey = false;\n        }\n        n += yield* this.pushIndicators();\n        switch (line[n]) {\n            case undefined:\n                return 'flow';\n            case '#':\n                yield* this.pushCount(line.length - n);\n                return 'flow';\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel += 1;\n                return 'flow';\n            case '}':\n            case ']':\n                yield* this.pushCount(1);\n                this.flowKey = true;\n                this.flowLevel -= 1;\n                return this.flowLevel ? 'flow' : 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'flow';\n            case '\"':\n            case \"'\":\n                this.flowKey = true;\n                return yield* this.parseQuotedScalar();\n            case ':': {\n                const next = this.charAt(1);\n                if (this.flowKey || isEmpty(next) || next === ',') {\n                    this.flowKey = false;\n                    yield* this.pushCount(1);\n                    yield* this.pushSpaces(true);\n                    return 'flow';\n                }\n            }\n            // fallthrough\n            default:\n                this.flowKey = false;\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseQuotedScalar() {\n        const quote = this.charAt(0);\n        let end = this.buffer.indexOf(quote, this.pos + 1);\n        if (quote === \"'\") {\n            while (end !== -1 && this.buffer[end + 1] === \"'\")\n                end = this.buffer.indexOf(\"'\", end + 2);\n        }\n        else {\n            // double-quote\n            while (end !== -1) {\n                let n = 0;\n                while (this.buffer[end - 1 - n] === '\\\\')\n                    n += 1;\n                if (n % 2 === 0)\n                    break;\n                end = this.buffer.indexOf('\"', end + 1);\n            }\n        }\n        // Only looking for newlines within the quotes\n        const qb = this.buffer.substring(0, end);\n        let nl = qb.indexOf('\\n', this.pos);\n        if (nl !== -1) {\n            while (nl !== -1) {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = qb.indexOf('\\n', cs);\n            }\n            if (nl !== -1) {\n                // this is an error caused by an unexpected unindent\n                end = nl - (qb[nl - 1] === '\\r' ? 2 : 1);\n            }\n        }\n        if (end === -1) {\n            if (!this.atEnd)\n                return this.setNext('quoted-scalar');\n            end = this.buffer.length;\n        }\n        yield* this.pushToIndex(end + 1, false);\n        return this.flowLevel ? 'flow' : 'doc';\n    }\n    *parseBlockScalarHeader() {\n        this.blockScalarIndent = -1;\n        this.blockScalarKeep = false;\n        let i = this.pos;\n        while (true) {\n            const ch = this.buffer[++i];\n            if (ch === '+')\n                this.blockScalarKeep = true;\n            else if (ch > '0' && ch <= '9')\n                this.blockScalarIndent = Number(ch) - 1;\n            else if (ch !== '-')\n                break;\n        }\n        return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#');\n    }\n    *parseBlockScalar() {\n        let nl = this.pos - 1; // may be -1 if this.pos === 0\n        let indent = 0;\n        let ch;\n        loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) {\n            switch (ch) {\n                case ' ':\n                    indent += 1;\n                    break;\n                case '\\n':\n                    nl = i;\n                    indent = 0;\n                    break;\n                case '\\r': {\n                    const next = this.buffer[i + 1];\n                    if (!next && !this.atEnd)\n                        return this.setNext('block-scalar');\n                    if (next === '\\n')\n                        break;\n                } // fallthrough\n                default:\n                    break loop;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('block-scalar');\n        if (indent >= this.indentNext) {\n            if (this.blockScalarIndent === -1)\n                this.indentNext = indent;\n            else {\n                this.indentNext =\n                    this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);\n            }\n            do {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = this.buffer.indexOf('\\n', cs);\n            } while (nl !== -1);\n            if (nl === -1) {\n                if (!this.atEnd)\n                    return this.setNext('block-scalar');\n                nl = this.buffer.length;\n            }\n        }\n        // Trailing insufficiently indented tabs are invalid.\n        // To catch that during parsing, we include them in the block scalar value.\n        let i = nl + 1;\n        ch = this.buffer[i];\n        while (ch === ' ')\n            ch = this.buffer[++i];\n        if (ch === '\\t') {\n            while (ch === '\\t' || ch === ' ' || ch === '\\r' || ch === '\\n')\n                ch = this.buffer[++i];\n            nl = i - 1;\n        }\n        else if (!this.blockScalarKeep) {\n            do {\n                let i = nl - 1;\n                let ch = this.buffer[i];\n                if (ch === '\\r')\n                    ch = this.buffer[--i];\n                const lastChar = i; // Drop the line if last char not more indented\n                while (ch === ' ')\n                    ch = this.buffer[--i];\n                if (ch === '\\n' && i >= this.pos && i + 1 + indent > lastChar)\n                    nl = i;\n                else\n                    break;\n            } while (true);\n        }\n        yield SCALAR;\n        yield* this.pushToIndex(nl + 1, true);\n        return yield* this.parseLineStart();\n    }\n    *parsePlainScalar() {\n        const inFlow = this.flowLevel > 0;\n        let end = this.pos - 1;\n        let i = this.pos - 1;\n        let ch;\n        while ((ch = this.buffer[++i])) {\n            if (ch === ':') {\n                const next = this.buffer[i + 1];\n                if (isEmpty(next) || (inFlow && flowIndicatorChars.has(next)))\n                    break;\n                end = i;\n            }\n            else if (isEmpty(ch)) {\n                let next = this.buffer[i + 1];\n                if (ch === '\\r') {\n                    if (next === '\\n') {\n                        i += 1;\n                        ch = '\\n';\n                        next = this.buffer[i + 1];\n                    }\n                    else\n                        end = i;\n                }\n                if (next === '#' || (inFlow && flowIndicatorChars.has(next)))\n                    break;\n                if (ch === '\\n') {\n                    const cs = this.continueScalar(i + 1);\n                    if (cs === -1)\n                        break;\n                    i = Math.max(i, cs - 2); // to advance, but still account for ' #'\n                }\n            }\n            else {\n                if (inFlow && flowIndicatorChars.has(ch))\n                    break;\n                end = i;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('plain-scalar');\n        yield SCALAR;\n        yield* this.pushToIndex(end + 1, true);\n        return inFlow ? 'flow' : 'doc';\n    }\n    *pushCount(n) {\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos += n;\n            return n;\n        }\n        return 0;\n    }\n    *pushToIndex(i, allowEmpty) {\n        const s = this.buffer.slice(this.pos, i);\n        if (s) {\n            yield s;\n            this.pos += s.length;\n            return s.length;\n        }\n        else if (allowEmpty)\n            yield '';\n        return 0;\n    }\n    *pushIndicators() {\n        switch (this.charAt(0)) {\n            case '!':\n                return ((yield* this.pushTag()) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '&':\n                return ((yield* this.pushUntil(isNotAnchorChar)) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '-': // this is an error\n            case '?': // this is an error outside flow collections\n            case ':': {\n                const inFlow = this.flowLevel > 0;\n                const ch1 = this.charAt(1);\n                if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {\n                    if (!inFlow)\n                        this.indentNext = this.indentValue + 1;\n                    else if (this.flowKey)\n                        this.flowKey = false;\n                    return ((yield* this.pushCount(1)) +\n                        (yield* this.pushSpaces(true)) +\n                        (yield* this.pushIndicators()));\n                }\n            }\n        }\n        return 0;\n    }\n    *pushTag() {\n        if (this.charAt(1) === '<') {\n            let i = this.pos + 2;\n            let ch = this.buffer[i];\n            while (!isEmpty(ch) && ch !== '>')\n                ch = this.buffer[++i];\n            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);\n        }\n        else {\n            let i = this.pos + 1;\n            let ch = this.buffer[i];\n            while (ch) {\n                if (tagChars.has(ch))\n                    ch = this.buffer[++i];\n                else if (ch === '%' &&\n                    hexDigits.has(this.buffer[i + 1]) &&\n                    hexDigits.has(this.buffer[i + 2])) {\n                    ch = this.buffer[(i += 3)];\n                }\n                else\n                    break;\n            }\n            return yield* this.pushToIndex(i, false);\n        }\n    }\n    *pushNewline() {\n        const ch = this.buffer[this.pos];\n        if (ch === '\\n')\n            return yield* this.pushCount(1);\n        else if (ch === '\\r' && this.charAt(1) === '\\n')\n            return yield* this.pushCount(2);\n        else\n            return 0;\n    }\n    *pushSpaces(allowTabs) {\n        let i = this.pos - 1;\n        let ch;\n        do {\n            ch = this.buffer[++i];\n        } while (ch === ' ' || (allowTabs && ch === '\\t'));\n        const n = i - this.pos;\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos = i;\n        }\n        return n;\n    }\n    *pushUntil(test) {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (!test(ch))\n            ch = this.buffer[++i];\n        return yield* this.pushToIndex(i, false);\n    }\n}\n\nexport { Lexer };\n","import * as TSU from \"@panyam/tsutils\";\nimport { ZERO, Atom, LeafAtom, Group } from \"./core\";\n\n/**\n * Base class for all renderable objects.\n *\n * Shape caches properties like bounding boxes to improve performance,\n * since bounding box calculations can be expensive. This also allows\n * testing layouts and positioning without worrying about implementation details.\n */\nexport abstract class Shape {\n  private static idCounter = 0;\n  readonly shapeId: number = Shape.idCounter++;\n\n  /**\n   * Note that x and y coordinates are not always the x and y coordinates\n   * of the bounding box.\n   * E.g., a circle's x and y coordinates are its center point and not the\n   * top left corner.\n   * These \"main\" coordinates are referred to as control coordinates.\n   */\n  protected _x: number | null = null;\n  protected _y: number | null = null;\n  protected _width: number | null = null;\n  protected _height: number | null = null;\n  protected _bbox: TSU.Geom.Rect;\n  protected _minSize: TSU.Geom.Size;\n  protected parentShape: Shape | null = null;\n  /** Child shapes contained within this shape */\n  children: Shape[] = [];\n\n  /**\n   * Gets the bounding box of this shape.\n   * Calculates it if it hasn't been calculated yet.\n   */\n  get bbox(): TSU.Geom.Rect {\n    if (!this._bbox) {\n      this._bbox = this.refreshBBox();\n    }\n    return this._bbox;\n  }\n\n  /**\n   * Gets the minimum size of this shape.\n   * This is usually the size of the bounding box.\n   */\n  get minSize(): TSU.Geom.Size {\n    if (!this._minSize) {\n      this._minSize = this.refreshMinSize();\n    }\n    return this._minSize;\n  }\n\n  /**\n   * Refreshes the bounding box of this shape.\n   * Called when the shape knows the bbox it is tracking cannot be trusted\n   * and has to be refreshed by calling native methods.\n   * @returns The refreshed bounding box\n   */\n  protected abstract refreshBBox(): TSU.Geom.Rect;\n\n  /**\n   * Refreshes the minimum size of this shape.\n   * @returns The refreshed minimum size\n   */\n  protected abstract refreshMinSize(): TSU.Geom.Size;\n\n  /**\n   * Updates the bounds of this shape.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected abstract updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null];\n\n  /**\n   * Invalidates the cached bounds of this shape.\n   * Forces recalculation of bounding box and minimum size.\n   */\n  invalidateBounds(): void {\n    this._minSize = null as unknown as TSU.Geom.Size;\n    this._bbox = null as unknown as TSU.Geom.Rect;\n  }\n\n  /**\n   * Sets the bounds of this shape.\n   *\n   * Note that null and NaN are valid values and mean the following:\n   * - null: Don't change the value\n   * - NaN: Set the value to null (use the bounding box's value)\n   *\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @param applyLayout Whether to apply layout immediately\n   * @returns The updated bounds values\n   */\n  setBounds(\n    x: number | null,\n    y: number | null,\n    w: number | null,\n    h: number | null,\n    applyLayout = false,\n  ): [number | null, number | null, number | null, number | null] {\n    if (x != null) {\n      if (isNaN(x)) {\n        this._x = null;\n      } else {\n        this._x = x;\n      }\n    }\n    if (y != null) {\n      if (isNaN(y)) {\n        this._y = null;\n      } else {\n        this._y = y;\n      }\n    }\n    if (w != null) {\n      if (isNaN(w)) {\n        this._width = null;\n      } else {\n        this._width = w;\n      }\n    }\n    if (h != null) {\n      if (isNaN(h)) {\n        this._height = null;\n      } else {\n        this._height = h;\n      }\n    }\n    const [nx, ny, nw, nh] = this.updateBounds(x, y, w, h);\n    if (nx != null) {\n      if (isNaN(nx)) {\n        this._x = null;\n      } else {\n        this._x = nx;\n      }\n    }\n    if (ny != null) {\n      if (isNaN(ny)) {\n        this._y = null;\n      } else {\n        this._y = ny;\n      }\n    }\n    if (nw != null) {\n      if (isNaN(nw)) {\n        this._width = null;\n      } else {\n        this._width = nw;\n      }\n    }\n    if (nh != null) {\n      if (isNaN(nh)) {\n        this._height = null;\n      } else {\n        this._height = nh;\n      }\n    }\n    if (applyLayout) this.refreshLayout();\n    // this.resetBBox();\n    return [nx, ny, nw, nh];\n  }\n\n  /**\n   * Checks if this shape has an explicit x coordinate.\n   */\n  get hasX(): boolean {\n    return this._x != null && !isNaN(this._x);\n  }\n\n  /**\n   * Checks if this shape has an explicit y coordinate.\n   */\n  get hasY(): boolean {\n    return this._y != null && !isNaN(this._y);\n  }\n\n  /**\n   * Checks if this shape has an explicit width.\n   */\n  get hasWidth(): boolean {\n    return this._width != null && !isNaN(this._width);\n  }\n\n  /**\n   * Checks if this shape has an explicit height.\n   */\n  get hasHeight(): boolean {\n    return this._height != null && !isNaN(this._height);\n  }\n\n  /**\n   * Gets the x coordinate within the parent's coordinate system.\n   */\n  get x(): number {\n    return this._x || 0;\n  }\n\n  /**\n   * Sets the x coordinate within the parent's coordinate system.\n   */\n  set x(x: number | null) {\n    // Here a manual x is being set - how does this interfere with the bounding box?\n    // We should _x to the new value to indicate a manual value was set.\n    // and reset bbox so that based on this x a new bbox may need to be calculated\n    this.setBounds(x == null ? NaN : x, null, null, null);\n  }\n\n  /**\n   * Gets the y coordinate within the parent's coordinate system.\n   */\n  get y(): number {\n    if (this._y != null) return this._y;\n    return 0; // this.bbox.y;\n  }\n\n  /**\n   * Sets the y coordinate within the parent's coordinate system.\n   */\n  set y(y: number | null) {\n    this.setBounds(null, y == null ? NaN : y, null, null);\n  }\n\n  /**\n   * Gets the width of this shape.\n   */\n  get width(): number {\n    if (this._width != null) return this._width;\n    return 0; // this.bbox.width;\n  }\n\n  /**\n   * Sets the width of this shape.\n   */\n  set width(w: number | null) {\n    this.setBounds(null, null, w == null ? NaN : w, null);\n  }\n\n  /**\n   * Gets the height of this shape.\n   */\n  get height(): number {\n    if (this._height != null) return this._height;\n    return 0; // this.bbox.height;\n  }\n\n  /**\n   * Sets the height of this shape.\n   */\n  set height(h: number | null) {\n    this.setBounds(null, null, null, h == null ? NaN : h);\n  }\n\n  /**\n   * Refreshes the layout of this shape.\n   * Called when bounds or other properties have changed to give the shape an\n   * opportunity to layout its children. For shapes with no children this is a no-op.\n   */\n  refreshLayout(): void {\n    // throw new Error(\"Implement this\");\n  }\n}\n\n/**\n * Represents an embellishment applied to a musical element.\n */\nexport abstract class Embelishment extends Shape {}\n\n/**\n * A shape that wraps an SVG element.\n * ElementShape provides the base class for all shapes that are rendered as SVG elements.\n */\nexport class ElementShape<T extends SVGGraphicsElement = SVGGraphicsElement> extends Shape {\n  /**\n   * Creates a new ElementShape.\n   * @param element The SVG element this shape wraps\n   */\n  constructor(public readonly element: T) {\n    super();\n  }\n\n  /**\n   * Refreshes the bounding box of this element.\n   * @returns The refreshed bounding box\n   */\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.element);\n  }\n\n  /**\n   * Refreshes the minimum size of this element.\n   * @returns The refreshed minimum size\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    return TSU.DOM.svgBBox(this.element);\n  }\n\n  /**\n   * Updates the bounds of this element.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  /**\n   * Refreshes the layout of this element.\n   * Updates the element's attributes based on the shape's properties.\n   */\n  refreshLayout(): void {\n    if (this.hasX) this.element.setAttribute(\"x\", \"\" + this._x);\n    if (this.hasY) this.element.setAttribute(\"y\", \"\" + this._y);\n  }\n}\n\n/**\n * Base class for views that represent atoms in the notation.\n * AtomView provides the visual representation of an atom.\n */\nexport abstract class AtomView extends Shape {\n  /** Nesting depth of this atom in the structure */\n  depth = 0;\n  /** Index of the role containing this atom */\n  roleIndex = 0;\n\n  // LayoutMetrics for the AtomView so all atomviews laid out on the\n  // same baseline will show up aligned vertically\n  /** Baseline position for vertical alignment */\n  baseline: number;\n  /** Ascent (space above baseline) */\n  ascent: number;\n  /** Descent (space below baseline) */\n  descent: number;\n  /** Height of capital letters */\n  capHeight: number;\n  /** Space between lines */\n  leading: number;\n\n  /**\n   * Checks if this atom view represents a leaf atom.\n   */\n  abstract isLeaf(): boolean;\n\n  abstract get totalDuration(): TSU.Num.Fraction;\n\n  /**\n   * Returns the horizontal offset from the atom's origin to where the note glyph starts.\n   * This accounts for left embellishments that appear before the note.\n   * Used by GroupView to align note glyphs at their correct time positions.\n   *\n   * Default is 0 (glyph starts at origin). Subclasses with left embellishments\n   * should override to return the width of left-side decorations.\n   */\n  get glyphOffset(): number {\n    return 0;\n  }\n\n  /**\n   * Creates the SVG elements needed for this atom view.\n   * @param parent The parent SVG element to attach to\n   */\n  abstract createElements(parent: SVGGraphicsElement): void;\n}\n\n/**\n * A view for leaf atoms (those that cannot contain other atoms).\n */\nexport abstract class LeafAtomView extends AtomView {\n  /**\n   * Creates a new LeafAtomView.\n   * @param leafAtom The leaf atom this view represents\n   */\n  constructor(public leafAtom: LeafAtom) {\n    super();\n  }\n\n  /**\n   * Leaf atom views always return true for isLeaf().\n   */\n  isLeaf(): boolean {\n    return true;\n  }\n\n  /**\n   * Gets a unique identifier for this view based on the atom's UUID.\n   */\n  get viewId(): number {\n    return this.leafAtom.uuid;\n  }\n\n  /**\n   * Returns the total duration of the atom rendered by this view.\n   */\n  get totalDuration(): TSU.Num.Fraction {\n    return this.leafAtom.duration;\n  }\n}\n\n/**\n * A view for group atoms that contain multiple child atoms.\n */\nexport abstract class GroupView extends AtomView {\n  /** Space between atoms in this group */\n  protected atomSpacing: number;\n  /** The SVG group element for this view */\n  protected groupElement: SVGGElement;\n  /** Views for the atoms in this group */\n  protected atomViews: AtomView[] = [];\n  private _embelishments: Embelishment[];\n  /** Whether this group represents notes by default */\n  defaultToNotes = true;\n  /** Whether this view needs layout */\n  needsLayout = true;\n  /** Scale factor for this group */\n  scaleFactor = 1.0;\n  /**\n   * When true, shows continuation markers (\",\") for atoms with duration > 1\n   * instead of just leaving empty space.\n   */\n  showContinuationMarkers = true;\n  /** SVG elements for continuation markers */\n  protected continuationMarkerElements: SVGTextElement[] = [];\n\n  /**\n   * Creates a new GroupView.\n   * @param group The group atom this view represents\n   * @param config Optional configuration object\n   */\n  constructor(\n    public group: Group,\n    config?: any,\n  ) {\n    super();\n    this.atomSpacing = 5;\n    this.setStyles(config || {});\n  }\n\n  /**\n   * Returns the total duration of the group rendered by this view.\n   */\n  get totalDuration(): TSU.Num.Fraction {\n    return this.group.totalChildDuration;\n  }\n\n  /**\n   * Creates the SVG elements needed for this group view.\n   * @param parent The parent SVG element to attach to\n   */\n  createElements(parent: SVGGraphicsElement): void {\n    this.groupElement = TSU.DOM.createSVGNode(\"g\", {\n      parent: parent,\n      attrs: {\n        class: \"groupViewRoot\",\n        id: \"groupViewRoot\" + this.group.uuid,\n      },\n    });\n\n    // now create child atom views for each atom in this Group\n    for (const atom of this.group.atoms.values()) {\n      const atomView = this.createAtomView(atom);\n      this.atomViews.push(atomView);\n    }\n    this.invalidateBounds();\n  }\n\n  /**\n   * Group views always return false for isLeaf().\n   */\n  isLeaf(): boolean {\n    return false;\n  }\n\n  /**\n   * Refreshes the bounding box of this group.\n   * @returns The refreshed bounding box\n   */\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.groupElement);\n  }\n\n  /**\n   * Refreshes the minimum size of this group using duration-based width calculation.\n   *\n   * ## Duration-Based Width Algorithm\n   *\n   * This algorithm ensures atoms with extended durations receive proportionally\n   * more horizontal space. For example, with `\\beatDuration(4)` and input `S 2 R G M`:\n   * - S has duration 1, R has duration 2, G has duration 1\n   * - R should visually occupy twice the horizontal space of S or G\n   *\n   * ### Algorithm Steps:\n   *\n   * 1. **Calculate width per duration unit**: For each atom, compute the visual width\n   *    needed per unit of duration: `(visualWidth + spacing) / duration`\n   *\n   * 2. **Find maximum**: Take the maximum width-per-duration across all atoms.\n   *    This ensures every atom has enough space for its visual content.\n   *\n   * 3. **Scale by total duration**: Multiply the max width-per-duration by the\n   *    group's total duration to get the final group width.\n   *\n   * ### Example:\n   * ```\n   * Atoms: S(dur=1, width=10px), R(dur=2, width=10px), G(dur=1, width=10px)\n   * Spacing: 5px\n   *\n   * Width per duration:\n   *   S: (10 + 5) / 1 = 15 px/unit\n   *   R: (10 + 5) / 2 = 7.5 px/unit\n   *   G: (10 + 5) / 1 = 15 px/unit\n   *\n   * Max width per duration: 15 px/unit\n   * Total duration: 1 + 2 + 1 = 4 units\n   * Group width: 15 * 4 = 60px\n   *\n   * Positioning:\n   *   S at x=0 (time 0/4 * 60 = 0)\n   *   R at x=15 (time 1/4 * 60 = 15)\n   *   G at x=45 (time 3/4 * 60 = 45)\n   * ```\n   *\n   * @returns The refreshed minimum size\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    let maxHeight = 0;\n\n    // Step 1: Calculate width per duration unit for each atom\n    let minWidthPerDuration = 0;\n    this.atomViews.forEach((av) => {\n      const ms = av.minSize;\n      const dur = av.totalDuration;\n      if (!dur.isZero) {\n        const durValue = dur.num / dur.den;\n        const widthPerDur = (ms.width + this.atomSpacing) / durValue;\n        // Step 2: Track maximum width per duration\n        minWidthPerDuration = Math.max(minWidthPerDuration, widthPerDur);\n      }\n      maxHeight = Math.max(maxHeight, ms.height);\n    });\n\n    // Step 3: Scale by total duration\n    const totalDuration = this.group.totalChildDuration;\n    const totalDurValue = totalDuration.num / totalDuration.den;\n    const totalWidth = minWidthPerDuration * totalDurValue;\n\n    return new TSU.Geom.Size(totalWidth * this.scaleFactor, maxHeight * this.scaleFactor);\n  }\n\n  /**\n   * Creates an atom view for a specific atom.\n   * @param atom The atom to create a view for\n   * @returns The created atom view\n   */\n  abstract createAtomView(atom: Atom): AtomView;\n\n  /**\n   * Updates the bounds of this group.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  /**\n   * Refreshes the layout of this group using duration-based positioning.\n   *\n   * ## Duration-Based Positioning Algorithm\n   *\n   * Atoms are positioned at x-coordinates proportional to their time offset\n   * within the group's total duration. This ensures that atoms with extended\n   * durations visually occupy the correct amount of horizontal space.\n   *\n   * ### Width Source Priority:\n   *\n   * 1. **Column width** (preferred): If width was set via `setBounds()` from the\n   *    grid layout system (ColAlign), use that width. This enables global alignment\n   *    across all beats in the same column.\n   *\n   * 2. **Minimum size**: Fall back to `minSize.width` calculated by `refreshMinSize()`.\n   *\n   * ### Positioning Formula:\n   * ```\n   * xPosition = (timeOffset / totalDuration) * groupWidth\n   * ```\n   *\n   * ### Continuation Markers:\n   *\n   * When `showContinuationMarkers` is true (default), atoms with duration > 1\n   * will have \",\" markers rendered at each additional time slot. For example,\n   * an atom with duration 2 will show \"R ,\" instead of \"R   \".\n   *\n   * This helps users visually understand that the note continues through\n   * multiple time slots without relying on empty space alone.\n   *\n   * ### Example:\n   * ```\n   * Input: S 2 R G (with beatDuration=4)\n   * Group width: 60px, Total duration: 4 units\n   *\n   * Positioning:\n   *   S at x=0   (time 0, offset 0/4 * 60 = 0)\n   *   R at x=15  (time 1, offset 1/4 * 60 = 15)\n   *   \",\" at x=30 (continuation marker for R at time 2)\n   *   G at x=45  (time 3, offset 3/4 * 60 = 45)\n   * ```\n   */\n  refreshLayout(): void {\n    let transform = \"translate(\" + this.x + \",\" + this.y + \")\";\n    if (this.scaleFactor < 1) {\n      transform += \" scale(\" + this.scaleFactor + \")\";\n    }\n    this.groupElement.setAttribute(\"transform\", transform);\n\n    const currY = 0;\n    const totalDur = this.group.totalChildDuration;\n\n    // Width source priority: column width (for global alignment) > minSize\n    const unscaledMinWidth = this.minSize.width / this.scaleFactor;\n    const groupWidth = this.hasWidth ? this.width / this.scaleFactor : unscaledMinWidth;\n\n    // Clear existing continuation markers before re-rendering\n    this.clearContinuationMarkers();\n\n    // Position each atom based on its time offset\n    let currTime = ZERO;\n    this.atomViews.forEach((av, index) => {\n      // Calculate where the NOTE GLYPH should appear based on time offset\n      const glyphX = totalDur.isZero ? 0 : currTime.timesNum(groupWidth).divby(totalDur).floor;\n      // Subtract glyphOffset so left embellishments don't push the glyph past its time position\n      // The atom origin is placed earlier, so the glyph ends up at the correct time position\n      const xPos = Math.max(0, glyphX - av.glyphOffset);\n      av.setBounds(xPos, currY, null, null, true);\n\n      // Render continuation markers for atoms with duration > 1\n      if (this.showContinuationMarkers && !totalDur.isZero) {\n        const atomDur = av.totalDuration;\n        const durValue = atomDur.num / atomDur.den;\n        if (durValue > 1) {\n          // Render one marker at each additional time slot within the atom's duration\n          const numMarkers = Math.floor(durValue) - 1;\n          for (let i = 1; i <= numMarkers; i++) {\n            // Marker time = currTime + (atomDuration * i / floor(duration))\n            const markerTime = currTime.plus(atomDur.timesNum(i).divbyNum(Math.floor(durValue)));\n            const markerX = markerTime.timesNum(groupWidth).divby(totalDur).floor;\n            this.renderContinuationMarker(markerX, currY);\n          }\n        }\n      }\n\n      currTime = currTime.plus(av.totalDuration);\n    });\n\n    this.invalidateBounds();\n    for (const e of this.embelishments) e.refreshLayout();\n    this.invalidateBounds();\n  }\n\n  /**\n   * Clears all continuation marker elements.\n   */\n  protected clearContinuationMarkers(): void {\n    for (const el of this.continuationMarkerElements) {\n      el.remove();\n    }\n    this.continuationMarkerElements = [];\n  }\n\n  /**\n   * Renders a continuation marker (\",\") at the specified position.\n   * @param x X position for the marker\n   * @param y Y position for the marker\n   */\n  protected renderContinuationMarker(x: number, y: number): void {\n    const marker = TSU.DOM.createSVGNode(\"text\", {\n      parent: this.groupElement,\n      attrs: {\n        class: \"continuationMarker\",\n        x: x.toString(),\n        y: y.toString(),\n      },\n      text: \",\",\n    }) as SVGTextElement;\n    this.continuationMarkerElements.push(marker);\n  }\n\n  /**\n   * Gets the embellishments for this group.\n   */\n  get embelishments(): Embelishment[] {\n    if (!this._embelishments) {\n      this._embelishments = this.createEmbelishments();\n    }\n    return this._embelishments;\n  }\n\n  /**\n   * Creates the embellishments for this group.\n   * @returns An array of embellishments\n   */\n  protected createEmbelishments(): Embelishment[] {\n    return [];\n  }\n\n  /**\n   * Sets the styles for this group.\n   * @param config Style configuration object\n   */\n  setStyles(config: any): void {\n    if (\"atomSpacing\" in config) this.atomSpacing = config.atomSpacing;\n    if (\"showContinuationMarkers\" in config) this.showContinuationMarkers = config.showContinuationMarkers;\n    this.needsLayout = true;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { load as loadGrammar, TokenHandler } from \"./dsl\";\nimport { makeParseTable } from \"./ptables\";\nimport { Parser, ParseTable } from \"./lr\";\nimport { LRItemGraph } from \"./lritems\";\nimport { logParserDebug } from \"./debug\";\n\n/**\n * Configuration options for creating a parser.\n */\nexport interface ParserOptions {\n  /**\n   * Parser algorithm to use.\n   * - \"slr\": Simple LR - smallest tables, may have false conflicts\n   * - \"lalr\": Look-Ahead LR - default, good balance of power and size\n   * - \"lr1\": Canonical LR(1) - most powerful, largest tables\n   * @default \"lalr\"\n   */\n  type?: \"slr\" | \"lalr\" | \"lr1\";\n\n  /**\n   * Custom tokenizer function. If not provided, one is auto-generated\n   * from %token and inline token definitions in the grammar.\n   */\n  tokenizer?: TLEX.NextTokenFunc;\n\n  /**\n   * Enable debug output.\n   * - \"lexer\": Log tokenizer program\n   * - \"parser\": Log parse table and state transitions\n   * - \"all\": Log both lexer and parser\n   */\n  debug?: \"all\" | \"lexer\" | \"parser\" | string;\n\n  /**\n   * Use left recursion for EBNF expansions (*, +).\n   * @default true\n   */\n  leftRecursive?: boolean;\n\n  /**\n   * Prefix for auxiliary non-terminals created by EBNF expansions.\n   * @default \"$\"\n   */\n  auxNTPrefix?: string;\n\n  /**\n   * Custom token handlers for post-processing tokens.\n   */\n  tokenHandlers?: TSU.StringMap<TokenHandler>;\n}\n\n/**\n * Creates a parser from a grammar DSL string.\n *\n * This is the main entry point for creating parsers in Galore.\n *\n * @param input - Grammar definition in DSL format\n * @param params - Configuration options\n * @returns A tuple of [parser, tokenFunc, itemGraph]\n *   - parser: The LR parser instance\n *   - tokenFunc: The generated tokenizer (or null if custom provided)\n *   - itemGraph: The LR item graph (useful for debugging)\n *\n * @example\n * ```typescript\n * import { newParser } from \"galore\";\n *\n * const [parser, tokenFunc, itemGraph] = newParser(`\n *   %token NUMBER /[0-9]+/\n *   %skip /[ \\\\t\\\\n]+/\n *\n *   Expr -> Expr \"+\" Term | Term ;\n *   Term -> NUMBER ;\n * `, { type: \"lalr\" });\n *\n * const result = parser.parse(\"1 + 2\");\n * ```\n */\nexport function newLRParser(\n  input: string,\n  params: ParserOptions | null = null,\n): [Parser, null | TLEX.NextTokenFunc, LRItemGraph] {\n  const options = params || ({} as ParserOptions);\n  const [ptable, tokenFunc, itemGraph] = newParseTable(input, options);\n  const parser = new Parser(ptable);\n  if (options.tokenizer || tokenFunc) {\n    parser.setTokenizer(options.tokenizer || tokenFunc!);\n  }\n  const debug = options.debug || \"\";\n  if (debug.split(\"|\").findIndex((p: string) => p == \"all\" || p == \"parser\") >= 0) {\n    logParserDebug(parser, itemGraph);\n  }\n  return [parser, tokenFunc, itemGraph];\n}\n\n/**\n * Creates a parse table from a grammar DSL string without creating a parser.\n *\n * Useful when you need access to the parse table for analysis or visualization.\n *\n * @param input - Grammar definition in DSL format\n * @param params - Configuration options\n * @returns A tuple of [parseTable, tokenFunc, itemGraph]\n *\n * @example\n * ```typescript\n * import { newParseTable, Printers } from \"galore\";\n *\n * const [ptable, tokenFunc, itemGraph] = newParseTable(grammar, { type: \"lalr\" });\n *\n * // Check for conflicts\n * if (ptable.hasConflicts) {\n *   console.log(\"Conflicts:\", ptable.conflictActions);\n * }\n *\n * // Visualize the parse table\n * const html = Printers.parseTableToHtml(ptable, { itemGraph });\n * ```\n */\nexport function newParseTable(\n  input: string,\n  params: ParserOptions | null = null,\n): [ParseTable, null | TLEX.NextTokenFunc, LRItemGraph] {\n  const options = params || ({} as ParserOptions);\n  const [g, tokenFunc] = loadGrammar(input, options as any);\n  g.augmentStartSymbol();\n  const [ptable, itemGraph] = makeParseTable(g, options.type);\n  return [ptable, tokenFunc, itemGraph];\n}\n","import { Parser, LRAction, ParseTable } from \"./lr\";\nimport { LRItemGraph } from \"./lritems\";\n\nexport function logParserDebug(parser: Parser, itemGraph?: LRItemGraph): void {\n  const g = parser.grammar;\n  const ptable = parser.parseTable;\n  console.log(\n    \"===============================\\nGrammar (as default): \\n\",\n    g.debugValue.map((x, i) => `${i + 1}  -   ${x}`),\n    \"===============================\\nGrammar (as Bison): \\n\",\n    g.debugValue.map((x, i) => `${x.replace(\"->\", \":\")} ; \\n`).join(\"\"),\n    \"===============================\\nParseTable: \\n\",\n    JSON.stringify(mergedDebugValue(ptable, itemGraph), null, 4),\n    \"===============================\\nConflicts: \\n\",\n    ptable.conflictActions,\n  );\n}\n\nexport function mergedDebugValue(ptable: ParseTable, itemGraph?: LRItemGraph): any {\n  const merged = {} as any;\n  const ptabDV = ptable.debugValue;\n  const igDV = itemGraph?.debugValue;\n  for (const stateId in ptabDV) {\n    const actions = ptabDV[stateId];\n    if (itemGraph) {\n      const items = igDV[stateId];\n      merged[stateId] = { items: items[\"items\"], actions: actions, goto: items[\"goto\"] };\n    } else {\n      merged[stateId] = actions;\n    }\n  }\n  return merged;\n}\n"],"names":["root","factory","exports","module","define","amd","this","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Entity","constructor","config","TYPE","uuid","counter","_parent","metadata","Error","parent","setParent","debugValue","type","toString","equals","another","expect","clone","out","newInstance","copyTo","TimedEntity","super","duration","assert","condition","msg","MAX_INT","Math","pow","TEvent","name","source","payload","_spawnedFrom","sourceState","cancelled","timeStamp","children","spawnedFrom","setSpawnedFrom","_rootEvent","rootEvent","spawn","child","push","State","stateData","id","enter","data","handle","event","EventEmitter","_eventHub","EventHub","eventHub","hub","oldHub","eventHubChanged","console","log","_handlers","_events","_inBatchMode","on","names","callback","_addHandler","removeOn","_removeHandler","_ensurestrings","split","map","v","trim","handlerlist","handler","forEach","evHandlers","i","length","splice","emit","evt","dispatchEvent","evtCallbacks","startBatchMode","cancelBatch","commitBatch","BATCH_EVENTS","ValueList","values","_firstChild","_lastChild","_size","pushBack","toJSON","Array","from","method","tmp","count","nextSibling","eqlFunc","size","first","tmp2","isEmpty","last","reversedValues","prevSibling","add","before","prev","pushFront","value","remove","next","popBack","popFront","Browser","gcdof","x","y","abs","t","IS_EXPLORER","navigator","userAgent","indexOf","IS_FIREFOX","IS_OPERA","toLowerCase","UAHasChrome","UAHasSafari","IS_SAFARI","IS_CHROME","Fraction","num","den","factorized","isNaN","gcd","parse","val","parts","parseInt","isWhole","isZero","isInfinity","isOne","ceil","floor","plus","plusNum","minus","minusNum","times","timesNum","divby","divbyNum","numDivby","mod","d","floorOfD","modNum","inverse","equalsNum","cmp","cmpNum","isLT","isLTE","isLTNum","isLTENum","isGT","isGTE","isGTNum","isGTENum","max","f1","f2","min","ZERO","ONE","INFINITY","Frac","a","b","TSU","CycleCursor","cycle","barIndex","beatIndex","instance","currBar","bars","result","beatLengths","beatCounts","beatCount","Bar","bl","bc","assign","instanceCount","totalBeatCount","total","Cycle","p","getAtIndex","globalIndex","offset","bar","beatLength","getPosition","globalOffset","cycleNum","realOffset","barDuration","iterateBeats","startBar","startBeat","startInstance","instanceIndex","reduce","DEFAULT","AtomType","Atom","parentGroup","isContinuation","_duration","markersBefore","mbef","m","markersAfter","maft","LeafAtom","beforeRest","splitAt","spillOver","createSpilloverSpace","Space","Marker","text","isBefore","isSilent","Literal","embelishments","embs","e","Note","octave","shift","fromLit","lit","NOTE","Group","atoms","durationIsMultiplier","addAtoms","a1","a2","atom","totalChildDuration","setDurationAsMultiplier","asMultiplier","setDuration","requiredDuration","targetGroup","remainingDur","durationFactor","lastChild","childDuration","newDuration","newRequiredDur","insertAtomsAt","removeAtoms","beforeAtom","adjustDuration","oldChildDuration","REST","GROUP","LABEL","scaleFactor","LayoutParams","beatDuration","_rowStartOffsets","_rowEndOffsets","_rowDurations","_totalLayoutDuration","_totalBeats","_beatLayouts","lineBreaks","layout","lineBreaksEqual","_lineBreaks","every","_a","getBeatLocation","beat","modIndex","index","totalBeats","cursor","refreshLayout","beatLayouts","totalLayoutDuration","cycleIter","akb","numBeats","beats","nextCP","rd","GridModel","idCounter","lastUpdatedAt","rows","rowAligns","Map","colAligns","r","firstRow","gr","numCells","rowIndex","firstCol","minCol","fc","cellsInRow","row","cell","cells","cellsInCol","col","cellAt","addRowAlign","align","set","addColAlign","addRows","insertBefore","numRows","newRow","GridRow","defaultRowAlign","addSuccessor","getRow","setValue","cellCreator","grow","GridCell","clearCellAt","GridCellEvent","CLEARED","loc","location","oldValue","_b","UPDATED","gridRow","colIndex","rowAlign","_rowAlign","addCell","colAlign","_colAlign","grid","c","coordOffset","h","maxLength","w","RowAlign","numCols","creator","filter","AlignedLine","needsLayout","_coordOffset","_maxLength","paddingBefore","paddingAfter","prevLines","nextLines","setMaxLength","setPadding","after","beforeAddingCell","removeCell","beforeRemovingCell","setOffset","cellView","getCellView","evalMaxLength","setBounds","changedCells","minSize","height","Beat","role","prevBeat","nextBeat","atomIsPlaceholder","endOffset","filled","remaining","preMarkers","curr","marker","postMarkers","allMinimalCycles","nodes","idFunc","edges","cycles","inACycle","node","startNode","visited","queue","newQueue","nextNode","edgeData","n","slice","defaultKeyFunc","IDSet","keyFunc","_entries","_entriesByKey","clear","predicate","e2","modified","l","entries","getByKey","ensure","entry","throwIfExists","has","SymbolSet","grammar","enforceSymbolType","Set","hasNull","debugString","labels","sort","join","skipAux","exp","getSymById","isAuxiliary","label","addFrom","includeNull","addTo","termid","term","isTerminal","delete","NullableSet","refresh","nonterms","beforeCount","allNonTerminals","nt","visit","rule","rulesForNT","isStrNullable","rhs","isNullable","str","fromIndex","toIndex","syms","SymSymbolSets","_count","forEachTerm","visitor","entriesFor","sym","addNull","srcEntries","destEntries","FirstSets","nullables","forEachTermIn","allNullable","j","symj","forEachRule","processRule","s","FollowSets","firstSets","g","startSymbol","Eof","Sym","auxType","precedence","assocLeft","creationId","compareTo","localeCompare","Str","append","lits","extend","strs","copy","startIndex","endIndex","numToDelete","itemsToAdd","diff","containsAt","RuleAction","isFunction","isChildPosition","Rule","action","Grammar","make","symbolSet","allRules","_rulesForNT","_followSets","_hasNull","auxNTCount","auxNTPrefix","Null","newTerm","followSets","augStartRule","_AugStartRule","augmentStartSymbol","augSym","newNT","addRule","addTerminals","terminals","nonTerminals","auxNonTerminals","allSymbols","forEachNT","rules","getRule","getSym","findRule","production","findIndex","nonterm","ensureSym","removeRules","pred","removeSymbols","newRules","newRhs","sym2","T","NT","isNT","isAuxNT","seq","exps","normalizeRule","anyof","ensureAuxNT","opt","atleast0","leftRec","auxNT","findAuxNT","which","newAuxNT","atleast1","newAuxNTName","findAuxNTByRules","ntRules","print","options","ruleSep","includeSemiColon","lambdaSymbol","terminalDerivingSymbols","nadded","allDerive","reachableSymbols","fromSymbol","reachable","ruleIndex","leftRecursion","CharClassType","charCodeAt","NINE","lA","lZ","uA","uZ","USCORE","CharClassHelper","matches","charCode","neg","res","match","CharClassHelpers","reString","spaceChars","PropertyName","PropertyValue","RegexType","CharType","OpCode","Regex","groupIndex","groupName","groupIsSilent","ignoreCase","dotAll","multiline","setOptions","isVariable","evalREString","modifiers","StartOfInput","tag","START_OF_INPUT","reverse","EndOfInput","END_OF_INPUT","Assertion","expr","cond","negate","LookAhead","LOOK_AHEAD","LookBack","LOOK_BACK","Quant","minCount","maxCount","greedy","QUANT","isUnlimited","quant","Cat","CAT","Union","UNION","option","Char","op","CHAR","ch","matchChar","LeafChar","args","Any","AnyChar","Class","charClass","CharClass","Single","SingleChar","PropertyEscape","propNameOrId","propValueOrId","SyntaxError","PropertyEscapes","String","fromCharCode","replace","CharGroup","chars","CharRange","Intersection","Range","start","end","Var","reversed","VAR","BackNamedRef","BACK_NAMED_REF","BackRef","BackNumRef","BACK_NUM_REF","skip","priority","matchIndex","activeStates","stateCanActivate","state","needsSpecificStates","isNewLineChar","Match","groups","positions","Prog","startCondition","scIsInclusive","instrs","stateMapping","registerState","opcode","char","Instr","with","initializer","instrDebugValue","InstrDebugValue","instr","comment","Thread","gen","parentId","registers","regIncr","regId","regAcquire","regRelease","regValue","VM","getState","currState","setState","prog","forward","configs","threadCounter","currThreads","nextThreads","startPos","genForOffset","savePosition","thread","pos","tapeIndex","jumpBy","delta","jumpTo","newOffset","forkTo","startGroup","newThread","endGroup","addThread","list","tape","nextCh","lastCh","Jump","Split","newOff","Save","tracer","threadQueued","GroupStart","GroupEnd","StartingChar","MLStartingChar","prevCh","EndingChar","MLEndingChar","StartOfWord","EndOfWord","RBegin","groupStart","matchSuccess","matchEnd","recurseMatch","Begin","consume","EnsureState","states","matchCurrPos","currChCodeLower","currChCodeUpper","currChCode","hasMore","charAt","startMatching","bestMatch","stepChar","startOffset","savedPos","canAdvance","newPos","currMatch","nextMatch","stepThread","advance","threadStepped","advanceTape","End","currPriority","CIChar","AnyNonNL","currCh","Compiler","regexResolver","listener","emitGroups","emitPosition","compile","ensureInstr","ind","compileExpr","currOffset","compileChar","ml","START_OF_WORD","END_OF_WORD","compileCat","compileUnion","compileQuant","compileVar","compileBackNamedRef","compileBackNumRef","compileLookAhead","compileLookBack","cat","ne","union","jumps","jmp","compileAtleast0","compileAtleast1","compileOptional","l1","l3","l2","la","begin","lb","TokenizerError","message","setPrototypeOf","UnexpectedTokenError","foundToken","expectedTokens","TapeInterface","hasIndex","toUpperCase","charCodeAtLower","charCodeAtUpper","Tape","input","_rawInput","content","substring","TapeHelper","advanceAfter","pattern","ensureNoPrefixSlash","advanceTo","lastIndex","currStart","numSlashes","prefix","success","Token","lookahead","lookback","isOneOf","expected","tok","TokenBuffer","nextToken","tokenizerContext","buffer","peek","nth","matchFunc","nextAction","token","consumeIf","expectToken","ensureToken","nextMatches","GroupCounter","current","isSpace","RegexParser","unicode","reduceLeft","stack","throwError","refNum","gtPos","clPos","parseCharGroup","rest","parseGroup","parseQuant","nchars","parseChar","depth","subExpr","currch","endch","parseEscapeChar","parseSingleChar","parsePropertyEscape","clEnd","eqPos","propStr","propName","propValue","WORD_CHAR","DIGITS","SPACES","hexSeq","hexVal","ucodeSeq","ucodeVal","sub","advanceIf","ignoreSpaces","obCount","ignoreSpaces2","foundComma","p1","p2","part1","part2","foundEq","build","exprFromJSRE","exprFromFlexRE","parser","FlexREParser","error","re","isRegExp","JSREParser","flexRE","strings","keys","raw","BaseTokenizer","_prog","_vm","onError","onMatchHandlers","matchHandlersByValue","variables","compiler","findRuleByValue","getVar","addVar","regex","currValue","find","onMatch","Builder","sortedRules","sortRules","vm","r1","r2","Tokenizer","reset","owner","startChar","err","gi","toToken","tokenize","tokens","DefaultTape","SINGLE_QUOTE_STRING","DOUBLE_QUOTE_STRING","JS_REGEX","str2regex","TokenType","NodeType","LRActionType","Loader","leftRecursive","generatedTokenizer","TLEX","regexSyntax","symbolsByLabel","newSymbolCallback","tokenHandlers","symbolForLabel","registerSymbol","ensureSymbol","assumedTerminal","currSym","et","lexer","ARROW","OPEN_SQ","CLOSE_SQ","OPEN_PAREN","CLOSE_PAREN","OPEN_BRACE","CLOSE_BRACE","STAR","PLUS","QMARK","SEMI_COLON","COLON","PIPE","COMMENT","STRING","REGEX","flags","NUMBER","PCT_IDENT","DOLLAR_NUM","DOLLAR_IDENT","IDENT","tokenizer","ntFunc","parseGrammar","parseRegex","syntax","tokPattern","RegExp","patternStr","peeked","parseDecl","parseDirective","directive","startsWith","endsWith","tokenHandler","parseTokenHandler","isDef","tokName","funcName","ident","parseProductions","parseProd","PFNode","childCount","childAt","reprString","PTNode","ParserBase","setTokenizer","tokenbuffer","SimpleParser","delegate","parseInput","ParseError","LRAction","gotoState","ACCEPT","SHIFT","REDUCE","Shift","goto","Reduce","Goto","GOTO","Accept","ParseTable","conflictActions","actions","hasConflicts","getActions","stateId","addAction","ac","fromId","symId","ParseStack","stateStack","nodeStack","top","pop","popN","L","Parser","parseTable","context","buildParseTree","copySingleChild","output","resolveActions","actionResolver","onTokenError","onNextToken","nextSym","nextValue","topState","topNode","newNode","ruleLen","childNode","beforeAddingChildNode","handlerName","ruleHandlers","onReduction","newAction","LRItem","position","pre","post","LRItemSet","ig","_key","_lookaheads","_hasLookAheads","itemGraph","addLookAhead","item","s1","s2","clearLookAheads","getLookAheads","revalKey","hasLookAheads","itemId","items","i1","i2","las","LRItemGraph","gotoSets","itemSets","startItem","startSet","evalGotoSets","currSet","gotoSet","setGoto","itemSet","newItemSet","advanceItemAndAdd","closure","itemToAdvance","fromItemSet","toItemSet","newItem","laSym","ensureGotoSet","fromSet","toSet","getGoto","forEachGoto","symid","gotoSetFor","iset","LR0ItemGraph","newset","LR1ItemGraph","B","suffix","bRules","br","makeSLRParseTable","evalLASetsForSLRItem","makeSLRAutomaton","makeParseTableFromLA","nextSet","lookaheads","lr1Item","evalLASetsForLALRItem","augGrammar","prevSets","findP","prevStates","nextState","pSet","pALabel","pA","ALIAS","Symbol","for","DOC","MAP","PAIR","SCALAR","SEQ","NODE_TYPE","isAlias","isDocument","isMap","isPair","isScalar","isSeq","isCollection","isNode","hasAnchor","anchor","BREAK","SKIP","REMOVE","visitor_","initVisitor","visit_","contents","freeze","path","ctrl","callVisitor","replaceNode","concat","ci","ck","cv","async","visitAsync","visitAsync_","Collection","Node","Value","Alias","Scalar","Seq","Pair","pt","escapeChars","escapeTagName","tn","Directives","yaml","tags","docStart","docEnd","defaultYaml","defaultTags","atDocument","version","atNextDocument","explicit","line","test","tagName","verbatim","decodeURIComponent","tagString","doc","lines","tagEntries","tagNames","some","anchorIsValid","sa","JSON","stringify","applyReviver","reviver","isArray","len","v0","v1","undefined","k","toJS","arg","ctx","aliasCount","anchors","onCreate","keep","Number","NodeBase","create","getPrototypeOf","getOwnPropertyDescriptors","range","mapAsMap","maxAliasCount","onAnchor","TypeError","mapKeyWarned","resolve","found","aliasResolveCache","_arg","ReferenceError","getAliasCount","_onComment","_onChompKeep","src","verifyAliasOrder","implicitKey","kc","vc","isScalarValue","createNode","schema","Boolean","BigInt","valueOf","aliasDuplicateObjects","onTagObj","sourceObjects","ref","tagObj","format","identify","findTagObject","iterator","nodeClass","default","collectionFromPath","isInteger","keepUndefined","BLOCK_FOLDED","BLOCK_LITERAL","PLAIN","QUOTE_DOUBLE","QUOTE_SINGLE","configurable","writable","it","addIn","done","isEmptyPath","deleteIn","getIn","keepScalar","hasAllNullValues","allowScalar","commentBefore","hasIn","setIn","stringifyComment","indentComment","indent","lineComment","includes","FOLD_FLOW","FOLD_BLOCK","FOLD_QUOTED","foldFlowLines","mode","indentAtStart","lineWidth","minContentWidth","onFold","onOverflow","endStep","folds","escapedFolds","overflow","escStart","escEnd","consumeMoreIndentedLines","fold","getFoldOptions","isBlock","containsDocumentMarker","doubleQuotedString","json","doubleQuotedAsJSON","minMultiLineLength","doubleQuotedMinMultiLineLength","code","substr","singleQuotedString","singleQuote","quotedString","qs","hasDouble","hasSingle","blockEndNewlines","blockString","onComment","onChompKeep","blockQuote","commentString","forceBlockIndent","literal","indentLength","limit","strLen","lineLengthOverLimit","chomp","endStart","endNlPos","startEnd","startWithSpace","startNlPos","header","foldedValue","literalFallback","foldOptions","body","stringifyString","inFlow","ss","_stringify","_type","actualString","indentStep","compat","plainString","defaultKeyType","defaultStringType","directives","resolvedAliases","testMatch","getTagObject","props","stringifyProps","MERGE_KEY","merge","description","addToJSMap","addMergeToJSMap","mergeValue","srcMap","addPairToJSMap","isMergeKey","jsKey","stringKey","strCtx","falseStr","flowCollectionPadding","indentSeq","nullStr","simpleKeys","trueStr","toStringOptions","collectionStyle","repeat","createStringifyContext","inStringifyKey","strKey","jsonStr","warning","logLevel","warn","stringifyKey","jsValue","createPair","_","allNullValues","keyComment","explicitKey","vsb","vcb","valueComment","keyCommentDone","chompKeep","spaceBefore","flow","valueCommentDone","valueStr","ws","vs0","nl0","hasNewline","hasPropsLine","sp0","stringifyPair","stringifyCollection","collection","stringifyFlowCollection","stringifyBlockCollection","blockItemPrefix","flowChars","itemIndent","itemCtx","addCommentBefore","ik","fcPadding","reqNewline","linesAtValue","iv","sum","ic","trimStart","findPair","YAMLMap","replacer","sortMapEntries","pair","overwrite","_pair","sortEntries","Type","YAMLSeq","idx","asItemIndex","string","nullTag","boolTag","stringifyNumber","minFractionDigits","isFinite","is","floatNaN","NaN","NEGATIVE_INFINITY","POSITIVE_INFINITY","floatExp","parseFloat","toExponential","intIdentify","intResolve","radix","intAsBigInt","intStringify","_onError","dot","stringifyJSON","binary","Uint8Array","atob","buf","btoa","resolvePairs","cn","createPairs","iterable","pairs","YAMLOMap","bind","omap","seenKeys","boolStringify","trueTag","falseTag","float","f","sign","intBin","intOct","int","intHex","YAMLSet","keepPair","parseSexagesimal","asBigInt","stringifySexagesimal","_60","unshift","padStart","intTime","floatTime","timestamp","Date","year","month","day","hour","minute","second","millisec","date","UTC","tz","toISOString","schema$1","schema$2","cst","_visit","field","GamakaType","itemAtPath","parentCollection","coll","Shape","shapeId","_x","_y","_width","_height","parentShape","bbox","_bbox","refreshBBox","_minSize","refreshMinSize","invalidateBounds","applyLayout","nx","ny","nw","nh","updateBounds","hasX","hasY","hasWidth","hasHeight","width","params","ptable","tokenFunc","eparser","debug","loadGrammar","makeLRParseTable","g2","ensureG2Sym","pi","newSymLabel","newSym","startState","transitions","buildRuleFrom","A","newSyms","xi","startSym","newA","newRHS","newRule","grammarFromLR0ItemGraph","makeLALRParseTable","makeParseTable","newParseTable","merged","ptabDV","igDV","mergedDebugValue","logParserDebug","G","toEmbelishment","emb","parseEmbelishment","errors","toCommandName","_tape","_owner","toBoolean","toNumber","toMarker","markerText","toOctavedNote","note","toRoleSelector","toLineAnnotation","toSingleLineRawString","toMultiLineRawString","endPat","endPos","toFrontMatter"],"ignoreList":[],"sourceRoot":""}
+{"version":3,"file":"notations.umd.min.js","mappings":"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","sources":["webpack://Notations/webpack/universalModuleDefinition","webpack://Notations/webpack/bootstrap","webpack://Notations/../../src/events.ts","webpack://Notations/webpack/runtime/define property getters","webpack://Notations/webpack/runtime/hasOwnProperty shorthand","webpack://Notations/../../src/entity.ts","webpack://Notations/../../src/types.ts","webpack://Notations/../../src/constants.ts","webpack://Notations/../../../src/comms/events.ts","webpack://Notations/../../src/list.ts","webpack://Notations/../../src/geom.ts","webpack://Notations/../../src/browser.ts","webpack://Notations/../../src/dom.ts","webpack://Notations/../../src/numberutils.ts","webpack://Notations/../../src/cycle.ts","webpack://Notations/../../src/core.ts","webpack://Notations/../../src/layouts.ts","webpack://Notations/../../src/grids.ts","webpack://Notations/../../src/beats.ts","webpack://Notations/../../src/graph.ts","webpack://Notations/../../src/sets.ts","webpack://Notations/../../src/grammar.ts","webpack://Notations/../../src/charclasses.ts","webpack://Notations/../../src/propertyescapes.ts","webpack://Notations/../../src/vm.ts","webpack://Notations/../../src/compiler.ts","webpack://Notations/../../src/errors.ts","webpack://Notations/../../src/tape.ts","webpack://Notations/../../src/token.ts","webpack://Notations/../../src/utils.ts","webpack://Notations/../../src/jsparser.ts","webpack://Notations/../../src/flexparser.ts","webpack://Notations/../../src/builder.ts","webpack://Notations/../../src/tokenizer.ts","webpack://Notations/../../src/samples.ts","webpack://Notations/../../src/dsl.ts","webpack://Notations/../../src/lr.ts","webpack://Notations/../../src/parser.ts","webpack://Notations/../../src/lritems.ts","webpack://Notations/../../src/ptables.ts","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/identity.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/visit.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/directives.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/anchors.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/applyReviver.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/toJS.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Node.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Alias.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Scalar.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/doc/createNode.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Collection.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyComment.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/foldFlowLines.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyString.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringify.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/merge.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/addPairToJSMap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/log.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/Pair.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyPair.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyCollection.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/YAMLMap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/map.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/nodes/YAMLSeq.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/seq.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/string.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/common/null.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/bool.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/stringify/stringifyNumber.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/float.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/int.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/core/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/json/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/bool.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/float.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/int.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/set.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/schema/tags.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/errors.js","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/parse/cst-visit.js","webpack://Notations/../../../src/carnatic/gamakas.ts","webpack://Notations/./node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/browser/dist/parse/lexer.js","webpack://Notations/../../src/shapes.ts","webpack://Notations/../../../src/carnatic/embelishments.ts","webpack://Notations/../../../src/carnatic/atomviews.ts","webpack://Notations/../../src/factory.ts","webpack://Notations/../../src/debug.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Notations\"] = factory();\n\telse\n\t\troot[\"Notations\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","/**\n * Model change events for incremental updates.\n *\n * This module defines the event types, interfaces, and observer patterns for\n * change notifications on model entities (Group, Role, Line, Block). These\n * events enable incremental updates to the rendering pipeline without full\n * re-renders.\n *\n * Uses the Observer pattern instead of pub/sub EventHub for:\n * - Type safety: Observers have strongly-typed method signatures\n * - Traceability: Easy to see who is observing what\n * - Explicit contracts: Clear interface between observable and observers\n *\n * Note: This module uses generic types to avoid circular dependencies with\n * core.ts and block.ts. The actual types are enforced at the call sites.\n */\n\n// ============================================\n// Event Types and Payloads\n// ============================================\n\n/**\n * Event types for Atom-related changes.\n */\nexport enum AtomChangeType {\n  /** Atoms were added to the end */\n  ADD = \"add\",\n  /** Atoms were inserted at a specific position */\n  INSERT = \"insert\",\n  /** Atoms were removed */\n  REMOVE = \"remove\",\n  /** An atom's properties changed (duration, value, etc.) */\n  UPDATE = \"update\",\n}\n\n/**\n * Event payload for atom changes in a Group or Role.\n * Generic T is typically Atom from core.ts.\n */\nexport interface AtomChangeEvent<T = any> {\n  /** The type of change */\n  type: AtomChangeType;\n  /** The atoms that were added, inserted, or removed */\n  atoms: T[];\n  /** For INSERT: the index where atoms were inserted */\n  index?: number;\n  /** For UPDATE: the specific property that changed */\n  property?: string;\n  /** For UPDATE: the old value of the property */\n  oldValue?: any;\n  /** For UPDATE: the new value of the property */\n  newValue?: any;\n}\n\n/**\n * Event types for Role-related changes on a Line.\n */\nexport enum RoleChangeType {\n  /** A role was added to the line */\n  ADD = \"add\",\n  /** A role was removed from the line */\n  REMOVE = \"remove\",\n}\n\n/**\n * Event payload for role changes on a Line.\n */\nexport interface RoleChangeEvent {\n  /** The type of change */\n  type: RoleChangeType;\n  /** The role that was added or removed */\n  roleName: string;\n}\n\n/**\n * Event types for BlockItem changes on a Block.\n */\nexport enum BlockItemChangeType {\n  /** An item was added to the block */\n  ADD = \"add\",\n  /** An item was removed from the block */\n  REMOVE = \"remove\",\n}\n\n/**\n * Event payload for block item changes.\n * Generic T is typically BlockItem (Block | Line | RawBlock) from block.ts.\n */\nexport interface BlockItemChangeEvent<T = any> {\n  /** The type of change */\n  type: BlockItemChangeType;\n  /** The item that was added or removed */\n  item: T;\n  /** For ADD: the index where the item was added */\n  index?: number;\n}\n\n// ============================================\n// Observer Interfaces\n// ============================================\n\n/**\n * Observer interface for Group atom changes.\n * Implement this interface to receive notifications when atoms are\n * added, inserted, or removed from a Group.\n *\n * @template TAtom The atom type (defaults to any to avoid circular deps)\n * @template TGroup The group type (defaults to any to avoid circular deps)\n */\nexport interface GroupObserver<TAtom = any, TGroup = any> {\n  /**\n   * Called when atoms are added to the end of the group.\n   * @param group The group that changed\n   * @param atoms The atoms that were added\n   * @param index The index where atoms were added\n   */\n  onAtomsAdded?(group: TGroup, atoms: TAtom[], index: number): void;\n\n  /**\n   * Called when atoms are inserted at a specific position.\n   * @param group The group that changed\n   * @param atoms The atoms that were inserted\n   * @param index The index where atoms were inserted\n   */\n  onAtomsInserted?(group: TGroup, atoms: TAtom[], index: number): void;\n\n  /**\n   * Called when atoms are removed from the group.\n   * @param group The group that changed\n   * @param atoms The atoms that were removed\n   */\n  onAtomsRemoved?(group: TGroup, atoms: TAtom[]): void;\n}\n\n/**\n * Observer interface for Role atom changes.\n * Implement this interface to receive notifications when atoms are\n * added, inserted, or removed from a Role.\n *\n * @template TAtom The atom type (defaults to any to avoid circular deps)\n * @template TRole The role type (defaults to any to avoid circular deps)\n */\nexport interface RoleObserver<TAtom = any, TRole = any> {\n  /**\n   * Called when atoms are added to the end of the role.\n   * @param role The role that changed\n   * @param atoms The atoms that were added\n   * @param index The index where atoms were added\n   */\n  onAtomsAdded?(role: TRole, atoms: TAtom[], index: number): void;\n\n  /**\n   * Called when atoms are inserted at a specific position.\n   * @param role The role that changed\n   * @param atoms The atoms that were inserted\n   * @param index The index where atoms were inserted\n   */\n  onAtomsInserted?(role: TRole, atoms: TAtom[], index: number): void;\n\n  /**\n   * Called when atoms are removed from the role.\n   * @param role The role that changed\n   * @param atoms The atoms that were removed\n   */\n  onAtomsRemoved?(role: TRole, atoms: TAtom[]): void;\n}\n\n/**\n * Observer interface for Line role changes.\n * Implement this interface to receive notifications when roles are\n * added or removed from a Line.\n *\n * @template TRole The role type (defaults to any to avoid circular deps)\n * @template TLine The line type (defaults to any to avoid circular deps)\n */\nexport interface LineObserver<TRole = any, TLine = any> {\n  /**\n   * Called when a role is added to the line.\n   * @param line The line that changed\n   * @param roleName The name of the added role\n   * @param role The role that was added\n   */\n  onRoleAdded?(line: TLine, roleName: string, role: TRole): void;\n\n  /**\n   * Called when a role is removed from the line.\n   * @param line The line that changed\n   * @param roleName The name of the removed role\n   */\n  onRoleRemoved?(line: TLine, roleName: string): void;\n}\n\n/**\n * Observer interface for Block item changes.\n * Implement this interface to receive notifications when items are\n * added or removed from a Block.\n *\n * @template TItem The block item type (defaults to any to avoid circular deps)\n * @template TBlock The block type (defaults to any to avoid circular deps)\n */\nexport interface BlockObserver<TItem = any, TBlock = any> {\n  /**\n   * Called when an item is added to the block.\n   * @param block The block that changed\n   * @param item The item that was added\n   * @param index The index where the item was added\n   */\n  onItemAdded?(block: TBlock, item: TItem, index: number): void;\n\n  /**\n   * Called when an item is removed from the block.\n   * @param block The block that changed\n   * @param item The item that was removed\n   * @param index The index where the item was located\n   */\n  onItemRemoved?(block: TBlock, item: TItem, index: number): void;\n}\n\n// ============================================\n// Legacy Event Names (kept for compatibility)\n// ============================================\n\n/**\n * Model event names as constants.\n * @deprecated Use observer interfaces instead\n */\nexport const ModelEvents = {\n  /** Emitted when atoms change in a Group or Role */\n  ATOMS_CHANGED: \"atomsChanged\",\n  /** Emitted when roles change on a Line */\n  ROLES_CHANGED: \"rolesChanged\",\n  /** Emitted when block items change on a Block */\n  ITEMS_CHANGED: \"itemsChanged\",\n  /** Emitted when an atom's duration changes */\n  DURATION_CHANGED: \"durationChanged\",\n} as const;\n\n/**\n * Type for model event names.\n * @deprecated Use observer interfaces instead\n */\nexport type ModelEventName = (typeof ModelEvents)[keyof typeof ModelEvents];\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import * as TSU from \"@panyam/tsutils\";\n\n/**\n * A common Entity base class with support for unique IDs, parent references,\n * copying, and debug info. This serves as the foundation for all entities\n * in the notation system.\n *\n * Note: Child management is intentionally NOT included here. Each container type\n * (BlockContainer, Line, Group, etc.) defines its own child management with\n * appropriate types.\n *\n * Observer Pattern:\n * Each observable entity subclass (Group, Role, Line, Block) manages its own\n * typed observer list. This provides type safety and clear contracts between\n * observables and observers.\n */\nexport class Entity {\n  readonly TYPE: string = \"Entity\";\n\n  private static counter = 0;\n  /** Unique identifier for this entity */\n  readonly uuid = Entity.counter++;\n  /** Parent entity in the tree hierarchy */\n  protected _parent: TSU.Nullable<Entity> = null;\n\n  /**\n   * Whether events/observer notifications are enabled for this entity.\n   * Subclasses check this flag before notifying observers.\n   */\n  protected _eventsEnabled = false;\n\n  /**\n   * Creates a new Entity.\n   * @param config Optional configuration object\n   */\n  constructor(config: any = null) {\n    config = config || {};\n    if (config.metadata) throw new Error(\"See where metadata is being passed\");\n  }\n\n  /**\n   * Enables observer notifications for this entity.\n   * Call this to activate change notifications on entities that support them.\n   * @returns This entity for method chaining\n   */\n  enableEvents(): this {\n    this._eventsEnabled = true;\n    return this;\n  }\n\n  /**\n   * Disables observer notifications for this entity.\n   * @returns This entity for method chaining\n   */\n  disableEvents(): this {\n    this._eventsEnabled = false;\n    return this;\n  }\n\n  /**\n   * Checks if events/observer notifications are enabled.\n   */\n  get eventsEnabled(): boolean {\n    return this._eventsEnabled;\n  }\n\n  /**\n   * Gets the parent entity.\n   */\n  get parent(): TSU.Nullable<Entity> {\n    return this._parent;\n  }\n\n  /**\n   * Sets the parent entity.\n   * @param parent The parent entity to set\n   */\n  setParent(parent: TSU.Nullable<Entity>): void {\n    this._parent = parent;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this entity.\n   * Usually overridden by children to add more debug info.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { type: this.TYPE };\n  }\n\n  /**\n   * Returns a simple string representation of this Entity.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Entity(id = ${this.uuid})`;\n  }\n\n  /**\n   * Checks if this Entity is equal to another Entity.\n   * @param another The Entity to compare with\n   * @param expect Optional parameter\n   * @returns True if the Entities are equal, false otherwise\n   */\n  equals(another: this, expect = false): boolean {\n    if (this.TYPE != another.TYPE) return false;\n    return true;\n  }\n\n  /**\n   * Creates a clone of this entity.\n   * Cloning is a two-part process:\n   * 1. Creation of a new instance via this.newInstance()\n   * 2. Copying of data into the new instance via this.copyTo()\n   *\n   * @returns A new instance of the same type with the same properties\n   */\n  clone(): this {\n    const out = this.newInstance();\n    this.copyTo(out);\n    return out;\n  }\n\n  /**\n   * Copies information about this instance into another instance of the same type.\n   * @param another The target instance to copy properties to\n   */\n  copyTo(another: this): void {\n    // Subclasses override to copy their specific properties\n  }\n\n  /**\n   * First part of the cloning process where the instance is created.\n   * @returns A new instance of the same type\n   */\n  protected newInstance(): this {\n    return new (this.constructor as any)();\n  }\n}\n\n/**\n * Music is all about timing! TimedEntities are base of all entities that\n * have a duration. This is an abstract class that all timed entities inherit from.\n */\nexport abstract class TimedEntity extends Entity {\n  readonly TYPE: string = \"TimedEntity\";\n\n  /**\n   * Gets the duration of this entity in terms of beats.\n   * By default, entity durations are readonly.\n   */\n  abstract get duration(): TSU.Num.Fraction;\n\n  /**\n   * Checks if this TimedEntity is equal to another TimedEntity.\n   * @param another The TimedEntity to compare with\n   * @returns True if the TimedEntities are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.duration.equals(another.duration);\n  }\n}\n","export type Timestamp = number;\nexport type NumberRange = [number, number];\n\nexport type StringMap<T> = { [key: string]: T };\nexport type NumMap<T> = { [key: number]: T };\nexport type Nullable<T> = T | null;\n\nexport type Undefined<T> = T | undefined | void;\n\nexport function assert(condition: boolean, msg?: string): asserts condition {\n  if (!condition) {\n    throw new Error(msg);\n  }\n}\n","export const INFINITY = 1e48;\nexport const MAX_INT = 2 ** 32;\nexport const MAX_LONG = 2 ** 64;\n","import { Nullable, Timestamp } from \"../types\";\n\n/**\n * Super class of all Events.\n */\nexport class TEvent {\n  // Globally unique ID for all events.\n  private static counter = 0;\n  readonly uuid = TEvent.counter++;\n\n  /**\n   * The event this event was spawned from (if any).\n   */\n  protected _spawnedFrom: Nullable<this> = null;\n\n  /**\n   * Name of the event.\n   */\n  readonly name: string;\n\n  /**\n   * Source from which this event is originating.\n   */\n  readonly source: any;\n\n  /**\n   * Source state that is set by the source of the event only\n   * *it* can use.\n   */\n  sourceState: any = null;\n\n  /**\n   * Event specific payload.\n   */\n  payload: any;\n\n  /**\n   * Whether the event was cancelled.\n   */\n  cancelled = false;\n\n  /**\n   * Timestamp of the event - optional.\n   */\n  timeStamp: Timestamp = -1;\n\n  /**\n   * All child events that were spawned from this Event.\n   * The parent/spawnedFrom and child event references help us\n   * form a call tree/trace of a events as it traverses\n   * the system.\n   */\n  children: TEvent[] = [];\n\n  constructor(name: string, source: any, payload?: any) {\n    this.name = name;\n    this.source = source;\n    this.payload = payload;\n  }\n\n  get spawnedFrom(): Nullable<this> {\n    return this._spawnedFrom;\n  }\n\n  protected setSpawnedFrom(msg: Nullable<this>): void {\n    this._spawnedFrom = msg;\n    if (msg == null) this._rootEvent = this;\n    else this._rootEvent = msg.rootEvent;\n  }\n\n  spawn(name: string, source: any, payload?: any): TEvent {\n    const child = new TEvent(name, source, payload);\n    child.setSpawnedFrom(this);\n    this.children.push(child);\n    return child;\n  }\n\n  /**\n   * The first/root message in the forward chain.\n   */\n  private _rootEvent: this;\n\n  get rootEvent(): this {\n    return this._rootEvent as this;\n  }\n}\n\nexport class State {\n  private static counter = 0;\n  stateData: any = null;\n  readonly id = State.counter++;\n\n  get name(): string {\n    return this.constructor.name;\n  }\n\n  enter(data: any): void {\n    this.stateData = data;\n  }\n\n  handle(event: TEvent): void {\n    // todo\n  }\n}\n\nexport type EventCallback = ((event: TEvent) => void) | ((event: TEvent) => Promise<void>);\n\nexport class EventEmitter {\n  protected _eventHub: EventHub | null;\n  constructor() {\n    this._eventHub = new EventHub();\n  }\n  get eventHub(): EventHub | null {\n    return this._eventHub;\n  }\n  set eventHub(hub: EventHub | null) {\n    const oldHub = this._eventHub;\n    this._eventHub = hub;\n    this.eventHubChanged(oldHub);\n  }\n  protected eventHubChanged(oldHub: EventHub | null): void {\n    // Do nothing\n    console.log(\"WARNING - EventHub Change Listener not implemented: \", this.constructor.name);\n  }\n}\n\nexport class EventHub {\n  private _handlers: { [key: string]: Array<EventCallback> } = {};\n\n  on(names: Array<string> | string, callback: EventCallback): this {\n    return this._addHandler(names, this._handlers, callback);\n  }\n\n  removeOn(names: Array<string> | string, callback: EventCallback): this {\n    return this._removeHandler(names, this._handlers, callback);\n  }\n\n  _ensurestrings(names: Array<string> | string): string[] {\n    if (typeof names === \"string\") {\n      names = (names as string).split(\",\");\n    }\n    return names.map(function (v) {\n      return v.trim();\n    });\n  }\n\n  _addHandler<T>(names: Array<string> | string, handlerlist: { [key: string]: Array<T> }, handler: T): this {\n    this._ensurestrings(names).forEach(function (name) {\n      handlerlist[name] = handlerlist[name] || [];\n      handlerlist[name].push(handler);\n    });\n    return this;\n  }\n\n  _removeHandler<T>(names: Array<string> | string, handlerlist: { [key: string]: Array<T> }, handler: T): this {\n    this._ensurestrings(names).forEach(function (name) {\n      const evHandlers = handlerlist[name] || [];\n      for (let i = 0; i < evHandlers.length; i++) {\n        if (evHandlers[i] == handler) {\n          evHandlers.splice(i, 1);\n          break;\n        }\n      }\n    });\n    return this;\n  }\n\n  emit(name: string, source: any, payload?: any): boolean {\n    const evt = new TEvent(name, source, payload);\n    if (this._inBatchMode) {\n      this._events.push(evt);\n      return true;\n    } else {\n      return this.dispatchEvent(evt);\n    }\n  }\n\n  dispatchEvent(event: TEvent): boolean {\n    const evtCallbacks = this._handlers[event.name] || [];\n    for (const callback of evtCallbacks) {\n      callback(event);\n      if (event.cancelled) return false;\n    }\n    return true;\n  }\n\n  // Support for transactional/batch event handling, where\n  // the user can allow a bunch of events to first collect\n  // before triggering a batch dispatch\n  public static BATCH_EVENTS = \"BatchEvents\";\n  protected _events: TEvent[] = [];\n  protected _inBatchMode = false;\n  startBatchMode(): this {\n    if (!this._inBatchMode) {\n      this._inBatchMode = true;\n    }\n    return this;\n  }\n\n  cancelBatch(): void {\n    this._inBatchMode = false;\n    this._events = [];\n  }\n\n  commitBatch(): void {\n    this._inBatchMode = false;\n    this.emit(EventHub.BATCH_EVENTS, this, this._events);\n    this._events = [];\n  }\n}\n\n/**\n * StateMachines allow declarative and stateful chaining of events.\n */\nexport class StateMachine {\n  private _states: { [key: string]: State } = {};\n  private _rootState: Nullable<State> = null;\n  private _currentState: Nullable<State> = null;\n  constructor() {\n    this._states = {};\n    this._rootState = null;\n    this._currentState = null;\n  }\n\n  /**\n   * The starting/root state of the machine.\n   *\n   * @param {String} name  Name of the default/root state.\n   */\n  set rootState(name: string) {\n    this._rootState = this.getState(name);\n    if (this._currentState == null) {\n      this._currentState = this._rootState;\n    }\n  }\n\n  /**\n   * Exits the current state (if any) and enters a new state.\n   *\n   * @param {String}   state   Name of the new state to enter.\n   * @param {Object}   data    State specific data for the state handler to use for the new state.\n   */\n  enter(state: string, data: any = null): void {\n    if (state == \"\") {\n      this._currentState = this._rootState;\n    } else {\n      this._currentState = this.getState(state);\n    }\n    if (this._currentState != null) {\n      this._currentState.enter(data);\n    }\n  }\n\n  /**\n   * Get the state by name.\n   *\n   * @param {String} name  Name of the state being queried.\n   * @returns {State} State object associated with the name.\n   */\n  getState(name: string): State {\n    if (!(name in this._states)) {\n      throw Error(\"State '\" + name + \"' not yet registered.\");\n    }\n    return this._states[name];\n  }\n\n  /**\n   * Register a new state in the state machine.\n   *\n   * @param {State} state  State being registered.  If another State with\n   * the same name exists, then a {DuplicateError} is thrown.\n   * @param {Bool} isRoot  Whether the new state is a root state.\n   */\n  registerState(state: State, isRoot = false): void {\n    const name = state.name;\n    if (name in this._states) {\n      throw Error(\"State '\" + name + \"' already registered.\");\n    }\n    this._states[name] = state;\n    if (isRoot || false) {\n      this.rootState = state.name;\n    }\n  }\n\n  /**\n   * Handles an event from the current state in the state machine possibly resulting in a state transition.\n   *\n   * @param {Object} name    Type of event being sent.\n   * @param {EventSource} source  The source generating the event.\n   * @param {Object} data    The event specific data.\n   */\n  handle(event: TEvent): void {\n    if (this._currentState == null) return;\n\n    const nextState: any = this._currentState.handle(event);\n    if (nextState != null) {\n      if (nextState == \"\") {\n        if (this._rootState != null) {\n          this.enter(this._rootState.name);\n        } else {\n          throw new Error(\"Root state has not been set\");\n        }\n      } else {\n        this.enter(nextState);\n      }\n    }\n  }\n}\n","import { Nullable } from \"./types\";\n\nexport interface ListNode<V> {\n  nextSibling: Nullable<V>;\n  prevSibling: Nullable<V>;\n}\n\nclass MutableListNode<V> implements ListNode<MutableListNode<V>> {\n  nextSibling: Nullable<MutableListNode<V>> = null;\n  prevSibling: Nullable<MutableListNode<V>> = null;\n  constructor(public value: V) {}\n}\n\n/**\n * A list implementation where the value itself contains next and prev pointers\n * so we do not need to create wrapper classes.\n */\nexport class ValueList<V extends ListNode<V>> {\n  protected _firstChild: Nullable<V> = null;\n  protected _lastChild: Nullable<V> = null;\n  protected _size = 0;\n\n  constructor(...values: V[]) {\n    for (const v of values) this.pushBack(v);\n  }\n\n  toJSON(): V[] {\n    return Array.from(this.values());\n  }\n\n  forEach(method: (val: V) => boolean | any): number {\n    let tmp: V | null = this._firstChild;\n    let count = 0;\n    while (tmp != null) {\n      if (method(tmp) == false) {\n        break;\n      }\n      count++;\n      tmp = tmp.nextSibling;\n    }\n    return count;\n  }\n\n  equals(another: ValueList<V>, eqlFunc: (val1: V, val2: V) => boolean): boolean {\n    if (this.size != another.size) return false;\n    let tmp = this.first;\n    let tmp2 = another.first;\n    for (; tmp != null && tmp2 != null; tmp = tmp.nextSibling, tmp2 = tmp2.nextSibling) {\n      if (!eqlFunc(tmp, tmp2)) {\n        return false;\n      }\n    }\n    return tmp == null && tmp2 == null;\n  }\n\n  get isEmpty(): boolean {\n    return this._size == 0;\n  }\n\n  get size(): number {\n    return this._size;\n  }\n\n  get first(): Nullable<V> {\n    return this._firstChild;\n  }\n\n  get last(): Nullable<V> {\n    return this._lastChild;\n  }\n\n  /**\n   * Generator of values in reverse order.\n   */\n  *reversedValues(): Generator<V> {\n    let tmp = this._lastChild;\n    while (tmp != null) {\n      yield tmp;\n      tmp = tmp.prevSibling;\n    }\n  }\n\n  /**\n   * Generator of values in forward order.\n   */\n  *values(): Generator<V> {\n    let tmp = this._firstChild;\n    while (tmp != null) {\n      yield tmp;\n      tmp = tmp.nextSibling;\n    }\n  }\n\n  add(child: V, before: Nullable<V> = null): this {\n    // Ensure that this node is not added anywhere else\n    if (child.nextSibling != null || child.prevSibling != null) {\n      throw new Error(\"New node already added to a list.  Remove it first\");\n    }\n    child.nextSibling = child.prevSibling = null;\n    this._size++;\n    if (this._firstChild == null || this._lastChild == null) {\n      this._firstChild = this._lastChild = child;\n    } else if (before == null) {\n      child.prevSibling = this._lastChild;\n      child.nextSibling = null;\n      this._lastChild.nextSibling = child;\n      this._lastChild = child;\n    } else if (before == this._firstChild) {\n      child.nextSibling = before;\n      child.prevSibling = null;\n      this._firstChild.prevSibling = child;\n      this._firstChild = child;\n    } else {\n      const prev = before.prevSibling;\n      child.nextSibling = before;\n      before.prevSibling = child;\n      child.prevSibling = prev;\n      if (prev != null) {\n        prev.nextSibling = child;\n      }\n    }\n    return this;\n  }\n\n  pushFront(value: V): this {\n    return this.add(value, this._firstChild);\n  }\n\n  pushBack(value: V): this {\n    return this.add(value);\n  }\n\n  /**\n   * Removes a child node from this list.\n   * It is upto the caller to ensure that this node indeed belongs\n   * to this list otherwise deletion of a non belonging node could result\n   * in undefined behaviour.\n   */\n  remove(child: V): this {\n    const next = child.nextSibling;\n    const prev = child.prevSibling;\n\n    if (next == null) {\n      this._lastChild = prev;\n      if (prev == null) this._firstChild = null;\n    } else {\n      next.prevSibling = prev;\n    }\n\n    if (prev == null) {\n      this._firstChild = next;\n      if (next == null) this._lastChild = null;\n    } else {\n      prev.nextSibling = next;\n    }\n\n    this._size--;\n\n    child.prevSibling = child.nextSibling = null;\n    return this;\n  }\n\n  popBack(): V {\n    if (this._lastChild == null) {\n      throw new Error(\"No children\");\n    }\n    const out = this._lastChild;\n    this.remove(out);\n    return out;\n  }\n\n  popFront(): V {\n    if (this._firstChild == null) {\n      throw new Error(\"No children\");\n    }\n    const out = this._firstChild;\n    this.remove(out);\n    return out;\n  }\n}\n\n/**\n * A list implementation where the values themselves need to be wrapper in a list node.\n * If values already have sibling node properties they can be direclty used\n * via ValueLists.\n */\nexport class List<V> {\n  private container: ValueList<MutableListNode<V>>;\n\n  constructor(...values: V[]) {\n    this.container = new ValueList<MutableListNode<V>>();\n    for (const v of values) this.push(v);\n  }\n\n  toJSON(): V[] {\n    return Array.from(this.values());\n  }\n\n  forEach(method: (val: V) => boolean | any): number {\n    return this.container.forEach((v) => method(v.value));\n  }\n\n  equals(another: List<V>, eqlFunc: (val1: V, val2: V) => boolean): boolean {\n    return this.container.equals(another.container, (a, b) => eqlFunc(a.value, b.value));\n  }\n\n  find(target: V): Nullable<MutableListNode<V>> {\n    for (const v of this.container.values()) {\n      if (target == v.value) {\n        return v;\n      }\n    }\n    return null;\n  }\n\n  get isEmpty(): boolean {\n    return this.container.isEmpty;\n  }\n\n  get size(): number {\n    return this.container.size;\n  }\n\n  get first(): Nullable<MutableListNode<V>> {\n    return this.container.first;\n  }\n\n  get last(): Nullable<MutableListNode<V>> {\n    return this.container.last;\n  }\n\n  /**\n   * Generator of values in reverse order.\n   */\n  *reversedValues(): Generator<V> {\n    for (const v of this.container.reversedValues()) yield v.value;\n  }\n\n  /**\n   * Generator of values in forward order.\n   */\n  *values(): Generator<V> {\n    for (const v of this.container.values()) yield v.value;\n  }\n\n  popBack(): V {\n    return this.container.popBack().value;\n  }\n\n  popFront(): V {\n    return this.container.popFront().value;\n  }\n\n  pushFront(value: V): this {\n    return this.add(value, this.container.first);\n  }\n\n  push(value: V): this {\n    return this.add(value);\n  }\n\n  add(child: V, before: Nullable<MutableListNode<V>> = null): this {\n    this.container.add(new MutableListNode(child), before);\n    return this;\n  }\n}\n","export interface Coords {\n  x: number;\n  y: number;\n}\n\nexport class Point implements Coords {\n  constructor(public x = 0, public y = 0) {}\n}\n\nexport class Size {\n  width = 0;\n  height = 0;\n  constructor(w = 0, h = 0) {\n    this.width = w;\n    this.height = h;\n  }\n}\n\nexport class Insets {\n  constructor(public left = 0, public top = 0, public right = 0, public bottom = 0) {}\n}\n\nexport interface BBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nexport class Rect implements BBox {\n  constructor(public x = 0, public y = 0, public width = 0, public height = 0) {}\n\n  static from(box: BBox): Rect {\n    return new Rect(box.x, box.y, box.width, box.height);\n  }\n\n  copy(): Rect {\n    return Rect.from(this);\n  }\n\n  /**\n   * Returns union with another box.\n   */\n  union(another: BBox | null): this {\n    if (another) {\n      const minX = Math.min(this.x, another.x);\n      const minY = Math.min(this.y, another.y);\n      const maxX = Math.max(this.x + this.width, another.x + another.width);\n      const maxY = Math.max(this.y + this.height, another.y + another.height);\n      this.x = minX;\n      this.y = minY;\n      this.width = maxX - minX;\n      this.height = maxY - minY;\n    }\n    return this;\n  }\n\n  /**\n   * Returns union of multiple boxes.\n   */\n  unionAll(...boxes: (BBox | null)[]): this {\n    for (const b of boxes) this.union(b);\n    return this;\n  }\n}\n","declare let navigator: any;\nexport class Browser {\n  static IS_EXPLORER = () => navigator && navigator.userAgent.indexOf(\"MSIE\") > -1;\n  static IS_FIREFOX = () => navigator && navigator.userAgent.indexOf(\"Firefox\") > -1;\n  static IS_OPERA = () => navigator && navigator.userAgent.toLowerCase().indexOf(\"op\") > -1;\n\n  protected static UAHasChrome = () => navigator && navigator.userAgent.indexOf(\"Chrome\") > -1;\n  protected static UAHasSafari = () => navigator && navigator.userAgent.indexOf(\"Safari\") > -1;\n  static IS_SAFARI = () => navigator && Browser.UAHasSafari() && (!Browser.UAHasChrome() || !Browser.UAHasSafari());\n  static IS_CHROME = () => navigator && Browser.UAHasChrome() && (!Browser.UAHasChrome() || !Browser.IS_OPERA());\n}\n","import { Undefined } from \"./types\";\nimport * as Geom from \"./geom\";\nimport { Browser } from \"./browser\";\n\ndeclare const $: any;\nconst fontMetrics: { [key: string]: any } = {};\n\n/**\n * Calculates the bounding box for an svg element in a consistent way across\n * browsers.\n */\nexport function svgBBox(element: SVGGraphicsElement): Geom.Rect {\n  const bbox = Geom.Rect.from(element.getBBox());\n  // Due to safari bug which returns really crazy span widths!\n  if (Browser.IS_SAFARI()) {\n    const clientRect = element.getClientRects()[0];\n    if (clientRect) {\n      const parentClientRect = element.parentElement?.getBoundingClientRect();\n      bbox.x = bbox.x + clientRect.x - (parentClientRect?.x || 0);\n      // bbox.y = clientRect.y; //  - (parentClientRect?.y || 0);\n      bbox.width = clientRect.width;\n      bbox.height = clientRect.height;\n    }\n  }\n  return bbox;\n}\n\nexport function getFontMetrics(fontFamily: string, fontSize: number): any {\n  if (!(fontFamily in fontMetrics)) {\n    fontMetrics[fontFamily] = {};\n  }\n  const familyMetrics = fontMetrics[fontFamily];\n  if (!(fontSize in familyMetrics)) {\n    const a = $(\"<div style='position:absolute;top:0;left:0'>M</div>\");\n    a.css(\"font-family\", fontFamily);\n    a.css(\"font-size\", fontSize);\n    $($(document)[0].body).append(a);\n    familyMetrics[fontSize] = {\n      height: a[0].offsetHeight,\n      size: fontSize,\n    };\n    a.remove();\n  }\n  return familyMetrics[fontSize];\n}\n\nexport function forEachChild(elem: Element, visitor: (child: Element, index: number) => Undefined<boolean>) {\n  const children = elem.children;\n  const L = children.length;\n  for (let i = 0; i < L; i++) {\n    const child = children[i];\n    if (visitor(child, i) == false) return false;\n  }\n}\n\nexport function forEachNode(elem: Element, visitor: (child: ChildNode, index: number) => Undefined<boolean>) {\n  const children = elem.childNodes;\n  const L = children.length;\n  for (let i = 0; i < L; i++) {\n    const child = children[i];\n    if (visitor(child, i) == false) return;\n  }\n}\n\nexport function forEachAttribute(elem: Element, visitor: (name: string, value: any) => Undefined<boolean>) {\n  const nodeNameMap = elem.attributes;\n  for (let i = 0; i < nodeNameMap.length; i++) {\n    const attrib = nodeNameMap[i];\n    if (visitor(attrib.name, attrib.value) == false) return;\n  }\n}\n\n/**\n * Processing of different kinds of attributes.\n */\nexport function parseCSSStyles(value: string) {\n  const out: any = {};\n  if (value && value != null) {\n    const values = value.split(\";\");\n    values.forEach(function (elem) {\n      if (elem.trim().length > 0) {\n        const kvpair = elem.split(\":\");\n        if (kvpair.length >= 2) {\n          const key = kvpair[0].trim();\n          const value = kvpair[1].trim();\n          if (key.length > 0) {\n            out[key] = value;\n          }\n        }\n      }\n    });\n  }\n  return out;\n}\n\nexport function getAttr(elem: Element, attrib: string, ...validators: any) {\n  let value = elem.getAttribute(attrib);\n  for (let i = 0; i < validators.length; i++) {\n    value = validators[i](value);\n  }\n  return value;\n}\n\nexport function ensureAttr(elem: Element, attrib: string) {\n  const value = elem.getAttribute(attrib) || null;\n  if (value == null) {\n    throw new Error(`Element MUST have Attribute: ${attrib}`);\n  }\n  return value;\n}\n\nexport function setAttr(elem: Element, name: string, value: any) {\n  return elem.setAttribute(name, value);\n}\n\nexport function getAttrOrStyle(elem: Element, attribName: string, cssStyles: any, styleName: string) {\n  return elem.getAttribute(attribName) || cssStyles[styleName];\n}\n\nexport function createSVGNode<T extends SVGGraphicsElement>(nodename: string, config?: any): any {\n  config = config || {};\n  config.ns = \"http://www.w3.org/2000/svg\";\n  return createNode(nodename, config) as T;\n}\n\nexport function createNode(nodename: string, config?: any): Element {\n  let out;\n  config = config || {};\n  const ns = config.ns;\n  const doc = config.doc || document;\n  const attrs = config.attrs || {};\n  const text = config.text || \"\";\n  const parent = config.parent || null;\n  if (ns) out = doc.createElementNS(ns, nodename);\n  else out = doc.createElement(nodename);\n  if (parent != null) {\n    parent.appendChild(out);\n  }\n  for (const attr in attrs || {}) {\n    const value = attrs[attr];\n    out.setAttribute(attr, value);\n  }\n  if (text) {\n    out.textContent = text;\n  }\n  return out;\n}\n\n/**\n * Remove a node from its parent.\n */\nexport function removeNode(node: Node): void {\n  node.parentNode?.removeChild(node);\n}\n\nexport function insertAfter(node: Node, ...newNodes: Node[]): boolean {\n  const parentNode = node.parentNode;\n  if (parentNode == null) return false;\n  const nextNode = node.nextSibling;\n  if (nextNode == null) {\n    for (let i = 0; i < newNodes.length; i++) {\n      parentNode.appendChild(newNodes[i]);\n    }\n  } else {\n    for (let i = 0; i < newNodes.length; i++) {\n      parentNode.insertBefore(newNodes[i], nextNode);\n    }\n  }\n  return true;\n}\n\nexport function getCSS(elem: Element, attr: string): any {\n  return (elem as any).style[attr];\n}\n\nexport function setCSS(elem: Element, attr: string, value: any): void {\n  (elem as any).style[attr] = value;\n}\n\nexport function ensureElement(elemOrId: Element | string, root: any = null): Element {\n  if (typeof elemOrId === \"string\") {\n    if (root == null) root = document;\n    return root.querySelector(elemOrId);\n  } else {\n    return elemOrId;\n  }\n}\n\n/*\nexport function setEnabled(elem: Element, enable = true): Element {\n  elem.prop(\"disabled\", !enable);\n  return elem;\n}\n\nexport function setVisible(elem: Element, show = true): Element {\n  if (show) {\n    elem.show();\n  } else {\n    elem.hide();\n  }\n  return elem;\n}\n\nexport function getcssint(elem: JQuery<HTMLElement>, attrib: string): number{\n  return parseInt(elem.css(attrib).replace(/px/, \"\"));\n}\n\nexport function centerElem(elem: JQuery<HTMLElement>, axis: string) {\n  const parent = elem.parent();\n  const horizPadding =\n    getcssint(elem, \"padding-left\") +\n    getcssint(elem, \"padding-right\") +\n    getcssint(elem, \"margin-left\") +\n    getcssint(elem, \"margin-right\") +\n    getcssint(parent, \"border-left\") +\n    getcssint(parent, \"border-right\");\n  const vertPadding =\n    getcssint(elem, \"padding-top\") +\n    getcssint(elem, \"padding-bottom\") +\n    getcssint(elem, \"margin-top\") +\n    getcssint(elem, \"margin-bottom\") +\n    getcssint(parent, \"border-top\") +\n    getcssint(parent, \"border-bottom\");\n  const finalHeight: number = (parent.height() as number) - vertPadding;\n  const finalWidth: number = (parent.width() as number) - horizPadding;\n  if (axis == \"x\") {\n    elem.css(\"left\", (finalWidth - (elem.width() as number)) / 2);\n  } else if (axis == \"y\") {\n    elem.css(\"top\", (finalHeight - (elem.height() as number)) / 2);\n  } else {\n    elem.css(\"left\", (finalWidth - (elem.width() as number)) / 2);\n    elem.css(\"top\", (finalHeight - (elem.height() as number)) / 2);\n  }\n}\n\nexport function fillChildComponent(elem: JQuery<HTMLElement>) {\n  const parent = elem.parent();\n  const horizPadding =\n    getcssint(elem, \"padding-left\") +\n    getcssint(elem, \"padding-right\") +\n    getcssint(elem, \"margin-left\") +\n    getcssint(elem, \"margin-right\") +\n    getcssint(parent, \"border-left\") +\n    getcssint(parent, \"border-right\");\n  const vertPadding =\n    getcssint(elem, \"padding-top\") +\n    getcssint(elem, \"padding-bottom\") +\n    getcssint(elem, \"margin-top\") +\n    getcssint(elem, \"margin-bottom\") +\n    getcssint(parent, \"border-top\") +\n    getcssint(parent, \"border-bottom\");\n  const finalHeight = (parent.height() as number) - vertPadding;\n  const finalWidth = (parent.width() as number) - horizPadding;\n  elem.height(finalHeight);\n  elem.width(finalWidth);\n}\n*/\n","import { Nullable } from \"./types\";\n\nexport function range(start: number, end: Nullable<number> = null, incr: Nullable<number> = 1): number[] {\n  if (end == null) {\n    const absStart = Math.abs(start);\n    const arr = Array.from({ length: absStart });\n    if (start >= 0) {\n      return arr.map((x, i) => i);\n    } else {\n      return arr.map((x, i) => i - (absStart - 1));\n    }\n  }\n  const out: number[] = [];\n  if (incr == null) {\n    incr = 1;\n  }\n  incr = Math.abs(incr);\n  if (start !== end) {\n    if (start < end) {\n      for (let i = start; i <= end; i += incr) {\n        out.push(i);\n      }\n    } else {\n      for (let i = start; i >= end; i -= incr) {\n        out.push(i);\n      }\n    }\n  }\n  return out;\n}\n\nexport function gcdof(x: number, y: number): number {\n  x = Math.abs(x);\n  y = Math.abs(y);\n  while (y > 0) {\n    const t = y;\n    y = x % y;\n    x = t;\n  }\n  return x;\n}\n\nexport class Fraction {\n  readonly num: number;\n  readonly den: number;\n\n  static readonly ZERO = new Fraction();\n  static readonly ONE = new Fraction(1, 1);\n  static readonly INFINITY = new Fraction(1, 0);\n\n  constructor(num = 0, den = 1, factorized = false) {\n    if (isNaN(num) || isNaN(den)) {\n      throw new Error(`Invalid numerator(${num}) or denminator(${den})`);\n    }\n    if (factorized) {\n      const gcd = gcdof(num, den);\n      num /= gcd;\n      den /= gcd;\n    }\n    this.num = num;\n    this.den = den;\n  }\n\n  static parse(val: string, factorized = false): Fraction {\n    const parts = val\n      .trim()\n      .split(\"/\")\n      .map((x) => x.trim());\n    let num = 1;\n    let den = 1;\n    if (parts.length == 1) num = parseInt(parts[0]);\n    else if (parts.length != 2) {\n      throw new Error(\"Invalid fraction string: \" + val);\n    } else {\n      if (parts[0].length > 0) {\n        num = parseInt(parts[0]);\n      }\n      if (parts[1].length > 0) {\n        den = parseInt(parts[1]);\n      }\n    }\n    if (isNaN(num) || isNaN(den)) {\n      throw new Error(\"Invalid fraction string: \" + val);\n    }\n    return new Fraction(num, den, factorized);\n  }\n\n  get isWhole(): boolean {\n    return this.num % this.den == 0;\n  }\n\n  get isZero(): boolean {\n    return this.num == 0;\n  }\n\n  get isInfinity(): boolean {\n    return this.den == 0;\n  }\n\n  get isOne(): boolean {\n    return this.num == this.den;\n  }\n\n  get ceil(): number {\n    if (this.num % this.den == 0) {\n      return this.num / this.den;\n    } else {\n      return 1 + Math.floor(this.num / this.den);\n    }\n  }\n\n  get floor(): number {\n    if (this.num % this.den == 0) {\n      return this.num / this.den;\n    } else {\n      return Math.floor(this.num / this.den);\n    }\n  }\n\n  plus(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den + this.den * another.num, this.den * another.den, factorized);\n  }\n\n  plusNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num + this.den * another, this.den, factorized);\n  }\n\n  minus(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den - this.den * another.num, this.den * another.den, factorized);\n  }\n\n  minusNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num - this.den * another, this.den, factorized);\n  }\n\n  times(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.num, this.den * another.den, factorized);\n  }\n\n  timesNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num * another, this.den, factorized);\n  }\n\n  divby(another: Fraction, factorized = false): Fraction {\n    return new Fraction(this.num * another.den, this.den * another.num, factorized);\n  }\n\n  divbyNum(another: number, factorized = false): Fraction {\n    return new Fraction(this.num, this.den * another, factorized);\n  }\n\n  /**\n   * Returns another / this.\n   */\n  numDivby(another: number, factorized = false): Fraction {\n    return new Fraction(this.den * another, this.num, factorized);\n  }\n\n  /**\n   * Returns this % another\n   */\n  mod(another: Fraction): Fraction {\n    // a (mod b) = a − b ⌊a / b⌋\n    const d = this.divby(another);\n    const floorOfD = Math.floor(d.num / d.den);\n    return this.minus(another.timesNum(floorOfD));\n  }\n\n  /*\n   * Returns this % another\n   */\n  modNum(another: number): Fraction {\n    // a (mod b) = a − b ⌊a / b⌋\n    const d = this.divbyNum(another);\n    const floorOfD = Math.floor(d.num / d.den);\n    return this.minusNum(another * floorOfD);\n  }\n\n  get inverse(): Fraction {\n    return new Fraction(this.den, this.num);\n  }\n\n  get factorized(): Fraction {\n    const gcd = gcdof(this.num, this.den);\n    return new Fraction(this.num / gcd, this.den / gcd);\n  }\n\n  equals(another: Fraction): boolean {\n    return this.num * another.den == this.den * another.num;\n  }\n\n  equalsNum(another: number): boolean {\n    return this.num == this.den * another;\n  }\n\n  cmp(another: Fraction): number {\n    return this.num * another.den - this.den * another.num;\n  }\n\n  cmpNum(another: number): number {\n    return this.num - this.den * another;\n  }\n\n  isLT(another: Fraction): boolean {\n    return this.cmp(another) < 0;\n  }\n\n  isLTE(another: Fraction): boolean {\n    return this.cmp(another) <= 0;\n  }\n\n  isLTNum(another: number): boolean {\n    return this.cmpNum(another) < 0;\n  }\n\n  isLTENum(another: number): boolean {\n    return this.cmpNum(another) <= 0;\n  }\n\n  isGT(another: Fraction): boolean {\n    return this.cmp(another) > 0;\n  }\n\n  isGTE(another: Fraction): boolean {\n    return this.cmp(another) >= 0;\n  }\n\n  isGTNum(another: number): boolean {\n    return this.cmpNum(another) > 0;\n  }\n\n  isGTENum(another: number): boolean {\n    return this.cmpNum(another) >= 0;\n  }\n\n  toString(): string {\n    return this.num + \"/\" + this.den;\n  }\n\n  static max(f1: Fraction, f2: Fraction): Fraction {\n    return f1.cmp(f2) > 0 ? f1 : f2;\n  }\n\n  static min(f1: Fraction, f2: Fraction): Fraction {\n    return f1.cmp(f2) < 0 ? f1 : f2;\n  }\n}\n\n// Shortcut helper\nexport const Frac = (a = 0, b = 1, factorized = false): Fraction => new Fraction(a, b, factorized);\n","import * as TSU from \"@panyam/tsutils\";\nimport { Entity, TimedEntity } from \"./entity\";\n\n/**\n * Alias to TSU.Num.Fraction in tsutils.\n */\ntype Fraction = TSU.Num.Fraction;\nexport type CyclePosition = [number, number, number];\nexport type CycleIterator = Generator<[CyclePosition, Fraction]>;\n\nconst ZERO = TSU.Num.Fraction.ZERO;\nconst ONE = TSU.Num.Fraction.ONE;\n\n/**\n * A cursor that traverses through a Cycle's beats in a controlled manner.\n * Allows forward and backward navigation through the cycle.\n */\nexport class CycleCursor {\n  /**\n   * Creates a new CycleCursor.\n   * @param cycle The Cycle to traverse\n   * @param barIndex The starting bar index, defaults to 0\n   * @param beatIndex The starting beat index within the bar, defaults to 0\n   * @param instance The starting instance index within the beat, defaults to 0\n   */\n  constructor(\n    public readonly cycle: Cycle,\n    public barIndex = 0,\n    public beatIndex = 0,\n    public instance = 0,\n  ) {}\n\n  /**\n   * Advances the cursor to the next beat and returns the current position and beat length.\n   * @returns A tuple containing the current position and beat length\n   */\n  get next(): [CyclePosition, Fraction] {\n    const currBar = this.cycle.bars[this.barIndex];\n    const result: [CyclePosition, Fraction] = [\n      [this.barIndex, this.beatIndex, this.instance],\n      currBar.beatLengths[this.beatIndex],\n    ];\n    this.instance++;\n    if (!currBar.beatCounts[this.beatIndex] || this.instance >= currBar.beatCounts[this.beatIndex]) {\n      this.instance = 0;\n      this.beatIndex++;\n      if (this.beatIndex >= currBar.beatLengths.length) {\n        this.beatIndex = 0;\n        this.barIndex++;\n        if (this.barIndex >= this.cycle.bars.length) {\n          this.barIndex = 0;\n        }\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Moves the cursor to the previous beat and returns the current position and beat length.\n   * @returns A tuple containing the current position and beat length\n   */\n  get prev(): [CyclePosition, Fraction] {\n    const currBar = this.cycle.bars[this.barIndex];\n    const result: [CyclePosition, Fraction] = [\n      [this.barIndex, this.beatIndex, this.instance],\n      currBar.beatLengths[this.beatIndex],\n    ];\n    // TODO - result should be set *after* decrementing if we had already\n    // done a \"next\" before this otherwise user may have to do a prev twice\n    this.instance--;\n    if (this.instance < 0) {\n      this.beatIndex--;\n      if (this.beatIndex < 0) {\n        this.barIndex--;\n        if (this.barIndex < 0) {\n          this.barIndex = this.cycle.bars.length - 1;\n        }\n        this.beatIndex = this.cycle.bars[this.barIndex].beatCount - 1;\n      }\n      this.instance = (this.cycle.bars[this.barIndex].beatCounts[this.beatIndex] || 1) - 1;\n    }\n    return result;\n  }\n}\n\n/**\n * Represents a bar in a musical cycle.\n * A bar consists of beats with specific lengths and counts.\n */\nexport class Bar extends TimedEntity {\n  readonly TYPE: string = \"Bar\";\n\n  /** Name of the bar (e.g., \"Laghu\", \"Dhrutam\") */\n  name: string;\n\n  /** Length/Duration of each beat in the bar */\n  beatLengths: Fraction[] = [];\n\n  /** How many times each beat should be repeated (the Kalai) */\n  beatCounts: number[] = [];\n\n  /**\n   * Creates a new Bar.\n   * @param config Configuration object containing name, beatLengths, and beatCounts\n   */\n  constructor(config: any = null) {\n    super((config = config || {}));\n    this.name = config.name || \"\";\n    for (const bl of config.beatLengths || []) {\n      if (typeof bl === \"number\") {\n        this.beatLengths.push(TSU.Num.Frac(bl));\n      } else {\n        this.beatLengths.push(bl);\n      }\n    }\n    for (const bc of config.beatCounts || []) {\n      this.beatCounts.push(bc);\n    }\n    while (this.beatCounts.length < this.beatLengths.length) {\n      this.beatCounts.push(1);\n    }\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Bar.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), name: name, beatLengths: this.beatLengths };\n  }\n\n  /**\n   * Checks if this Bar is equal to another Bar.\n   * @param another The Bar to compare with\n   * @returns True if the Bars are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    if (!super.equals(another)) return false;\n    if (this.beatLengths.length != another.beatLengths.length) return false;\n    if (this.beatCounts.length != another.beatCounts.length) return false;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      if (!this.beatLengths[i].equals(another.beatLengths[i])) return false;\n    }\n    for (let i = 0; i < this.beatCounts.length; i++) {\n      if (this.beatCounts[i] != another.beatCounts[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Copies the properties of this Bar to another Bar.\n   * @param another The target Bar to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.name = this.name;\n    another.beatLengths = [...this.beatLengths];\n    another.beatCounts = [...this.beatCounts];\n  }\n\n  /**\n   * Gets the instance count for a specific beat in the bar.\n   * @param beatIndex The index of the beat\n   * @returns The number of instances for the specified beat\n   */\n  instanceCount(beatIndex: number): number {\n    if (beatIndex > this.beatCounts.length) {\n      // by default each beat has 1 instance?\n      return 1;\n    } else {\n      return this.beatCounts[beatIndex];\n    }\n  }\n\n  /**\n   * Gets the number of unique beats in this bar (irrespective of instances).\n   */\n  get beatCount(): number {\n    return this.beatLengths.length;\n  }\n\n  /**\n   * Gets the total number of beat instances in this bar.\n   */\n  get totalBeatCount(): number {\n    let out = 0;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      out += this.beatCounts[i] || 1;\n    }\n    return out;\n  }\n\n  /**\n   * Gets the total duration of time across all beats in this bar.\n   */\n  get duration(): Fraction {\n    let total = ZERO;\n    for (let i = 0; i < this.beatLengths.length; i++) {\n      total = total.plus(this.beatLengths[i].timesNum(this.beatCounts[i] || 1));\n    }\n    return total;\n  }\n}\n\n/**\n * Represents a complete rhythmic cycle pattern composed of bars.\n * In carnatic music, this typically represents a tala.\n */\nexport class Cycle extends TimedEntity {\n  readonly TYPE: string = \"Cycle\";\n\n  /** Name of the cycle (e.g., \"Adi Thalam\") */\n  name: string;\n\n  /** The bars that make up this cycle */\n  bars: Bar[];\n\n  /**\n   * Default cycle representing Adi Thalam (4+2+2 structure).\n   */\n  static readonly DEFAULT = new Cycle({\n    name: \"Adi Thalam\",\n    bars: [\n      new Bar({ name: \"Laghu\", beatLengths: [1, 1, 1, 1] }),\n      new Bar({ name: \"Dhrutam\", beatLengths: [1, 1] }),\n      new Bar({ name: \"Dhrutam\", beatLengths: [1, 1] }),\n    ],\n  });\n\n  /**\n   * Creates a new Cycle.\n   * @param config Configuration object containing name and bars\n   */\n  constructor(config: null | { name?: string; bars?: Bar[] } = null) {\n    super((config = config || {}));\n    this.name = config.name || \"\";\n    this.bars = config.bars || [];\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Cycle.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), name: name, bars: this.bars.map((p) => p.debugValue()) };\n  }\n\n  /**\n   * Gets all child entities of this Cycle.\n   * @returns An array of child entities (bars)\n   */\n  children(): Entity[] {\n    return this.bars;\n  }\n\n  /**\n   * Checks if this Cycle is equal to another Cycle.\n   * @param another The Cycle to compare with\n   * @returns True if the Cycles are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    if (!super.equals(another)) {\n      return false;\n    }\n    if (this.bars.length != another.bars.length) return false;\n    for (let i = 0; i < this.bars.length; i++) {\n      if (!this.bars[i].equals(another.bars[i])) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Given a global beat index, returns the position within the cycle.\n   *\n   * @param globalIndex The global beat index\n   * @returns A tuple containing [cycle number, position, start offset]\n   *         - cycle: The nth cycle in which the beat lies\n   *         - position: [barIndex, beatIndex, instance] within the cycle\n   *         - startOffset: Offset of the beat at this global index\n   */\n  getAtIndex(globalIndex: number): [number, CyclePosition, Fraction] {\n    let cycle = 0;\n    while (globalIndex < 0) {\n      globalIndex += this.totalBeatCount;\n      cycle--;\n    }\n    if (globalIndex >= this.totalBeatCount) {\n      cycle = Math.floor(globalIndex / this.totalBeatCount);\n    }\n    globalIndex = globalIndex % this.totalBeatCount;\n    let offset = ZERO;\n    for (let barIndex = 0; barIndex < this.bars.length; barIndex++) {\n      const bar = this.bars[barIndex];\n      if (globalIndex >= bar.totalBeatCount) {\n        globalIndex -= bar.totalBeatCount;\n        offset = offset.plus(bar.duration);\n      } else {\n        // this is the bar!\n        for (let beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {\n          const beatLength = bar.beatLengths[beatIndex];\n          const beatCount = bar.beatCounts[beatIndex] || 1;\n          if (globalIndex >= beatCount) {\n            globalIndex -= beatCount;\n            offset = offset.plus(beatLength.timesNum(beatCount));\n          } else {\n            // this is it\n            const instance = globalIndex;\n            return [cycle, [barIndex, beatIndex, instance], offset.plus(beatLength.timesNum(instance))];\n          }\n        }\n      }\n    }\n    throw new Error(\"Should not be here!\");\n  }\n\n  /**\n   * Given a global offset, returns the position within the cycle.\n   *\n   * @param globalOffset The global time offset\n   * @returns A tuple containing [cycle number, position, note offset, global index]\n   *         - cycle: The nth cycle in which the offset lies\n   *         - position: [barIndex, beatIndex, instance] within the cycle\n   *         - startOffset: The note offset within the beat\n   *         - globalIndex: The beat index within the entire cycle\n   */\n  getPosition(globalOffset: Fraction): [number, CyclePosition, Fraction, number] {\n    const duration = this.duration;\n    let cycleNum = 0;\n    if (globalOffset.isLT(ZERO)) {\n      while (globalOffset.isLT(ZERO)) {\n        cycleNum--;\n        globalOffset = globalOffset.plus(duration);\n      }\n    } else if (globalOffset.isGTE(duration)) {\n      const realOffset = globalOffset.mod(duration);\n      globalOffset = globalOffset.minus(realOffset).divby(duration);\n      TSU.assert(globalOffset.isWhole);\n      cycleNum = globalOffset.floor;\n      globalOffset = realOffset;\n    }\n\n    // here globalOffset is positive and >= 0 and < this.duration\n    let globalIndex = 0;\n    for (let barIndex = 0; barIndex < this.bars.length; barIndex++) {\n      const bar = this.bars[barIndex];\n      const barDuration = bar.duration;\n      if (globalOffset.isGTE(barDuration)) {\n        globalOffset = globalOffset.minus(barDuration);\n      } else {\n        // this is the bar!\n        for (let beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {\n          const beatLength = bar.beatLengths[beatIndex];\n          const beatCount = bar.beatCounts[beatIndex] || 1;\n          for (let instance = 0; instance < beatCount; instance++, globalIndex++) {\n            if (globalOffset.isGTE(beatLength)) {\n              globalOffset = globalOffset.minus(beatLength);\n            } else {\n              // this is it\n              return [cycleNum, [barIndex, beatIndex, instance], globalOffset, globalIndex];\n            }\n          }\n        }\n      }\n      globalIndex += bar.totalBeatCount;\n    }\n\n    throw new Error(\"Should not be here!\");\n  }\n\n  /**\n   * Creates an iterator that yields beats in sequence from a starting position.\n   *\n   * @param startBar The starting bar index, defaults to 0\n   * @param startBeat The starting beat index, defaults to 0\n   * @param startInstance The starting instance index, defaults to 0\n   * @returns A generator that yields [position, beat length] pairs\n   */\n  *iterateBeats(startBar = 0, startBeat = 0, startInstance = 0): CycleIterator {\n    let barIndex = startBar;\n    let beatIndex = startBeat;\n    let instanceIndex = startInstance;\n    while (true) {\n      const currBar = this.bars[barIndex];\n      yield [[barIndex, beatIndex, instanceIndex], currBar.beatLengths[beatIndex]];\n      instanceIndex++;\n      if (!currBar.beatCounts[beatIndex] || instanceIndex >= currBar.beatCounts[beatIndex]) {\n        instanceIndex = 0;\n        beatIndex++;\n        if (beatIndex >= currBar.beatLengths.length) {\n          beatIndex = 0;\n          barIndex++;\n          if (barIndex >= this.bars.length) {\n            barIndex = 0;\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Copies the properties of this Cycle to another Cycle.\n   * @param another The target Cycle to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.name = this.name;\n    another.bars = this.bars.map((x) => x.clone());\n  }\n\n  /**\n   * Gets the number of unique beats in this cycle (irrespective of instances).\n   */\n  get beatCount(): number {\n    let out = 0;\n    for (const bar of this.bars) out += bar.beatCount;\n    return out;\n  }\n\n  /**\n   * Gets the total number of beat instances in this cycle.\n   */\n  get totalBeatCount(): number {\n    let out = 0;\n    for (const bar of this.bars) out += bar.totalBeatCount;\n    return out;\n  }\n\n  /**\n   * Gets the total duration of time across all bars in this cycle.\n   */\n  get duration(): Fraction {\n    return this.bars.reduce((x, y) => x.plus(y.duration), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Entity, TimedEntity } from \"./entity\";\nimport { LayoutParams } from \"./layouts\";\nimport { AtomChangeType, GroupObserver, RoleObserver, LineObserver } from \"./events\";\n\n/**\n * Alias to TSU.Num.Fraction in tsutils.\n */\ntype Fraction = TSU.Num.Fraction;\nexport const ZERO = TSU.Num.Fraction.ZERO;\nexport const ONE = TSU.Num.Fraction.ONE;\n\n/**\n * AtomType enums are used to denote specific Atoms\n * Each type represents a specific musical or notational element.\n * @enum\n */\nexport enum AtomType {\n  NOTE = \"Note\",\n  LITERAL = \"Literal\",\n  SYLLABLE = \"Syllable\",\n  SPACE = \"Space\",\n  GROUP = \"Group\",\n  LABEL = \"Label\",\n  REST = \"Rest\",\n  MARKER = \"Marker\",\n}\n\n/**\n * Atoms are the base class for all timed entities that can appear in a Notation.\n * An Atom represents the fundamental building block of the notation system.\n */\nexport abstract class Atom extends TimedEntity {\n  readonly TYPE: string = \"Atom\";\n\n  protected _duration: Fraction;\n  /** Markers to be displayed before this atom */\n  markersBefore: Marker[];\n  /** Markers to be displayed after this atom */\n  markersAfter: Marker[];\n  /** Next atom in the sequence */\n  nextSibling: TSU.Nullable<Atom> = null;\n  /** Previous atom in the sequence */\n  prevSibling: TSU.Nullable<Atom> = null;\n  /** The Group this Atom belongs to, if any */\n  parentGroup: TSU.Nullable<Group> = null;\n\n  /** Indicates if this Atom is a continuation from a previous atom */\n  isContinuation = false;\n\n  /**\n   * Creates a new Atom with the specified duration.\n   * @param duration The duration of the atom, defaults to ONE (1/1)\n   */\n  constructor(duration = ONE) {\n    super();\n    this._duration = duration || ONE;\n  }\n\n  /**\n   * Splits this atom at the specified duration.\n   * @param requiredDuration The duration at which to split the atom\n   * @returns A new atom representing the portion beyond the split point, or null if no split is needed\n   */\n  abstract splitAt(requiredDuration: Fraction): TSU.Nullable<Atom>;\n\n  /**\n   * Returns a debug-friendly representation of this Atom.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = super.debugValue();\n    if (!this.duration.isOne) {\n      out.duration = this.duration.factorized.toString();\n    }\n    if (this.isContinuation) {\n      out.isContinuation = true;\n    }\n    if ((this.markersBefore || []).length > 0) {\n      out.mbef = this.markersBefore.map((m) => m.debugValue());\n    }\n    if ((this.markersAfter || []).length > 0) {\n      out.maft = this.markersAfter.map((m) => m.debugValue());\n    }\n    return out;\n  }\n\n  /**\n   * Copies the properties of this atom to another atom.\n   * @param another The target atom to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another._duration = new TSU.Num.Fraction(this.duration.num, this.duration.den);\n  }\n\n  /**\n   * Gets the duration of this atom.\n   */\n  get duration(): Fraction {\n    return this._duration;\n  }\n\n  /**\n   * Sets the duration of this atom.\n   */\n  set duration(d: Fraction) {\n    this._duration = d;\n  }\n}\n\n/**\n * Base class for atoms that cannot contain other atoms.\n * LeafAtom represents atomic elements that can't be further subdivided.\n */\nexport abstract class LeafAtom extends Atom {\n  readonly TYPE: string = \"LeafAtom\";\n\n  /** Indicates if this atom is followed by a rest */\n  beforeRest = false;\n\n  /**\n   * Splits this atom at a certain duration.\n   * If this atom's duration is longer than the given duration, it's truncated\n   * to the given duration and a continuation space is returned.\n   *\n   * @param duration The duration at which to split the atom\n   * @returns A new Space atom representing the spillover if needed, otherwise null\n   */\n  splitAt(duration: Fraction): TSU.Nullable<Atom> {\n    if (this.duration.cmp(duration) > 0) {\n      const spillOver = this.createSpilloverSpace(this.duration.minus(duration));\n      spillOver.isContinuation = true;\n      this.duration = duration;\n      // TODO - Here we need to move the markersAfter to the spill-over as it doesnt belong to this any more\n      return spillOver;\n    }\n    return null;\n  }\n\n  /**\n   * Creates a Space atom to represent spillover duration when splitting.\n   * @param duration The duration of the spillover\n   * @returns A new Space atom\n   */\n  protected createSpilloverSpace(duration: Fraction): Space {\n    return new Space(duration);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this LeafAtom.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return this.beforeRest ? { ...super.debugValue(), beforeRest: true } : super.debugValue();\n  }\n}\n\n/**\n * Represents a marker or annotation in the notation.\n * Markers can be placed before or after atoms to provide additional context.\n */\nexport class Marker extends Entity {\n  readonly TYPE = \"Marker\";\n\n  /**\n   * Creates a new Marker with the specified text.\n   * @param text The text content of the marker\n   * @param isBefore Whether the marker should appear before (true) or after (false) its associated atom\n   */\n  constructor(\n    public text: string,\n    public isBefore = true,\n  ) {\n    super();\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Marker.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), text: this.text, before: this.isBefore };\n  }\n\n  /**\n   * Returns a string representation of this Marker.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Marker(${this.text}-${this.isBefore})`;\n  }\n}\n\n/**\n * Represents a rest (silence) in the notation.\n * Rests are zero-length atoms that indicate a pause.\n */\nexport class Rest extends LeafAtom {\n  readonly TYPE = \"Rest\";\n\n  /**\n   * Creates a new Rest.\n   * Rests are zero length by default.\n   */\n  constructor() {\n    super(ZERO);\n  }\n}\n\n/**\n * Represents a space or silence in the notation.\n * Spaces can be used to denote either silence or continuations of previous notes.\n */\nexport class Space extends LeafAtom {\n  readonly TYPE = \"Space\";\n\n  /**\n   * Indicates whether this is a silent space or a continuation of the previous note.\n   */\n  isSilent = false;\n\n  /**\n   * Creates a new Space with the specified duration and silence property.\n   * @param duration The duration of the space, defaults to ONE (1/1)\n   * @param isSilent Whether the space represents silence (true) or a continuation (false)\n   */\n  constructor(duration = ONE, isSilent = false) {\n    super(duration);\n    this.isSilent = isSilent;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Space.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { ...super.debugValue(), isSilent: this.isSilent };\n  }\n\n  /**\n   * Returns a string representation of this Space.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Space(${this.duration}-${this.isSilent})`;\n  }\n\n  /**\n   * Copies the properties of this Space to another Space.\n   * @param another The target Space to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.isSilent = this.isSilent;\n  }\n\n  /**\n   * Checks if this Space is equal to another Space.\n   * @param another The Space to compare with\n   * @returns True if the Spaces are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.isSilent == another.isSilent;\n  }\n\n  /**\n   * Creates a Space atom to represent spillover duration when splitting.\n   * @param duration The duration of the spillover\n   * @returns A new Space atom with the same silence property as this Space\n   */\n  protected createSpilloverSpace(duration: Fraction): Space {\n    const out = super.createSpilloverSpace(duration);\n    out.isSilent = this.isSilent;\n    return out;\n  }\n}\n\n/**\n * Represents a literal value in the notation.\n * Literals are the basic building blocks for notes and syllables.\n */\nexport class Literal extends LeafAtom {\n  readonly TYPE: string = \"Literal\";\n\n  /**\n   * The embellishments applied to this Literal.\n   */\n  embelishments: any[] = [];\n\n  /**\n   * Creates a new Literal with the specified value and duration.\n   * @param value The string value of the literal\n   * @param duration The duration of the literal, defaults to ONE (1/1)\n   */\n  constructor(\n    public value: string,\n    duration = ONE,\n  ) {\n    super(duration);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Literal.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue(), value: this.value };\n    if (this.embelishments.length > 0) {\n      out.embs = this.embelishments.map((e) => (\"debugValue\" in e ? e.debugValue() : e));\n    }\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Literal.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Lit(${this.duration}-${this.value})`;\n  }\n\n  /**\n   * Checks if this Literal is equal to another Literal.\n   * @param another The Literal to compare with\n   * @returns True if the Literals are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.value == another.value;\n  }\n\n  /**\n   * Copies the properties of this Literal to another Literal.\n   * @param another The target Literal to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.value = this.value;\n  }\n}\n\n/**\n * Represents a syllable in lyrics or text to be sung.\n * Extends Literal to provide specialized handling for sung text.\n */\nexport class Syllable extends Literal {\n  readonly TYPE = \"Syllable\";\n\n  /**\n   * Creates a Syllable from a Literal.\n   * @param lit The Literal to convert to a Syllable\n   * @returns A new Syllable with the properties of the Literal\n   */\n  static fromLit(lit: Literal): Syllable {\n    if (lit.TYPE == AtomType.SYLLABLE) return lit as Syllable;\n    const out = new Syllable(lit.value, lit.duration);\n    out.embelishments = lit.embelishments;\n    out.beforeRest = lit.beforeRest;\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Syllable.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Syll(${this.duration}-${this.value})`;\n  }\n}\n\n/**\n * Represents a musical note in the notation.\n * Extends Literal to add properties specific to musical notes.\n */\nexport class Note extends Literal {\n  readonly TYPE = \"Note\";\n\n  /**\n   * Which octave the note is in. Can be positive or negative to indicate higher or lower octaves.\n   */\n  octave = 0;\n\n  /**\n   * How the note is shifted - i.e., shifted towards major or minor by # of semi-tones.\n   */\n  shift: number | boolean = 0;\n\n  /**\n   * Creates a new Note with the specified properties.\n   * @param value The string value of the note\n   * @param duration The duration of the note, defaults to ONE (1/1)\n   * @param octave The octave of the note, defaults to 0\n   * @param shift The shift of the note, defaults to 0\n   */\n  constructor(value: string, duration = ONE, octave = 0, shift = 0) {\n    super(value, duration);\n    this.octave = octave;\n    this.shift = shift;\n  }\n\n  /**\n   * Creates a Note from a Literal.\n   * @param lit The Literal to convert to a Note\n   * @returns A new Note with the properties of the Literal\n   */\n  static fromLit(lit: Literal): Note {\n    if (lit.TYPE == AtomType.NOTE) return lit as Note;\n    const out = new Note(lit.value, lit.duration);\n    out.embelishments = lit.embelishments;\n    out.beforeRest = lit.beforeRest;\n    return out;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Note.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue() };\n    if (this.octave != 0) out.octave = this.octave;\n    if (this.shift != 0) out.shift = this.shift;\n    return out;\n  }\n\n  /**\n   * Returns a string representation of this Note.\n   * @returns A string representation\n   */\n  toString(): string {\n    return `Note(${this.duration}-${this.value}-${this.octave})`;\n  }\n\n  /**\n   * Checks if this Note is equal to another Note.\n   * @param another The Note to compare with\n   * @returns True if the Notes are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return super.equals(another) && this.octave == another.octave && this.shift == another.shift;\n  }\n\n  /**\n   * Copies the properties of this Note to another Note.\n   * @param another The target Note to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.octave = this.octave;\n    another.shift = this.shift;\n  }\n}\n\n/**\n * Represents a group of atoms that are treated as a single unit.\n * Groups can contain any number of atoms, including other groups.\n */\nexport class Group extends Atom {\n  readonly TYPE = \"Group\";\n\n  /**\n   * Indicates whether the duration is static or linear to the number of atoms in this group.\n   * When true, the duration is used as a multiplier for the total child duration.\n   * When false, the duration is absolute.\n   */\n  durationIsSpeedMultiplier = false;\n\n  /**\n   * The list of atoms in this group.\n   */\n  readonly atoms = new TSU.Lists.ValueList<Atom>();\n\n  /**\n   * Observers that receive notifications when atoms change.\n   */\n  private _observers: GroupObserver<Atom, Group>[] = [];\n\n  /**\n   * Creates a new Group containing the specified atoms.\n   * @param atoms The atoms to include in this group\n   */\n  constructor(...atoms: Atom[]) {\n    super(atoms.length == 0 ? ZERO : ONE);\n    this.addAtoms(false, ...atoms);\n  }\n\n  /**\n   * Adds an observer to receive atom change notifications.\n   * @param observer The observer to add\n   * @returns A function to remove the observer\n   */\n  addObserver(observer: GroupObserver<Atom, Group>): () => void {\n    this._observers.push(observer);\n    return () => this.removeObserver(observer);\n  }\n\n  /**\n   * Removes an observer.\n   * @param observer The observer to remove\n   */\n  removeObserver(observer: GroupObserver<Atom, Group>): void {\n    const index = this._observers.indexOf(observer);\n    if (index >= 0) {\n      this._observers.splice(index, 1);\n    }\n  }\n\n  /**\n   * Notifies observers of atom changes.\n   */\n  private notifyObservers(type: AtomChangeType, atoms: Atom[], index: number): void {\n    if (!this._eventsEnabled) return;\n    for (const observer of this._observers) {\n      switch (type) {\n        case AtomChangeType.ADD:\n          observer.onAtomsAdded?.(this, atoms, index);\n          break;\n        case AtomChangeType.INSERT:\n          observer.onAtomsInserted?.(this, atoms, index);\n          break;\n        case AtomChangeType.REMOVE:\n          observer.onAtomsRemoved?.(this, atoms);\n          break;\n      }\n    }\n  }\n\n  /**\n   * Checks if this Group is equal to another Group.\n   * @param another The Group to compare with\n   * @param expect Optional parameter\n   * @returns True if the Groups are equal, false otherwise\n   */\n  equals(another: this, expect = false): boolean {\n    if (!super.equals(another)) return false;\n    return this.atoms.equals(another.atoms, (a1, a2) => a1.equals(a2));\n  }\n\n  /**\n   * Copies the properties of this Group to another Group.\n   * @param another The target Group to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.durationIsSpeedMultiplier = this.durationIsSpeedMultiplier;\n    for (const atom of this.atoms.values()) {\n      another.atoms.add(atom.clone());\n    }\n  }\n\n  /**\n   * Gets the duration of this group.\n   * If durationIsSpeedMultiplier is true, returns the total child duration divided by the multiplier.\n   * Otherwise, returns the absolute duration.\n   */\n  get duration(): Fraction {\n    if (this.durationIsSpeedMultiplier) {\n      return this.totalChildDuration.divby(this._duration);\n    } else {\n      return this._duration;\n    }\n  }\n\n  /**\n   * Sets this group to use a multiplier for duration calculations.\n   * @param asSpeedMultiplier Whether to use the duration as a speed multiplier.  Eg If our duration was 2 and this was\n   *                          set then since the speed is doubled - then the actual duration is halved.\n   * @returns This Group instance for method chaining\n   */\n  setDurationAsMultiplier(asSpeedMultiplier = true): this {\n    this.durationIsSpeedMultiplier = asSpeedMultiplier;\n    return this;\n  }\n\n  /**\n   * Sets the duration of this group.\n   * @param d The new duration\n   * @param asSpeedMultiplier Whether to use the duration as a speed multiplier.  Eg If our duration was 2 and this was\n   *                          set then since the speed is doubled - then the actual duration is halved.\n   * @returns This Group instance for method chaining\n   */\n  setDuration(d: Fraction, asSpeedMultiplier = false): this {\n    this._duration = d;\n    this.durationIsSpeedMultiplier = asSpeedMultiplier;\n    return this;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Group.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = { ...super.debugValue(), atoms: Array.from(this.atoms.values(), (a) => a.debugValue()) };\n    if (this.durationIsSpeedMultiplier) out.durationIsSpeedMultiplier = true;\n    return out;\n  }\n\n  /**\n   * Splits this group into two parts.\n   * The first part (this group) fits within the given duration and everything else\n   * longer than the given duration is returned as a new Group.\n   *\n   * @param requiredDuration The duration at which to split the group\n   * @returns A new Group containing the atoms beyond the split point, or null if no split is needed\n   */\n  splitAt(requiredDuration: Fraction): TSU.Nullable<Group> {\n    if (this.duration.isLTE(requiredDuration) || requiredDuration.isLTE(ZERO)) {\n      return null;\n    }\n    const targetGroup = new Group();\n    if (this.durationIsSpeedMultiplier) {\n      targetGroup.durationIsSpeedMultiplier = true;\n      targetGroup._duration = this._duration;\n    }\n\n    let remainingDur = this.duration;\n    const totalChildDuration = this.totalChildDuration;\n    const durationFactor = this.durationIsSpeedMultiplier\n      ? ONE.divby(this._duration)\n      : this._duration.divby(totalChildDuration, true);\n    while (remainingDur.isGT(requiredDuration) && this.atoms.last) {\n      const lastChild = this.atoms.last;\n      // Child's duration is absolute in its own \"system\"\n      // Its duration within the parent (this) group's frame of reference depends\n      // on whether the parent's duration is absolute or as a multiplier\n      //\n      // realChildDuration = case (group.durationIsMultiper) {\n      //  | true  => child.duration / this._duration\n      //  | false => child.duration * this._duration / total child duration\n      //  }\n      const childDuration = lastChild.duration.times(durationFactor);\n      const newDuration = remainingDur.minus(childDuration);\n      if (newDuration.isGTE(requiredDuration)) {\n        // remove ourselves and add to target\n        // in both cases duration will be adjusted if need be\n        this.removeAtoms(true, lastChild);\n        targetGroup.insertAtomsAt(targetGroup.atoms.first, true, lastChild);\n        if (newDuration.equals(requiredDuration)) {\n          // we have reached the end so return\n          return targetGroup;\n        }\n      } else {\n        // our scenario is now this:\n        //\n        // totalParentDuration = 10\n        // required = 8\n        // lastChildDuration (relative to parent) is 5\n        //\n        // durWithoutLast = 10 - 5\n        // newRequired = requiredDur - durWithoutLast = 3\n        //\n        // However 3 is a duration in the parent's frame of reference\n        // this has to be converted back to the child's FoR\n        const newRequiredDur = requiredDuration.minus(newDuration, true).divby(durationFactor, true);\n        // console.log( \"newRequiredDur: \", newRequiredDur, \"requiedDur: \", requiredDuration, \"remainingDur: \", remainingDur,);\n        // then the last item needs to be split, and by how much?\n        const spillOver = lastChild.splitAt(newRequiredDur);\n        if (spillOver == null) {\n          throw new Error(\"Spill over cannot be null here\");\n        }\n        if (!this.durationIsSpeedMultiplier) {\n          // Our own duration has also now changed\n          this._duration = requiredDuration;\n        } else {\n          if (this._duration.isZero) throw new Error(\"How can this be?\");\n        }\n        spillOver.isContinuation = true;\n        // Add spill over to the target\n        targetGroup.insertAtomsAt(targetGroup.atoms.first, true, spillOver);\n        return targetGroup;\n      }\n      remainingDur = newDuration;\n    }\n    return targetGroup;\n  }\n\n  /**\n   * Gets the total duration of all child atoms.\n   * @returns The sum of durations of all atoms in this group\n   */\n  get totalChildDuration(): Fraction {\n    let out = ZERO;\n    for (const atom of this.atoms.values()) {\n      out = out.plus(atom.duration);\n    }\n    return out;\n  }\n\n  /**\n   * Inserts atoms before a given cursor atom.\n   * If the cursor atom is null, the atoms are appended at the end.\n   *\n   * @param beforeAtom The atom before which to insert the new atoms, or null to append\n   * @param adjustDuration Whether to adjust this group's duration based on the new atoms\n   * @param atoms The atoms to insert\n   * @returns This Group instance for method chaining\n   */\n  insertAtomsAt(beforeAtom: TSU.Nullable<Atom>, adjustDuration = false, ...atoms: Atom[]): this {\n    adjustDuration = adjustDuration && !this.durationIsSpeedMultiplier;\n    const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;\n\n    // Calculate insertion index for event notification\n    let insertIndex: number;\n    if (beforeAtom) {\n      // Find index of beforeAtom using for loop\n      insertIndex = 0;\n      for (const a of this.atoms.values()) {\n        if (a === beforeAtom) break;\n        insertIndex++;\n      }\n    } else {\n      // Appending to end - use size property\n      insertIndex = this.atoms.size;\n    }\n\n    // Track which atoms were actually added (excluding REST atoms)\n    const addedAtoms: Atom[] = [];\n\n    // First form a chain of the given atoms\n    for (const atom of atoms) {\n      if (atom.parentGroup != null) {\n        if (atom.parentGroup != this) {\n          throw new Error(\"Atom belongs to another parent. Remove it first\");\n        }\n        atom.parentGroup.removeAtoms(false, atom);\n      }\n      if (atom.TYPE == AtomType.REST) {\n        const last = this.atoms.last;\n        if (last && last.TYPE != AtomType.GROUP && last.TYPE != AtomType.LABEL) {\n          (last as LeafAtom).beforeRest = true;\n        }\n      } else {\n        atom.parentGroup = this;\n        this.atoms.add(atom, beforeAtom);\n        addedAtoms.push(atom);\n      }\n    }\n    if (adjustDuration) {\n      if (this._duration.isZero) {\n        if (this.durationIsSpeedMultiplier) throw new Error(\"How can this be?\");\n        this._duration = this.totalChildDuration;\n      } else {\n        const scaleFactor = this.totalChildDuration.divby(oldChildDuration);\n        this._duration = this._duration.times(scaleFactor, true);\n      }\n    }\n\n    // Notify observers if atoms were added\n    if (addedAtoms.length > 0) {\n      const type = beforeAtom ? AtomChangeType.INSERT : AtomChangeType.ADD;\n      this.notifyObservers(type, addedAtoms, insertIndex);\n    }\n\n    return this;\n  }\n\n  /**\n   * Adds atoms to the end of this group's atom list.\n   *\n   * @param adjustDuration Whether to adjust this group's duration based on the new atoms\n   * @param atoms The atoms to add\n   * @returns This Group instance for method chaining\n   */\n  addAtoms(adjustDuration = false, ...atoms: Atom[]): this {\n    return this.insertAtomsAt(null, adjustDuration, ...atoms);\n  }\n\n  /**\n   * Removes atoms from this group's child list.\n   *\n   * @param adjustDuration Whether to adjust this group's duration after removing atoms\n   * @param atoms The atoms to remove\n   * @returns This Group instance for method chaining\n   */\n  removeAtoms(adjustDuration = false, ...atoms: Atom[]): this {\n    adjustDuration = adjustDuration && !this.durationIsSpeedMultiplier;\n    const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;\n\n    // Track which atoms were actually removed\n    const removedAtoms: Atom[] = [];\n\n    for (const atom of atoms) {\n      if (atom.parentGroup == this) {\n        this.atoms.remove(atom);\n        atom.parentGroup = null;\n        removedAtoms.push(atom);\n      } else if (atom.parentGroup != null) {\n        throw new Error(\"Atom cannot be removed as it does not belong to this group\");\n      }\n    }\n    if (adjustDuration) {\n      if (this._duration.isZero) {\n        if (this.durationIsSpeedMultiplier) throw new Error(\"How can this be?\");\n        this._duration = this.totalChildDuration;\n      } else {\n        const scaleFactor = this.totalChildDuration.divby(oldChildDuration);\n        this._duration = this._duration.times(scaleFactor, true);\n      }\n    }\n\n    // Notify observers if atoms were removed\n    if (removedAtoms.length > 0) {\n      this.notifyObservers(AtomChangeType.REMOVE, removedAtoms, -1);\n    }\n\n    return this;\n  }\n}\n\n/**\n * Represents a line of notation containing multiple roles.\n * A line can have atoms starting before or after the cycle.\n */\nexport class Line extends Entity {\n  readonly TYPE: string = \"Line\";\n\n  /**\n   * Offset tells how many notes before or after the cycle this line's atoms start at.\n   */\n  offset: Fraction = ZERO;\n\n  /**\n   * The roles contained in this line.\n   */\n  roles: Role[] = [];\n\n  /**\n   * Text to be displayed in the margin of the line.\n   * This is a hacky solution to doing left side pre-margin text typically\n   * found in notations - e.g., line X of a pallavi has this. This makes vertical\n   * space less wasteful.\n   *\n   * A better solution is inter-beat annotation but it is very complex for now.\n   */\n  marginText = \"\";\n\n  /**\n   * The LayoutParams associated with this line.\n   */\n  layoutParams: LayoutParams;\n\n  /**\n   * Observers that receive notifications when roles change.\n   */\n  private _observers: LineObserver<Role, Line>[] = [];\n\n  /**\n   * Adds an observer to receive role change notifications.\n   * @param observer The observer to add\n   * @returns A function to remove the observer\n   */\n  addObserver(observer: LineObserver<Role, Line>): () => void {\n    this._observers.push(observer);\n    return () => this.removeObserver(observer);\n  }\n\n  /**\n   * Removes an observer.\n   * @param observer The observer to remove\n   */\n  removeObserver(observer: LineObserver<Role, Line>): void {\n    const index = this._observers.indexOf(observer);\n    if (index >= 0) {\n      this._observers.splice(index, 1);\n    }\n  }\n\n  /**\n   * Finds the index of a role with the given name.\n   * @param name The name of the role to find\n   * @returns The index of the role, or -1 if not found\n   */\n  indexOfRole(name: string): number {\n    for (let i = 0; i < this.roles.length; i++) {\n      if (this.roles[i].name == name) return i;\n    }\n    return -1;\n  }\n\n  /**\n   * Checks if this line is empty (has no content in any role).\n   */\n  get isEmpty(): boolean {\n    for (const r of this.roles) if (!r.isEmpty) return false;\n    return true;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Line.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    const out = {\n      ...super.debugValue(),\n      roles: this.roles.map((r) => r.debugValue()),\n    };\n    if (!this.offset.isZero) {\n      out.offset = this.offset.toString();\n    }\n    return out;\n  }\n\n  /**\n   * Copies the properties of this Line to another Line.\n   * @param another The target Line to copy properties to\n   */\n  copyTo(another: this): void {\n    super.copyTo(another);\n    another.roles = this.roles.map((r) => r.clone());\n  }\n\n  /**\n   * Adds atoms to a role in this line.\n   * @param roleName The name of the role to add atoms to\n   * @param defaultToNotes Whether to default to notes for this role\n   * @param atoms The atoms to add\n   * @returns This Line instance for method chaining\n   */\n  addAtoms(roleName: string, defaultToNotes: boolean, ...atoms: Atom[]): this {\n    const role = this.ensureRole(roleName, defaultToNotes);\n    role.addAtoms(...atoms);\n    return this;\n  }\n\n  /**\n   * Ensures a role with the given name exists in this line, creating it if needed.\n   * @param roleName The name of the role to ensure\n   * @param defaultToNotes Whether to default to notes for this role\n   * @returns The role with the specified name\n   */\n  ensureRole(roleName: string, defaultToNotes: boolean): Role {\n    // Ensure we have this many roles\n    let ri = this.roles.findIndex((r) => r.name == roleName);\n    if (ri < 0) {\n      ri = this.roles.length;\n      const role = new Role(this, roleName);\n      role.defaultToNotes = defaultToNotes;\n      this.roles.push(role);\n\n      // Notify observers of new role\n      if (this._eventsEnabled) {\n        for (const observer of this._observers) {\n          observer.onRoleAdded?.(this, roleName, role);\n        }\n      }\n    }\n    return this.roles[ri];\n  }\n\n  /**\n   * Removes a role from this line.\n   * @param roleName The name of the role to remove\n   * @returns True if the role was removed, false if not found\n   */\n  removeRole(roleName: string): boolean {\n    const ri = this.roles.findIndex((r) => r.name == roleName);\n    if (ri >= 0) {\n      this.roles.splice(ri, 1);\n\n      // Notify observers of removed role\n      if (this._eventsEnabled) {\n        for (const observer of this._observers) {\n          observer.onRoleRemoved?.(this, roleName);\n        }\n      }\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Gets the maximum duration across all roles in this line.\n   */\n  get duration(): Fraction {\n    let max = ZERO;\n    for (const role of this.roles) {\n      max = TSU.Num.Fraction.max(role.duration, max);\n    }\n    return max;\n  }\n}\n\n/**\n * Represents a specific role or voice in a line of notation.\n * Each role contains a sequence of atoms.\n */\nexport class Role extends Entity {\n  readonly TYPE = \"Role\";\n\n  /**\n   * Whether this role represents notes by default.\n   */\n  defaultToNotes = true;\n\n  /**\n   * The atoms in this role.\n   */\n  atoms: Atom[] = [];\n\n  /**\n   * Observers that receive notifications when atoms change.\n   */\n  private _observers: RoleObserver<Atom, Role>[] = [];\n\n  /**\n   * Creates a new Role with the specified line and name.\n   * @param line The line this role belongs to\n   * @param name The name of the role\n   */\n  constructor(\n    public readonly line: Line,\n    public readonly name: string,\n  ) {\n    super();\n  }\n\n  /**\n   * Adds an observer to receive atom change notifications.\n   * @param observer The observer to add\n   * @returns A function to remove the observer\n   */\n  addObserver(observer: RoleObserver<Atom, Role>): () => void {\n    this._observers.push(observer);\n    return () => this.removeObserver(observer);\n  }\n\n  /**\n   * Removes an observer.\n   * @param observer The observer to remove\n   */\n  removeObserver(observer: RoleObserver<Atom, Role>): void {\n    const index = this._observers.indexOf(observer);\n    if (index >= 0) {\n      this._observers.splice(index, 1);\n    }\n  }\n\n  /**\n   * Notifies observers of atom changes.\n   */\n  private notifyObservers(type: AtomChangeType, atoms: Atom[], index: number): void {\n    if (!this._eventsEnabled) return;\n    for (const observer of this._observers) {\n      switch (type) {\n        case AtomChangeType.ADD:\n          observer.onAtomsAdded?.(this, atoms, index);\n          break;\n        case AtomChangeType.INSERT:\n          observer.onAtomsInserted?.(this, atoms, index);\n          break;\n        case AtomChangeType.REMOVE:\n          observer.onAtomsRemoved?.(this, atoms);\n          break;\n      }\n    }\n  }\n\n  /**\n   * Checks if this role is empty (has no atoms).\n   */\n  get isEmpty(): boolean {\n    return this.atoms.length == 0;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this Role.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return { name: this.name, atoms: this.atoms.map((a) => a.debugValue()) };\n  }\n\n  /**\n   * Adds atoms to the end of this role.\n   * @param atoms The atoms to add\n   */\n  addAtoms(...atoms: Atom[]): void {\n    this.insertAtomsAt(this.atoms.length, ...atoms);\n  }\n\n  /**\n   * Inserts atoms at a specific index in this role.\n   * @param index The index at which to insert\n   * @param atoms The atoms to insert\n   */\n  insertAtomsAt(index: number, ...atoms: Atom[]): void {\n    // Track which atoms were actually added (excluding REST atoms)\n    const addedAtoms: Atom[] = [];\n    let last: null | Atom = index > 0 ? this.atoms[index - 1] : null;\n\n    for (const atom of atoms) {\n      if (atom.TYPE == AtomType.REST) {\n        if (last && last.TYPE != AtomType.GROUP && last.TYPE != AtomType.LABEL) {\n          (last as LeafAtom).beforeRest = true;\n        }\n      } else {\n        this.atoms.splice(index + addedAtoms.length, 0, atom);\n        addedAtoms.push(atom);\n      }\n      last = atom;\n    }\n\n    // Notify observers if atoms were added\n    if (addedAtoms.length > 0) {\n      const isAppend = index >= this.atoms.length - addedAtoms.length;\n      const type = isAppend ? AtomChangeType.ADD : AtomChangeType.INSERT;\n      this.notifyObservers(type, addedAtoms, index);\n    }\n  }\n\n  /**\n   * Removes atoms from this role.\n   * @param atoms The atoms to remove\n   */\n  removeAtoms(...atoms: Atom[]): void {\n    const removedAtoms: Atom[] = [];\n\n    for (const atom of atoms) {\n      const idx = this.atoms.indexOf(atom);\n      if (idx >= 0) {\n        this.atoms.splice(idx, 1);\n        removedAtoms.push(atom);\n      }\n    }\n\n    // Notify observers if atoms were removed\n    if (removedAtoms.length > 0) {\n      this.notifyObservers(AtomChangeType.REMOVE, removedAtoms, -1);\n    }\n  }\n\n  /**\n   * Copies the properties of this Role to another Role.\n   * @param another The target Role to copy properties to\n   */\n  copyTo(another: Role): void {\n    another.addAtoms(...this.atoms);\n  }\n\n  /**\n   * Gets the total duration of all atoms in this role.\n   */\n  get duration(): Fraction {\n    return this.atoms.reduce((a, b) => a.plus(b.duration), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Cycle, CyclePosition, CycleCursor } from \"./cycle\";\n\ntype Fraction = TSU.Num.Fraction;\nconst ZERO = TSU.Num.Fraction.ZERO;\n\n/**\n * Manages layout parameters for arranging beats and notes in the notation.\n * LayoutParams determines how beats are organized into lines and rows based on\n * cycle patterns and line breaks.\n */\nexport class LayoutParams {\n  private static counter = 0;\n  /** Unique identifier for this layout parameters instance */\n  readonly uuid = LayoutParams.counter++;\n\n  /** Duration of a single beat (multiplier for beat lengths) */\n  beatDuration: number;\n\n  /** The cycle pattern to use for this layout */\n  cycle: Cycle;\n\n  /** The pattern of line breaks to apply */\n  protected _lineBreaks: number[];\n\n  /** Cache of row start offsets */\n  private _rowStartOffsets: Fraction[];\n\n  /** Cache of row end offsets */\n  private _rowEndOffsets: Fraction[];\n\n  /** Cache of row durations */\n  private _rowDurations: Fraction[];\n\n  /** Total duration of the layout pattern */\n  private _totalLayoutDuration;\n\n  /** Cached beat layout information */\n  private _beatLayouts: [CyclePosition, Fraction][][];\n\n  /** Total number of beats across all layout lines */\n  private _totalBeats: number;\n\n  /**\n   * Creates a new LayoutParams instance.\n   * @param config Configuration object containing beatDuration, cycle, and lineBreaks\n   */\n  constructor(config?: any) {\n    config = config || {};\n    this.beatDuration = config.beatDuration || 1;\n    if (\"cycle\" in config) this.cycle = config.cycle;\n    if (!this.cycle || this.cycle.duration.isZero) {\n      this.cycle = Cycle.DEFAULT;\n    }\n\n    this._rowStartOffsets = [];\n    this._rowEndOffsets = [];\n    this._rowDurations = [];\n    this._totalLayoutDuration = ZERO;\n    this._totalBeats = 0;\n    this._beatLayouts = [];\n    this.lineBreaks = config.lineBreaks || config.layout || [];\n  }\n\n  /**\n   * Checks if this LayoutParams is equal to another LayoutParams.\n   * @param another The LayoutParams to compare with\n   * @returns True if the LayoutParams are equal, false otherwise\n   */\n  equals(another: this): boolean {\n    return (\n      // super.equals(another) &&\n      this.beatDuration == another.beatDuration &&\n      this.cycle.equals(another.cycle) &&\n      this.lineBreaksEqual(another._lineBreaks)\n    );\n  }\n\n  /**\n   * Checks if the line breaks pattern is equal to another pattern.\n   * @param another The line breaks pattern to compare with\n   * @returns True if the patterns are equal, false otherwise\n   */\n  lineBreaksEqual(another: number[]): boolean {\n    return this._lineBreaks.length == another.length && this._lineBreaks.every((x, i) => x == another[i]);\n  }\n\n  /**\n   * Returns a debug-friendly representation of this LayoutParams.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return {\n      // ...super.debugValue(),\n      cycle: this.cycle?.debugValue(),\n      beatDuration: this.beatDuration,\n      lineBreaks: this._lineBreaks,\n    };\n  }\n\n  /**\n   * Returns the \"location\" of a beat within a layout.\n   *\n   * Lines are broken into beats of notes and those beats are aligned as per\n   * the specs in the LayoutParams (breaks). For example if the breaks param\n   * stipulates [5, 5, 4] then we have 5 beats in the first 2 lines and 4 in\n   * the last line.\n   *\n   * @param beat The beat to locate\n   * @returns A tuple containing [layoutLine, layoutColumn, rowOffset]\n   *         - layoutLine: The line in the layout break spec this beat falls in\n   *         - layoutColumn: The column within the layoutLine\n   *         - rowOffset: The offset of the beat from the start of the row/line\n   */\n  getBeatLocation(beat: {\n    index: number;\n    barIndex: number;\n    beatIndex: number;\n    instance: number;\n  }): [number, number, Fraction] {\n    //\n    // If a line contains say 50 beats (B1 - B50), then it is laid out as:\n    //\n    //      C0  C1  C2  C3  C4\n    //    ---------------------\n    // L0 | B1  B2  B3  B4  B5\n    // L1 | B6  B7  B8  B9  B10\n    // L2 | B11 B12 B13 B14\n    // L0 | B15 B16 B17 B18 B19\n    // L1 | B20 B21 B22 B23 B24\n    // L2 | B25 B26 B27 B28\n    // L0 | B29 B30 B31 B32 B33\n    // L1 | B34 B35 B36 B37 B38\n    // L2 | B39 B40 B41 B42\n    // L0 | B43 B44 B45 B46 B47\n    // L1 | B48 B49 B50\n    //\n    // This methods returns the triple: [layoutLine, layoutColumn, rowOffset]\n    // where\n    //\n    //  layoutLine: The particular line in the layout break spec this index falls in.\n    //              *Note*: Since lines can start with negative offsets, we can\n    //              even return a layoutLine that is towards the end and then go\n    //              back to 0, eg 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4 ...\n    //              (eg returns L0 or L1 ... Ln)\n    //  layoutColumn: The column within the layoutLine line where this beat falls.\n    //                (eg C0 - C4 above - or depending on how many columns exist\n    //                in the particular layout line).\n    //  rowOffset: The note offset of the beat from the start of the row/line\n    //             (not from the start of the cycle).\n    //\n    // Note the beatIndex can also be negative so we can return a beat\n    // starting from before the cycle starting point.\n    //\n    //  To calculate the \"real\" line globally simply do:\n    //\n    //    realLine = lineBreaks.length  // Math.floor(beatIndex / this.totalBeats) + layoutLine;\n    //\n    // Some examples here are (using B1-B50 above):\n    const modIndex = beat.index % this.totalBeats;\n    let total = 0;\n    for (let i = 0; i < this._lineBreaks.length; i++) {\n      if (modIndex < total + this._lineBreaks[i]) {\n        // TODO: What is the right offset here?\n        let offset = ZERO;\n        if (modIndex > total) {\n          const cursor = new CycleCursor(this.cycle, beat.barIndex, beat.beatIndex, beat.instance);\n          let [, duration] = cursor.prev;\n          for (let i = total; i < modIndex; i++) {\n            [, duration] = cursor.prev;\n            offset = offset.plus(duration.timesNum(this.beatDuration));\n          }\n        }\n        return [i, modIndex - total, offset];\n      }\n      total += this._lineBreaks[i];\n    }\n    throw new Error(\"Invalid beat index: \" + beat.index);\n    return [-1, -1, ZERO];\n  }\n\n  /**\n   * Gets the line layout pattern - i.e., number of beats in each line - as a\n   * repeating pattern.\n   *\n   * For example 4,2,4 indicates that the notes in our song should be\n   * laid out 4 beats in line 1, 2 beats in line 2, 4 beats in line 3 and\n   * 4 beats in line 4 and so on as long as there are more notes available\n   * in this line.\n   */\n  get lineBreaks(): number[] {\n    if (!this._lineBreaks || this._lineBreaks.length == 0) {\n      // trigger a refresh\n      this.lineBreaks = [this.cycle.beatCount];\n    }\n    return this._lineBreaks;\n  }\n\n  /**\n   * Sets the line layout pattern.\n   */\n  set lineBreaks(val: number[]) {\n    this._lineBreaks = val;\n    this.refreshLayout();\n  }\n\n  /**\n   * Returns the number of beats in each line based on the line layout\n   * after taking beatDuration into account.\n   */\n  get beatLayouts(): ReadonlyArray<ReadonlyArray<[CyclePosition, Fraction]>> {\n    if (!this._beatLayouts || this._beatLayouts.length < this.lineBreaks.length) {\n      this.refreshLayout();\n    }\n    return this._beatLayouts;\n  }\n\n  /**\n   * Gets the total number of beats across all lines in the layout pattern.\n   */\n  get totalBeats(): number {\n    this.beatLayouts;\n    return this._totalBeats;\n  }\n\n  /**\n   * Gets the total duration of all beats across all lines in the layout pattern.\n   */\n  get totalLayoutDuration(): Fraction {\n    this.beatLayouts;\n    return this._totalLayoutDuration;\n  }\n\n  /**\n   * Refreshes the layout calculations based on the current cycle and line breaks.\n   * This rebuilds the beat layouts, row durations, and offset information.\n   */\n  protected refreshLayout(): void {\n    const cycleIter = this.cycle.iterateBeats();\n    const akb = this.beatDuration;\n    this._beatLayouts = this.lineBreaks.map((numBeats, index) => {\n      const beats: [CyclePosition, Fraction][] = [];\n      // see what the beat lengths are here\n      for (let i = 0; i < numBeats; i++) {\n        const nextCP = cycleIter.next().value;\n        nextCP[1] = nextCP[1].timesNum(akb);\n        beats.push(nextCP);\n      }\n      return beats;\n    });\n    this._totalBeats = this.lineBreaks.reduce((a, b) => a + b, 0);\n    this._rowDurations = this._beatLayouts.map((beats) => beats.reduce((x, y) => x.plus(y[1]), ZERO));\n    this._rowDurations.forEach((rd, index) => {\n      this._rowStartOffsets[index] = index == 0 ? ZERO : this._rowStartOffsets[index - 1].plus(rd);\n    });\n    this._rowEndOffsets = this._rowDurations.map((rd, index) => {\n      return this._rowStartOffsets[index].plus(rd);\n    });\n    this._totalLayoutDuration = this._rowDurations.reduce((x, y) => x.plus(y), ZERO);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n// import * as kiwi from \"@lume/kiwi\";\n\n/**\n * Event emitted when layout changes occur in a GridLayoutGroup.\n * Subscribers can use this to update their views incrementally.\n */\nexport interface LayoutChangeEvent {\n  /** The range of rows affected by the change */\n  affectedRowRange: { start: number; end: number } | null;\n  /** The range of columns affected by the change */\n  affectedColRange: { start: number; end: number } | null;\n  /** Whether column widths changed (requires horizontal re-layout) */\n  columnWidthsChanged: boolean;\n  /** Whether row heights changed (requires vertical re-layout) */\n  rowHeightsChanged: boolean;\n  /** The grid models that were affected */\n  affectedGridModels: GridModel[];\n}\n\n/**\n * Callback type for layout change subscribers.\n */\nexport type LayoutChangeCallback = (event: LayoutChangeEvent) => void;\n\n/**\n * A generic grid layout system for hosting child views (similar to GridBagLayout).\n * This provides a framework for hosting BeatViews in a structured grid arrangement,\n * with support for rows, columns, and alignment.\n *\n * Grid \"cells\" can be referred to by cell indexes. Additionally, grid rows and\n * columns can have names (like in spreadsheets) so that even when rows and columns\n * are inserted, though indexes may change, the \"addresses\" remain fixed and immovable.\n */\nexport class GridModel extends TSU.Events.EventEmitter {\n  private static idCounter = 0;\n  readonly uuid = GridModel.idCounter++;\n  /** Timestamp of the last update to this grid */\n  lastUpdatedAt = 0;\n  // cells = new SparseArray<SparseArray<GridCell>>();\n  /** The rows in this grid */\n  rows: GridRow[] = [];\n  /** Mapping of row indices to row alignment objects */\n  rowAligns = new Map<number, RowAlign>();\n  /** Mapping of column indices to column alignment objects */\n  colAligns = new Map<number, ColAlign>();\n\n  /**\n   * Returns a debug-friendly representation of this GridModel.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    const out = {\n      rows: this.rows.map((r) => r.debugValue()),\n      lastUpdatedAt: this.lastUpdatedAt,\n    } as any;\n    return out;\n  }\n\n  /**\n   * Gets the index of the first non-empty row.\n   * @returns The index of the first row containing cells, or -1 if none\n   */\n  get firstRow(): number {\n    for (const gr of this.rows) {\n      if (gr.numCells > 0) return gr.rowIndex;\n    }\n    return -1;\n  }\n\n  /**\n   * Gets the index of the leftmost column containing cells.\n   * @returns The index of the first column containing cells, or -1 if none\n   */\n  get firstCol(): number {\n    let minCol = -1;\n    for (const gr of this.rows) {\n      const fc = gr.firstCol;\n      if (fc >= 0) {\n        if (minCol < 0 || fc < minCol) {\n          minCol = fc;\n        }\n      }\n    }\n    return minCol;\n  }\n\n  /**\n   * Gets all non-empty cells in a specific row.\n   * @param row The index of the row\n   * @returns An array of cells in the row\n   */\n  cellsInRow(row: number): GridCell[] {\n    const out = [] as GridCell[];\n    const gr = this.rows[row];\n    if (gr) {\n      for (const cell of gr.cells) {\n        if (cell?.value) out.push(cell);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all non-empty cells in a specific column.\n   * @param col The index of the column\n   * @returns An array of cells in the column\n   */\n  cellsInCol(col: number): GridCell[] {\n    const out = [] as GridCell[];\n    for (const gr of this.rows) {\n      const cell = gr.cellAt(col);\n      if (cell?.value) out.push(cell);\n    }\n    return out;\n  }\n\n  /**\n   * Adds a row alignment object to the grid.\n   * @param align The row alignment to add\n   */\n  addRowAlign(align: RowAlign): void {\n    this.rowAligns.set(align.uuid, align);\n  }\n\n  /**\n   * Adds a column alignment object to the grid.\n   * @param align The column alignment to add\n   */\n  addColAlign(align: ColAlign): void {\n    this.colAligns.set(align.uuid, align);\n  }\n\n  /**\n   * Adds rows to the grid.\n   * @param insertBefore The index before which to insert the rows, or -1 to append\n   * @param numRows The number of rows to add\n   * @returns This grid instance for method chaining\n   */\n  addRows(insertBefore = -1, numRows = 1): this {\n    if (insertBefore < 0) {\n      insertBefore = this.rows.length;\n    }\n    let next = this.rows[insertBefore] || null;\n    const prev = this.rows[insertBefore - 1] || null;\n    for (let i = numRows - 1; i >= 0; i--) {\n      const newRow = new GridRow(this, insertBefore + i);\n      this.rows.splice(insertBefore, 0, newRow);\n      if (next != null) {\n        newRow.defaultRowAlign.addSuccessor(next.defaultRowAlign);\n      }\n      if (i == 0 && insertBefore > 0) {\n        prev.defaultRowAlign.addSuccessor(newRow.defaultRowAlign);\n      }\n      next = newRow;\n    }\n    for (let i = insertBefore + numRows; i < this.rows.length; i++) {\n      this.rows[i].rowIndex += numRows;\n    }\n    return this;\n  }\n\n  /**\n   * Gets a row at the specified index, creating it if necessary.\n   * @param row The index of the row to get\n   * @returns The row at the specified index\n   */\n  getRow(row: number): GridRow {\n    if (row >= this.rows.length) {\n      this.addRows(-1, 1 + row - this.rows.length);\n    }\n    return this.rows[row];\n  }\n\n  /**\n   * Sets a value in a cell at the specified row and column.\n   * @param row The row index\n   * @param col The column index\n   * @param value The value to set\n   * @param cellCreator Optional function to create a custom cell\n   * @returns The previous value of the cell\n   */\n  setValue(row: number, col: number, value: any, cellCreator?: (row: GridRow, col: number) => GridCell): any {\n    const grow = this.getRow(row);\n    if (!cellCreator) {\n      cellCreator = (row: GridRow, col: number) => {\n        return new GridCell(row, col);\n      };\n    }\n    if (value == null) {\n      const out = grow.clearCellAt(col);\n      if (out != null) {\n        this.eventHub?.emit(GridCellEvent.CLEARED, this, {\n          loc: out.location,\n        });\n      }\n      return out;\n    } else {\n      const cell = grow.cellAt(col, cellCreator) as GridCell;\n      const oldValue = cell.value;\n      this.eventHub?.emit(GridCellEvent.UPDATED, this, {\n        loc: cell.location,\n        cell: cell,\n        oldValue: cell.value,\n      });\n      cell.value = value;\n      return oldValue;\n    }\n  }\n\n  /**\n   * Handles changes to the event hub.\n   */\n  protected eventHubChanged(): void {\n    console.log(\"Event Hub Changed for GridModel\");\n  }\n}\n\n/**\n * Interface for a view associated with a grid cell.\n * GridCellView defines the contract for views that can be placed in grid cells.\n */\nexport interface GridCellView {\n  /** The grid cell this view is associated with */\n  readonly cell: GridCell;\n  /** X-coordinate of the view */\n  x: number;\n  /** Y-coordinate of the view */\n  y: number;\n  /** Width of the view */\n  width: number;\n  /** Height of the view */\n  height: number;\n\n  /**\n   * Sets the bounds of the view.\n   * @param x New x-coordinate, or null to keep current value\n   * @param y New y-coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @param applyLayout Whether to apply layout immediately\n   * @returns The new bounds values\n   */\n  setBounds(\n    x: number | null,\n    y: number | null,\n    w: number | null,\n    h: number | null,\n    applyLayout: boolean,\n  ): [number | null, number | null, number | null, number | null];\n\n  /** Whether this view needs layout */\n  readonly needsLayout: boolean;\n\n  /** The minimum size this view requires */\n  readonly minSize: TSU.Geom.Size;\n\n  /** The bounding box of this view */\n  readonly bbox: TSU.Geom.Rect;\n}\n\n/**\n * Enum defining the events that can occur on grid cells.\n */\nexport enum GridCellEvent {\n  ADDED = \"CellAdded\",\n  CLEARED = \"CellCleared\",\n  REMOVED = \"CellRemoved\",\n  UPDATED = \"CellUpdated\",\n  MOVED = \"CellMoved\",\n}\n\n/**\n * Represents a cell in the grid.\n * GridCell holds a value and manages alignment with rows and columns.\n */\nexport class GridCell {\n  private static idCounter = 0;\n  readonly uuid = GridCell.idCounter++;\n  /** The view associated with this cell */\n  cellView: GridCellView | null;\n  private _rowAlign: RowAlign;\n  private _colAlign: ColAlign;\n\n  /**\n   * Creates a new GridCell.\n   * @param gridRow The row this cell belongs to\n   * @param colIndex The column index of this cell\n   * @param value Optional initial value for the cell\n   */\n  constructor(\n    public gridRow: GridRow,\n    public colIndex: number,\n    public value: any = null,\n  ) {\n    this.rowAlign = gridRow.defaultRowAlign;\n  }\n\n  /**\n   * Gets the row alignment for this cell.\n   */\n  get rowAlign(): RowAlign {\n    return this._rowAlign;\n  }\n\n  /**\n   * Sets the row alignment for this cell.\n   */\n  set rowAlign(val: RowAlign) {\n    val.addCell(this);\n    this._rowAlign = val;\n  }\n\n  /**\n   * Gets the column alignment for this cell.\n   */\n  get colAlign(): ColAlign {\n    return this._colAlign;\n  }\n\n  /**\n   * Sets the column alignment for this cell.\n   */\n  set colAlign(val: ColAlign) {\n    val.addCell(this);\n    this._colAlign = val;\n  }\n\n  /**\n   * Gets the location string for this cell (rowIndex:colIndex).\n   */\n  get location(): string {\n    return this.gridRow.rowIndex + \":\" + this.colIndex;\n  }\n\n  /**\n   * Gets the grid this cell belongs to.\n   */\n  get grid(): GridModel {\n    return this.gridRow.grid;\n  }\n\n  /**\n   * Gets the row index of this cell.\n   */\n  get rowIndex(): number {\n    return this.gridRow.rowIndex;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this GridCell.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    const out = {\n      r: this.gridRow.rowIndex,\n      c: this.colIndex,\n      value: this.value,\n      y: this.rowAlign.coordOffset,\n      h: this.rowAlign.maxLength,\n    } as any;\n    if (this.colAlign) {\n      out.x = this.colAlign.coordOffset;\n      out.w = this.colAlign.maxLength;\n    }\n    return out;\n  }\n}\n\n/**\n * Represents a row of grid cells in a GridModel.\n */\nexport class GridRow {\n  /** The cells in this row */\n  cells: (null | GridCell)[] = [];\n  /** The default vertical alignment for all cells in this row */\n  defaultRowAlign: RowAlign;\n\n  /**\n   * Creates a new GridRow.\n   * @param grid The grid this row belongs to\n   * @param rowIndex The index of this row\n   */\n  constructor(\n    public grid: GridModel,\n    public rowIndex: number,\n  ) {\n    this.defaultRowAlign = new RowAlign();\n    this.grid.addRowAlign(this.defaultRowAlign);\n  }\n\n  /**\n   * Gets the index of the first non-empty column in this row.\n   */\n  get firstCol() {\n    for (let i = 0; i < this.cells.length; i++) {\n      if (this.cells[i]?.value) {\n        return i;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * Gets the number of columns in this row.\n   */\n  get numCols() {\n    return this.cells.length;\n  }\n\n  /**\n   * Gets the number of cells that contain values.\n   */\n  get numCells() {\n    let i = 0;\n    for (const cell of this.cells) {\n      if (cell != null && cell.value != null) i++;\n    }\n    return i;\n  }\n\n  /**\n   * Gets the cell at the specified column index, optionally creating it if it doesn't exist.\n   * @param col The column index\n   * @param creator Optional function to create the cell if it doesn't exist\n   * @returns The cell at the specified index, or null if it doesn't exist and no creator was provided\n   */\n  cellAt(col: number, creator?: (row: GridRow, col: number) => GridCell): GridCell | null {\n    let out = this.cells[col] || null;\n    if (!out && creator) {\n      this.cells[col] = out = creator(this, col);\n      out.gridRow = this;\n      out.colIndex = col;\n      if (out.rowAlign) {\n        this.grid.addRowAlign(out.rowAlign);\n      }\n      if (out.colAlign) {\n        this.grid.addColAlign(out.colAlign);\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Clears the cell at the given column.\n   * Note this is not the same as \"removing\" a cell.\n   * Removing a cell would require all cells to the \"right\" to be shifted left.\n   * @param col The column index\n   * @returns The cell that was cleared, or null if none existed\n   */\n  clearCellAt(col: number): GridCell | null {\n    const out = this.cells[col] || null;\n    if (out) {\n      this.cells[col] = null;\n    }\n    return out;\n  }\n\n  /**\n   * Returns a debug-friendly representation of this GridRow.\n   * @returns An object containing debug information\n   */\n  debugValue() {\n    return {\n      r: this.rowIndex,\n      cells: this.cells.filter((c) => c).map((c) => c?.debugValue()),\n    };\n  }\n}\n\n/**\n * Base class for row and column alignment objects.\n * AlignedLine manages the alignment of cells along a line (row or column).\n */\nexport abstract class AlignedLine {\n  private static idCounter = 0;\n  readonly uuid = AlignedLine.idCounter++;\n  /** Whether this line needs layout */\n  needsLayout = false;\n  /** The coordinate offset of this line */\n  protected _coordOffset = 0;\n  /** The maximum length of this line */\n  protected _maxLength = 0;\n  /** Padding before this line */\n  paddingBefore = 5;\n  /** Padding after this line */\n  paddingAfter = 5;\n  /** The cells that belong to this line */\n  cells: GridCell[] = [];\n  /** Function to get a view for a cell value */\n  getCellView: (value: any) => GridCellView;\n\n  /**\n   * Sets the offset of this line.\n   * @param val The new offset value\n   */\n  abstract setOffset(val: number): void;\n\n  /**\n   * Evaluates the maximum length required for this line.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum length\n   */\n  abstract evalMaxLength(changedCells: GridCell[]): number;\n\n  /**\n   * Gets the coordinate offset of this line.\n   */\n  get coordOffset(): number {\n    return this._coordOffset;\n  }\n\n  /**\n   * Gets the maximum length of this line, including padding.\n   */\n  get maxLength(): number {\n    return this._maxLength + this.paddingBefore + this.paddingAfter;\n  }\n\n  /**\n   * Sets the maximum length of this line.\n   * @param length The new maximum length\n   */\n  setMaxLength(length: number) {\n    this._maxLength = length;\n  }\n\n  /**\n   * Sets the padding before and after this line.\n   * @param before Padding before the line\n   * @param after Padding after the line\n   */\n  setPadding(before: number, after: number): void {\n    if (before >= 0) {\n      this.paddingBefore = before;\n    }\n    if (after >= 0) {\n      this.paddingAfter = after;\n    }\n  }\n\n  /**\n   * Adds a cell to this line.\n   * @param cell The cell to add\n   * @returns This line instance for method chaining\n   */\n  addCell(cell: GridCell): this {\n    if (this.beforeAddingCell(cell)) {\n      this.cells.push(cell);\n    }\n    return this;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected abstract beforeAddingCell(cell: GridCell): boolean;\n\n  /**\n   * Removes a cell from this line.\n   * @param cell The cell to remove\n   * @returns This line instance for method chaining\n   */\n  removeCell(cell: GridCell): this {\n    if (this.beforeRemovingCell(cell)) {\n      for (let i = 0; i < this.cells.length; i++) {\n        if (this.cells[i].uuid == cell.uuid) {\n          this.cells.splice(i, 1);\n          break;\n        }\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  protected abstract beforeRemovingCell(cell: GridCell): boolean;\n\n  // The \"neighboring\" lines that depend on this line to be placed\n  // before they are placed\n  /** Lines that must be positioned before this line */\n  prevLines = [] as this[];\n  /** Lines that must be positioned after this line */\n  nextLines = [] as this[];\n\n  /**\n   * Adds a successor line to this line.\n   * @param next The line to add as a successor\n   */\n  addSuccessor(next: this): void {\n    // Set nextCol as a successor of this col\n    // TODO - Ensure no cycles\n    for (const c of this.nextLines) {\n      if (c == next) return;\n    }\n    this.nextLines.push(next);\n    next.prevLines.push(this);\n  }\n\n  /* TODO: Disabling only to improve test coverage as this method is\n   * not used.\n   * When we have mutable grids where we can insert/remove neighbors\n   * we can enable this again.\n   */\n  /*\n  removeSuccessor(next: this): void {\n    // Set nextCol as a successor of this col\n    // TODO - Ensure no cycles\n    for (let i = 0; i < this.nextLines.length; i++) {\n      if (this.nextLines[i] == next) {\n        this.nextLines.splice(i, 1);\n        break;\n      }\n    }\n    for (let i = 0; i < next.prevLines.length; i++) {\n      if (next.prevLines[i] == this) {\n        next.prevLines.splice(i, 1);\n        break;\n      }\n    }\n  }\n  */\n}\n\n/**\n * Manages the alignment of cells in a column.\n */\nexport class ColAlign extends AlignedLine {\n  paddingBefore = 10;\n  /** Padding after this line */\n  paddingAfter = 10;\n\n  /**\n   * Sets the offset of this column and updates all associated cells.\n   * @param val The new offset value\n   */\n  setOffset(val: number): void {\n    this._coordOffset = val;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        if (this._maxLength <= 0) {\n          // this hasnt been evaluated yet so do it!\n          this.evalMaxLength();\n        }\n        cellView.setBounds(val, null, this.maxLength, null, true);\n      }\n    }\n  }\n\n  /**\n   * Evaluates the maximum width required for this column.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum width\n   */\n  evalMaxLength(changedCells: GridCell[] = []): number {\n    this._maxLength = 0;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        this._maxLength = Math.max(cellView.minSize.width, this._maxLength);\n      }\n    }\n    return this._maxLength;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected beforeAddingCell(cell: GridCell): boolean {\n    if (cell.colAlign && cell.colAlign != this) {\n      cell.colAlign.removeCell(cell);\n    }\n    return cell.colAlign != this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  beforeRemovingCell(cell: GridCell): boolean {\n    return cell.colAlign == this;\n  }\n}\n\n/**\n * Manages the alignment of cells in a row.\n */\nexport class RowAlign extends AlignedLine {\n  /**\n   * Sets the Y coordinate of all cells in this row.\n   * @param val The new Y coordinate\n   */\n  setOffset(val: number): void {\n    this._coordOffset = val;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        if (this._maxLength <= 0) {\n          // this hasnt been evaluated yet so do it!\n          this.evalMaxLength();\n        }\n        cellView.setBounds(null, val, null, this.maxLength, true);\n      }\n    }\n  }\n\n  /**\n   * Evaluates the maximum height required for this row.\n   * @param changedCells Cells that have changed and need re-evaluation\n   * @returns The maximum height\n   */\n  evalMaxLength(changedCells: GridCell[] = []): number {\n    this._maxLength = 0;\n    for (const cell of this.cells) {\n      if (cell.value) {\n        const cellView = this.getCellView(cell);\n        this._maxLength = Math.max(cellView.minSize.height, this._maxLength);\n      }\n    }\n    return this._maxLength;\n  }\n\n  /**\n   * Called before adding a cell to perform validation or preparation.\n   * @param cell The cell to be added\n   * @returns Whether the cell should be added\n   */\n  protected beforeAddingCell(cell: GridCell): boolean {\n    if (cell.rowAlign && cell.rowAlign != this) {\n      cell.rowAlign.removeCell(cell);\n    }\n    return cell.rowAlign != this;\n  }\n\n  /**\n   * Called before removing a cell to perform validation.\n   * @param cell The cell to be removed\n   * @returns Whether the cell should be removed\n   */\n  beforeRemovingCell(cell: GridCell): boolean {\n    return cell.rowAlign == this;\n  }\n}\n\n/**\n * The layout manager for a collection of GridViews bound by common alignment objects.\n * Manages the layout of multiple grid models, ensuring proper alignment between them.\n */\nexport class GridLayoutGroup {\n  // rowAligns = new Map<number, RowAlign>();\n  // colAligns = new Map<number, ColAlign>();\n  /** The grid models managed by this layout group */\n  gridModels = [] as GridModel[];\n\n  /** Subscribers to layout change events */\n  private layoutChangeSubscribers = new Set<LayoutChangeCallback>();\n\n  /** Previous column widths by ColAlign uuid - for detecting actual changes */\n  private previousColumnWidths = new Map<number, number>();\n\n  /** Previous row heights by RowAlign uuid - for detecting actual changes */\n  private previousRowHeights = new Map<number, number>();\n\n  /**\n   * Subscribes to layout change events.\n   * @param callback Function to call when layout changes\n   * @returns Unsubscribe function\n   */\n  onLayoutChange(callback: LayoutChangeCallback): () => void {\n    this.layoutChangeSubscribers.add(callback);\n    return () => {\n      this.layoutChangeSubscribers.delete(callback);\n    };\n  }\n\n  /**\n   * Notifies all subscribers of a layout change.\n   * @param event The layout change event\n   */\n  protected notifyLayoutChange(event: LayoutChangeEvent): void {\n    for (const callback of this.layoutChangeSubscribers) {\n      try {\n        callback(event);\n      } catch (e) {\n        console.error(\"Error in layout change callback:\", e);\n      }\n    }\n  }\n\n  /**\n   * Gets the number of layout change subscribers.\n   */\n  get subscriberCount(): number {\n    return this.layoutChangeSubscribers.size;\n  }\n\n  /**\n   * Event handler for processing events from grid models.\n   */\n  private eventHandler = (event: TSU.Events.TEvent) => {\n    this.applyModelEvents(event.payload);\n  };\n\n  /**\n   * Adds a grid model to this layout group.\n   * @param gridModel The grid model to add\n   * @returns True if the model was added successfully\n   */\n  addGridModel(gridModel: GridModel): boolean {\n    gridModel.eventHub?.on(TSU.Events.EventHub.BATCH_EVENTS, this.eventHandler);\n    this.gridModels.push(gridModel);\n    return true;\n  }\n\n  /**\n   * Gets all row alignment objects that have no predecessors.\n   * @returns An array of starting row alignments\n   */\n  startingRowAligns(): RowAlign[] {\n    const out = [] as RowAlign[];\n    const visited = {} as any;\n    for (const gm of this.gridModels) {\n      for (const cell of gm.cellsInRow(gm.firstRow)) {\n        if (cell.rowAlign && !visited[cell.rowAlign.uuid]) {\n          visited[cell.rowAlign.uuid] = true;\n          out.push(cell.rowAlign);\n        }\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all column alignment objects that have no predecessors.\n   * @returns An array of starting column alignments\n   */\n  startingColAligns(): ColAlign[] {\n    const out = [] as ColAlign[];\n    const visited = {} as any;\n    for (const gm of this.gridModels) {\n      for (const cell of gm.cellsInCol(gm.firstCol)) {\n        if (cell.colAlign && !visited[cell.colAlign.uuid]) {\n          visited[cell.colAlign.uuid] = true;\n          out.push(cell.colAlign);\n        }\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Removes a grid model from this layout group.\n   * @param gridModel The grid model to remove\n   */\n  removeGridModel(gridModel: GridModel): void {\n    gridModel.eventHub?.removeOn(TSU.Events.EventHub.BATCH_EVENTS, this.eventHandler);\n  }\n\n  /**\n   * Function to get a view for a cell value.\n   */\n  getCellView: (cell: GridCell) => GridCellView;\n\n  /**\n   * Gets the starting row alignments.\n   */\n  get startingRows(): RowAlign[] {\n    return this.startingRowAligns();\n  }\n\n  /**\n   * Gets the starting column alignments.\n   */\n  get startingCols(): ColAlign[] {\n    return this.startingColAligns();\n  }\n\n  /**\n   * Forces a full refresh of the layout.\n   * This recalculates all row and column sizes and positions.\n   * @param notify Whether to notify subscribers of the change (default: true)\n   */\n  refreshLayout(notify = true): void {\n    const changedRowAligns = {} as any;\n    const changedColAligns = {} as any;\n\n    for (const rowAlign of this.startingRowAligns()) {\n      if (!(rowAlign.uuid in changedRowAligns)) {\n        changedRowAligns[rowAlign.uuid] = {\n          align: rowAlign,\n          cells: [],\n        };\n      }\n    }\n\n    for (const colAlign of this.startingColAligns()) {\n      if (!(colAlign.uuid in changedColAligns)) {\n        changedColAligns[colAlign.uuid] = {\n          align: colAlign,\n          cells: [],\n        };\n      }\n    }\n\n    // Pass the previous dimension maps for O(1) inline change detection\n    const rowHeightsChanged = this.doBfsLayout(this.startingRows, changedRowAligns, this.previousRowHeights);\n    const columnWidthsChanged = this.doBfsLayout(this.startingCols, changedColAligns, this.previousColumnWidths);\n\n    // Notify subscribers of full refresh\n    if (notify && this.layoutChangeSubscribers.size > 0) {\n      this.notifyLayoutChange({\n        affectedRowRange: null, // null means all rows\n        affectedColRange: null, // null means all columns\n        columnWidthsChanged,\n        rowHeightsChanged,\n        affectedGridModels: this.gridModels,\n      });\n    }\n  }\n\n  /**\n   * Applies model events to update the layout.\n   * @param events The events to process\n   */\n  protected applyModelEvents(events: TSU.Events.TEvent[]): void {\n    // As the grid model changes (cell content changed, cleared etc) we need\n    // to refresh our layout based on this.\n    // As a first step the new height and width of all changed cells is\n    // evaluted to see which rows and/or columns are affected (and need to be\n    // resized/repositioned).\n    const [changedRowAligns, changedColAligns, affectedGridModels] = this.changesForEvents(events);\n    const hadRowChanges = Object.keys(changedRowAligns).length > 0;\n    const hadColChanges = Object.keys(changedColAligns).length > 0;\n\n    // Pass the previous dimension maps for O(1) inline change detection\n    const rowHeightsChanged = this.doBfsLayout(this.startingRows, changedRowAligns, this.previousRowHeights);\n    const columnWidthsChanged = this.doBfsLayout(this.startingCols, changedColAligns, this.previousColumnWidths);\n\n    // Notify subscribers of incremental changes\n    if (this.layoutChangeSubscribers.size > 0 && (hadRowChanges || hadColChanges)) {\n      // Calculate affected ranges from the changed alignments\n      const affectedRowRange = this.calculateAffectedRowRange(changedRowAligns);\n      const affectedColRange = this.calculateAffectedColRange(changedColAligns);\n\n      this.notifyLayoutChange({\n        affectedRowRange,\n        affectedColRange,\n        columnWidthsChanged,\n        rowHeightsChanged,\n        affectedGridModels: affectedGridModels,\n      });\n    }\n  }\n\n  /**\n   * Calculates the range of affected rows from changed row alignments.\n   * Returns null if no rows changed or range cannot be determined.\n   */\n  protected calculateAffectedRowRange(changedRowAligns: any): { start: number; end: number } | null {\n    let minRow = Infinity;\n    let maxRow = -Infinity;\n\n    for (const alignId in changedRowAligns) {\n      const { cells } = changedRowAligns[alignId];\n      for (const cell of cells) {\n        const rowIndex = cell.gridRow.rowIndex;\n        minRow = Math.min(minRow, rowIndex);\n        maxRow = Math.max(maxRow, rowIndex);\n      }\n    }\n\n    if (minRow === Infinity) return null;\n    return { start: minRow, end: maxRow };\n  }\n\n  /**\n   * Calculates the range of affected columns from changed column alignments.\n   * Returns null if no columns changed or range cannot be determined.\n   */\n  protected calculateAffectedColRange(changedColAligns: any): { start: number; end: number } | null {\n    let minCol = Infinity;\n    let maxCol = -Infinity;\n\n    for (const alignId in changedColAligns) {\n      const { cells } = changedColAligns[alignId];\n      for (const cell of cells) {\n        const colIndex = cell.colIndex;\n        minCol = Math.min(minCol, colIndex);\n        maxCol = Math.max(maxCol, colIndex);\n      }\n    }\n\n    if (minCol === Infinity) return null;\n    return { start: minCol, end: maxCol };\n  }\n\n  /**\n   * Checks if an alignment's maxLength changed from previous value.\n   * Updates the stored previous value. O(1) cost.\n   * @param align The alignment to check\n   * @param previousMap Map storing previous lengths\n   * @returns true if length changed (or is new)\n   */\n  private checkAndUpdateLength<T extends AlignedLine>(align: T, previousMap: Map<number, number>): boolean {\n    const previous = previousMap.get(align.uuid);\n    const current = align.maxLength;\n    previousMap.set(align.uuid, current);\n    return previous === undefined || previous !== current;\n  }\n\n  /**\n   * Determines which rows and columns need to be updated based on events.\n   * @param events The events to process\n   * @returns A tuple containing the changed row alignments, column alignments, and affected grid models\n   */\n  protected changesForEvents(events: TSU.Events.TEvent[]): [any, any, GridModel[]] {\n    // Step 1 - topologically sort RowAligns of changed cells\n    // Step 2 - topologically sort ColAligns of changed cells\n    // Step 3 -\n    const cellVisited = {} as any;\n    const changedRowAligns = {} as any;\n    const changedColAligns = {} as any;\n    const affectedGridModelsSet = new Set<GridModel>();\n    // Going in reverse means we only get the latest event affecting a cell\n    // instead of going through every change.\n    // Later on we can revisit this if the events are edge triggered instead\n    // of level triggered\n    for (let i = events.length - 1; i >= 0; i--) {\n      const event = events[i];\n      const loc = event.payload.loc;\n      if (cellVisited[loc]) continue;\n      cellVisited[loc] = true;\n      const [row, col] = loc.split(\":\").map((x: string) => parseInt(x));\n      const gridModel = event.source as GridModel;\n      affectedGridModelsSet.add(gridModel);\n      const cell = gridModel.getRow(row).cellAt(col);\n      if (cell) {\n        // TODO - For now we are marking both row and col as having\n        // changed for a cell.  We can optimize this to only row or\n        // col based on whether height or width has changed.\n        if (!(cell.rowAlign.uuid in changedRowAligns)) {\n          changedRowAligns[cell.rowAlign.uuid] = {\n            align: cell.rowAlign,\n            cells: [],\n          };\n        }\n        changedRowAligns[cell.rowAlign.uuid][\"cells\"].push(cell);\n\n        if (!(cell.colAlign.uuid in changedColAligns)) {\n          changedColAligns[cell.colAlign.uuid] = {\n            align: cell.colAlign,\n            cells: [],\n          };\n        }\n        changedColAligns[cell.colAlign.uuid][\"cells\"].push(cell);\n      }\n    }\n    return [changedRowAligns, changedColAligns, Array.from(affectedGridModelsSet)];\n  }\n\n  /**\n   * Ensures that a cell view getter function is available for an alignment.\n   * @param align The alignment to check\n   * @returns The cell view getter function\n   */\n  protected ensureGetCellView(align: AlignedLine) {\n    if (!align.getCellView) {\n      if (!this.getCellView) {\n        return null;\n      }\n      align.getCellView = this.getCellView;\n    }\n    return align.getCellView;\n  }\n\n  /**\n   * Performs a breadth-first layout of aligned lines.\n   * @param startingLines The lines to start from\n   * @param changedAligns Map of alignment IDs to changed alignments\n   * @param previousLengths Map to track previous lengths for change detection\n   * @returns true if any dimension (width/height) actually changed\n   */\n  protected doBfsLayout<T extends AlignedLine>(\n    startingLines: T[],\n    changedAligns: any,\n    previousLengths?: Map<number, number>,\n  ): boolean {\n    // 1. start from the starting lines and do a BF traversal\n    // 2. If a line not visited (ie laid out):\n    //      if it is in the changedAlign list then reval its length (w/h)\n    //      set its offset and length if either width or offset has changed\n    //      offset can be thought of changed if the preceding line's offset has changed\n    // first do above for rows\n    if (!this.getCellView) return false;\n    let anyDimensionChanged = false;\n\n    for (const alignId in changedAligns) {\n      const val = changedAligns[alignId];\n      this.ensureGetCellView(val.align);\n      val.align.evalMaxLength(val.cells);\n\n      // Check if this alignment's length actually changed (O(1))\n      if (previousLengths && this.checkAndUpdateLength(val.align, previousLengths)) {\n        anyDimensionChanged = true;\n      }\n    }\n\n    let lineQueue = [] as [null | T, T][];\n    const visitedLines = {} as any;\n    for (const line of startingLines) lineQueue.push([null, line]);\n    const lineOffsetChanged = {} as any;\n    while (lineQueue.length > 0) {\n      const nextQueue = [] as [null | T, T][];\n      for (let i = 0; i < lineQueue.length; i++) {\n        const [prevLineAlign, lineAlign] = lineQueue[i];\n        visitedLines[lineAlign.uuid] = true;\n        let newOffset = lineAlign.coordOffset;\n        let lineChanged = lineAlign.uuid in changedAligns;\n        if (prevLineAlign) {\n          if (lineOffsetChanged[prevLineAlign.uuid]) {\n            newOffset = prevLineAlign.coordOffset + prevLineAlign.maxLength;\n            lineChanged = true;\n          }\n        }\n        if (lineChanged) {\n          this.ensureGetCellView(lineAlign);\n          lineAlign.setOffset(newOffset);\n          lineOffsetChanged[lineAlign.uuid] = true;\n        }\n\n        // Add next neighbors now\n        for (const next of lineAlign.nextLines) {\n          if (!visitedLines[next.uuid]) {\n            nextQueue.push([lineAlign, next]);\n          }\n        }\n      }\n      lineQueue = nextQueue;\n    }\n\n    return anyDimensionChanged;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { AtomType, Marker, Group, Line, Atom, Space, Role } from \"./\";\nimport { CycleIterator, CyclePosition } from \"./cycle\";\nimport { WindowIterator } from \"./iterators\";\nimport { LayoutParams } from \"./layouts\";\nimport { GridModel, GridRow, GridCell, ColAlign, GridLayoutGroup } from \"./grids\";\nimport { Block, BlockItem, isLine, isBlock } from \"./notation\";\n\ntype Fraction = TSU.Num.Fraction;\nconst ZERO = TSU.Num.Fraction.ZERO;\nconst ONE = TSU.Num.Fraction.ONE;\n\n/**\n * Represents a single beat in the notation.\n * A beat contains one or more atoms and has a specific position in a bar.\n */\nexport class Beat {\n  private static idCounter = 0;\n  readonly uuid = Beat.idCounter++;\n  // Should this be as flat Atoms or should we keep it as atoms and breakdown later?\n\n  /** The atom contained in this beat */\n  atom: Atom;\n  protected atomIsPlaceholder = false;\n\n  /**\n   * Creates a new Beat.\n   * @param index The index of this beat in the sequence\n   * @param role The role this beat belongs to\n   * @param offset The time offset of this beat from the start\n   * @param duration The duration of this beat\n   * @param barIndex The index of the bar containing this beat\n   * @param beatIndex The index of this beat within its bar\n   * @param instance The instance number of this beat\n   * @param prevBeat The previous beat in the sequence, if any\n   * @param nextBeat The next beat in the sequence, if any\n   */\n  constructor(\n    public readonly index: number,\n    public readonly role: Role,\n    public readonly offset: Fraction,\n    public readonly duration: Fraction,\n    public readonly barIndex: number,\n    public readonly beatIndex: number,\n    public readonly instance: number,\n    public readonly prevBeat: null | Beat,\n    public nextBeat: null | Beat,\n  ) {}\n\n  /**\n   * Returns a debug-friendly representation of this Beat.\n   * @returns An object containing debug information\n   */\n  debugValue(): any {\n    return {\n      index: this.index,\n      role: this.role.name,\n      offset: this.offset.toString(),\n      duration: this.duration.toString(),\n      barIndex: this.barIndex,\n      beatIndex: this.beatIndex,\n      instance: this.instance,\n      atom: this.atom.debugValue(),\n    };\n  }\n\n  /**\n   * Gets the end offset of this beat (offset + duration).\n   */\n  get endOffset(): Fraction {\n    return this.offset.plus(this.duration);\n  }\n\n  /**\n   * Checks if this beat is filled completely (no remaining space).\n   */\n  get filled(): boolean {\n    return this.remaining.isZero;\n  }\n\n  /**\n   * Gets the remaining duration available in this beat.\n   */\n  get remaining(): Fraction {\n    return this.atom ? this.duration.minus(this.atom.duration, true) : this.duration;\n  }\n\n  /**\n   * Adds an atom to this beat.\n   * @param atom The atom to add\n   * @returns True if the atom was added successfully, false if there's not enough space\n   */\n  add(atom: Atom): boolean {\n    if (this.remaining.cmp(atom.duration) < 0) {\n      return false;\n    }\n    if (!this.atom) {\n      this.atom = atom;\n    } else {\n      if (!this.atomIsPlaceholder) {\n        this.atomIsPlaceholder = true;\n        this.atom = new Group(this.atom).setDuration(ONE, true);\n      }\n      (this.atom as Group).addAtoms(true, atom);\n    }\n    return true;\n  }\n\n  /**\n   * Gets all markers that should be displayed before this beat.\n   * @returns An array of Marker objects\n   */\n  get preMarkers(): Marker[] {\n    const out = [] as Marker[];\n    let curr: Atom | null = this.atom;\n    while (curr != null) {\n      for (const marker of curr.markersBefore || []) {\n        out.push(marker);\n      }\n      if (curr.TYPE == AtomType.GROUP) {\n        curr = (curr as Group).atoms.first;\n      } else {\n        curr = null;\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Gets all markers that should be displayed after this beat.\n   * @returns An array of Marker objects\n   */\n  get postMarkers(): Marker[] {\n    const out = [] as Marker[];\n    let curr: Atom | null = this.atom;\n    while (curr != null) {\n      out.splice(0, 0, ...(curr.markersAfter || []));\n      if (curr.TYPE == AtomType.GROUP) {\n        curr = (curr as Group).atoms.last;\n      } else {\n        curr = null;\n      }\n    }\n    return out;\n  }\n}\n\n/**\n * Builds a sequence of beats from atoms according to layout parameters.\n * Used to convert a flat sequence of atoms into structured beats for display.\n */\nexport class BeatsBuilder {\n  /** All atoms divided into beats */\n  readonly beats: Beat[] = [];\n  readonly startIndex: number;\n  readonly beatOffset: Fraction;\n  cycleIter: CycleIterator;\n  windowIter: WindowIterator;\n\n  /** Callback for when an atom is added to this role */\n  onAtomAdded: (atom: Atom, beat: Beat) => void;\n\n  /** Callback for when a new beat is added */\n  onBeatAdded: (beat: Beat) => void;\n\n  /** Callback for when a beat has been filled */\n  onBeatFilled: (beat: Beat) => void;\n\n  /**\n   * Creates a new BeatsBuilder.\n   * @param role The role containing the atoms\n   * @param layoutParams Layout parameters for structuring beats\n   * @param startOffset The starting offset for the first beat, defaults to ZERO\n   * @param atoms Initial atoms to add to the beats\n   */\n  constructor(\n    public readonly role: Role,\n    public readonly layoutParams: LayoutParams,\n    public readonly startOffset: Fraction = ZERO,\n    ...atoms: Atom[]\n  ) {\n    const [, [bar, beat, instance], beatOffset, index] = layoutParams.cycle.getPosition(startOffset);\n    this.cycleIter = layoutParams.cycle.iterateBeats(bar, beat, instance);\n    this.windowIter = new WindowIterator();\n    this.beatOffset = beatOffset;\n\n    // evaluate the start beatindex - typically it would be 0 if things start\n    // at beginning of a cycle.  But if the start offset is < 0 then the\n    // startIndex should also shift accordingly\n    this.startIndex = index;\n    this.addAtoms(...atoms);\n  }\n\n  /**\n   * Adds atoms to be processed into beats.\n   * @param atoms The atoms to add\n   */\n  addAtoms(...atoms: Atom[]): void {\n    // First add all atoms to the atom Iterator so we can\n    // fetch them as FlatAtoms.  This is needed because atoms\n    // passed here could be unflatted (via groups) or much larger\n    // than what can fit in the given role/bar etc.  So this\n    // flattening and windowing is needed before we add them\n    // to the views - and this is done by the durationIterators.\n    this.windowIter.push(...atoms);\n    while (this.windowIter.hasMore) {\n      // get the last/current row and add a new one if it is full\n      let currBeat = this.beats[this.beats.length - 1];\n\n      // First add a row if last row is filled\n      if (this.beats.length == 0 || currBeat.filled) {\n        // what should be the beatlengths be here?\n        currBeat = this.addBeat();\n      }\n\n      // For this beat get symbols in all roles\n      const [remAtoms, filled] = this.windowIter.get(currBeat.remaining);\n      TSU.assert(remAtoms.length > 0, \"Atleast one element should have been available here\");\n      // render the atoms now\n      for (const atom of remAtoms) {\n        // console.log(\"Adding FA: \", flatAtom.debugValue(), flatAtom.atom);\n        TSU.assert(currBeat.add(atom), \"Should return true as we are already using a duration iterator here\");\n        if (this.onAtomAdded) this.onAtomAdded(atom, currBeat);\n      }\n      if (currBeat.filled) {\n        if (this.onBeatFilled) this.onBeatFilled(currBeat);\n      }\n    }\n  }\n\n  /**\n   * Adds a new beat to the sequence.\n   * @returns The newly created beat\n   */\n  protected addBeat(): Beat {\n    const numBeats = this.beats.length;\n    const lastBeat = numBeats == 0 ? null : this.beats[numBeats - 1];\n    const nextCP: [CyclePosition, Fraction] = this.cycleIter.next().value;\n    const apb = this.layoutParams.beatDuration;\n    const newBeat = new Beat(\n      lastBeat == null ? this.startIndex : lastBeat.index + 1,\n      this.role,\n      lastBeat == null ? this.startOffset.minus(this.beatOffset).timesNum(apb, true) : lastBeat.endOffset,\n      nextCP[1].timesNum(apb),\n      nextCP[0][0],\n      nextCP[0][1],\n      nextCP[0][2],\n      lastBeat,\n      null,\n    );\n    if (lastBeat == null && this.beatOffset.isGT(ZERO)) {\n      // Add spaces to fill up empty beats\n      newBeat.add(new Space(this.beatOffset.timesNum(apb)));\n    }\n    if (lastBeat) lastBeat.nextBeat = newBeat;\n    this.beats.push(newBeat);\n    if (this.onBeatAdded) this.onBeatAdded(newBeat);\n    return newBeat;\n  }\n}\n\n/**\n * Represents a column of beats in a layout grid.\n * Used for aligning beats vertically in the notation.\n */\nexport class BeatColumn extends ColAlign {\n  /** Spacing between atoms in this column */\n  atomSpacing = 2;\n  /** Unique key for this column */\n  readonly key: string;\n\n  /**\n   * Creates a new BeatColumn.\n   * @param offset The starting offset of this column\n   * @param endOffset The ending offset of this column\n   * @param markerType The type of marker for this column (negative: before, positive: after, zero: normal)\n   */\n  constructor(\n    public readonly offset: Fraction,\n    public readonly endOffset: Fraction,\n    public readonly markerType: number,\n  ) {\n    super();\n    offset = offset.factorized;\n    endOffset = endOffset.factorized;\n    this.key = BeatColumn.keyFor(offset, endOffset, markerType);\n  }\n\n  /**\n   * Generates a key for identifying columns with the same offsets and marker type.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker (negative: before, positive: after, zero: normal)\n   * @returns A string key\n   */\n  static keyFor(offset: Fraction, endOffset: Fraction, markerType = 0): string {\n    offset = offset.factorized;\n    endOffset = endOffset.factorized;\n    if (markerType < 0) {\n      // return the column for the marker \"before\" this col\n      // int his case only the \"start offset\" is needed and length doesnt matter\n      return \":\" + offset.toString();\n    } else if (markerType > 0) {\n      // return the column for the marker \"after\" this col\n      // in this case only thd end offset matters\n      return endOffset.toString() + \":\";\n    } else {\n      return offset.toString() + \":\" + endOffset.toString();\n    }\n  }\n}\n\n/**\n * Manages the organization of beats into columns based on their offsets.\n * Used to create a directed acyclic graph (DAG) of beat columns for layout purposes.\n *\n * Grouping of beats by their column based on the layout params.\n * The confusion is we have beats broken up and saved in columns\n * but we are loosing how a line is supposed to access it in its own way\n * we have beatsByRole for getting all beats for a role (in a line)\n * sequentially we have beatColumns for getting all beats in a particular\n * column across all lines and roles globally.\n *\n * What we want here is for a given line get all roles, their beats\n * in zipped way.  eg for a Line with 3 roles and say 10 beats each\n * (with the breaks of 4, 1) we need:\n *\n * R1 B1 R1 B2 R1 B3 R1 B4\n * R2 B1 R2 B2 R2 B3 R2 B4\n * R3 B1 R3 B2 R3 B3 R3 B4\n *\n * R1 B5\n * R2 B5\n * R3 B5\n *\n * R1 B6 R1 B7 R1 B8 R1 B9\n * R2 B6 R2 B7 R2 B8 R2 B9\n * R3 B6 R3 B7 R3 B8 R3 B9\n *\n * R1 B10\n * R2 B10\n * R3 B10\n *\n *\n * Here we have 5 distinct beat columns:\n *\n * 1: R1B1, R2B1, R3B1, R1B6, R2B6, R3B6,\n * 2: R1B2, R2B2, R3B2, R1B7, R2B7, R3B7,\n * 3: R1B3, R2B3, R3B3, R1B8, R2B8, R3B8,\n * 4: R1B4, R2B4, R3B4, R1B9, R2B9, R3B9,\n * 5: R1B5, R2B5, R3B5, R1B10, R2B10, R3B10,\n *\n */\nexport class BeatColDAG {\n  /** Map of column keys to BeatColumn objects */\n  beatColumns = new Map<string, BeatColumn>();\n\n  /**\n   * Creates a new BeatColDAG.\n   * @param layoutGroup The layout group to associate with this DAG\n   */\n  constructor(public readonly layoutGroup: GridLayoutGroup) {\n    //\n  }\n\n  /**\n   * Gets the beat column for a given duration at the specified offset.\n   * Creates a new column if none exists.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker\n   * @returns The BeatColumn for the specified parameters\n   */\n  getBeatColumn(offset: Fraction, endOffset: Fraction, markerType = 0): BeatColumn {\n    const [bcol, newcreated] = this.ensureBeatColumn(offset, endOffset, markerType);\n    if (newcreated) {\n      if (markerType == 0) {\n        const [prevcol] = this.ensureBeatColumn(offset, endOffset, -1);\n        const [nextcol] = this.ensureBeatColumn(offset, endOffset, 1);\n        prevcol.addSuccessor(bcol);\n        bcol.addSuccessor(nextcol);\n        for (const other of this.beatColumns.values()) {\n          // only join the \"marker\" columns\n          if (other.markerType == -1 && endOffset.equals(other.offset)) {\n            // our next col is a preecessor of other\n            nextcol.addSuccessor(other);\n          } else if (other.markerType == 1 && other.endOffset.equals(offset)) {\n            // our prev col is a predecessor of other\n            other.addSuccessor(prevcol);\n          }\n        }\n      }\n    }\n    return bcol;\n  }\n\n  /**\n   * Ensures a beat column exists for the given parameters.\n   * @param offset The starting offset\n   * @param endOffset The ending offset\n   * @param markerType The type of marker\n   * @returns A tuple containing the column and whether it was newly created\n   */\n  protected ensureBeatColumn(offset: Fraction, endOffset: Fraction, markerType = 0): [BeatColumn, boolean] {\n    const key = BeatColumn.keyFor(offset, endOffset, markerType);\n    let bcol = this.beatColumns.get(key) || null;\n    const newcreated = bcol == null;\n    if (!bcol) {\n      bcol = new BeatColumn(offset, endOffset, markerType);\n      this.beatColumns.set(key, bcol);\n    }\n    return [bcol, newcreated];\n  }\n}\n\n/** Type alias for line IDs */\ntype LineId = number;\n/** Type alias for layout parameter IDs */\ntype LPID = number;\n\n/**\n * Manages the beat layouts for all lines in a notation.\n * Handles the creation of grid models, positioning of beats, and alignment of beats across lines.\n */\nexport class GlobalBeatLayout {\n  /** Map of line IDs to grid models */\n  gridModelsForLine = new Map<LineId, GridModel>();\n  /** Map of line IDs to arrays of beats for each role */\n  roleBeatsForLine = new Map<LineId, Beat[][]>();\n  /** Map of layout parameter IDs to beat column DAGs */\n  beatColDAGsByLP = new Map<LPID, BeatColDAG>();\n  /** The global layout group for all grid models */\n  readonly gridLayoutGroup: GridLayoutGroup;\n\n  /**\n   * Creates a new GlobalBeatLayout.\n   * @param sharedGridLayoutGroup Optional shared GridLayoutGroup for column alignment across multiple views.\n   *                               If not provided, a new GridLayoutGroup is created internally.\n   */\n  constructor(sharedGridLayoutGroup?: GridLayoutGroup) {\n    this.gridLayoutGroup = sharedGridLayoutGroup ?? new GridLayoutGroup();\n  }\n\n  /**\n   * Gets the GridModel associated with a particular line, creating one if it doesn't exist.\n   * @param lineid The ID of the line\n   * @returns The GridModel for the line\n   */\n  getGridModelForLine(lineid: LineId): GridModel {\n    let out = this.gridModelsForLine.get(lineid) || null;\n    if (!out) {\n      out = new GridModel();\n      this.gridLayoutGroup.addGridModel(out);\n      this.gridModelsForLine.set(lineid, out);\n    }\n    return out;\n  }\n\n  /**\n   * Gets the BeatColDAG for a specific layout parameter ID, creating one if it doesn't exist.\n   * @param lpid The layout parameter ID\n   * @returns The BeatColDAG for the layout parameters\n   */\n  protected beatColDAGForLP(lpid: LPID): BeatColDAG {\n    let out = this.beatColDAGsByLP.get(lpid) || null;\n    if (!out) {\n      out = new BeatColDAG(this.gridLayoutGroup);\n      this.beatColDAGsByLP.set(lpid, out);\n    }\n    return out;\n  }\n\n  /**\n   * Adds a line to the beat layout.\n   * This ensures that a line is broken down into beats and added into a dedicated GridModel.\n   *\n   * A line must also be given the layout params by which the beat breakdown will happen.\n   * This LayoutParams object does not have to be unique per line (this non-constraint allows\n   * beats to be aligned across lines).\n   *\n   * @param line The line to add\n   */\n  addLine(line: Line): void {\n    const gridModel = this.getGridModelForLine(line.uuid) as GridModel;\n    gridModel.eventHub?.startBatchMode();\n    this.lineToRoleBeats(line, gridModel);\n    gridModel.eventHub?.commitBatch();\n  }\n\n  /**\n   * Recursively processes a block and its children to build beat layouts.\n   * Uses block.children() to get expanded children (e.g., RepeatBlock expands to N copies).\n   *\n   * @param block The block to process\n   */\n  processBlock(block: Block): void {\n    for (const child of block.children()) {\n      this.processBlockItem(child);\n    }\n  }\n\n  /**\n   * Processes a single block item (Block, Line, or RawBlock).\n   *\n   * @param item The item to process\n   */\n  protected processBlockItem(item: BlockItem): void {\n    if (isLine(item)) {\n      const line = item as Line;\n      if (!line.isEmpty && line.layoutParams != null) {\n        this.addLine(line);\n      }\n    } else if (isBlock(item)) {\n      this.processBlock(item as Block);\n    }\n    // RawBlocks are ignored (no beat layout for raw content)\n  }\n\n  /**\n   * Converts a line into a series of beats for each role.\n   * @param line The line to convert\n   * @param gridModel The grid model to use\n   * @returns Arrays of beats for each role\n   */\n  protected lineToRoleBeats(line: Line, gridModel: GridModel): Beat[][] {\n    const lp = line.layoutParams;\n    const roleBeats = [] as Beat[][];\n    this.roleBeatsForLine.set(line.uuid, roleBeats);\n    const lineOffset = line.offset.divbyNum(lp.beatDuration);\n    for (const role of line.roles) {\n      const bb = new BeatsBuilder(role, lp, lineOffset, ...role.atoms);\n      roleBeats.push(bb.beats);\n\n      // Add these to the beat layout too\n      for (const beat of bb.beats) {\n        // beat.ensureUniformSpaces(layoutParams.beatDuration);\n        this.addBeat(beat, gridModel);\n      }\n    }\n    return roleBeats;\n  }\n\n  /**\n   * Adds a beat to the layout.\n   * @param beat The beat to add\n   * @param gridModel The grid model to add the beat to\n   * @returns The grid cell containing the beat\n   */\n  protected addBeat(beat: Beat, gridModel: GridModel): GridCell {\n    // Get the beat column at this index (and line) and add to it.\n    const line = beat.role.line;\n    const lp = line.layoutParams;\n    const beatColDAG = this.beatColDAGForLP(lp.uuid);\n    const [layoutLine, layoutColumn, rowOffset] = lp.getBeatLocation(beat);\n    const colEnd = rowOffset.plus(beat.duration, true);\n    const bcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 0);\n\n    // Since a beat's column has a \"pre\" and \"post\" col to, each\n    // beat has 3 columns for it\n    const roleIndex = beat.role.line.indexOfRole(beat.role.name);\n    const nthLine = Math.floor(beat.index / lp.totalBeats);\n    const realLine = lp.lineBreaks.length * nthLine + layoutLine;\n    const realRow = line.roles.length * realLine + roleIndex;\n    // pre marker goes on realCol - 1, post marker goes on realCol + 1\n    const realCol = 1 + layoutColumn * 3;\n    const preMarkers = beat.preMarkers;\n    if (preMarkers.length > 0) {\n      const val = {\n        beat: beat,\n        markers: preMarkers,\n      };\n      const precol = beatColDAG.getBeatColumn(rowOffset, colEnd, -1);\n      gridModel.setValue(realRow, realCol - 1, val, (gridRow: GridRow, col: number) => {\n        const cell = new GridCell(gridRow, col);\n        cell.colAlign = precol;\n        return cell;\n      });\n    }\n    const postMarkers = beat.postMarkers;\n    if (postMarkers.length > 0) {\n      const val = {\n        beat: beat,\n        markers: postMarkers,\n      };\n      const postcol = beatColDAG.getBeatColumn(rowOffset, colEnd, 1);\n      gridModel.setValue(realRow, realCol + 1, val, (gridRow: GridRow, col: number) => {\n        const cell = new GridCell(gridRow, col);\n        cell.colAlign = postcol;\n        return cell;\n      });\n    }\n    return gridModel.setValue(realRow, realCol, beat, (gridRow: GridRow, col: number) => {\n      const cell = new GridCell(gridRow, col);\n      cell.colAlign = bcol;\n      return cell;\n    });\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n\ntype EdgeData = any;\ntype EdgeFunctor<T> = (node: T) => ReadonlyArray<[T, EdgeData]>;\ntype IDFunc<T> = (t: T) => number | string;\n\nexport function allMinimalCycles<T>(\n  nodes: ReadonlyArray<T>,\n  idFunc: IDFunc<T>,\n  edges: EdgeFunctor<T>,\n): ReadonlyArray<[T, EdgeData]> {\n  // Tells which cycle a node is assigned to if any\n  const cycles: [T, EdgeData][] = [];\n  const inACycle = {} as any;\n  nodes.forEach((node) => {\n    // start from node and do a BFS to see what cycle a node appears in\n    if (!(idFunc(node) in inACycle)) {\n      const startNode = node;\n      const visited = {} as any;\n      let queue: [T, [EdgeData, T][]][] = [[node, []]];\n      while (queue.length > 0) {\n        const newQueue: [T, [EdgeData, T][]][] = [];\n        for (let i = 0; i < queue.length; i++) {\n          const [node, c] = queue[i];\n          TSU.assert(node != null);\n          const e = edges(node);\n          let cycle = [...c];\n          for (const [nextNode, edgeData] of e) {\n            if (nextNode == startNode) {\n              // we have a cycle\n              cycle.push([edgeData, nextNode]);\n              cycle.forEach(([e, n], i) => (inACycle[n] = true));\n              cycles.push([startNode, cycle]);\n              cycle = cycle.slice(0, cycle.length - 1);\n            } else if (!(idFunc(nextNode) in visited)) {\n              visited[idFunc(nextNode)] = true;\n              newQueue.push([nextNode, [...cycle, [edgeData, nextNode]]]);\n            }\n          }\n        }\n        queue = newQueue;\n      }\n    }\n  });\n  return cycles;\n}\n\nexport function digraph(): void {\n  //\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Grammar, Sym, Str, Rule } from \"./grammar\";\n\ntype NumMap<T> = TSU.NumMap<T>;\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\nconst defaultKeyFunc = (x: any) => x.key;\n\nexport class Trie<T> {\n  protected keyFunc: (t: T) => string;\n  readonly root: TrieNode<T> = new TrieNode();\n\n  constructor(keyFunc: (t: T) => string) {\n    this.keyFunc = keyFunc;\n  }\n\n  add(values: T[], fromIndex = 0): TrieNode<T> {\n    // we are at the bottom\n    let curr = this.root;\n    for (let i = fromIndex; i < values.length; i++) {\n      const key = this.keyFunc(values[i]);\n      if (curr.children.has(key)) {\n        curr = curr.children.get(key)!;\n      } else {\n        const newNode = new TrieNode<T>();\n        newNode.value = values[i];\n        newNode.parent = curr;\n        curr.children.set(key, newNode);\n        curr = newNode;\n      }\n    }\n    curr.isLeaf = true;\n    return curr;\n  }\n\n  get debugValue(): any {\n    return this.root.debugValue;\n  }\n}\n\nexport class TrieNode<T> {\n  isLeaf = false;\n  value: Nullable<T> = null;\n  parent: Nullable<TrieNode<T>> = null;\n  children = new Map<string, TrieNode<T>>();\n\n  get debugValue(): any {\n    const out = { value: this.value, children: {} as any } as any;\n    if (this.isLeaf) out[\"isLeaf\"] = true;\n    for (const [key, value] of this.children.entries()) {\n      out.children[key] = value.debugValue;\n    }\n    return out;\n  }\n}\n\nexport class IDSet<T extends { id: number }> {\n  protected _entries: T[] = [];\n  protected _entriesByKey: StringMap<T> = {};\n  protected keyFunc: (t: T) => string;\n\n  constructor(keyFunc: (t: T) => string = defaultKeyFunc) {\n    this.keyFunc = keyFunc;\n  }\n\n  clear(): void {\n    this._entries = [];\n    this._entriesByKey = {};\n  }\n\n  /**\n   * Removes all entries that match a predict.\n   */\n  remove(predicate: (t: T) => boolean): boolean {\n    const e2: T[] = [];\n    this._entriesByKey = {};\n    let modified = false;\n    for (let l = 0; l < this._entries.length; l++) {\n      const e = this._entries[l];\n      if (!predicate(e)) {\n        // keep it if predicate failes\n        e.id = e2.length;\n        e2.push(e);\n        this._entriesByKey[this.keyFunc(e)] = e;\n      } else {\n        modified = true;\n      }\n    }\n    this._entries = e2;\n    return modified;\n  }\n\n  get entries(): ReadonlyArray<T> {\n    return this._entries;\n  }\n\n  get(id: number): T {\n    TSU.assert(id >= 0 && id < this._entries.length);\n    return this._entries[id];\n  }\n\n  getByKey(key: string): Nullable<T> {\n    return this._entriesByKey[key] || null;\n  }\n\n  ensure(entry: T, throwIfExists = false): T {\n    // see if this itemset exists\n    if (this.has(entry)) {\n      if (throwIfExists) throw new Error(`Entry ${this.keyFunc(entry)} already exists`);\n      return this._entriesByKey[this.keyFunc(entry)];\n    } else {\n      this._entriesByKey[this.keyFunc(entry)] = entry;\n      entry.id = this._entries.length;\n      this._entries.push(entry);\n      return entry;\n    }\n  }\n\n  has(entry: T): boolean {\n    return this.keyFunc(entry) in this._entriesByKey;\n  }\n\n  get size(): number {\n    return this._entries.length;\n  }\n}\n\nexport class SymbolSet {\n  readonly grammar: Grammar;\n  readonly enforceSymbolType: Nullable<boolean>;\n  entries = new Set<number>();\n  hasNull = false;\n\n  constructor(grammar: Grammar, enforceSymbolType: Nullable<boolean> = true) {\n    this.grammar = grammar;\n    this.enforceSymbolType = enforceSymbolType;\n  }\n\n  get debugString(): string {\n    return \"<\" + this.labels().sort().join(\", \") + \">\";\n  }\n\n  labels(skipAux = false): string[] {\n    const out: string[] = [];\n    for (const i of this.entries) {\n      const exp = this.grammar.getSymById(i);\n      TSU.assert(exp != null);\n      if (!skipAux || !exp.isAuxiliary) out.push(exp.label);\n    }\n    if (this.hasNull) out.push(\"\");\n    return out;\n  }\n\n  addFrom(another: SymbolSet, includeNull = true): number {\n    return another.addTo(this, includeNull);\n  }\n\n  addTo(another: SymbolSet, includeNull = true): number {\n    const before = another.entries.size;\n    for (const termid of this.entries) {\n      another.entries.add(termid);\n    }\n    if (includeNull) {\n      another.hasNull = this.hasNull || another.hasNull;\n    }\n    return another.entries.size - before;\n  }\n\n  has(term: Sym): boolean {\n    return this.entries.has(term.id);\n  }\n\n  add(term: Sym): this {\n    TSU.assert(\n      this.enforceSymbolType == null || this.enforceSymbolType == term.isTerminal,\n      `Terminal types being enforced: ${this.enforceSymbolType}`,\n    );\n    this.entries.add(term.id);\n    return this;\n  }\n\n  delete(term: Sym): boolean {\n    return this.entries.delete(term.id);\n  }\n\n  get size(): number {\n    return this.entries.size + (this.hasNull ? 1 : 0);\n  }\n}\n\n/**\n * Tells which non terminals are nullables.\n */\nexport class NullableSet {\n  readonly grammar: Grammar;\n  entries: Set<number>;\n  private visited: any;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n    this.refresh();\n  }\n\n  get nonterms(): Sym[] {\n    const out: Sym[] = [];\n    this.entries.forEach((id) => {\n      const e = this.grammar.getSymById(id);\n      TSU.assert(e != null && !e.isTerminal);\n      out.push(e);\n    });\n    return out;\n  }\n\n  refresh(): void {\n    // Nuke entries cache.  Will force isNullable to recompute.\n    this.entries = new Set();\n    this.visited = {};\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.entries.size;\n      this.grammar.allNonTerminals.forEach((nt) => this.visit(nt));\n    } while (beforeCount != this.entries.size);\n  }\n\n  protected visit(nt: Sym): void {\n    for (const rule of this.grammar.rulesForNT(nt)) {\n      if (this.isStrNullable(rule.rhs)) {\n        this.add(nt);\n        break;\n      }\n    }\n  }\n\n  isNullable(nt: Sym): boolean {\n    return !nt.isTerminal && this.entries.has(nt.id);\n  }\n\n  isStrNullable(str: Str, fromIndex = 0, toIndex: Nullable<number> = null): boolean {\n    if (toIndex == null) {\n      toIndex = str.length - 1;\n    }\n    for (let i = fromIndex; i <= toIndex; i++) {\n      if (!this.isNullable(str.syms[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  add(nt: Sym): void {\n    TSU.assert(!nt.isTerminal);\n    this.entries.add(nt.id);\n  }\n}\n\nclass SymSymbolSets {\n  readonly grammar: Grammar;\n  entries: NumMap<SymbolSet> = {};\n  private _count = 0;\n\n  constructor(grammar: Grammar) {\n    this.grammar = grammar;\n  }\n\n  refresh(): void {\n    this.entries = {};\n    this._count = 0;\n  }\n\n  forEachTerm(nt: Sym, visitor: (x: Nullable<Sym>) => boolean | void): void {\n    const entries = this.entriesFor(nt);\n    entries.entries.forEach((x) => {\n      const term = this.grammar.getSymById(x);\n      TSU.assert(term != null && term.isTerminal);\n      visitor(term);\n    });\n    if (entries.hasNull) visitor(null);\n  }\n\n  get debugValue(): any {\n    const out = {} as any;\n    for (const x in this.entries) out[this.grammar.getSymById(x as any)!.label] = this.entries[x].debugString;\n    return out;\n  }\n\n  get count(): number {\n    let c = 0;\n    for (const x in this.entries) c += this.entries[x].size;\n    return c;\n    // TSU.assert(c == this._count, \"Count mismatch\")\n    // return this._count;\n  }\n\n  entriesFor(sym: Sym): SymbolSet {\n    if (sym.id in this.entries) {\n      return this.entries[sym.id];\n    } else {\n      const out = new SymbolSet(this.grammar);\n      this.entries[sym.id] = out;\n      return out;\n    }\n  }\n\n  /**\n   * Add the null symbol into this set of terminals for a given expression.\n   */\n  addNull(nt: Sym): boolean {\n    const entries = this.entriesFor(nt);\n    if (entries.hasNull) return false;\n    entries.hasNull = true;\n    return true;\n  }\n\n  /**\n   * Add a Null, term or another expression to the set of terminals\n   * for a given expression.  If source is an expression then all\n   * of the source expression's terminal symbosl are added to exp's\n   * term set.\n   */\n  add(nt: Sym, source: Sym, includeNull = true): boolean {\n    if (nt.isTerminal) {\n      TSU.assert(false, \"Should not be here\");\n    }\n    const entries = this.entriesFor(nt);\n    if (source.isTerminal) {\n      if (entries.has(source)) return false;\n      // console.log(`Adding Term(${term.label}) to Set of ${exp.id}`);\n      entries.add(source);\n      this._count++;\n    } else {\n      const srcEntries = this.entriesFor(source);\n      const destEntries = this.entriesFor(nt);\n      const count = srcEntries.addTo(destEntries, includeNull);\n      this._count += count;\n    }\n    return true;\n  }\n}\n\n/**\n * For each symbol maps its label to a list of terminals that\n * start that non terminal.\n */\nexport class FirstSets extends SymSymbolSets {\n  readonly nullables: NullableSet;\n\n  constructor(grammar: Grammar, nullables?: NullableSet) {\n    super(grammar);\n    if (!nullables) {\n      nullables = new NullableSet(grammar);\n    }\n    this.nullables = nullables;\n    this.refresh();\n  }\n\n  /**\n   * For a given string return the first(str) starting at a given index.\n   * Including eps if it exists.\n   */\n  forEachTermIn(str: Str, fromIndex = 0, visitor: (term: Nullable<Sym>) => void): void {\n    // This needs to be memoized by exp.id + index\n    const syms = str.syms;\n    const visited = {} as any;\n    let allNullable = true;\n    for (let j = fromIndex; allNullable && j < syms.length; j++) {\n      const symj = syms[j];\n      if (symj.isTerminal) {\n        visitor(symj);\n        allNullable = false;\n      } else {\n        const nt = symj as Sym;\n        this.forEachTerm(nt, (term) => {\n          if (term != null && !(term.id in visited)) {\n            visited[term.id] = true;\n            visitor(term);\n          }\n        });\n        if (!this.nullables.isNullable(symj as Sym)) {\n          allNullable = false;\n        }\n      }\n    }\n    if (allNullable) visitor(null);\n  }\n\n  /**\n   * Reevaluates the first sets of a grammar.\n   * This method assumes that the grammar's nullables are fresh.\n   */\n  refresh(): void {\n    super.refresh();\n    // this.grammar.terminals.forEach((t) => this.add(t, t));\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.count;\n      this.grammar.forEachRule(null, (rule) => {\n        this.processRule(rule);\n      });\n    } while (beforeCount != this.count);\n  }\n\n  processRule(rule: Rule): void {\n    const nullables = this.nullables;\n    let allNullable = true;\n    for (const s of rule.rhs.syms) {\n      // First(s) - null will be in First(nonterm)\n      // Null will onlybe added if all symbols are nullable\n      this.add(rule.nt, s, false);\n      if (s.isTerminal || !nullables.isNullable(s as Sym)) {\n        // since s is not nullable the next rule's first set\n        // cannot affect nonterm's firs set\n        allNullable = false;\n        break;\n      }\n    }\n    if (allNullable) this.addNull(rule.nt);\n  }\n}\n\n/**\n * For each symbol maps its label to a list of terminals that\n * start that non terminal.\n */\nexport class FollowSets extends SymSymbolSets {\n  readonly firstSets: FirstSets;\n\n  constructor(grammar: Grammar, firstSets?: FirstSets) {\n    super(grammar);\n    this.firstSets = firstSets || new FirstSets(grammar);\n    this.refresh();\n  }\n\n  get nullables(): NullableSet {\n    return this.firstSets.nullables;\n  }\n\n  /**\n   * Reevaluates the follow sets of each expression in our grammar.\n   * This method assumes that the grammar's nullables and firstSets are\n   * up-to-date.\n   */\n  refresh(): void {\n    super.refresh();\n    const g = this.grammar;\n    TSU.assert(g.startSymbol != null, \"Select start symbol of the grammar\");\n    this.add(g.startSymbol, g.Eof);\n\n    let beforeCount = 0;\n    do {\n      beforeCount = this.count;\n      this.grammar.forEachRule(null, (rule) => this.processRule(rule));\n    } while (beforeCount != this.count);\n  }\n\n  /**\n   * Add Follows[source] into Follows[dest] recursively.\n   */\n  processRule(rule: Rule): void {\n    const syms = rule.rhs.syms;\n    const firstSets = this.firstSets;\n    const nullables = this.firstSets.nullables;\n\n    // Rule 1:\n    //  If A -> aBb1b2b3..bn:\n    //    Follow(B) = Follow(B) U { First(b1b2b3...bn) - eps }\n    for (let i = 0; i < syms.length; i++) {\n      const sym = syms[i];\n      if (sym.isTerminal) continue;\n      firstSets.forEachTermIn(rule.rhs, i + 1, (term) => {\n        if (term != null) this.add(sym, term);\n      });\n    }\n\n    // Rule 2:\n    //  If A -> aBb1b2b3..bn:\n    //    if Nullable(b1b2b3...bn):\n    //      Follow(B) = Follow(B) U Follow(N)\n    for (let i = syms.length - 1; i >= 0; i--) {\n      if (syms[i].isTerminal) continue;\n\n      // This needs to be memoized??\n      let allNullable = true;\n      for (let j = i + 1; j < syms.length; j++) {\n        const symj = syms[j];\n        if (symj.isTerminal || !nullables.isNullable(symj as Sym)) {\n          allNullable = false;\n          break;\n        }\n      }\n      if (allNullable) {\n        this.add(syms[i], rule.nt);\n      }\n    }\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { allMinimalCycles } from \"./graph\";\nimport { IDSet, SymbolSet, FirstSets, FollowSets, NullableSet } from \"./sets\";\n\ntype StringMap<T> = TSU.StringMap<T>;\ntype Nullable<T> = TSU.Nullable<T>;\n\n/**\n * Symbols represent both terminals and non-terminals in our system.\n * Chosing a convention of using a single class to represent both instead\n * of a base class with Term and NonTerm children has the following effects:\n * 1. We can change the type of a literal when doing things like reading\n *    a grammar DSL when we dont konw if a symbol is a term or non-term\n *    until *all* the declarations have been read and parsed.\n * 2. The down side of this we would need more explicit isTerm checks\n *    but we would have done that anyway by calling getTerm and getNT\n *    verions of the getSym method.\n */\nexport class Sym {\n  isAuxiliary = false;\n  auxType: string | null = null;\n  precedence = 1;\n  assocLeft = true;\n\n  private static idCounter = -1;\n\n  /**\n   * An ID assigned to indicate order of \"creation\" of this symbol in the grammar.\n   */\n  creationId = -1;\n\n  /**\n   * ID unique across all expression within the grammar.\n   */\n  id: number;\n\n  /**\n   * Creates a new symbol in the grammar.\n   *\n   * @param   grammar     Grammar this symbol belongs to.\n   * @param   label       Label for the symbol.\n   * @param   isTerminal  Whether the symbol is a terminal or not.\n   * @param   id          ID unique across all expression within the\n   *                      grammar.\n   */\n  constructor(\n    public readonly grammar: Grammar,\n    public readonly label: string,\n    public isTerminal: boolean,\n    id: Nullable<number> = null,\n  ) {\n    this.isTerminal = isTerminal;\n    this.label = label;\n    if (id == null) {\n      this.id = Sym.idCounter--;\n    } else {\n      this.id = id;\n    }\n  }\n\n  compareTo(another: this): number {\n    return this.label.localeCompare(another.label);\n  }\n\n  equals(another: this): boolean {\n    return this.label == another.label;\n  }\n\n  toString(): string {\n    return this.label;\n  }\n}\n\nexport class Str {\n  syms: Sym[];\n\n  constructor(...syms: Sym[]) {\n    this.syms = syms || [];\n  }\n\n  append(...lits: Sym[]): this {\n    for (const l of lits) this.syms.push(l);\n    return this;\n  }\n\n  extend(...strs: Str[]): this {\n    for (const s of strs) this.append(...s.syms);\n    return this;\n  }\n\n  copy(): Str {\n    return new Str(...this.syms);\n  }\n\n  add(lit: Sym): void {\n    this.syms.push(lit);\n  }\n\n  isTerminal(index: number): boolean {\n    return this.syms[index].isTerminal;\n  }\n\n  get length(): number {\n    return this.syms.length;\n  }\n\n  toString(): string {\n    return this.syms.map((s) => s.toString()).join(\" \");\n  }\n\n  slice(startIndex: number, endIndex: number): Str {\n    return new Str(...this.syms.slice(startIndex, endIndex));\n  }\n\n  splice(index: number, numToDelete: number, ...itemsToAdd: Sym[]): Str {\n    this.syms.splice(index, numToDelete, ...itemsToAdd);\n    return this;\n  }\n\n  compareTo(another: this): number {\n    for (let i = 0; i < this.syms.length && i < another.syms.length; i++) {\n      const diff = this.syms[i].compareTo(another.syms[i]);\n      if (diff != 0) return diff;\n    }\n    return this.syms.length - another.syms.length;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  /**\n   * Returns true if another string is a substring within\n   * this string at the given offset.\n   */\n  containsAt(offset: number, another: Str): boolean {\n    let i = 0;\n    for (; i < another.length && offset + i < this.syms.length; i++) {\n      if (!this.syms[offset + i].equals(another.syms[i])) return false;\n      // if (this.cardinalities[i] != another.cardinalities[i]) return false;\n    }\n    return i == another.length;\n  }\n\n  get debugString(): string {\n    return this.syms.map((lit) => lit.label).join(\" \");\n  }\n}\n\nexport class RuleAction {\n  constructor(public value: string | number) {}\n\n  get isFunction(): boolean {\n    return typeof this.value === \"string\";\n  }\n\n  get isChildPosition(): boolean {\n    return typeof this.value === \"number\";\n  }\n}\n\nexport class Rule {\n  id: number;\n  constructor(\n    public nt: Sym,\n    public rhs: Str,\n    public action: RuleAction | null = null,\n  ) {\n    if (nt.isTerminal) {\n      throw new Error(\"Cannot add rules to a terminal\");\n    }\n  }\n\n  get debugString(): string {\n    return `${this.nt.label} -> ${this.rhs.debugString}`;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  compareTo(another: this): number {\n    TSU.assert(!isNaN(this.id));\n    const diff = this.nt.compareTo(another.nt);\n    if (diff == 0) {\n      this.rhs.compareTo(another.rhs);\n    }\n    return diff;\n  }\n}\n\nexport class Grammar {\n  public startSymbol: Nullable<Sym> = null;\n  modified = true;\n  protected symbolSet = new IDSet<Sym>((s) => s.label);\n  protected allRules: Rule[] = [];\n  protected _rulesForNT: Nullable<StringMap<Rule[]>> = null;\n  protected _followSets: Nullable<FollowSets> = null;\n\n  /**\n   * Prefix used for auxiliary symbols.\n   */\n  auxNTPrefix: string;\n\n  readonly Null: Sym;\n  readonly Eof: Sym;\n  private _AugStartRule: Rule;\n  private _hasNull = false;\n\n  /**\n   * A way of creating Grammars with a \"single expresssion\".\n   */\n  static make(callback: (g: Grammar) => void): Grammar {\n    const g = new Grammar();\n    callback(g);\n    return g;\n  }\n\n  constructor(config?: any) {\n    config = config || {};\n    this.auxNTPrefix = config.auxNTPrefix || \"$\";\n    this.Null = this.newTerm(\"\");\n    this.Eof = this.newTerm(\"$end\");\n  }\n\n  rulesForNT(nt: Sym): Rule[] {\n    TSU.assert(!nt.isTerminal);\n    if (this._rulesForNT == null) {\n      this._rulesForNT = {};\n      for (const rule of this.allRules) {\n        if (!(rule.nt.label in this._rulesForNT)) {\n          this._rulesForNT[rule.nt.label] = [];\n        }\n        this._rulesForNT[rule.nt.label].push(rule);\n      }\n    }\n    if (!(nt.label in this._rulesForNT)) {\n      this._rulesForNT[nt.label] = [];\n    }\n    return this._rulesForNT[nt.label];\n  }\n\n  get nullables(): NullableSet {\n    return this.firstSets.nullables;\n  }\n\n  get firstSets(): FirstSets {\n    return this.followSets.firstSets;\n  }\n\n  get followSets(): FollowSets {\n    if (this.modified || this._followSets == null) {\n      this.refresh();\n    }\n    TSU.assert(this._followSets != null);\n    return this._followSets;\n  }\n\n  get augStartRule(): Rule {\n    return this._AugStartRule;\n  }\n\n  augmentStartSymbol(label = \"$accept\"): this {\n    TSU.assert(this._AugStartRule == null, \"Ensure this grammar has not yet been augmented.\");\n    TSU.assert(this.startSymbol != null, \"Start symbol not yet set\");\n    const augSym = this.newNT(label);\n    this._AugStartRule = new Rule(augSym, new Str(this.startSymbol));\n    this.addRule(this._AugStartRule, 0);\n    return this;\n  }\n\n  refresh(): this {\n    this.symbolSet.entries.forEach((s, i) => (s.id = i));\n    this._rulesForNT = null;\n    this.allRules.forEach((rule, i) => {\n      rule.id = i;\n    });\n    this._followSets = new FollowSets(this);\n    this.modified = false;\n    return this;\n  }\n\n  addTerminals(...terminals: string[]): void {\n    for (const t of terminals) {\n      this.newTerm(t);\n    }\n  }\n\n  get terminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => x.isTerminal);\n  }\n\n  get allNonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => !x.isTerminal);\n  }\n\n  get nonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => !x.isTerminal && !x.isAuxiliary);\n  }\n\n  get auxNonTerminals(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries.filter((x) => x.isAuxiliary);\n  }\n\n  get allSymbols(): ReadonlyArray<Sym> {\n    return this.symbolSet.entries;\n  }\n\n  /**\n   * A way to quickly iterate through all non-terminals.\n   */\n  forEachNT(visitor: (nt: Sym) => void | boolean | undefined | null): void {\n    for (const sym of this.symbolSet.entries) {\n      if (sym.isTerminal) continue;\n      if (visitor(sym) == false) return;\n    }\n  }\n\n  /**\n   * A iterator across all the rules for either all non terminals in this grammar\n   * for a single non terminal (if the nt value is non null).\n   *\n   * @param visitor\n   */\n  forEachRule(nt: Nullable<Sym>, visitor: (rule: Rule, index: number) => void | boolean | undefined | null): boolean {\n    const rules = nt == null ? this.allRules : this.rulesForNT(nt) || [];\n    for (let i = 0; i < rules.length; i++) {\n      if (visitor(rules[i], i) == false) return false;\n    }\n    return true;\n  }\n\n  getRule(nt: string | Sym, index: number): Rule {\n    if (typeof nt === \"string\") nt = this.getSym(nt)!;\n    TSU.assert(nt != null);\n    return this.rulesForNT(nt)[index];\n  }\n\n  /**\n   * Return the the index of a rule if it already exists to prevent duplicates.\n   */\n  findRule(nt: Sym, production: Str): number {\n    return this.rulesForNT(nt).findIndex((r) => r.nt == nt && r.rhs.equals(production));\n  }\n\n  /**\n   * Adds a new rule to a particular non terminal of the grammar\n   * Each rule represents a production of the form:\n   *\n   * name -> A B C D;\n   *\n   * Null production can be represented with an empty exps list.\n   */\n  add(nt: string | Sym, production: Str, action: RuleAction | null = null): Rule {\n    let nonterm: Nullable<Sym> = null;\n    if (typeof nt === \"string\") {\n      nonterm = this.getSym(nt);\n      if (nonterm == null) {\n        // create it\n        nonterm = this.newNT(nt);\n      }\n    } else {\n      nonterm = this.ensureSym(nt);\n    }\n    return this.addRule(new Rule(nonterm, production, action));\n  }\n\n  /**\n   * Add a rule directly.\n   */\n  addRule(rule: Rule, index = -1): Rule {\n    if (this.findRule(rule.nt, rule.rhs) >= 0) {\n      throw new Error(\"Duplicate rule: \" + rule.debugString);\n    }\n    rule.id = this.allRules.length;\n    if (rule.rhs.length == 0) this._hasNull = true;\n    if (index < 0) {\n      this.allRules.push(rule);\n    } else {\n      this.allRules.splice(index, 0, rule);\n    }\n    this._rulesForNT = null;\n    // this.rulesForNT(rule.nt).push(rule);\n    this.modified = true;\n    return rule;\n  }\n\n  /**\n   * Removes all rules from the grammar which match the given predicate.\n   */\n  removeRules(pred: (r: Rule) => boolean): boolean {\n    this.allRules = this.allRules.filter((r) => !pred(r));\n    this._rulesForNT = null;\n    this.modified = true;\n    return true;\n  }\n\n  /**\n   * Removes all symbols from the grammar and all of its productions which match\n   * a particular predicate.\n   */\n  removeSymbols(pred: (s: Sym) => boolean): boolean {\n    let modified = false;\n    const newRules: Rule[] = [];\n    this.allRules.forEach((r) => {\n      if (pred(r.nt)) return;\n      // if it was already a null production then leave it\n      if (r.rhs.length == 0) {\n        newRules.push(r);\n      } else {\n        const newRhs = new Str(...r.rhs.syms.filter((s) => !pred(s)));\n        modified = modified || r.rhs.length != newRhs.length;\n        if (newRhs.length > 0) {\n          newRules.push(new Rule(r.nt, newRhs));\n        }\n      }\n    });\n    this.allRules = newRules;\n    modified = this.symbolSet.remove(pred) || modified;\n    this.modified = this.modified || modified;\n    return modified;\n  }\n\n  /**\n   * Gets or creates a terminal with the given label.\n   * The grammar acts as a factory for terminal symbols\n   * so that we can reuse symbols instead of having\n   * users create new symbols each time.\n   *\n   * This also ensures that users are not able mix terminal\n   * and non terminal labels.\n   */\n  getSymById(id: number): Nullable<Sym> {\n    // if (id == Grammar.AUG_SYM_ID) return this._AugStartRule?.nt || null;\n    // else if (id == this.Eof.id) return this.Eof;\n    // else if (id == this.Null.id) return this.Null;\n    return this.symbolSet.get(id);\n  }\n\n  getSym(label: string): Nullable<Sym> {\n    // if (this._AugStartRule && label == this._AugStartRule.nt.label) return this._AugStartRule.nt;\n    return this.symbolSet.getByKey(label);\n  }\n\n  ensureSym(sym: Sym, throwIfExists = false): Sym {\n    const sym2 = this.symbolSet.ensure(sym, throwIfExists);\n    if (sym == sym2) {\n      if (sym2.creationId < 0) {\n        sym2.creationId = this.symbolSet.size;\n      }\n    } else {\n      TSU.assert(!throwIfExists, \"Should have already thrown error\");\n    }\n    return sym2;\n  }\n\n  /**\n   * Ensures that a terminal by a given name exists (creating if\n   * necessary).  If a terminal already exists by this label then\n   * an error is thrown.\n   *\n   * The grammar acts as a factory for terminal and non terminal symbols\n   * so that we can reuse symbols instead of having users create new\n   * symbols each time.  This also ensures that users are not able mix\n   * terminal and non terminal labels.\n   */\n  T(label: string, throwIfExists = false): Sym {\n    let t = this.getSym(label);\n    if (t != null) {\n      if (throwIfExists) throw new Error(`Terminal ${label} is already exists`);\n      if (!t.isTerminal) throw new Error(`Symbol (${label}) already exists as a non-terminal`);\n    } else {\n      t = new Sym(this, label, true);\n      t = this.ensureSym(t, true);\n    }\n    return t;\n  }\n\n  /**\n   * Ensures that a non term by a given name exists (creating if\n   * necessary).  If a terminal already exists by this label then\n   * an error is thrown.\n   *\n   * The grammar acts as a factory for terminal and non terminal symbols\n   * so that we can reuse symbols instead of having users create new\n   * symbols each time.  This also ensures that users are not able mix\n   * terminal and non terminal labels.\n   */\n  NT(label: string, isAuxiliary = false, throwIfExists = false): Sym {\n    let nt = this.getSym(label);\n    if (nt != null) {\n      if (throwIfExists) throw new Error(`Non-terminal ${label} is already exists`);\n      if (nt.isTerminal) throw new Error(`Symbol (${label}) already exists as a terminal`);\n    } else {\n      nt = new Sym(this, label, false);\n      nt.isAuxiliary = isAuxiliary;\n      nt = this.ensureSym(nt, true);\n      if (!isAuxiliary && this.startSymbol == null) {\n        this.startSymbol = nt;\n      }\n    }\n    return nt;\n  }\n\n  /**\n   * Creates a terminal with the given label if one does not\n   * already exist.\n   */\n  newTerm(label: string): Sym {\n    return this.T(label, true);\n  }\n\n  /**\n   * Creates a non terminal with the given label if it does not\n   * already exist.\n   */\n  newNT(label: string, isAuxiliary = false): Sym {\n    return this.NT(label, isAuxiliary, true);\n  }\n\n  /**\n   * Checks if a given label is a terminal.\n   */\n  isTerminal(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && t.isTerminal;\n  }\n\n  /**\n   * Checks if a given label is a non-terminal.\n   */\n  isNT(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && !t.isTerminal && !t.isAuxiliary;\n  }\n\n  /**\n   * Checks if a given label is an auxiliary non-terminal.\n   */\n  isAuxNT(label: string): boolean {\n    const t = this.getSym(label);\n    return t != null && !t.isTerminal && t.isAuxiliary;\n  }\n\n  seq(...exps: (Str | string)[]): Str {\n    if (exps.length == 1) {\n      return this.normalizeRule(exps[0]);\n    } else {\n      const out = new Str();\n      for (const e of exps) {\n        const s = this.normalizeRule(e);\n        // insert string here inline\n        // A ( B C D ) => A B C D\n        for (let i = 0; i < s.length; i++) {\n          // out.add(s.syms[i], s.cardinalities[i]);\n          out.add(s.syms[i]);\n        }\n      }\n      return out;\n    }\n  }\n\n  /**\n   * Provides a union rule:\n   *\n   * (A | B | C | D)\n   *\n   * Each of A, B, C or D themselves could be strings or literals.\n   */\n  anyof(...rules: (Str | string)[]): Str {\n    if (rules.length == 1) {\n      return this.normalizeRule(rules[0]);\n    } else {\n      // see if there is already NT with the exact set of rules\n      // reuse if it exists.  That would make this method\n      // Idempotent (which it needs to be).\n      return new Str(this.ensureAuxNT(...rules.map((r) => this.normalizeRule(r))));\n    }\n  }\n\n  opt(exp: Str | string): Str {\n    // convert to aux rule\n    const out = this.anyof(exp, new Str());\n    const nt = out.syms[0];\n    TSU.assert(out.syms.length == 1 && nt.isAuxiliary, \"NT must be an auxiliary symbol\");\n    nt.auxType = \"opt\";\n    return out;\n  }\n\n  atleast0(exp: Str | string, leftRec = true): Str {\n    const s = this.normalizeRule(exp);\n    // We want to find another auxiliary NT that has the following rules:\n    //    X -> exp X | ;    # if leftRec = true\n    //\n    //    X -> X exp | ;    # otherwise:\n    let auxNT = this.findAuxNT((auxNT) => {\n      const rules = this.rulesForNT(auxNT);\n      if (rules.length != 2) return false;\n\n      let which = 0;\n      if (rules[0].rhs.length == 0) {\n        which = 1;\n      } else if (rules[1].rhs.length == 0) {\n        which = 0;\n      } else {\n        return false;\n      }\n\n      const rule = rules[which].rhs;\n      if (rule.length != 1 + exp.length) return false;\n      if (rule.syms[0].equals(auxNT)) {\n        return rule.containsAt(1, s);\n      } else if (rule.syms[rule.length - 1].equals(auxNT)) {\n        return rule.containsAt(0, s);\n      }\n      return false;\n    });\n    if (auxNT == null) {\n      auxNT = this.newAuxNT();\n      auxNT.auxType = leftRec ? \"atleast0:left\" : \"atleast0\";\n      this.add(auxNT, new Str());\n      if (leftRec) {\n        this.add(auxNT, new Str(auxNT).extend(s));\n      } else {\n        this.add(auxNT, s.copy().append(auxNT));\n      }\n    }\n    return new Str(auxNT);\n  }\n\n  atleast1(exp: Str | string, leftRec = true): Str {\n    const s = this.normalizeRule(exp);\n    // We want to find another auxiliary NT that has the following rules:\n    //    X -> exp X | exp ;    # if leftRec = true\n    //\n    //    X -> X exp | exp ;    # otherwise:\n    let auxNT = this.findAuxNT((auxNT) => {\n      const rules = this.rulesForNT(auxNT);\n      if (rules.length != 2) return false;\n\n      let which = 0;\n      if (rules[0].rhs.equals(s)) {\n        which = 1;\n      } else if (rules[1].rhs.equals(s)) {\n        which = 0;\n      } else {\n        return false;\n      }\n\n      const rule = rules[which].rhs;\n      if (rule.length != 1 + exp.length) return false;\n      if (rule.syms[0].equals(auxNT)) {\n        return rule.containsAt(1, s);\n      } else if (rule.syms[rule.length - 1].equals(auxNT)) {\n        return rule.containsAt(0, s);\n      }\n      return false;\n    });\n    if (auxNT == null) {\n      auxNT = this.newAuxNT();\n      auxNT.auxType = leftRec ? \"atleast1:left\" : \"atleast1\";\n      this.add(auxNT, s);\n      if (leftRec) {\n        this.add(auxNT, new Str(auxNT).extend(s));\n      } else {\n        this.add(auxNT, s.copy().append(auxNT));\n      }\n    }\n    return new Str(auxNT);\n  }\n\n  normalizeRule(exp: Str | string): Str {\n    if (typeof exp === \"string\") {\n      const lit = this.getSym(exp);\n      if (lit == null) throw new Error(`Invalid symbol: '${exp}'`);\n      return new Str(lit);\n    } else {\n      // We have an expression that needs to be fronted by an\n      // auxiliarry non-terminal\n      return exp;\n    }\n  }\n\n  // Override this to have a different\n  protected auxNTCount = 0;\n  protected newAuxNTName(): string {\n    return this.auxNTPrefix + this.auxNTCount++;\n  }\n\n  newAuxNT(name = \"\"): Sym {\n    if (name == \"\") name = this.newAuxNTName();\n    return this.newNT(name, true);\n  }\n\n  ensureAuxNT(...rules: Str[]): Sym {\n    let nt = this.findAuxNTByRules(...rules);\n    if (nt == null) {\n      nt = this.newAuxNT();\n      nt.auxType = \"anyof\";\n      for (const rule of rules) this.add(nt, rule);\n    }\n    return nt;\n  }\n\n  /**\n   * Find an auxiliary rule that has the same rules as the ones here.\n   * This can be used to ensure duplicate rules are not created for\n   * union expressions.\n   */\n  findAuxNT(filter: (nt: Sym) => boolean): Nullable<Sym> {\n    for (const auxNT of this.symbolSet.entries) {\n      if (!auxNT.isAuxiliary) continue;\n      if (filter(auxNT)) return auxNT;\n    }\n    return null;\n  }\n\n  findAuxNTByRules(...rules: Str[]): Nullable<Sym> {\n    return this.findAuxNT((auxNT) => {\n      const ntRules = this.rulesForNT(auxNT);\n      if (ntRules.length != rules.length) return false;\n      for (let i = 0; i < ntRules.length; i++) {\n        if (!ntRules[i].rhs.equals(rules[i])) return false;\n      }\n      return true;\n    });\n  }\n\n  print(options: any = null): string[] {\n    options = options || {};\n    const ruleSep = options.ruleSep || \"->\";\n    const includeSemiColon = options.includeSemiColon || false;\n    const lambdaSymbol = options.lambdaSymbol || \"\";\n    const out: string[] = [];\n    this.forEachRule(null, (rule: Rule, index: number) => {\n      let r = `${rule.nt.label} ${ruleSep} `;\n      if (rule.rhs.length > 0) r += rule.rhs.debugString;\n      else r += lambdaSymbol;\n      if (includeSemiColon) r += \" ;\";\n      out.push(r);\n    });\n    return out;\n  }\n\n  /**\n   * Returns a flat list of all productions in a single list.\n   */\n  get debugValue(): string[] {\n    const out: string[] = [];\n    this.forEachRule(null, (rule: Rule, index: number) => {\n      out.push(`${rule.nt.label} -> ${rule.rhs.debugString}`);\n    });\n    return out;\n  }\n\n  /**\n   * Returns all non terminals that can derive terminals.\n   */\n  get terminalDerivingSymbols(): SymbolSet {\n    const out = new SymbolSet(this, null);\n    let nadded = -1;\n    let allDerive = true;\n    while (nadded != 0) {\n      nadded = 0;\n      for (const rule of this.allRules) {\n        allDerive = true;\n        for (const sym of rule.rhs.syms) {\n          if (!out.has(sym)) {\n            if (sym.isTerminal) {\n              out.add(sym);\n              nadded++;\n            } else {\n              allDerive = false;\n            }\n          }\n        }\n        if (allDerive && !out.has(rule.nt)) {\n          out.add(rule.nt);\n          nadded++;\n        }\n      }\n    }\n    return out;\n  }\n\n  /*\n   * Returns all non terminal that are reachable from a given symbol.\n   * If the FROM symbol is omitted then the start symbol is used.\n   */\n  reachableSymbols(fromSymbol: Nullable<Sym> = null): SymbolSet {\n    if (fromSymbol == null) {\n      fromSymbol = this._AugStartRule ? this._AugStartRule.nt : this.startSymbol;\n    }\n    TSU.assert(fromSymbol != null, \"Start symbol does not exist\");\n    const reachable = new SymbolSet(this, false).add(fromSymbol);\n    let queue: Sym[] = [fromSymbol];\n    while (queue.length > 0) {\n      const newQueue: Sym[] = [];\n      for (const curr of queue) {\n        for (const rule of this.rulesForNT(curr)) {\n          for (const sym of rule.rhs.syms) {\n            if (!sym.isTerminal && !reachable.has(sym)) {\n              newQueue.push(sym);\n              reachable.add(sym);\n            }\n          }\n        }\n      }\n      queue = newQueue;\n    }\n    return reachable;\n  }\n\n  /**\n   * Returns all cycles in this grammar.\n   */\n  get cycles(): ReadonlyArray<[Sym, any]> {\n    /*\n     * Returns the edge of the given nonterm\n     * For a nt such that:\n     *             S -> alpha1 X1 beta1 |\n     *                  alpha2 X2 beta2 |\n     *                  ...\n     *                  alphaN XN betaN |\n     *\n     * S's neighbouring nodes would be Xk if all of alphak is optional\n     * AND all of betak is optional\n     */\n    const edgeFunctor = (node: Sym): [Sym, any][] => {\n      const out: [Sym, any][] = [];\n      this.forEachRule(node, (rule, ruleIndex) => {\n        rule.rhs.syms.forEach((s, j) => {\n          if (s.isTerminal) return;\n          if (this.nullables.isStrNullable(rule.rhs, 0, j - 1) && this.nullables.isStrNullable(rule.rhs, j + 1)) {\n            out.push([s, [node, ruleIndex]]);\n          }\n        });\n      });\n      return out;\n    };\n    return allMinimalCycles(this.allNonTerminals, (val: Sym) => val.label, edgeFunctor);\n  }\n\n  /**\n   * Returns a set of \"Starting\" non terminals which have atleast\n   * one production containing left recursion.\n   */\n  get leftRecursion(): any {\n    const edgeFunctor = (node: Sym): [Sym, any][] => {\n      const out: [Sym, any][] = [];\n      this.forEachRule(node, (rule, ruleIndex) => {\n        rule.rhs.syms.forEach((s, j) => {\n          if (s.isTerminal) return;\n          out.push([s, ruleIndex]);\n          // If this is symbol is not nullable then we can stop here\n          return this.nullables.isNullable(s);\n        });\n      });\n      return out;\n    };\n    return allMinimalCycles(this.allNonTerminals, (val: Sym) => val.id, edgeFunctor);\n  }\n}\n","export enum CharClassType {\n  WORD_CHAR,\n  DIGITS,\n  SPACES,\n}\n\nconst ZERO = \"0\".charCodeAt(0);\nconst NINE = \"9\".charCodeAt(0);\nconst lA = \"a\".charCodeAt(0);\nconst lZ = \"z\".charCodeAt(0);\nconst uA = \"A\".charCodeAt(0);\nconst uZ = \"Z\".charCodeAt(0);\nconst USCORE = \"_\".charCodeAt(0);\n\n/**\n * An abstract class to be implemented for enabling different types of char classes.\n * Char classes are a form of \"short codes\" to identify characters.  eg SPACES, DIGITS etc.\n * Char classes are only shortcuts.  One can get away without using them and instead explicitly\n * construct the underlying state machine or regex (eg DIGIT could be replaced with [0-9]).\n */\nexport abstract class CharClassHelper {\n  matches(charCode: number, neg: boolean): boolean {\n    const res = this.match(charCode);\n    return neg ? !res : res;\n  }\n  protected abstract match(charCode: number): boolean;\n  abstract reString(neg: boolean): string;\n}\n\nconst spaceChars = \" \\f\\n\\r\\t\\v\\u00a0\\u1680\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff\";\n\n/**\n * Spaces - \\s => [ \\b\\c\\u00a0\\t\\r\\n\\u2028\\u2029<BOM><USP>]\n * BOM = \\uFEFF\n * USP = Other unicode space separator\n */\nexport class Spaces extends CharClassHelper {\n  match(charCode: number): boolean {\n    // if (charCode == 0x180e) return true;\n    if (charCode >= 0x2000 && charCode <= 0x200a) return true;\n    for (let i = 0; i < spaceChars.length; i++) {\n      if (spaceChars.charCodeAt(i) == charCode) return true;\n    }\n    return false;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\S\" : \"\\\\s\";\n  }\n}\n\n/**\n * Char class for denoting a digit - [0-9].\n */\nexport class Digit extends CharClassHelper {\n  match(charCode: number): boolean {\n    return charCode >= ZERO && charCode <= NINE;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\D\" : \"\\\\d\";\n  }\n}\n\n/**\n * Char class for denoting \"\\\\w\" - ie any WordChar\n */\nexport class WordChar extends CharClassHelper {\n  match(charCode: number): boolean {\n    return (\n      charCode == USCORE ||\n      (charCode >= ZERO && charCode <= NINE) ||\n      (charCode >= lA && charCode <= lZ) ||\n      (charCode >= uA && charCode <= uZ)\n    );\n    return true;\n  }\n\n  reString(neg: boolean): string {\n    return neg ? \"\\\\W\" : \"\\\\w\";\n  }\n}\n\nexport const CharClassHelpers: ReadonlyArray<CharClassHelper> = [new WordChar(), new Digit(), new Spaces()];\n","export enum PropertyName {\n  // Binary Property Names\n  gc,\n  General_Category = gc,\n  sc,\n  Script = sc,\n  scx,\n  Script_Extension = scx,\n\n  // Non binary property names\n  Any,\n  ASCII,\n  AHex,\n  ASCII_Hex_Digit = AHex,\n  Alpha,\n  Alphabetic = Alpha,\n  Bidi_M,\n  Bidi_Mirrored = Bidi_M,\n  Bidi_C,\n  Bidi_Control = Bidi_C,\n  CI,\n  Case_Ignorable = CI,\n  Cased,\n  CWCF,\n  Changes_When_Casefolded = CWCF,\n  CWCM,\n  Changes_When_Casemapped = CWCM,\n  CWL,\n  Changes_When_Lowercased = CWL,\n  CWKCF,\n  Changes_When_NFKC_Casefolded = CWKCF,\n  CWT,\n  Changes_When_Titlecased = CWT,\n  CWU,\n  Changes_When_Uppercased = CWU,\n  Dash,\n  DI,\n  Default_Ignorable_Code_Point = DI,\n  Dep,\n  Deprecated = Dep,\n  Dia,\n  Diacritic = Dia,\n  Emoji,\n  Emoji_Component,\n  Emoji_Modifier,\n  Emoji_Modifier_Base,\n  Emoji_Presentation,\n  Ext,\n  Extender = Ext,\n  Gr_Base,\n  Grapheme_Base = Gr_Base,\n  Gr_Ext,\n  Grapheme_Extend = Gr_Ext,\n  Hex,\n  Hex_Digit = Hex,\n  IDSB,\n  IDS_Binary_Operator = IDSB,\n  IDST,\n  IDS_Trinary_Operator = IDST,\n  IDC,\n  ID_Continue = IDC,\n  IDS,\n  ID_Start = IDS,\n  Ideo,\n  Ideographic = Ideo,\n  Join_C,\n  Join_Control = Join_C,\n  LOE,\n  Logical_Order_Exception = LOE,\n  Lower,\n  Lowercase = Lower,\n  Math,\n  NChar,\n  Noncharacter_Code_Point = NChar,\n  Pat_Syn,\n  Pattern_Syntax = Pat_Syn,\n  Pat_WS,\n  Pattern_White_Space = Pat_WS,\n  QMark,\n  Quotation_Mark = QMark,\n  Radical,\n  RI,\n  Regional_Indicator = RI,\n  STerm,\n  Sentence_Terminal = STerm,\n  SD,\n  Soft_Dotted = SD,\n  Term,\n  Terminal_Punctuation = Term,\n  UIdeo,\n  Unified_Ideograph = UIdeo,\n  Upper,\n  Uppercase = Upper,\n  VS,\n  Variation_Selector = VS,\n  space,\n  White_Space = space,\n  XIDC,\n  XID_Continue = XIDC,\n  XIDS,\n  XID_Start = XIDS,\n}\n\nexport enum PropertyValue {\n  // General Category proeprty values\n  LC,\n  Cased_Letter = LC,\n  Pe,\n  Close_Punctuation = Pe,\n  Pc,\n  Connector_Punctuation = Pc,\n  Cc,\n  cntrl = Cc,\n  Control = Cc,\n  Sc,\n  Currency_Symbol = Sc,\n  Pd,\n  Dash_Punctuation = Pd,\n  Nd,\n  digit = Nd,\n  Decimal_Number = digit,\n  Me,\n  Enclosing_Mark = Me,\n  Pf,\n  Final_Punctuation = Pf,\n  Cf,\n  Format = Cf,\n  Pi,\n  Initial_Punctuation = Pi,\n  L,\n  Letter = L,\n  Nl,\n  Letter_Number = Nl,\n  Zl,\n  Line_Separator = Zl,\n  Ll,\n  Lowercase_Letter = Ll,\n  M,\n  Combining_Mark = M,\n  Mark,\n  Sm,\n  Math_Symbol = Sm,\n  Lm,\n  Modifier_Letter = Lm,\n  Sk,\n  Modifier_Symbol = Sk,\n  Mn,\n  Nonspacing_Mark = Mn,\n  N,\n  Number = N,\n  Ps,\n  Open_Punctuation = Ps,\n  C,\n  Other = C,\n  Lo,\n  Other_Letter = Lo,\n  No,\n  Other_Number = No,\n  Po,\n  Other_Punctuation = Po,\n  So,\n  Other_Symbol = So,\n  Zp,\n  Paragraph_Separator = Zp,\n  Co,\n  Private_Use = Co,\n  P,\n  punct = P,\n  Punctuation = P,\n  Z,\n  Separator = Z,\n  Zs,\n  Space_Separator = Zs,\n  Mc,\n  Spacing_Mark = Mc,\n  Cs,\n  Surrogate = Cs,\n  S,\n  Symbol = S,\n  Lt,\n  Titlecase_Letter = Lt,\n  Cn,\n  Unassigned = Cn,\n  Lu,\n  Uppercase_Letter = Lu,\n  // Script and Script Extension proeprty values\n}\n\nexport function propertyNameFor(value: string): PropertyName {\n  value = value.trim();\n  if (!(value in PropertyName)) {\n    throw new SyntaxError(\"Invalid property name: \" + value);\n  }\n  return (PropertyName as any)[value];\n}\n\nexport function propertyValueFor(value: string): PropertyValue {\n  value = value.trim();\n  if (!(value in PropertyValue)) {\n    throw new SyntaxError(\"Invalid property value: \" + value);\n  }\n  return (PropertyValue as any)[value];\n}\n\nexport function propertyNameString(value: number): string {\n  if (!(value in PropertyName)) {\n    throw new Error(\"Invalid property name: \" + value);\n  }\n  return PropertyName[value];\n}\n\nexport function propertyValueString(value: number): string {\n  if (!(value in PropertyValue)) {\n    throw new Error(\"Invalid property value: \" + value);\n  }\n  return PropertyValue[value];\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport { Char } from \"./core\";\n\nfunction isNewLineChar(ch: string): boolean {\n  return ch == \"\\r\" || ch == \"\\n\" || ch == \"\\u2028\" || ch == \"\\u2029\";\n}\n\nexport class Match {\n  groups: [number, number][] = [];\n  positions: number[] = [];\n  constructor(public priority = 10, public matchIndex = -1, public start = -1, public end = -1) {}\n}\n\nexport enum OpCode {\n  // Any character\n  Any,\n  // Any character not including a new line\n  AnyNonNL,\n  // Char and CI Chars\n  Char,\n  CIChar,\n  // NegChar,\n  // NegCIChar,\n\n  // Non char opcodes\n  Match,\n  Noop,\n  Save,\n  Split,\n  Jump,\n  Begin, // Forward lookahead matches\n  RBegin, // Reverse lookahead matches\n  End,\n\n  // Look ahead and Look back matchers\n  // ^ and $ that are not activated on newlines\n  StartingChar,\n  EndingChar,\n  // ^ and $ that are activated on newlines as well\n  MLStartingChar,\n  MLEndingChar,\n  StartOfWord,\n  EndOfWord,\n  GroupStart,\n  GroupEnd,\n\n  // Stops the thread if state does not match\n  EnsureState,\n}\n\nexport class Prog {\n  instrs: Instr[] = [];\n  stateMapping: Map<string, number>;\n\n  constructor(public readonly startCondition = \"INITIAL\", public readonly scIsInclusive = true) {\n    this.stateMapping = new Map<string, number>();\n    this.registerState(\"INITIAL\");\n    this.registerState(startCondition);\n  }\n\n  get length(): number {\n    return this.instrs.length;\n  }\n\n  /**\n   * Adds a state to our program and returns the state's index.\n   */\n  registerState(state: string): number {\n    if (!this.stateMapping.has(state)) {\n      this.stateMapping.set(state, this.stateMapping.size);\n    }\n    return this.stateMapping.get(state) || -1;\n  }\n\n  add(opcode: any, char: null | Char = null, ...args: number[]): Instr {\n    const out = new Instr(opcode, char).add(...args);\n    out.offset = this.instrs.length;\n    this.instrs.push(out);\n    return out;\n  }\n\n  static with(initializer: (prog: Prog) => void): Prog {\n    const out = new Prog();\n    initializer(out);\n    return out;\n  }\n\n  debugValue(instrDebugValue: (instr: Instr) => string = InstrDebugValue): any {\n    if (instrDebugValue) {\n      return this.instrs.map((instr, index) => {\n        if (instr.comment.trim().length > 0) return `L${index}: ${instrDebugValue(instr)}     # ${instr.comment}`;\n        else return `L${index}: ${instrDebugValue(instr)}`;\n      });\n    } else {\n      return this.instrs.map((instr, index) => `L${index}: ${instr.debugValue}`);\n    }\n  }\n}\n\nexport class Instr {\n  offset = 0;\n  comment = \"\";\n  args: number[] = [];\n  // used for char match instructions - if opcode == Char or CIChar\n  constructor(public readonly opcode: any, public char: null | Char = null) {\n    this.char = char;\n  }\n\n  add(...args: number[]): this {\n    this.args.push(...args);\n    return this;\n  }\n\n  get debugValue(): any {\n    let c = this.comment.trim();\n    if (c.length > 0) c = \"    # \" + c;\n    return `${this.opcode} ${this.args.join(\" \")}    ${this.char || \"\"}   ${c}`;\n  }\n}\n\n/**\n * A thread that is performing an execution of the regex VM.\n */\nexport class Thread {\n  parentId = -1;\n  id = 0;\n  priority = 0;\n  /**\n   * Saved positions into the input stream for the purpose of\n   * partial and custom matches.\n   */\n  groups: [number, number][] = [];\n  positions: number[] = [];\n  registers: TSU.NumMap<number> = {};\n\n  /**\n   * Create a thread at the given offset\n   */\n  constructor(public readonly offset: number = 0, public readonly gen: number = 0) {}\n\n  regIncr(regId: number): void {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    this.registers[regId]++;\n  }\n\n  regAcquire(regId: number): void {\n    if (regId in this.registers) {\n      throw new Error(`Register at offset ${regId} already acquired.  Release it first`);\n    }\n    this.registers[regId] = 0;\n  }\n\n  regRelease(regId: number): void {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    delete this.registers[regId];\n  }\n\n  regValue(regId: number): number {\n    if (!(regId in this.registers)) {\n      throw new Error(`Register at offset ${regId} is invalid`);\n    }\n    return this.registers[regId];\n  }\n}\n\nexport interface VMTracer {\n  threadDequeued(thread: Thread, tapeIndex: number): void;\n  threadStepped(thread: Thread, tapeIndex: number, gen: number): void;\n  threadQueued(thread: Thread, tapeIndex: number): void;\n}\n\nexport class VM {\n  // TODO - To prevent excessive heap activity and GC\n  // create a pool of threads and just have a cap on\n  // match sizes\n  // To eve simplify each Thread could just be something like:\n  // number[] where\n  //  number[0] == offset\n  //  number[1-2*MaxSubs] = Substitutions\n  //  number[2*MaxSubs - 2*MaxSubs + M] = Registers\n  //      where M = Max number of NewReg instructions\n  protected threadCounter = 0;\n  protected currThreads: Thread[] = [];\n  protected nextThreads: Thread[] = [];\n  protected startPos = 0; // Where the match is beginning from - this will be set to tape.index when match is called\n  // Initial state is always 0\n  protected currState = 0;\n\n  /**\n   * Get the current lexer state (for incremental lexing support).\n   * State is used to track context-sensitive lexing (e.g., inside string, comment).\n   */\n  getState(): number {\n    return this.currState;\n  }\n\n  /**\n   * Set the lexer state (for incremental lexing support).\n   * Allows restarting lexing from a saved state.\n   */\n  setState(state: number): void {\n    this.currState = state;\n  }\n\n  protected gen = 0;\n  // Records which \"generation\" of the match a particular\n  // offset is in.  If a thread is added at a particular\n  // offset the generation number is used to see if the\n  // thread is a duplicate (and avoided if so).  This\n  // ensures that are linearly bounded on the number of\n  // number threads as we match.\n  protected genForOffset: TSU.NumMap<number> = {};\n\n  tracer: VMTracer;\n  constructor(\n    public readonly prog: Prog,\n    public readonly start = 0,\n    public readonly end = -1,\n    public readonly forward = true,\n    configs: any = {},\n  ) {\n    if (end < 0) {\n      end = prog.length - 1;\n    }\n    this.end = end;\n  }\n\n  savePosition(thread: Thread, pos: number, tapeIndex: number): void {\n    while (thread.positions.length <= pos) thread.positions.push(-1);\n    thread.positions[pos] = tapeIndex;\n  }\n\n  jumpBy(thread: Thread, delta = 1): Thread {\n    return this.jumpTo(thread, thread.offset + delta);\n  }\n\n  jumpTo(thread: Thread, newOffset: number): Thread {\n    // TODO - Why create new thread here - investigate if we can\n    // return the same thread with the offset updated?\n    // if we really want a \"history\" we could jsut keep prev offsets\n    // in a list so we can keep a trace\n    const out = new Thread(newOffset, this.gen);\n    out.id = thread.id;\n    out.parentId = thread.parentId;\n    out.priority = thread.priority;\n    out.positions = thread.positions;\n    out.groups = thread.groups;\n    out.registers = thread.registers;\n    return out;\n  }\n\n  forkTo(thread: Thread, newOffset: number): Thread {\n    const out = new Thread(newOffset, this.gen);\n    out.id = ++this.threadCounter;\n    out.parentId = thread.id;\n    out.priority = thread.priority;\n    out.positions = [...thread.positions];\n    out.groups = [...thread.groups];\n    out.registers = { ...thread.registers };\n    return out;\n  }\n\n  startGroup(thread: Thread, groupIndex: number, tapeIndex: number): Thread {\n    const newThread = this.forkTo(thread, thread.offset + 1);\n    newThread.groups.push([groupIndex, tapeIndex]);\n    return newThread;\n  }\n\n  endGroup(thread: Thread, groupIndex: number, tapeIndex: number): Thread {\n    const newThread = this.forkTo(thread, thread.offset + 1);\n    newThread.groups.push([-groupIndex, tapeIndex]);\n    return newThread;\n  }\n\n  addThread(thread: Thread, list: Thread[], tape: Tape, delta = 0): void {\n    if (\n      thread.offset < this.start ||\n      thread.offset > this.end ||\n      this.genForOffset[thread.offset - this.start] == this.gen\n    ) {\n      // duplicate\n      return;\n    }\n    this.genForOffset[thread.offset - this.start] = this.gen;\n    const instr = this.prog.instrs[thread.offset];\n    let nextCh: string;\n    let lastCh: string;\n    let newThread: Thread;\n    // if (this.tracer) this.tracer.threadStepped(thread, tape.index, this.gen);\n    const opcode = instr.opcode;\n    switch (opcode) {\n      case OpCode.Jump:\n        newThread = this.jumpTo(thread, instr.args[0]);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.Split:\n        for (let j = 0; j < instr.args.length; j++) {\n          const newOff = instr.args[j];\n          // TODO - only fork on position/group write instead of always forking on a split\n          const newThread = j == 0 ? this.jumpTo(thread, newOff) : this.forkTo(thread, newOff);\n          this.addThread(newThread, list, tape, delta);\n        }\n        break;\n      case OpCode.Save:\n        newThread = this.jumpTo(thread, thread.offset + 1);\n        this.savePosition(newThread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.GroupStart:\n        newThread = this.startGroup(thread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.GroupEnd:\n        newThread = this.endGroup(thread, instr.args[0], tape.index + delta);\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index + delta);\n        this.addThread(newThread, list, tape, delta);\n        break;\n      case OpCode.StartingChar:\n      case OpCode.MLStartingChar:\n        // only proceed further if prev was a newline or start\n        lastCh = this.prevCh(tape);\n        if (tape.index == 0 || (opcode == OpCode.MLStartingChar && isNewLineChar(lastCh))) {\n          // have a match so can go forwrd but dont advance tape on\n          // the same generation\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n        break;\n      case OpCode.EndingChar:\n      case OpCode.MLEndingChar:\n        // On end of input we dont advance tape but thread moves on\n        // if at end of line boundary\n        // check if next is end of input\n        nextCh = this.nextCh(tape);\n        if (nextCh == \"\" || (opcode == OpCode.MLEndingChar && isNewLineChar(nextCh))) {\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n        break;\n      case OpCode.StartOfWord:\n        // only proceed further if prev was a newline or start\n        /*\n        lastCh = this.prevCh(tape);\n        if (tape.index == 0 || (this.multiline && (isNewLineChar(lastCh) || isSpaceChar(lastCh)))) {\n          // have a match so can go forwrd but dont advance tape on\n          // the same generation\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n       */\n        break;\n      case OpCode.EndOfWord:\n        // On end of input we dont advance tape but thread moves on\n        // if at end of line boundary\n        // check if next is end of input\n        /*\n        nextCh = this.nextCh(tape);\n        if (nextCh == \"\" || (this.multiline && (isNewLineChar(nextCh) || isSpaceChar(nextCh)))) {\n          this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n        }\n       */\n        break;\n      case OpCode.RBegin:\n        {\n          const [groupIndex, negate, end] = instr.args;\n          const pos = (1 + groupIndex) * 2;\n          const groupStart = thread.positions[pos];\n          const [matchSuccess, matchEnd] = this.recurseMatch(\n            tape,\n            groupStart - 1,\n            instr.offset + 1,\n            end,\n            false,\n            negate == 1,\n          );\n          if (matchSuccess) {\n            // TODO - Consider using a DFA for this case so we can mitigate\n            // pathological cases with an exponential blowup on a success\n            this.addThread(this.jumpTo(thread, end + 1), list, tape, delta);\n          }\n        }\n        break;\n      case OpCode.Begin:\n        // This results in a new VM being created for this sub program and\n        // kicking off a backtracking execution - Making these as explicit\n        // constructs for the user to use means the user can make this choice\n        // on their own voilition\n        const [consume, negate, end] = instr.args;\n        if (consume == 1) {\n          // since this results in the consumption of a character (similar to \"Char\")\n          // defer this to the list\n          if (this.tracer) this.tracer.threadQueued(thread, tape.index);\n          list.push(thread);\n        } else {\n          const [matchSuccess, matchEnd] = this.recurseMatch(\n            tape,\n            tape.index + 1,\n            instr.offset + 1,\n            end,\n            true,\n            negate == 1,\n          );\n          if (matchSuccess) {\n            // TODO - Consider using a DFA for this case so we can mitigate\n            // pathological cases with an exponential blowup on a success\n            this.addThread(this.jumpTo(thread, end + 1), list, tape, delta);\n          }\n        }\n        break;\n      case OpCode.EnsureState:\n        const states = instr.args;\n        for (const state of states) {\n          if (this.currState == state) {\n            this.addThread(this.jumpBy(thread, 1), list, tape, delta);\n            break;\n          }\n        }\n        break;\n      default:\n        if (this.tracer) this.tracer.threadQueued(thread, tape.index);\n        list.push(thread);\n        break;\n    }\n  }\n\n  matchCurrPos(tape: Tape, char: Char, ignoreCase = false): boolean {\n    if (ignoreCase) {\n      return char.match(tape.currChCodeLower) || char.match(tape.currChCodeUpper);\n    } else {\n      return char.match(tape.currChCode);\n    }\n  }\n\n  protected hasMore(tape: Tape): boolean {\n    return this.forward ? tape.hasMore : tape.index >= 0;\n  }\n\n  protected nextCh(tape: Tape): string {\n    const next = tape.index + (this.forward ? 1 : -1);\n    return tape.charAt(next);\n    // if (next < 0 || next >= tape.input.length) return \"\";\n    // return tape.input[next];\n  }\n\n  protected prevCh(tape: Tape): string {\n    return tape.charAt(tape.index - (this.forward ? 1 : -1));\n    // return tape.input[tape.index - (this.forward ? 1 : -1)];\n  }\n\n  /**\n   * Runs the given instructions and returns a triple:\n   * [matchId, matchStart, matchEnd]\n   */\n  match(tape: Tape): Match | null {\n    // this.gen = 0; this.genForOffset = {};\n    if (this.end < this.start) return null;\n    this.startMatching(tape);\n    let bestMatch: TSU.Nullable<Match> = null;\n    while (this.currThreads.length > 0) {\n      bestMatch = this.stepChar(tape, bestMatch);\n    }\n    // ensure tape is rewound to end of last match\n    if (bestMatch != null) tape.index = bestMatch.end;\n    return bestMatch;\n  }\n\n  recurseMatch(\n    tape: Tape,\n    tapeIndex: number,\n    startOffset: number,\n    endOffset: number,\n    forward = true,\n    negate = false,\n  ): [boolean, number] {\n    const savedPos = tape.index;\n    if (!tape.canAdvance(forward ? 1 : -1)) return [negate, -1];\n    tape.index = tapeIndex;\n    // tape.advance(forward ? 1 : -1);\n    const vm = new VM(this.prog, startOffset, endOffset, forward);\n    const match = vm.match(tape);\n    const newPos = tape.index;\n    tape.index = savedPos; // always restore it first and let caller use it\n    return [(match != null && !negate) || (match == null && negate), newPos];\n  }\n\n  startMatching(tape: Tape): void {\n    this.currThreads = [];\n    this.nextThreads = [];\n    this.gen++;\n    this.addThread(new Thread(this.start, this.gen), this.currThreads, tape);\n    // let largestMatchEnd = -1;\n    // let lastMatchIndex = -1;\n    this.startPos = tape.index;\n  }\n\n  stepChar(tape: Tape, currMatch: TSU.Nullable<Match> = null): TSU.Nullable<Match> {\n    // At this point all our threads are point to the next \"transition\" or \"match\" action.\n    this.gen++;\n    // console.log(`Ch (@${tape.index}): ${tape.currChCode}, Gen (${this.gen})`);\n    for (let i = 0; i < this.currThreads.length; i++) {\n      const thread = this.currThreads[i];\n      // console.log(`   Thread (${i}): ${thread.offset}(${thread.gen})`);\n      const nextMatch = this.stepThread(tape, thread);\n      if (nextMatch != null) {\n        if (\n          currMatch == null ||\n          nextMatch.priority > currMatch.priority ||\n          (nextMatch.priority == currMatch.priority && nextMatch.end > currMatch.end)\n        ) {\n          currMatch = nextMatch;\n          break;\n        } else if (currMatch != nextMatch) {\n          // Since we kill of lower priority matches becuase of matchedInGen\n          // we should not be here\n          // TSU.assert(false, \"Should not be here\");\n        }\n      }\n    }\n    if (this.hasMore(tape)) {\n      tape.advance(this.forward ? 1 : -1);\n    }\n    this.currThreads = this.nextThreads;\n    this.nextThreads = [];\n    return currMatch;\n  }\n\n  stepThread(tape: Tape, thread: Thread): TSU.Nullable<Match> {\n    if (this.tracer) this.tracer.threadStepped(thread, tape.index, this.gen);\n    let currMatch: TSU.Nullable<Match> = null;\n    const instrs = this.prog.instrs;\n    const instr = instrs[thread.offset];\n    const opcode = instr.opcode;\n    const args = instr.args;\n    const delta = this.forward ? 1 : -1;\n    // Do char match based actions\n    let advanceTape = false;\n    let ch: number;\n    switch (opcode) {\n      case OpCode.RBegin:\n        throw new Error(\"Invalid state.  Reverse matches must be handled in addThread\");\n        break;\n      case OpCode.Begin:\n        const [consume, negate, end] = instr.args;\n        TSU.assert(consume == 1, \"Plain lookahead cannot be here\");\n        const [matchSuccess, matchEnd] = this.recurseMatch(tape, tape.index, instr.offset + 1, end, true, negate == 1);\n        if (matchSuccess) {\n          // TODO - Consider using a DFA for this case so we can mitigate\n          // pathological cases with an exponential blowup\n          // on a success we have a few options\n          this.addThread(this.jumpTo(thread, end + 1), this.nextThreads, tape);\n        }\n        break;\n      case OpCode.End:\n        // Return back to calling VM - very similar to a match\n        const out = new Match(-1, -1, this.startPos, tape.index);\n        out.groups = thread.groups;\n        out.positions = thread.positions;\n        return out;\n        break;\n      case OpCode.Match:\n        // we have a match on this thread so return it\n        // Update the match if we are a higher prioirty or longer match\n        // than what was already found (if any)\n        if (tape.index > this.startPos) {\n          const currPriority = instr.args[0];\n          const matchIndex = instr.args[1];\n          currMatch = new Match();\n          currMatch.start = this.startPos;\n          currMatch.end = tape.index;\n          currMatch.priority = currPriority;\n          currMatch.matchIndex = matchIndex;\n          currMatch.groups = thread.groups;\n          currMatch.positions = thread.positions;\n        }\n        break;\n      case OpCode.Char:\n      case OpCode.CIChar:\n        if (this.hasMore(tape)) {\n          advanceTape = this.matchCurrPos(tape, instr.char!, opcode == OpCode.CIChar);\n        }\n        break;\n      /*\n      case OpCode.NegChar:\n      case OpCode.NegCIChar:\n        if (this.hasMore(tape)) {\n          advanceTape = !this.matchCurrPos(tape, args, opcode == OpCode.NegCIChar);\n        }\n        break;\n      */\n      case OpCode.AnyNonNL:\n      case OpCode.Any:\n        if (this.hasMore(tape)) {\n          advanceTape = opcode == OpCode.Any || !isNewLineChar(tape.currCh);\n        }\n        break;\n    }\n    if (advanceTape /* && this.hasMore(tape) */) {\n      this.addThread(this.jumpBy(thread, 1), this.nextThreads, tape, delta);\n    }\n    return currMatch;\n  }\n}\n\nexport function InstrDebugValue(instr: Instr): string {\n  switch (instr.opcode) {\n    case OpCode.Match:\n      return `Match ${instr.args[0]} ${instr.args[1]}`;\n    // case OpCode.NegChar:\n    // case OpCode.NegCIChar:\n    case OpCode.Char:\n    case OpCode.CIChar: {\n      let out = `${OpCode[instr.opcode].toString()} `;\n      // out += `${CharType[instr.args[0]]}`;\n      // for (let i = 1; i < instr.args.length; i++) out += \" \" + instr.args[i];\n      out += `${instr.char!.debugValue()}`;\n      return out;\n    }\n    case OpCode.Any:\n      return \".\";\n    case OpCode.AnyNonNL:\n      return \"NL.\";\n    case OpCode.StartingChar:\n      return \"^\";\n    case OpCode.MLStartingChar:\n      return \"NL^\";\n    case OpCode.EndingChar:\n      return \"$NL\";\n    case OpCode.MLEndingChar:\n      return \"$NL_MultiLine\";\n    case OpCode.Save:\n      return `Save ${instr.args[0]}`;\n    case OpCode.GroupStart:\n      return `GroupStart ${instr.args[0]}`;\n    case OpCode.GroupEnd:\n      return `GroupEnd ${instr.args[0]}`;\n    case OpCode.Split:\n      return `Split ${instr.args.join(\", \")}`;\n    case OpCode.Jump:\n      return `Jump ${instr.args[0]}`;\n    case OpCode.Begin:\n      return `Begin ${instr.args.join(\" \")}`;\n    case OpCode.RBegin:\n      return `RBegin ${instr.args.join(\" \")}`;\n    case OpCode.End:\n      return `End ${instr.args.join(\" \")}`;\n    case OpCode.EnsureState:\n      return `EnsureState ${instr.args.join(\" \")}`;\n    default:\n      throw new Error(\"Invalid Opcode: \" + instr.opcode);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\n\nimport {\n  Rule,\n  RegexType,\n  Quant,\n  Regex,\n  Cat,\n  Char,\n  CharType,\n  Var,\n  BackNumRef,\n  BackNamedRef,\n  LookAhead,\n  LookBack,\n  Union,\n} from \"./core\";\nimport { OpCode, Prog, Instr } from \"./vm\";\n\nexport type RegexResolver = (name: string) => Regex;\nexport type CompilerListener = (expr: Regex, prog: Prog, start: number, length: number) => void;\n\n/**\n * The regex Compiler compiles a parsed regular expression tree into bytecode that is\n * executed by the VM.\n */\nexport class Compiler {\n  emitGroups = false;\n  emitPosition = true;\n  constructor(\n    public regexResolver: TSU.Nullable<RegexResolver>,\n    public listener: TSU.Nullable<CompilerListener> = null,\n  ) {}\n\n  compile(rules: Rule[]): Prog {\n    // Split across each of our expressions\n    const out = new Prog();\n    // only add the split instruction if we have more than one rule\n    const split: Instr = rules.length <= 1 ? new Instr(OpCode.Split) : out.add(OpCode.Split, null);\n    rules.forEach((rule, i) => {\n      split.add(out.instrs.length);\n      const ignoreCase = rule.expr.ignoreCase == null ? false : rule.expr.ignoreCase;\n      const dotAll = rule.expr.dotAll == null ? true : rule.expr.dotAll;\n      const multiline = rule.expr.multiline == null ? true : rule.expr.multiline;\n      if (rule.needsSpecificStates && rule.activeStates != null) {\n        const ensureInstr = out.add(OpCode.EnsureState, null);\n        rule.activeStates.forEach((state) => {\n          const ind = out.registerState(state);\n          ensureInstr.add(ind);\n        });\n      }\n      this.compileExpr(rule.expr, out, ignoreCase, dotAll, multiline);\n      out.add(OpCode.Match, null).add(rule.priority, rule.matchIndex >= 0 ? rule.matchIndex : i);\n    });\n    return out;\n  }\n\n  /**\n   * Compile a given expression into a set of instructions.\n   */\n  protected compileExpr(expr: Regex, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): number {\n    const start = prog.length;\n    const currOffset = prog.length;\n    if (expr.groupIndex >= 0) {\n      if (this.emitPosition) prog.add(OpCode.Save).add((1 + expr.groupIndex) * 2);\n      if (this.emitGroups) prog.add(OpCode.GroupStart).add(1 + expr.groupIndex);\n    }\n    if (expr.tag == RegexType.CHAR) {\n      this.compileChar(expr as Char, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.START_OF_INPUT) {\n      const ml = expr.multiline == null ? multiline : expr.multiline;\n      prog.add(ml ? OpCode.MLStartingChar : OpCode.StartingChar);\n    } else if (expr.tag == RegexType.END_OF_INPUT) {\n      const ml = expr.multiline == null ? multiline : expr.multiline;\n      prog.add(ml ? OpCode.MLEndingChar : OpCode.EndingChar);\n    } else if (expr.tag == RegexType.START_OF_WORD) {\n      prog.add(OpCode.StartOfWord);\n    } else if (expr.tag == RegexType.END_OF_WORD) {\n      prog.add(OpCode.EndOfWord);\n    } else if (expr.tag == RegexType.CAT) {\n      this.compileCat(expr as Cat, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.UNION) {\n      this.compileUnion(expr as Union, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.QUANT) {\n      this.compileQuant(expr as Quant, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.VAR) {\n      this.compileVar(expr as Var, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.BACK_NAMED_REF) {\n      this.compileBackNamedRef(expr as BackNamedRef, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.BACK_NUM_REF) {\n      this.compileBackNumRef(expr as BackNumRef, prog, ignoreCase, dotAll, multiline);\n      // } else if (expr.tag == RegexType.NEG) { this.compileNeg(expr as Neg, prog);\n    } else if (expr.tag == RegexType.LOOK_AHEAD) {\n      this.compileLookAhead(expr as LookAhead, prog, ignoreCase, dotAll, multiline);\n    } else if (expr.tag == RegexType.LOOK_BACK) {\n      this.compileLookBack(expr as LookBack, prog, ignoreCase, dotAll, multiline);\n    } else {\n      throw new Error(\"Regex Type not yet supported: \" + expr.tag);\n    }\n    if (expr.groupIndex >= 0) {\n      if (this.emitGroups) prog.add(OpCode.GroupEnd).add(1 + expr.groupIndex);\n      if (this.emitPosition) prog.add(OpCode.Save).add((1 + expr.groupIndex) * 2 + 1);\n    }\n    if (this.listener && prog.length > currOffset) {\n      this.listener(expr, prog, currOffset, prog.length - currOffset);\n    }\n    return prog.length - start;\n  }\n\n  protected compileChar(char: Char, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    if (char.op == CharType.AnyChar) {\n      // TODO - Should neg be ignored?\n      prog.add(dotAll ? OpCode.Any : OpCode.AnyNonNL);\n    } else {\n      const instr = prog.add(ignoreCase ? OpCode.CIChar : OpCode.Char);\n      instr.char = char;\n      /*\n      // We have Neg or not, CI or not\n      const instr = prog.add(\n        ignoreCase ? (char.neg ? OpCode.NegCIChar : OpCode.CIChar) : char.neg ? OpCode.NegChar : OpCode.Char,\n      );\n      instr.add(char.op);\n\n      // And now the arguments\n      for (const arg of char.args) instr.add(arg);\n      */\n    }\n  }\n\n  protected compileCat(cat: Cat, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    for (const child of cat.children) {\n      this.compileExpr(child, prog, ignoreCase, dotAll, multiline);\n    }\n  }\n\n  protected compileBackNumRef(\n    ne: BackNumRef,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // TODO - This may need a resolution at \"runtime\" so the instruction\n    // should reflect as such?\n    // See compiler.spec.ts - \"Test Back Named Groups\"\n    throw new Error(\"BackNumRef Not Implemented\");\n  }\n\n  protected compileBackNamedRef(\n    ne: BackNamedRef,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // TODO - This may need a resolution at \"runtime\" so the instruction\n    // should reflect as such?\n    // See compiler.spec.ts - \"Test Back Named Groups\"\n    throw new Error(\"BackNameRef Not Implemented\");\n  }\n\n  protected compileVar(v: Var, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    const name = v.name.trim();\n    const expr = this.regexResolver ? this.regexResolver(name) : null;\n    if (expr == null) {\n      throw new Error(`Cannot find expression: ${name}`);\n    }\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n  }\n\n  protected compileUnion(union: Union, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    const split = prog.add(OpCode.Split);\n    const jumps: Instr[] = [];\n\n    for (let i = 0; i < union.options.length; i++) {\n      split.add(prog.length);\n      this.compileExpr(union.options[i], prog, ignoreCase, dotAll, multiline);\n      if (i < union.options.length - 1) {\n        jumps.push(prog.add(OpCode.Jump));\n      }\n    }\n    for (const jmp of jumps) {\n      jmp.add(prog.length);\n    }\n  }\n\n  /**\n   * Compiles a repetition (with quantifiers) into its instructions.  This explicitly expands\n   * a rule of the form x\\{a,b\\} to xx... (a) times followed by x? (b - a) times\n   */\n  protected compileQuant(quant: Quant, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    // optimize the special cases of *, ? and +\n    if (quant.minCount == 0 && quant.maxCount == TSU.Constants.MAX_INT) {\n      // *\n      this.compileAtleast0(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else if (quant.minCount == 1 && quant.maxCount == TSU.Constants.MAX_INT) {\n      // +\n      this.compileAtleast1(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else if (quant.minCount == 0 && quant.maxCount == 1) {\n      // ?\n      this.compileOptional(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n    } else {\n      // general case - Currently going with Option 1\n      //\n      // - convert x{a,b} to xxxxxx (a) times followed by x? b - a times\n      for (let i = 0; i < quant.minCount; i++) {\n        this.compileExpr(quant.expr, prog, ignoreCase, dotAll, multiline);\n      }\n      // generate x? b - a times\n      if (quant.isUnlimited) {\n        // then generate a a* here\n        this.compileAtleast0(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n      } else {\n        for (let i = quant.minCount; i < quant.maxCount; i++) {\n          this.compileOptional(quant.expr, prog, quant.greedy, ignoreCase, dotAll, multiline);\n        }\n      }\n    }\n  }\n\n  protected compileAtleast1(\n    expr: Regex,\n    prog: Prog,\n    greedy = true,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const l1 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    const split = prog.add(OpCode.Split);\n    const l3 = prog.length;\n    if (greedy) {\n      split.add(l1, l3);\n    } else {\n      split.add(l3, l1);\n    }\n  }\n\n  protected compileAtleast0(\n    expr: Regex,\n    prog: Prog,\n    greedy: boolean,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const split = prog.add(OpCode.Split);\n    const l1 = split.offset;\n    const l2 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    prog.add(OpCode.Jump).add(l1);\n    const l3 = prog.length;\n    if (greedy) {\n      split.add(l2, l3);\n    } else {\n      split.add(l3, l2);\n    }\n  }\n\n  protected compileOptional(\n    expr: Regex,\n    prog: Prog,\n    greedy: boolean,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    const split = prog.add(OpCode.Split);\n    const l1 = prog.length;\n    this.compileExpr(expr, prog, ignoreCase, dotAll, multiline);\n    const l2 = prog.length;\n    if (greedy) {\n      split.add(l1, l2);\n    } else {\n      split.add(l2, l1);\n    }\n  }\n\n  /**\n   * Compiles lookahead assertions\n   */\n  protected compileLookAhead(\n    la: LookAhead,\n    prog: Prog,\n    ignoreCase: boolean,\n    dotAll: boolean,\n    multiline: boolean,\n  ): void {\n    // how should this work?\n    // Ensure that assertion matches first before continuing with the expression\n    this.compileExpr(la.expr, prog, ignoreCase, dotAll, multiline);\n    const begin = prog.add(OpCode.Begin).add(0, la.negate ? 1 : 0); // negate if needed\n    this.compileExpr(la.cond, prog, ignoreCase, dotAll, multiline);\n    const end = prog.add(OpCode.End).add(begin.offset);\n    begin.add(end.offset);\n  }\n\n  /**\n   * Compiles lookback assertions\n   */\n  protected compileLookBack(lb: LookBack, prog: Prog, ignoreCase: boolean, dotAll: boolean, multiline: boolean): void {\n    // Ensure that assertion matches first before continuing with the expression\n    this.compileExpr(lb.expr, prog, ignoreCase, dotAll, multiline);\n    TSU.assert(lb.expr.groupIndex >= 0, \"LookBack Assertion requires expression to have a group Index\");\n    const begin = prog.add(OpCode.RBegin).add(lb.expr.groupIndex, lb.negate ? 1 : 0); // negate if needed\n    this.compileExpr(lb.cond.reverse(), prog, ignoreCase, dotAll, multiline);\n    const end = prog.add(OpCode.End).add(begin.offset);\n    begin.add(end.offset);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Token } from \"./token\";\n\nexport class TokenizerError extends Error {\n  readonly name: string = \"TokenizerError\";\n\n  constructor(\n    message: string,\n    public offset: number,\n    public length: number,\n    public type: string,\n    public value: any = null,\n  ) {\n    super(message);\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\nexport class UnexpectedTokenError extends Error {\n  readonly name: string = \"UnexpectedTokenError\";\n  expectedTokens: Token[];\n\n  constructor(public foundToken: TSU.Nullable<Token>, ...expectedTokens: Token[]) {\n    super(\n      `Found Token: ${foundToken?.tag || \"EOF\"} (${foundToken?.value || \"\"}), Expected: ${expectedTokens.join(\", \")}`,\n    );\n    this.expectedTokens = expectedTokens;\n  }\n}\n","export abstract class TapeInterface {\n  index = 0;\n  abstract charAt(index: number): string;\n  abstract hasIndex(index: number): boolean;\n  abstract substring(startIndex: number, endIndex: number): string;\n\n  constructor(public forward = true) {}\n\n  advance(delta = 1): boolean {\n    const next = this.forward ? this.index + delta : this.index - delta;\n    // if (!this.hasIndex(next)) return false;\n    this.index = next;\n    return true;\n  }\n\n  canAdvance(delta = 1): boolean {\n    const next = this.forward ? this.index + delta : this.index - delta;\n    return this.hasIndex(next);\n  }\n\n  get hasMore(): boolean {\n    const next = this.forward ? this.index : this.index - 1;\n    return this.hasIndex(next);\n    // return this.forward ? this.index < this.input.length : this.index > 0;\n  }\n\n  get currCh(): string {\n    return this.charAt(this.index);\n  }\n\n  get prevCh(): string {\n    return this.charAt(this.index - (this.forward ? 1 : -1));\n  }\n\n  get nextCh(): string {\n    const next = this.index + (this.forward ? 1 : -1);\n    return this.charAt(next);\n  }\n\n  get currChCode(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.charCodeAt(0);\n    // return this.input.charCodeAt(this.index);\n  }\n\n  get currChCodeLower(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.toLowerCase().charCodeAt(0);\n  }\n\n  get currChCodeUpper(): number {\n    if (!this.hasMore) return -1;\n    return this.currCh.toUpperCase().charCodeAt(0);\n  }\n\n  charCodeAt(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).charCodeAt(0);\n  }\n\n  charCodeAtLower(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).toLowerCase().charCodeAt(0);\n  }\n\n  charCodeAtUpper(index: number): number {\n    if (!this.hasIndex(index)) return -1;\n    return this.charAt(index).toUpperCase().charCodeAt(0);\n  }\n}\n\n/**\n * A Tape of characters we would read with some extra helpers like rewinding\n * forwarding and prefix checking that is fed into the different tokenizers\n * used by the scannerless parsers.\n */\nexport class Tape extends TapeInterface {\n  protected _rawInput: string;\n  readonly input: string[];\n\n  constructor(input: string, public forward = true) {\n    super(forward);\n    this._rawInput = input;\n    this.input = [...input];\n  }\n\n  push(content: string): void {\n    this._rawInput += content;\n    this.input.push(...content);\n  }\n\n  substring(startIndex: number, endIndex: number): string {\n    return this._rawInput.substring(startIndex, endIndex);\n    // return this.input.slice(startIndex, endIndex).join(\"\");\n  }\n\n  hasIndex(index: number): boolean {\n    return index >= 0 && index < this.input.length;\n  }\n\n  charAt(index: number): string {\n    if (index < 0 || index >= this.input.length) return \"\";\n    return this.input[index];\n  }\n}\n\nexport class TapeHelper {\n  /**\n   * Advances the tape to the end of the first occurence of\n   * the given pattern.\n   */\n  static advanceAfter(tape: TapeInterface, pattern: string, ensureNoPrefixSlash = true): number {\n    let pos = TapeHelper.advanceTo(tape, pattern, ensureNoPrefixSlash);\n    if (pos >= 0) {\n      pos += pattern.length;\n      tape.index = pos;\n    }\n    return pos;\n  }\n\n  /**\n   * Advances the tape till the start of a given pattern.\n   * This is not the most optimal implementation and just does a brute\n   * force search at each index.  Instead using the Regex interface\n   * directly will be faster.\n   */\n  static advanceTo(tape: TapeInterface, pattern: string, ensureNoPrefixSlash = true): number {\n    const lastIndex = tape.index;\n    while (tape.hasMore) {\n      const currStart = tape.index;\n      if (TapeHelper.matches(tape, pattern)) {\n        const endIndex = tape.index;\n        tape.index = currStart;\n        let numSlashes = 0;\n        if (ensureNoPrefixSlash) {\n          for (let i = endIndex - 1; i >= 0; i--) {\n            if (tape.charAt(i) == \"\\\\\") numSlashes++;\n            else break;\n          }\n        }\n        if (numSlashes % 2 == 0) {\n          return tape.index;\n        }\n      }\n      tape.advance(1);\n    }\n    tape.index = lastIndex;\n    throw new Error(`Unexpected end of input before (${pattern})`);\n    return -1;\n  }\n\n  /**\n   * Tells if the given prefix is matche at the current position of the tokenizer.\n   */\n  static matches(tape: TapeInterface, prefix: string, advance = true): boolean {\n    const lastIndex = tape.index;\n    let i = 0;\n    let success = true;\n    for (; i < prefix.length; i++) {\n      if (prefix[i] != tape.currCh) {\n        success = false;\n        break;\n      }\n      tape.advance(1);\n    }\n    // Reset pointers if we are only peeking or match failed\n    if (!advance || !success) {\n      tape.index = lastIndex;\n    }\n    return success;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport { TokenizerError, UnexpectedTokenError } from \"./errors\";\n\nexport type TokenType = number | string;\n\nexport class Token {\n  private static idCounter = 0;\n  // ID for uniquely identifying tokens if needed for shallow equality\n  id = Token.idCounter++;\n  value: any = null;\n  groups: TSU.NumMap<number[]> = {};\n  positions: TSU.NumMap<[number, number]> = {};\n\n  // Incremental lexing support fields\n  /**\n   * Lexer state when this token was constructed.\n   * 0 = INITIAL state. Higher numbers represent other states (e.g., inside string, comment).\n   * Used for incremental lexing to restart from a token boundary.\n   */\n  state = 0;\n\n  /**\n   * Number of characters read beyond this token's lexeme to determine it.\n   * Most tokens need 1 char lookahead to know they're complete (e.g., identifier ends on non-alnum).\n   * Used for incremental lexing dependency tracking.\n   */\n  lookahead = 1;\n\n  /**\n   * Number of preceding tokens whose lookahead reaches this token.\n   * Default 1 means the previous token's lookahead extends into this token.\n   * Used for incremental lexing to find affected region on edit.\n   */\n  lookback = 1;\n\n  constructor(public tag: TokenType, public readonly matchIndex: number, public start: number, public end: number) {}\n\n  isOneOf(...expected: any[]): boolean {\n    for (const tok of expected) {\n      if (this.tag == tok) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n\nexport type NextTokenFunc = (tape: Tape, owner: any) => Token | null;\n\n/**\n * A wrapper on a tokenizer for providing features like k-lookahead, token\n * insertion, rewinding, expectation enforcement etc.\n */\nexport class TokenBuffer {\n  buffer: Token[] = [];\n\n  constructor(public readonly nextToken: NextTokenFunc, public tokenizerContext: any) {}\n\n  next(tape: Tape): Token | null {\n    const out = this.peek(tape);\n    if (out != null) {\n      this.consume();\n    }\n    return out;\n  }\n\n  /**\n   * Peek at the nth token in the token stream.\n   */\n  peek(tape: Tape, nth = 0): Token | null {\n    while (this.buffer.length <= nth) {\n      const tok = this.nextToken(tape, this.tokenizerContext);\n      if (tok == null) return null;\n      this.buffer.push(tok);\n    }\n    return this.buffer[nth];\n  }\n\n  match(\n    tape: Tape,\n    matchFunc: (token: Token) => boolean,\n    ensure = false,\n    consume = true,\n    nextAction?: (token: Token) => boolean | undefined,\n  ): Token | null {\n    const token = this.peek(tape);\n    if (token != null) {\n      if (matchFunc(token)) {\n        if (nextAction && nextAction != null) {\n          nextAction(token);\n        }\n        if (consume) {\n          this.consume();\n        }\n      } else if (ensure) {\n        // Should we throw an error?\n        throw new UnexpectedTokenError(token);\n      } else {\n        return null;\n      }\n    } else if (ensure) {\n      throw new TokenizerError(\"Unexpected end of input\", -1, 0, \"UnexpectedEndOfInput\");\n    }\n    return token;\n  }\n\n  consume(): void {\n    this.buffer.splice(0, 1);\n  }\n\n  consumeIf(tape: Tape, ...expected: TokenType[]): Token | null {\n    return this.match(tape, (t) => t.isOneOf(...expected));\n  }\n\n  expectToken(tape: Tape, ...expected: TokenType[]): Token {\n    return this.match(tape, (t) => t.isOneOf(...expected), true, true) as Token;\n  }\n\n  ensureToken(tape: Tape, ...expected: TokenType[]): Token {\n    return this.match(tape, (t) => t.isOneOf(...expected), true, false) as Token;\n  }\n\n  nextMatches(tape: Tape, ...expected: TokenType[]): Token | null {\n    const token = this.peek(tape);\n    if (token == null) return null;\n    for (const tok of expected) {\n      if (token.tag == tok) return token;\n    }\n    return null;\n  }\n}\n","export class GroupCounter {\n  value = -1;\n  next(): number {\n    return ++this.value;\n  }\n  get current(): number {\n    return this.value;\n  }\n}\n\nexport function isSpace(ch: string): boolean {\n  return ch == \" \" || ch == \"\\t\" || ch == \"\\n\" || ch == \"\\r\";\n}\n\n// function isSpaceChar(ch: string): boolean { return ch == \" \" || ch == \"\\t\"; }\n","import * as TSU from \"@panyam/tsutils\";\nimport {\n  Quant,\n  RegexType,\n  StartOfInput,\n  EndOfInput,\n  Regex,\n  Cat,\n  Char,\n  LeafChar,\n  CharGroup,\n  CharType,\n  Var,\n  BackNamedRef,\n  BackNumRef,\n  LookAhead,\n  LookBack,\n  Union,\n} from \"./core\";\nimport { CharClassType } from \"./charclasses\";\nimport { GroupCounter } from \"./utils\";\n\n/**\n * A RegexParser for parsing regex strings in JS RegExp format.\n * This class will seldom have to be used directly.  Instead use one of the methods in {@link Builder}\n */\nexport class RegexParser {\n  protected unicode: boolean;\n  protected counter: GroupCounter;\n  /**\n   * @param pattern The pattern string being parsed.\n   * @param config  Configs for the regex to include whether parsing is unicode or plain ASCII.\n   */\n  constructor(public readonly pattern: string, config?: { unicode?: boolean }) {\n    this.counter = new GroupCounter();\n    this.unicode = config?.unicode || false;\n  }\n\n  protected reduceLeft(stack: Regex[]): Regex {\n    const r = stack.length == 1 ? stack[0] : new Cat(...stack);\n    // remove all elements on stack\n    stack.splice(0);\n    return r;\n  }\n\n  protected throwError(msg: string): void {\n    throw new SyntaxError(`Error in JS RE '${this.pattern}': ${msg}`);\n  }\n\n  /**\n   * Creates a regex tree given a string\n   */\n  parse(curr = 0, end = -1): Regex {\n    const pattern = this.pattern;\n    const stack: Regex[] = [];\n    if (end < 0) end = pattern.length - 1;\n    while (curr <= end) {\n      const currCh = pattern[curr];\n      // see if we have groups so they get highest preference\n      if (currCh == \".\") {\n        stack.push(LeafChar.Any());\n        curr++;\n      } else if (currCh == \"\\\\\" && pattern[curr + 1] >= \"1\" && pattern[curr + 1] <= \"9\") {\n        // Numeric references\n        curr++;\n        let num = \"\";\n        while (curr <= end && pattern[curr] >= \"0\" && pattern[curr] <= \"9\") {\n          num = num + pattern[curr++];\n        }\n        const refNum = parseInt(num);\n        if (refNum > this.counter.current + 1) {\n          this.throwError(\"Invalid reference: \" + refNum);\n        }\n        stack.push(new BackNumRef(refNum));\n      } else if (currCh == \"\\\\\" && pattern[curr + 1] == \"k\" && pattern[curr + 2] == \"<\") {\n        // Named references\n        curr += 3;\n        let gtPos = curr;\n        while (gtPos <= end && pattern[gtPos] != \">\") gtPos++;\n        if (gtPos > end) this.throwError(\"Expected '>' found EOI\");\n        const name = pattern.substring(curr, gtPos);\n        if (name.trim() == \"\") {\n          this.throwError(\"Expected name\");\n        }\n        stack.push(new BackNamedRef(name));\n        curr = gtPos + 1;\n      } else if (currCh == \"[\") {\n        // character ranges\n        let clPos = curr + 1;\n        while (clPos <= end && pattern[clPos] != \"]\") {\n          if (pattern[clPos] == \"\\\\\") clPos++;\n          clPos++;\n        }\n        if (clPos > end) this.throwError(\"Expected ']' found EOI\");\n        stack.push(this.parseCharGroup(curr + 1, clPos - 1));\n        curr = clPos + 1;\n      } else if (currCh == \"^\") {\n        stack.push(new StartOfInput());\n        curr++;\n      } else if (currCh == \"$\") {\n        stack.push(new EndOfInput());\n        curr++;\n      } else if (currCh == \"|\") {\n        if (curr + 1 <= end) {\n          // reduce everything \"until now\" and THEN apply\n          const prev = this.reduceLeft(stack);\n          // this.parse everything to the right\n          const rest = this.parse(curr + 1, end);\n          return new Union(prev, rest);\n        }\n        curr = end + 1;\n      } else if (currCh == \"(\") {\n        curr = this.parseGroup(stack, curr, end);\n      } else if (currCh == \")\" || currCh == \"]\" || currCh == \"}\") {\n        this.throwError(`Unmatched ${currCh}.  Try using \\\\${currCh}`);\n      } else if (pattern[curr] == \"*\" || pattern[curr] == \"?\" || pattern[curr] == \"+\" || pattern[curr] == \"{\") {\n        curr = this.parseQuant(stack, curr, end);\n      } else {\n        // plain old alphabets\n        const [result, nchars] = this.parseChar(curr, end);\n        stack.push(result);\n        curr += nchars;\n      }\n    }\n    if (stack.length <= 0) {\n      // this.throwError(`Invalid Regex (${curr} - ${end}): ${pattern}`);\n    }\n    if (stack.length == 1) return stack[0];\n    return new Cat(...stack);\n  }\n\n  protected parseGroup(stack: Regex[], curr: number, end: number): number {\n    // we have a grouping or an assertion\n    let clPos = curr + 1;\n    let depth = 0;\n    const pattern = this.pattern;\n    while (clPos <= end && (pattern[clPos] != \")\" || depth > 0)) {\n      if (pattern[clPos] == \"(\") depth++;\n      else if (pattern[clPos] == \")\") depth--;\n      if (pattern[clPos] == \"\\\\\") clPos++;\n      clPos++;\n    }\n    if (clPos > end) this.throwError(\"Expected ')' found EOI\");\n\n    curr++;\n    if (pattern[curr] == \"?\") {\n      // assertions\n      curr++; // skip the \"?\"\n      if (pattern[curr] == \":\") {\n        // A non capturing\n        stack.push(this.parse(curr + 1, clPos - 1));\n      } else if (pattern[curr] == \"<\" && pattern[curr + 1] != \"!\" && pattern[curr + 1] != \"=\") {\n        // Named capture group\n        const groupIndex = this.counter.next();\n        let groupName = \"\";\n        // get name of this group\n        let gtPos = curr + 1;\n        while (gtPos <= end && pattern[gtPos] != \">\") {\n          groupName += pattern[gtPos];\n          gtPos++;\n        }\n        const subExpr = this.parse(gtPos + 1, clPos - 1);\n        subExpr.groupIndex = groupIndex;\n        if (groupName.length > 0) subExpr.groupName = groupName;\n      } else {\n        // We have lookback/ahead assertions\n        let after = true;\n        if (pattern[curr] == \"<\") {\n          curr++;\n          after = false;\n        }\n        const neg = pattern[curr++] == \"!\";\n        const cond = this.parse(curr, clPos - 1);\n        if (after) {\n          // reduce everything \"until now\" and THEN apply\n          if (stack.length == 0) {\n            // this.throwError(\"LookAhead condition cannot be before empty rule\");\n          }\n          // const endIndex = stack.length - 1;\n          // stack[endIndex] = new LookAhead(stack[endIndex], cond, neg);\n          const expr = new LookAhead(this.reduceLeft(stack), cond, neg);\n          stack.push(expr);\n        } else {\n          // Lookbacks are interesting, we have something like:\n          // (?<!...)abcde\n          // clPos points to \")\" We need abcde also parsed\n          // and then lookback applied to it\n          const rest = this.parse(clPos + 1, end);\n          if (rest.groupIndex < 0) {\n            rest.groupIndex = this.counter.next();\n            rest.groupIsSilent = true;\n          }\n          stack.push(new LookBack(rest, cond, neg));\n          return end + 1;\n        }\n      }\n    } else {\n      // plain old grouping of the form (xyz)\n      const groupIndex = this.counter.next();\n      let neg = false;\n      if (pattern[curr] == \"^\") {\n        neg = true;\n        curr++;\n      }\n      let subExpr = this.parse(curr, clPos - 1);\n      // if (neg) subExpr = new Neg(subExpr);\n      // Do the next before the previous call if we want group\n      // index to match outer brackets first\n      if (subExpr.groupIndex >= 0) {\n        // Already set so create cat\n        subExpr = new Cat(subExpr);\n      }\n      subExpr.groupIndex = groupIndex;\n      stack.push(subExpr);\n    }\n    return clPos + 1;\n  }\n\n  protected parseCharGroup(curr: number, end: number): Char {\n    const out: Char[] = [];\n    // first see which characters are in this (until the end)\n    let i = curr;\n    let neg = false;\n    const pattern = this.pattern;\n    if (pattern[i] == \"^\") {\n      neg = true;\n      i++;\n    }\n    for (; i <= end; ) {\n      const [currch, nchars] = this.parseChar(i, end);\n      i += nchars;\n      if (i < pattern.length && pattern[i] == \"-\") {\n        i++;\n        // TODO - Should this be for all such \"operator\" charactors?\n        if (pattern[i] == \"]\" || pattern[i] == \"[\") {\n          // Special case for something like:\n          // [....x-] or [.....x-[:alpha:]]\n          out.push(currch);\n          out.push(LeafChar.Single(\"-\"));\n        } else if (i <= end) {\n          const [endch, nchars] = this.parseChar(i, end);\n          if (currch.op != CharType.SingleChar || endch.op != CharType.SingleChar) {\n            this.throwError(\"Char range cannot start or end in a char class\");\n          }\n          if (endch.args[0] < currch.args[0]) {\n            this.throwError(\"End cannot be less than start\");\n          }\n          out.push(CharGroup.Range(currch, endch));\n          i += nchars;\n        } else {\n          this.throwError(\"Unterminated char class\");\n        }\n      } else {\n        out.push(currch);\n      }\n    }\n    return CharGroup.Union(neg, out);\n  }\n\n  protected parseChar(index = 0, end = 0): [LeafChar, number] {\n    if (this.pattern[index] == \"\\\\\") {\n      return this.parseEscapeChar(index, end);\n    } else {\n      return this.parseSingleChar(index, end);\n    }\n  }\n\n  protected parseSingleChar(index = 0, end = 0): [LeafChar, number] {\n    // single char\n    const ch = this.pattern.charCodeAt(index);\n    return [LeafChar.Single(ch), 1];\n  }\n\n  protected parsePropertyEscape(index = 0, end = 0): [LeafChar, number] {\n    const pattern = this.pattern;\n    if (pattern[index] + 1 != \"{\") {\n      this.throwError(\"Invalid property escape\");\n    }\n    index += 2;\n    let clEnd = index;\n    let eqPos = -1;\n    while (clEnd <= end && pattern[clEnd] != \"}\") {\n      if (pattern[clEnd] == \"=\") eqPos = clEnd;\n      clEnd++;\n    }\n    if (clEnd > end) {\n      this.throwError(\"Invalid property escape\");\n    }\n    // see if this is a lone property escape\n    const propStr = pattern.substring(index, clEnd);\n    let propName = \"General_Category\";\n    let propValue = propStr;\n    if (eqPos >= 0) {\n      const parts = propStr.split(\"=\");\n      if (parts.length != 2) this.throwError(\"Invalid property escape\");\n      propName = parts[0].trim();\n      propValue = parts[1].trim();\n    }\n    return [LeafChar.PropertyEscape(propName, propValue), 2 + clEnd + 1 - index];\n  }\n\n  protected parseEscapeChar(index = 0, end = 0): [LeafChar, number] {\n    const pattern = this.pattern;\n    TSU.assert(pattern[index] == \"\\\\\", \"Expected '\\\\'\");\n    // escape char\n    index++;\n    if (index > end) {\n      this.throwError(\"Encounted unexpected end of input after \\\\\");\n    }\n    const ch = pattern[index];\n    if ((this.unicode && ch == \"p\") || ch == \"P\") {\n      // property escapes\n      return this.parsePropertyEscape(index, end);\n    }\n    switch (ch) {\n      // char classes\n      case \"w\":\n        return [LeafChar.Class(CharClassType.WORD_CHAR), 2];\n      case \"W\":\n        return [LeafChar.Class(CharClassType.WORD_CHAR, true), 2];\n      case \"d\":\n        return [LeafChar.Class(CharClassType.DIGITS), 2];\n      case \"D\":\n        return [LeafChar.Class(CharClassType.DIGITS, true), 2];\n      case \"s\":\n        return [LeafChar.Class(CharClassType.SPACES), 2];\n      case \"S\":\n        return [LeafChar.Class(CharClassType.SPACES, true), 2];\n      case \"0\":\n        if (pattern[index + 1] >= \"0\" && pattern[index + 1] <= \"9\" && this.unicode) {\n          this.throwError(\"Invalid decimal escape\");\n        }\n        return [LeafChar.Single(\"\\0\"), 2];\n      case \"r\":\n        return [LeafChar.Single(\"\\r\"), 2];\n      case \"n\":\n        return [LeafChar.Single(\"\\n\"), 2];\n      case \"f\":\n        return [LeafChar.Single(\"\\f\"), 2];\n      case \"b\":\n        return [LeafChar.Single(\"\\b\"), 2];\n      case \"v\":\n        return [LeafChar.Single(\"\\v\"), 2];\n      case \"t\":\n        return [LeafChar.Single(\"\\t\"), 2];\n      case \"c\":\n        // ControlEscape:\n        // https://262.ecma-international.org/5.1/#sec-15.10.2.10\n        if (this.unicode || index >= end) {\n          this.throwError(`Invalid char sequence at ${index}, ${end}`);\n        }\n        const next = pattern.charCodeAt(index + 1) % 32;\n        return [LeafChar.Single(next), 3];\n      case \"x\":\n        // 2 digit hex digits\n        index++;\n        if (index >= end) {\n          this.throwError(`Invalid hex sequence at ${index}, ${end}`);\n        }\n        const hexSeq = pattern.substring(index, index + 2);\n        const hexVal = parseInt(hexSeq, 16);\n        TSU.assert(!isNaN(hexVal), `Invalid hex sequence: '${hexSeq}'`);\n        return [LeafChar.Single(hexVal), 4];\n      case \"u\": // this could \\uABCD or \\u{ABCDEF}\n        index++;\n        // 4 digit hex digits for unicode\n        if (index > end - 3) {\n          this.throwError(`Invalid unicode sequence at ${index}`);\n        }\n        const ucodeSeq = pattern.substring(index, index + 4);\n        const ucodeVal = parseInt(ucodeSeq, 16);\n        if (isNaN(ucodeVal)) {\n          this.throwError(`Invalid unicode sequence: '${ucodeSeq}'`);\n        }\n        return [LeafChar.Single(ucodeVal), 6];\n      case \"^\": // List of special operators that need to be escaped\n      case \"$\":\n      case \".\":\n      case \"*\":\n      case \"+\":\n      case \"?\":\n      case \"\\\\\":\n      case \"'\":\n      case '\"':\n      case \"(\":\n      case \")\":\n      case \"[\":\n      case \"]\":\n      case \"{\":\n      case \"}\":\n      case \"|\":\n      case \"/\":\n        return [LeafChar.Single(ch), 2];\n      default:\n        if (this.unicode) this.throwError(\"Invalid escape character: \" + ch);\n        return [LeafChar.Single(ch), 2];\n    }\n  }\n\n  protected parseQuant(stack: Regex[], curr: number, end: number): number {\n    const pattern = this.pattern;\n    const lastCh = pattern[curr - 1];\n    let minCount = 1,\n      maxCount = 1;\n    if (pattern[curr] == \"*\") {\n      minCount = 0;\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (pattern[curr] == \"+\") {\n      minCount = Math.min(minCount, 1);\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (pattern[curr] == \"?\") {\n      minCount = 0;\n      maxCount = Math.max(maxCount, 1);\n    } else if (pattern[curr] == \"{\") {\n      // find the next \"}\"\n      const clPos = pattern.indexOf(\"}\", curr + 1);\n      if (clPos <= curr || clPos > end) {\n        this.throwError(\"Unexpected end of input while looking for '}'\");\n      }\n      const sub = pattern.substring(curr + 1, clPos).trim();\n      const parts = sub.split(\",\").map((x) => parseInt(x.trim()));\n      curr = clPos;\n      if (parts.length == 1) {\n        if (isNaN(parts[0])) {\n          if (sub.trim().length > 0) {\n            stack.push(new Var(sub.trim()));\n            return curr + 1;\n          } else {\n            this.throwError(`Invalid quantifier: /${sub}/`);\n          }\n        }\n        minCount = maxCount = parts[0];\n      } else if (parts.length == 2) {\n        minCount = isNaN(parts[0]) ? 0 : parts[0];\n        maxCount = isNaN(parts[1]) ? TSU.Constants.MAX_INT : parts[1];\n        if (minCount > maxCount) {\n          this.throwError(`Invalid Quant /${sub}/: Min must be <= Max`);\n        }\n      } else if (parts.length > 2) {\n        this.throwError(`Invalid quantifier spec: \"{${sub}}\"`);\n      }\n    } else {\n      throw new Error(\"Here?\");\n    }\n    // Quantifiers\n    if (stack.length <= 0) {\n      this.throwError(\"Quantifier cannot appear before an expression\");\n    }\n    // no optimizations - convert the last one into a Quantifier\n    // and we will start to fill in the quantities and greediness\n    const last = stack[stack.length - 1];\n    if (last.tag == RegexType.QUANT && (lastCh == \"*\" || lastCh == \"?\" || lastCh == \"+\" || lastCh == \"}\")) {\n      this.throwError(\"Nothing to repeat\");\n    }\n    if (this.unicode && (last.tag == RegexType.LOOK_AHEAD || last.tag == RegexType.LOOK_BACK)) {\n      this.throwError(\"Cannot have quantifier on assertion in unicode mode\");\n    }\n    const quant = (stack[stack.length - 1] = new Quant(last));\n    quant.minCount = minCount;\n    quant.maxCount = maxCount;\n    // check if there is an extra lazy quantifier\n    curr++;\n    if (curr <= end && pattern[curr] == \"?\" && quant.greedy) {\n      curr++;\n      quant.greedy = false;\n    }\n    return curr;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { TapeInterface as Tape } from \"./tape\";\nimport {\n  LookAhead,\n  Quant,\n  RegexType,\n  StartOfInput,\n  EndOfInput,\n  Regex,\n  Cat,\n  CharType,\n  Char,\n  LeafChar,\n  CharGroup,\n  Var,\n  Union,\n} from \"./core\";\nimport { CharClassType } from \"./charclasses\";\nimport { GroupCounter, isSpace } from \"./utils\";\n\nfunction advanceIf(tape: Tape, ch: string): boolean {\n  const pos = tape.index;\n  for (let i = 0; i < ch.length; i++) {\n    if (tape.currCh != ch.charAt(i)) {\n      tape.index = pos;\n      return false;\n    }\n    tape.advance(1);\n  }\n  return true;\n}\n\n/**\n * A RegexParser for parsing regex strings in Flex RE format.\n * This class will seldom have to be used directly.  Instead use one of the methods in {@link Builder}\n */\nexport class RegexParser {\n  protected counter: GroupCounter = new GroupCounter();\n\n  parse(pattern: Tape, ignoreSpaces = false, obCount = 0): Regex {\n    const stack: Regex[] = [];\n\n    while (pattern.hasMore) {\n      const currCh = pattern.currCh;\n      // see if we have groups so they get highest preference\n      if (advanceIf(pattern, \".\")) {\n        stack.push(LeafChar.Any());\n      } else if (advanceIf(pattern, \"^\")) {\n        const x = new StartOfInput();\n        x.multiline = true;\n        stack.push(x);\n      } else if (advanceIf(pattern, \"$\")) {\n        const x = new EndOfInput();\n        x.multiline = true;\n        stack.push(x);\n      } else if (advanceIf(pattern, \"|\")) {\n        // reduce everything \"until now\" and THEN apply\n        const prev = this.reduceLeft(stack);\n        // this.parse everything to the right\n        const rest = this.parse(pattern, ignoreSpaces, obCount);\n        return new Union(prev, rest);\n      } else if (currCh == \"[\") {\n        stack.push(this.parseCharGroup(pattern));\n      } else if (currCh == \"*\" || currCh == \"?\" || currCh == \"+\" || currCh == \"{\") {\n        this.parseQuant(pattern, stack);\n      } else if (ignoreSpaces && isSpace(currCh)) {\n        // do nothing\n        pattern.advance(1);\n      } else if (ignoreSpaces && advanceIf(pattern, \"/*\")) {\n        // Read everything until a */\n        while (pattern.currCh != \"*\" || pattern.nextCh != \"/\") {\n          if (!pattern.hasMore) {\n            this.throwError(pattern, \"Unterminated comment\");\n          }\n          pattern.advance(1);\n        }\n        pattern.advance(2);\n        // now do nothing\n      } else if (advanceIf(pattern, \"{-}\")) {\n        // char class intersection\n        throw new Error(\"Intersection Not yet supported\");\n      } else if (advanceIf(pattern, \"{+}\")) {\n        // char class union\n        throw new Error(\"Union Not yet supported\");\n      } else if (advanceIf(pattern, \"(\")) {\n        if (advanceIf(pattern, \"?\")) {\n          if (advanceIf(pattern, \"#\")) {\n            while (pattern.hasMore && pattern.currCh != \")\") pattern.advance(1);\n            TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n          } else {\n            // pattern of the form (?r-s:pattern)\n            let ignoreCase = false;\n            let dotAll = false;\n            let ignoreSpaces2 = ignoreSpaces as boolean;\n            let neg = false;\n            while (pattern.hasMore && pattern.currCh != \":\") {\n              if (pattern.currCh == \"i\") {\n                ignoreCase = neg ? false : true;\n              } else if (pattern.currCh == \"s\") {\n                dotAll = neg ? false : true;\n              } else if (pattern.currCh == \"x\") {\n                ignoreSpaces2 = neg ? false : true;\n              } else if (pattern.currCh == \"-\") {\n                neg = true;\n              }\n              pattern.advance(1);\n            }\n            TSU.assert(advanceIf(pattern, \":\"), \"Expected ':'\");\n            const groupIndex = this.counter.next();\n            let subExpr = this.parse(pattern, ignoreSpaces2, obCount + 1);\n            if (subExpr.groupIndex >= 0) {\n              // Already set so create cat\n              subExpr = new Cat(subExpr);\n            }\n            subExpr.dotAll = dotAll;\n            subExpr.ignoreCase = ignoreCase;\n            subExpr.groupIndex = groupIndex;\n            stack.push(subExpr);\n            TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n          }\n        } else {\n          // parse the subgroup and give it a group number\n          const groupIndex = this.counter.next();\n          let subExpr = this.parse(pattern, ignoreSpaces, obCount + 1);\n          if (subExpr.groupIndex >= 0) {\n            // Already set so create cat\n            subExpr = new Cat(subExpr);\n          }\n          subExpr.groupIndex = groupIndex;\n          stack.push(subExpr);\n          TSU.assert(advanceIf(pattern, \")\"), \"Expected ')'\");\n        }\n      } else if (currCh == \")\") {\n        if (obCount == 0) {\n          this.throwError(pattern, `Unmatched ${currCh}.  Try using \\\\${currCh}`);\n        }\n        // stop here so we can recurse up\n        break;\n      } else if (currCh == \"]\" || currCh == \"}\") {\n        this.throwError(pattern, `Unmatched ${currCh}.  Try using \\\\${currCh}`);\n      } else if (advanceIf(pattern, \"/\")) {\n        // LookAheads\n        const prev = this.reduceLeft(stack);\n        // this.parse everything to the right\n        const rest = this.parse(pattern, ignoreSpaces, obCount);\n        return new LookAhead(prev, rest, false);\n      } else if (advanceIf(pattern, '\"')) {\n        // raw string\n        while (pattern.currCh != '\"') {\n          if (!pattern.hasMore) {\n            this.throwError(pattern, \"Unterminated string\");\n          }\n          stack.push(this.parseChar(pattern));\n        }\n        pattern.advance(1);\n      } else {\n        // plain old alphabets\n        stack.push(this.parseChar(pattern));\n      }\n    }\n    if (stack.length == 1) return stack[0];\n    return new Cat(...stack);\n  }\n\n  protected parseQuant(pattern: Tape, stack: Regex[]): void {\n    let minCount = 1,\n      maxCount = 1;\n    if (advanceIf(pattern, \"*\")) {\n      minCount = 0;\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (advanceIf(pattern, \"+\")) {\n      minCount = Math.min(minCount, 1);\n      maxCount = TSU.Constants.MAX_INT;\n    } else if (advanceIf(pattern, \"?\")) {\n      minCount = 0;\n      maxCount = Math.max(maxCount, 1);\n    } else if (advanceIf(pattern, \"{\")) {\n      let foundComma = false;\n      let p1 = \"\";\n      let p2 = \"\";\n      while (pattern.hasMore && pattern.currCh != \"}\") {\n        if (pattern.currCh == \",\") foundComma = true;\n        else {\n          if (!foundComma) p1 += pattern.currCh;\n          else p2 += pattern.currCh;\n        }\n        pattern.advance(1);\n      }\n      if (!pattern.hasMore) {\n        this.throwError(pattern, \"Invalid property escape\");\n      }\n      // see if this is a lone property escape\n      p1 = p1.trim();\n      p2 = p2.trim();\n      // advance over the \"}\"\n      pattern.advance(1);\n\n      const part1 = parseInt(p1);\n      const part2 = parseInt(p2);\n      if (foundComma) {\n        minCount = isNaN(part1) ? 0 : part1;\n        maxCount = isNaN(part2) ? TSU.Constants.MAX_INT : part2;\n        if (minCount > maxCount) {\n          this.throwError(pattern, `Invalid Quant /${p1},${p2}/: Min must be <= Max`);\n        }\n      } else {\n        if (isNaN(part1)) {\n          if (p1.length > 0) {\n            stack.push(new Var(p1));\n            // nothing more\n            return;\n          } else {\n            this.throwError(pattern, `Invalid quantifier: /${p1}/`);\n          }\n          minCount = maxCount = 1;\n        } else {\n          minCount = maxCount = part1;\n        }\n      }\n    } else {\n      this.throwError(pattern, \"Expected '{', '*', '?' or '+', Found: \" + pattern.currCh);\n    }\n    // Quantifiers\n    if (stack.length <= 0) {\n      this.throwError(pattern, \"Quantifier cannot appear before an expression\");\n    }\n    // no optimizations - convert the last one into a Quantifier\n    // and we will start to fill in the quantities and greediness\n    const last = stack[stack.length - 1];\n    let quant: Quant;\n    if (last.tag == RegexType.QUANT && last.groupIndex < 0) {\n      // Fold repeated quants unless they are not in a group\n      quant = last as Quant;\n      quant.minCount = Math.min(minCount, quant.minCount);\n      quant.maxCount = Math.max(maxCount, quant.maxCount);\n    } else {\n      quant = stack[stack.length - 1] = new Quant(last);\n      quant.minCount = minCount;\n      quant.maxCount = maxCount;\n    }\n    // check if there is an extra lazy quantifier\n    if (quant.greedy && advanceIf(pattern, \"?\")) {\n      quant.greedy = false;\n    }\n  }\n\n  protected parseCharGroup(pattern: Tape): Char {\n    const out: Char[] = [];\n    TSU.assert(advanceIf(pattern, \"[\"), \"Expected '['\");\n    // first see which characters are in this (until the end)\n    const neg = advanceIf(pattern, \"^\");\n    while (pattern.currCh != \"]\") {\n      const currch = this.parseChar(pattern);\n      if (advanceIf(pattern, \"-\")) {\n        if (pattern.hasMore) {\n          // TODO - Should this be for all such \"operator\" charactors?\n          if (pattern.currCh == \"]\" || pattern.currCh == \"[\") {\n            // Special case for something like:\n            // [....x-] or [.....x-[:alpha:]]\n            out.push(currch);\n            out.push(LeafChar.Single(\"-\"));\n          } else {\n            const endch = this.parseChar(pattern);\n            if (currch.op != CharType.SingleChar || endch.op != CharType.SingleChar) {\n              this.throwError(pattern, \"Char range cannot start or end in a char class\");\n            }\n            if (endch.args[0] < currch.args[0]) {\n              this.throwError(pattern, \"End cannot be less than start\");\n            }\n            // currch.end = endch.start;\n            out.push(CharGroup.Range(currch, endch));\n          }\n        } else {\n          this.throwError(pattern, \"Unterminated char class\");\n        }\n      } else {\n        out.push(currch);\n      }\n    }\n    TSU.assert(advanceIf(pattern, \"]\"), \"']' expected\");\n    return CharGroup.Union(neg, out);\n  }\n\n  protected parseChar(pattern: Tape): LeafChar {\n    if (pattern.currCh == \"\\\\\") {\n      return this.parseEscapeChar(pattern);\n    } else {\n      return this.parseSingleChar(pattern);\n    }\n  }\n\n  protected parseSingleChar(pattern: Tape): LeafChar {\n    // single char\n    const ch = pattern.currCh;\n    pattern.advance(1);\n    return LeafChar.Single(ch);\n  }\n\n  protected parsePropertyEscape(pattern: Tape): LeafChar {\n    TSU.assert(advanceIf(pattern, \"\\\\{\"), \"Invalid property escape\");\n    pattern.advance(2);\n    let foundEq = false;\n    let propName = \"\";\n    let propValue = \"\";\n    while (pattern.hasMore && pattern.currCh != \"}\") {\n      if (pattern.currCh == \"=\") foundEq = true;\n      else {\n        if (!foundEq) propName += pattern.currCh;\n        else propValue += pattern.currCh;\n      }\n      pattern.advance(1);\n    }\n    if (!pattern.hasMore) {\n      this.throwError(pattern, \"Invalid property escape\");\n    }\n    // see if this is a lone property escape\n    propName = propName.trim();\n    propValue = propValue.trim();\n    if (!foundEq) {\n      propValue = propName;\n      propName = \"General_Category\";\n    }\n    // advance over the \"}\"\n    pattern.advance(1);\n    return LeafChar.PropertyEscape(propName, propValue);\n  }\n\n  protected parseEscapeChar(pattern: Tape): LeafChar {\n    TSU.assert(advanceIf(pattern, \"\\\\\"), \"Expected '\\\\'\");\n    // escape char\n    if (!pattern.hasMore) {\n      this.throwError(pattern, \"Encounted unexpected end of input after \\\\\");\n    }\n    if (advanceIf(pattern, \"w\")) {\n      return LeafChar.Class(CharClassType.WORD_CHAR);\n    } else if (advanceIf(pattern, \"W\")) {\n      return LeafChar.Class(CharClassType.WORD_CHAR, true);\n    } else if (advanceIf(pattern, \"d\")) {\n      return LeafChar.Class(CharClassType.DIGITS);\n    } else if (advanceIf(pattern, \"D\")) {\n      return LeafChar.Class(CharClassType.DIGITS, true);\n    } else if (advanceIf(pattern, \"s\")) {\n      return LeafChar.Class(CharClassType.SPACES);\n    } else if (advanceIf(pattern, \"S\")) {\n      return LeafChar.Class(CharClassType.SPACES, true);\n    } else if (advanceIf(pattern, \"0\")) {\n      return LeafChar.Single(\"\\0\");\n    } else if (advanceIf(pattern, \"r\")) {\n      return LeafChar.Single(\"\\r\");\n    } else if (advanceIf(pattern, \"n\")) {\n      return LeafChar.Single(\"\\n\");\n    } else if (advanceIf(pattern, \"f\")) {\n      return LeafChar.Single(\"\\f\");\n    } else if (advanceIf(pattern, \"b\")) {\n      return LeafChar.Single(\"\\b\");\n    } else if (advanceIf(pattern, \"v\")) {\n      return LeafChar.Single(\"\\v\");\n    } else if (advanceIf(pattern, \"t\")) {\n      return LeafChar.Single(\"\\t\");\n    } else if (advanceIf(pattern, \"\\\\\")) {\n      return LeafChar.Single(\"\\\\\");\n    } else if (advanceIf(pattern, \"'\")) {\n      return LeafChar.Single(\"'\");\n    } else if (advanceIf(pattern, '\"')) {\n      return LeafChar.Single('\"');\n    } else if (advanceIf(pattern, \"x\")) {\n      // 2 digit hex digits\n      if (!pattern.hasMore) {\n        this.throwError(pattern, `Invalid hex sequence at ${pattern.index}`);\n      }\n      const hexSeq = pattern.currCh + pattern.nextCh;\n      const hexVal = parseInt(hexSeq, 16);\n      TSU.assert(!isNaN(hexVal), `Invalid hex sequence: '${hexSeq}'`);\n      pattern.advance(2);\n      return LeafChar.Single(hexVal);\n    } else if (advanceIf(pattern, \"u\")) {\n      // 4 digit hex digits for unicode\n      if (!pattern.canAdvance(3)) {\n        // index >= pattern.input.length - 3) {\n        this.throwError(pattern, `Invalid unicode sequence at ${pattern.index}`);\n      }\n      const ucodeSeq = pattern.substring(pattern.index, pattern.index + 4);\n      const ucodeVal = parseInt(ucodeSeq, 16);\n      if (isNaN(ucodeVal)) {\n        this.throwError(pattern, `Invalid unicode sequence: '${ucodeSeq}'`);\n      }\n      pattern.advance(4);\n      return LeafChar.Single(ucodeVal);\n    }\n    // default\n    const ch = pattern.currCh;\n    pattern.advance(1);\n    return LeafChar.Single(ch);\n  }\n\n  protected reduceLeft(stack: Regex[]): Regex {\n    const r = stack.length == 1 ? stack[0] : new Cat(...stack);\n    // remove all elements on stack\n    stack.splice(0);\n    return r;\n  }\n\n  protected throwError(pattern: Tape, msg: string): void {\n    throw new Error(msg);\n    // this.throwError(pattern, `Error in Flex RE '${pattern.input}': ${msg}`);\n  }\n}\n","import { Rule, Regex, REPatternType } from \"./core\";\nimport { RegexParser as JSREParser } from \"./jsparser\";\nimport { RegexParser as FlexREParser } from \"./flexparser\";\nimport { Tape } from \"./tape\";\n\n/**\n * Uber method to build a Regex given either a regex string or a JS regex.\n *\n * @param pattern   Either a regex pattern, a JS RegExp object, or an already parsed Regex object.\n * @param config    TBD\n *\n * @return A {@link Rule} object that contains the pattern as well as its normalized regex tree.\n */\nexport function build(pattern: string | RegExp | Regex, config?: any): Rule {\n  if (typeof pattern === \"string\") {\n    const rule = new Rule(exprFromJSRE(pattern, config), config);\n    rule.pattern = pattern;\n    return rule;\n  } else if (pattern.constructor.name == \"RegExp\") {\n    const rule = new Rule(exprFromJSRE(pattern as RegExp, config), config);\n    rule.pattern = (pattern as RegExp).source;\n    return rule;\n  } else {\n    // Already compiled expression\n    return new Rule(pattern as Regex, config);\n  }\n}\n\n/*\nexport function fromRE(pattern: string, config?: any): Rule {\n  const expr = new JSREParser(pattern, config).parse();\n  const rule = new Rule(expr, config);\n  rule.pattern = pattern;\n  return rule;\n}\n\nexport function fromJSRE(re: RegExp, config?: any): Rule {\n  const expr = exprFromJSRE(re);\n  const rule = new Rule(expr, config);\n  rule.pattern = re.source;\n  return rule;\n}\n\nexport function fromFlexRE(re: string, config?: any): Rule {\n  const expr = exprFromFlexRE(re);\n  const rule = new Rule(expr, config);\n  rule.pattern = re;\n  return rule;\n}\n*/\n\n/**\n * \"Flattens\" either a single REPatternType or a list of REPatternTypes into a flat list of all\n * REPatternTypes at the leaf levels.\n */\nexport function flatten(re: REPatternType | REPatternType[], index = 0, rules?: Rule[]): Rule[] {\n  rules = rules || [];\n  if (typeof re === \"string\") {\n    rules.push(build(re, { tag: index }));\n  } else if (re.constructor == RegExp) {\n    rules.push(build(re, { tag: index }));\n  } else if (re.constructor == Rule) {\n    rules.push(re as Rule);\n  } else if (re.constructor == Regex) {\n    rules.push(new Rule(re as Regex));\n  } else {\n    const res = re as (RegExp | Rule | string)[];\n    for (let i = 0; i < res.length; i++) {\n      flatten(res[i], i, rules);\n    }\n  }\n  return rules;\n}\n\n/**\n * Takes a string assumed to be in Flex RE format and parses the Regex expression out of it.\n */\nexport function exprFromFlexRE(pattern: string): Regex {\n  const parser = new FlexREParser();\n  try {\n    const expr = parser.parse(new Tape(pattern));\n    // if not specified default to false\n    if (expr.dotAll == null) expr.dotAll = false;\n    if (expr.multiline == null) expr.multiline = false;\n    return expr;\n  } catch (error) {\n    console.log(\"Error in FLEX RE: \", pattern);\n    throw error;\n  }\n}\n\n/**\n * Takes a string assumed to be in JS RE format and parses the Regex expression out of it.\n */\nexport function exprFromJSRE(re: string | RegExp, config?: any): Regex {\n  config = config || {};\n  const isRegExp = typeof re !== \"string\";\n  const pattern = typeof re === \"string\" ? re : re.source;\n  if (isRegExp) config.unicode = (re as RegExp).unicode;\n  const expr = new JSREParser(pattern, config).parse();\n  if (typeof re !== \"string\") {\n    expr.dotAll = re.dotAll;\n    expr.ignoreCase = re.ignoreCase;\n    expr.multiline = re.multiline;\n  }\n  return expr;\n}\n\n/**\n * A way to build a JS RE from a string literal, eg: jsRE`a*b+`\n */\nexport function jsRE(strings: TemplateStringsArray, ...keys: any[]): Regex {\n  // what we have is the raw value of this template and this can be parsed by our parser\n  const merged = String.raw(strings, ...keys);\n  return exprFromJSRE(merged);\n}\n\n/**\n * A way to build a Flex RE from a string literal, eg: flexRE`a*b+`\n */\nexport function flexRE(strings: TemplateStringsArray, ...keys: any[]): Regex {\n  const merged = String.raw(strings, ...keys);\n  return exprFromFlexRE(merged);\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Regex, Union, Rule, RuleConfig } from \"./core\";\nimport { Prog, Match, VM } from \"./vm\";\nimport { Compiler } from \"./compiler\";\nimport { TapeInterface as Tape, Tape as DefaultTape } from \"./tape\";\nimport { TokenizerError } from \"./errors\";\nimport * as Builder from \"./builder\";\nimport { Token, TokenType } from \"./token\";\n\nexport type RuleMatchHandler = (rule: Rule, tape: Tape, token: Token, owner: any) => any;\nexport type TokenizerErrorHandler = (error: Error, tape: Tape, startIndex: number) => Error | null;\n\nexport function toToken(tag: TokenType, m: Match, tape: Tape | null): Token {\n  const out = new Token(tag, m.matchIndex, m.start, m.end);\n  for (let i = 0; i < m.positions.length; i += 2) {\n    if (m.positions[i] >= 0) {\n      out.positions[Math.floor(i / 2)] = [m.positions[i], m.positions[i + 1]];\n    }\n  }\n  for (const [groupIndex, tapeIndex] of m.groups) {\n    const gi = Math.abs(groupIndex);\n    if (!(gi in out.groups)) {\n      out.groups[gi] = [];\n    }\n    out.groups[gi].push(tapeIndex);\n  }\n  if (tape != null) out.value = tape.substring(m.start, m.end);\n  return out;\n}\n\nexport class BaseTokenizer {\n  protected _prog: Prog | null = null;\n  protected _vm: VM | null = null;\n\n  /**\n   * Error handler called when an invalid character or lexeme is encountered.\n   * If this method returns back an error then the tokenization stops otherwise\n   * (if a null is returned) then tokenization continues.\n   *\n   * @param error       The error currently caught and being handled.\n   * @param tape        The tape currently being tokenized.\n   * @param startIndex  The start index when the tokenization began resulting in the error.\n   */\n  onError: TokenizerErrorHandler | null = null;\n\n  // Stores named rules\n  // Rules are a \"regex\", whether literal or not\n  allRules: Rule[] = [];\n  onMatchHandlers: (RuleMatchHandler | null)[] = [];\n  matchHandlersByValue: any = {};\n  variables = new Map<string, Regex>();\n  compiler: Compiler = new Compiler((name) => {\n    let out = this.variables.get(name) || null;\n    if (out == null) out = this.findRuleByValue(name)?.expr || null;\n    if (out == null) throw new Error(`Invalid regex reference: ${name}`);\n    return out;\n  });\n\n  getVar(name: string): Regex | null {\n    return this.variables.get(name) || null;\n  }\n\n  addVar(name: string, regex: Regex): this {\n    let currValue = this.variables.get(name) || null;\n    if (currValue == null) {\n      currValue = regex;\n    } else {\n      currValue = new Union(currValue, regex);\n    }\n    this.variables.set(name, regex);\n    return this;\n  }\n\n  findRuleByValue(value: any): Rule | null {\n    return this.allRules.find((r) => r.tag == value) || null;\n  }\n\n  /**\n   * Helper method over the addRule method that converts the pattern to its normalized expression form\n   * and adds a rule to the tokenizer.\n   *\n   * @param pattern     A raw string or a JS RegExp, or parsed Regex expression\n   *                    (either from JS or Flex RE syntax).\n   * @param config      Rule configs to control priority and other aspects of rules to be used during\n   *                    the match stage.\n   * @param onMatch     A callback method called when the rule is matched.\n   */\n  add(\n    pattern: string | RegExp | Regex,\n    config?: RuleConfig | RuleMatchHandler | null,\n    onMatch: RuleMatchHandler | null = null,\n  ): this {\n    if (typeof config === \"function\") {\n      onMatch = config;\n      config = null;\n    }\n    return this.addRule(Builder.build(pattern, config), onMatch);\n  }\n\n  /**\n   * Helper method over the addRule method that converts the pattern to its normalized expression form\n   * and adds a rule to the tokenizer.\n   *\n   * @param rule        A normalized Rule object that contains both the pattern as well as rule configs\n   *                    to be used during the match and afterwards (if successfully matched).\n   * @param onMatch     A callback method called when the rule is matched.\n   */\n  addRule(rule: Rule, onMatch: null | RuleMatchHandler = null): this {\n    rule.matchIndex = this.allRules.length;\n    this.allRules.push(rule);\n    this.onMatchHandlers.push(onMatch);\n    this._prog = null;\n    this._vm = null;\n    return this;\n  }\n\n  /**\n   * Add a token match callback by value.\n   */\n  on(tag: any, onMatch: RuleMatchHandler): this {\n    this.matchHandlersByValue[tag] = onMatch;\n    return this;\n  }\n\n  get prog(): Prog {\n    if (this._prog == null) {\n      const sortedRules = this.sortRules();\n      this._prog = this.compiler.compile(sortedRules);\n    }\n    return this._prog;\n  }\n\n  get vm(): VM {\n    if (this._vm == null) {\n      this._vm = new VM(this.prog);\n    }\n    return this._vm;\n  }\n\n  protected sortRules(): Rule[] {\n    // Sort rules so high priority ones appear first\n    const sortedRules: Rule[] = this.allRules.map((rule) => rule);\n    sortedRules.sort((r1, r2) => {\n      if (r1.priority != r2.priority) return r2.priority - r1.priority;\n      return r1.matchIndex - r2.matchIndex;\n    });\n    return sortedRules;\n  }\n}\n\n/**\n * A batch tokenizer.\n */\nexport class Tokenizer extends BaseTokenizer {\n  idCounter = 0;\n\n  /**\n   * Get the current lexer state (for incremental lexing support).\n   * State is used to track context-sensitive lexing modes.\n   */\n  getState(): number {\n    return this.vm.getState();\n  }\n\n  /**\n   * Set the lexer state (for incremental lexing support).\n   * Allows restarting lexing from a saved state.\n   */\n  setState(state: number): void {\n    this.vm.setState(state);\n  }\n\n  /**\n   * Reset the tokenizer state. Useful for incremental lexing\n   * when restarting from a different position.\n   */\n  reset(): void {\n    this.idCounter = 0;\n    // Reset VM state to initial\n    if (this._vm) {\n      this._vm.setState(0);\n    }\n  }\n\n  next(tape: Tape, owner: any): Token | null {\n    if (!tape.hasMore) {\n      return null;\n    }\n    const startIndex = tape.index;\n    const startChar = tape.currCh;\n    const m = this.vm.match(tape);\n    if (m == null) {\n      // no match so we have an error\n      let err: Error | null = null;\n      if (tape.index == startIndex + 1) {\n        err = new TokenizerError(`Unexpected Character: ${startChar}`, startIndex, 1, \"UnexpectedCharacter\", startChar);\n      } else {\n        err = new TokenizerError(\n          `Unexpected Symbol: ${tape.substring(startIndex, tape.index)}`,\n          startIndex,\n          tape.index - startIndex,\n          \"UnexpectedLexeme\",\n        );\n      }\n      if (this.onError) {\n        err = this.onError(err, tape, startIndex);\n      }\n      if (err != null) {\n        throw err;\n      } else {\n        // err has been ocnsumed so we can restart tokenizer at the current position\n        return this.next(tape, owner);\n      }\n    }\n    const rule = this.allRules[m.matchIndex];\n    let token = toToken(rule.tag, m, tape);\n    token.id = this.idCounter++;\n    let onMatch = this.onMatchHandlers[m.matchIndex];\n    if (!onMatch) {\n      onMatch = this.matchHandlersByValue[rule.tag];\n    }\n    if (onMatch) {\n      token = onMatch(rule, tape, token, owner);\n      if (token == null) {\n        // null is returned by onMatch to skip tokens\n        return this.next(tape, owner);\n      }\n    } else if (rule.skip) {\n      return this.next(tape, owner);\n    }\n    return token;\n  }\n\n  tokenize(tape: string | Tape, owner: any = null): Token[] {\n    const tokens = [] as Token[];\n    if (typeof tape === \"string\") {\n      tape = new DefaultTape(tape);\n    }\n    let next = this.next(tape, owner);\n    while (next) {\n      tokens.push(next);\n      try {\n        next = this.next(tape, owner);\n      } catch (err: any) {\n        tokens.push({\n          tag: \"ERROR\",\n          start: err.offset,\n          end: err.offset + err.length,\n          value: err.message,\n        } as Token);\n        break;\n      }\n    }\n    return tokens;\n  }\n}\n","import { flexRE } from \"./builder\";\n\nexport const SINGLE_QUOTE_STRING = flexRE`[\"]([^\"\\\\\\n]|\\\\.|\\\\\\n)*[\"]`;\nexport const DOUBLE_QUOTE_STRING = flexRE`[']([^'\\\\\\n]|\\\\.|\\\\\\n)*[']`;\nexport const SIMPLE_JS_STRING = '\"(.*?(?<!\\\\\\\\))\"';\nexport const JS_REGEX_WITHOUT_LB = String.raw`/([^\\\\/]|\\\\.)*/([imus]*)`;\nexport const JS_REGEX = String.raw`/(.+?(?<!\\\\))/([imus]*)`;\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Str, Rule, RuleAction } from \"./grammar\";\n\ntype Tape = TLEX.TapeInterface;\n\nconst str2regex = (s: string | number): string => {\n  if (typeof s === \"number\") return \"\" + s;\n  return s.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n};\n\nexport enum TokenType {\n  STRING = \"STRING\",\n  REGEX = \"REGEX\",\n  NUMBER = \"NUMBER\",\n  SPACES = \"SPACES\",\n  IDENT = \"IDENT\",\n  PCT_IDENT = \"PCT_IDENT\",\n  STAR = \"STAR\",\n  PLUS = \"PLUS\",\n  QMARK = \"QMARK\",\n  PIPE = \"PIPE\",\n  DOLLAR_NUM = \"DOLLAR_NUM\",\n  DOLLAR_IDENT = \"DOLLAR_IDENT\",\n  OPEN_PAREN = \"OPEN_PAREN\",\n  CLOSE_PAREN = \"CLOSE_PAREN\",\n  OPEN_BRACE = \"OPEN_BRACE\",\n  CLOSE_BRACE = \"CLOSE_BRACE\",\n  OPEN_SQ = \"OPEN_SQ\",\n  CLOSE_SQ = \"CLOSE_SQ\",\n  COMMENT = \"COMMENT\",\n  ARROW = \"ARROW\",\n  COLCOLHYPHEN = \"COLCOLHYPHEN\",\n  COLON = \"COLON\",\n  SEMI_COLON = \"SEMI_COLON\",\n}\n\nexport type NewSymbolCallback = TSU.Nullable<(label: string, assumedTerminal: boolean) => Sym | void>;\nexport type TokenHandler = (token: TLEX.Token, tape: TLEX.TapeInterface, owner: any) => TLEX.Token | null;\n\nexport interface LoaderConfig {\n  grammar?: Grammar;\n  leftRecursive?: boolean;\n  newSymbolCallback?: NewSymbolCallback;\n  tokenHandlers: TSU.StringMap<TokenHandler>;\n  debug?: string;\n}\n\n/**\n * Entry point in loading a grammar from a DSL spec.\n */\nexport function load(input: string, params?: LoaderConfig): [Grammar, null | TLEX.NextTokenFunc] {\n  params = params || ({} as LoaderConfig);\n  const g = new Grammar(params.grammar || {});\n  const eparser = new Loader(input, { ...params, grammar: g });\n  // g.augmentStartSymbol();\n  const tokenFunc = eparser.generatedTokenizer.next.bind(eparser.generatedTokenizer);\n  const debug = params.debug || \"\";\n  if (debug.split(\"|\").findIndex((p: string) => p == \"all\" || p == \"lexer\") >= 0) {\n    console.log(\"Prog: \\n\", `${eparser.generatedTokenizer.vm.prog.debugValue().join(\"\\n\")}`);\n  }\n  return [g, tokenFunc];\n}\n\n/**\n * The SemanticHandler is the bridge between the DSL, the Grammar, the Parser\n * and the caller of the parser.\n * In the DSL semantic actions can be added to tokenizer and grammar specs.\n * However the problem how to invoke them during runtime.\n *\n * For example in the grammar:\n *\n * E -> E + E { add($1, $3) }\n *\n * declares that when this rule is reduced the \"add\" function (in user land) is\n * invoked with the results of the right hand side values.\n *\n * This parsing however is done by the DSL loader and at this time the \"add\" method\n * is not declared anywhere.   In fact the the declaration is only  used by the parser\n * driver (after the parse tables have been constructed and parsing is started on\n * a real input).   The parser here needs to supply the definition for \"add\" method.\n * Note only this only the parser can call what is needed to kick off the \"add\" method\n * to be invoked.\n *\n * So the parser will need something like:\n *\n * while (input) {\n *    ....\n *    reduceRule(Nt, E1, E2, E3 ..., \"action\")\n * }\n *\n * the \"action\" will be part of the SemanticHandler\n *\n * reduceRule(Nt...., \"action\") {\n *  Nt.value = semanticHandler.getAction(\"action\").apply(E1, E2...., En);\n * }\n *\n * Similarly the caller of the \"parse\" method could populate the actions, eg:\n *\n * semanticHandler.register(\"action\", (a, b, c) => {\n *    return ....;\n * });\n *\n * The DSL loader in turn returns a semanticHandler instance just the way it\n * creates a tokenizer.\n *\n * There are a couple of options here.\n *\n * 1. Keep actions simple and store action IDs and let the caller do all the work, eg:\n *\n * E -> E + E { add $1 $3 }\n *\n * 2. Provide a stronger expression syntax:\n *\n * Or we could add a slightly more functional syntax so that a proper interpreter like setup is possible, eg:\n *\n * E -> E + E { add(halve($1), double($3)) }\n *\n * Here instead of calling an action \"add\" we could actually store expression trees and call an interpreter\n * with attribute value bindings.\n *\n * For now we will go with (1) as it is simpler and we can always build up (2) if doing (1) alone is too verbose.\n *\n * With (1), syntax for semantic actions is:\n *\n *  SemAction -> \"{\" ActionSpec \"}\" ;\n *\n *  ActionSpec -> DOLLAR_NUM\n *              | IDENT ( IDENT | DOLLAR_NUM | NUM | STRING | BOOLEAN | NULL ) *\n *              ;\n *\n * 3. There is an evern simpler third option.  Instead of the parser trying to martial parameters etc it could just\n * let the handler do the work of martialling/extracting parameters from children.  This is effective and easy\n *\n * In this mode all child nodes are passed as is to the handler and it is upto the handler to return the semantic\n * value of the production.\n */\n\nexport function Tokenizer(): TLEX.Tokenizer {\n  const lexer = new TLEX.Tokenizer();\n  lexer.add(/->/, { tag: TokenType.ARROW });\n  lexer.add(/\\[/, { tag: TokenType.OPEN_SQ });\n  lexer.add(/\\]/, { tag: TokenType.CLOSE_SQ });\n  lexer.add(/\\(/, { tag: TokenType.OPEN_PAREN });\n  lexer.add(/\\)/, { tag: TokenType.CLOSE_PAREN });\n  lexer.add(/\\{/, { tag: TokenType.OPEN_BRACE });\n  lexer.add(/\\}/, { tag: TokenType.CLOSE_BRACE });\n  lexer.add(/\\*/, { tag: TokenType.STAR });\n  lexer.add(/\\+/, { tag: TokenType.PLUS });\n  lexer.add(/\\?/, { tag: TokenType.QMARK });\n  lexer.add(/;/, { tag: TokenType.SEMI_COLON });\n  lexer.add(/:/, { tag: TokenType.COLON });\n  lexer.add(/\\|/, { tag: TokenType.PIPE });\n  lexer.add(/\\s+/m, { tag: TokenType.SPACES }, () => null);\n  lexer.add(/\\/\\*.*?\\*\\//s, { tag: TokenType.COMMENT }, () => null);\n  lexer.add(/\\/\\/.*$/m, { tag: TokenType.COMMENT }, () => null);\n  lexer.add(TLEX.Samples.DOUBLE_QUOTE_STRING, { tag: TokenType.STRING }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end - 1);\n    return token;\n  });\n  lexer.add(TLEX.Samples.SINGLE_QUOTE_STRING, { tag: TokenType.STRING }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end - 1);\n    return token;\n  });\n  lexer.add(TLEX.Samples.JS_REGEX, { tag: TokenType.REGEX }, (rule, tape, token) => {\n    const pattern = tape.substring(token.positions[1][0], token.positions[1][1]);\n    const flags = tape.substring(token.positions[3][0], token.positions[3][1]);\n    token.value = [pattern, flags];\n    return token;\n  });\n  lexer.add(/\\d+/, { tag: TokenType.NUMBER }, (rule, tape, token) => {\n    token.value = parseInt(tape.substring(token.start, token.end));\n    return token;\n  });\n  lexer.add(/%([\\w][\\w\\d_]*)/, { tag: TokenType.PCT_IDENT }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end);\n    return token;\n  });\n  lexer.add(/\\$\\d+/, { tag: TokenType.DOLLAR_NUM }, (rule, tape, token) => {\n    token.value = parseInt(tape.substring(token.start + 1, token.end));\n    return token;\n  });\n  lexer.add(/\\$([\\w][\\w\\d_]*)/, { tag: TokenType.DOLLAR_IDENT }, (rule, tape, token) => {\n    token.value = tape.substring(token.start + 1, token.end);\n    return token;\n  });\n  lexer.add(/[\\w][\\w\\d_]*/, { tag: TokenType.IDENT });\n  return lexer;\n}\n\nexport enum NodeType {\n  GRAMMAR = \"GRAMMAR\",\n  DECL = \"DECL\",\n  RULE = \"RULE\",\n  PROD_NULL = \"PROD_NULL\",\n  PROD_STR = \"PROD_STR\",\n  PROD_UNION = \"PROD_UNION\",\n  PROD_NAME = \"PROD_NAME\",\n  PROD_STRING = \"PROD_STRING\",\n  PROD_NUM = \"PROD_NUM\",\n  PROD_IDENT = \"PROD_IDENT\",\n  PROD_STAR = \"PROD_STAR\",\n  PROD_PLUS = \"PROD_PLUS\",\n  PROD_OPTIONAL = \"PROD_OPTIONAL\",\n  IDENT = \"IDENT\",\n  ERROR = \"ERROR\",\n  COMMENT = \"COMMENT\",\n}\n\n/**\n * EBNF Grammar:\n *\n * grammar -> rules;\n *\n * decl -> rule ;\n *\n * rules -> rule | rule rules ;\n *\n * rule -> IDENT \"->\" top_productions \";\" ;\n *\n * top_productions -> ( actionSpec ) ?\n *                |   prod ( actionSpec ) ? top_productions\n *                ;\n *\n * productions ->\n *              | prod  \"|\" productions\n *              ;\n *\n * prod -> ( prod_group | optional_prod | IDENT ( \":\" name ) ? | STRING ) ( \"*\" | \"+\" | \"?\" ) ?\n *      ;\n *\n * prod_group -> \"(\" productions \")\"  ;\n *\n * optional_prod -> \"[\" productions \"]\"  ;\n *\n * actionSpec := \"{\" IDENT \"(\" IDENT ( \",\" IDENT ) * \")\" \"}\"\n */\nexport class Loader {\n  readonly grammar: Grammar;\n  private tokenizer: TLEX.TokenBuffer;\n  private leftRecursive = false;\n  readonly generatedTokenizer: TLEX.Tokenizer = new TLEX.Tokenizer();\n  tokenHandlers: TSU.StringMap<TokenHandler>;\n\n  /*\n   * The newSymbol callback provided to the contructor is a way for the client to\n   * be given a chance to create a symbol given a new label that is encountered.\n   * The client can either return a null to let this parser define the Symbol\n   * or return a Symbol which will be associated with the given label going\n   * forward.\n   *\n   * The newSymbol callback will ONLY be called once for each new label\n   * encountered by the parser.   If the client returns a duplicte symbol\n   * then parsing fails.\n   */\n  private newSymbolCallback: NewSymbolCallback;\n  private symbolsByLabel: TSU.StringMap<Sym>;\n\n  /**\n   * Allowed regex syntaxes - js or flex\n   */\n  private regexSyntax = \"js\";\n\n  constructor(input: string, config?: LoaderConfig) {\n    config = config || ({} as LoaderConfig);\n    this.symbolsByLabel = {};\n    this.grammar = config.grammar || new Grammar();\n    this.leftRecursive = \"leftRecursive\" in config ? config.leftRecursive || false : true;\n    this.newSymbolCallback = config.newSymbolCallback || null;\n    this.tokenHandlers = config.tokenHandlers || {};\n    this.parse(input);\n  }\n\n  /**\n   * As the parser creates encounters a new literal or an identifier (hinting at\n   * either a terminal or a non terminal), it needs to know which symbol to associate\n   * with this lit/ident going forward.\n   *\n   * All symbols created for the grammar, since they are either created\n   * by this parser or by the client (invokved by this parser), are\n   * stored locally to be returned in this method.\n   */\n  symbolForLabel(label: string): TSU.Nullable<Sym> {\n    return this.symbolsByLabel[label] || null;\n  }\n\n  /**\n   * Registers a symbol for a given label.\n   */\n  registerSymbol(label: string, sym: Sym): void {\n    TSU.assert(!(label in this.symbolsByLabel), `${label} is already registered`);\n    this.symbolsByLabel[label] = sym;\n  }\n\n  /**\n   * Ensures that a symbol exists for a given label (as found in the parser spec)\n   * to be used through out the grammar.\n   */\n  ensureSymbol(label: string, assumedTerminal: boolean): Sym {\n    let currSym = this.symbolForLabel(label);\n\n    if (currSym != null) return currSym;\n    else if (this.newSymbolCallback) {\n      // then give the user a chance to create a symbol for this\n      currSym = this.newSymbolCallback(label, assumedTerminal) || null;\n    }\n    if (currSym == null) {\n      if (assumedTerminal) {\n        currSym = this.grammar.newTerm(label);\n      } else {\n        currSym = this.grammar.newNT(label);\n      }\n    }\n    // then register it so it is used going forward\n    this.registerSymbol(label, currSym);\n    return currSym;\n  }\n\n  parse(input: string): void {\n    const et = Tokenizer();\n    const ntFunc = (tape: Tape, owner: any) => {\n      const out = et.next(tape, this);\n      return out;\n    };\n    this.tokenizer = new TLEX.TokenBuffer(ntFunc, this);\n    this.parseGrammar(new TLEX.Tape(input));\n  }\n\n  parseRegex(tape: TLEX.TapeInterface, tag?: string, priority = 0, syntax = \"\"): TLEX.Rule {\n    if (syntax == \"\") syntax = this.regexSyntax;\n    if (syntax == \"js\") {\n      const tokPattern = this.tokenizer.expectToken(tape, TokenType.STRING, TokenType.NUMBER, TokenType.REGEX);\n      let rule: TLEX.Rule;\n      if (!tag || tag.length == 0) {\n        tag = \"/\" + tokPattern.value[0] + \"/\" + tokPattern.value[1];\n      }\n      if (tokPattern.tag == TokenType.STRING || tokPattern.tag == TokenType.NUMBER) {\n        const pattern = str2regex(tokPattern.value);\n        rule = TLEX.Builder.build(pattern, { tag: tag, priority: priority + 20 });\n      } else if (tokPattern.tag == TokenType.REGEX) {\n        let re = tokPattern.value[0];\n        if (tokPattern.value[1].length > 0) {\n          // Flags given so create\n          re = new RegExp(tokPattern.value[0], tokPattern.value[1]);\n        }\n        rule = TLEX.Builder.build(re, { tag: tag, priority: priority + 10 });\n      } else {\n        throw new TLEX.UnexpectedTokenError(tokPattern);\n      }\n      return rule;\n    } else {\n      // Flex style RE - no delimiters - just read until end of line and strip spaces\n      let patternStr = \"\";\n      while (tape.hasMore && tape.currCh != \"\\n\") {\n        patternStr += tape.currCh;\n        tape.advance();\n      }\n      patternStr = patternStr.trim();\n      if (!tag || tag.length == 0) {\n        tag = \"/\" + patternStr + \"/\";\n      }\n      return new TLEX.Rule(TLEX.Builder.exprFromFlexRE(patternStr), { tag: tag, priority: priority });\n    }\n  }\n\n  parseGrammar(tape: TLEX.Tape): void {\n    let peeked = this.tokenizer.peek(tape);\n    while (peeked != null) {\n      if (peeked.tag == TokenType.IDENT) {\n        // declaration\n        this.parseDecl(tape);\n      } else if (peeked.tag == TokenType.PCT_IDENT) {\n        this.tokenizer.next(tape);\n        this.parseDirective(tape, peeked.value);\n      } else {\n        throw new SyntaxError(`Declaration must start with IDENT or PCT_IDENT.  Found: '${peeked.value}' instead.`);\n      }\n      peeked = this.tokenizer.peek(tape);\n    }\n  }\n\n  parseDirective(tape: TLEX.TapeInterface, directive: string): void {\n    if (directive == \"start\") {\n      // override start directive\n      const next = this.tokenizer.expectToken(tape, TokenType.IDENT);\n      this.grammar.startSymbol = this.ensureSymbol(next.value as string, false);\n    } else if (directive == \"resyntax\") {\n      // override start directive\n      const next = this.tokenizer.expectToken(tape, TokenType.IDENT);\n      if (next.value != \"js\" && next.value != \"flex\") {\n        throw new SyntaxError(\"Invalid regex syntax: \" + next.value);\n      }\n      this.regexSyntax = next.value;\n    } else if (directive.startsWith(\"skip\")) {\n      const rule = this.parseRegex(tape, \"\", 30, directive.endsWith(\"flex\") ? \"flex\" : \"\");\n      const tokenHandler = this.parseTokenHandler(tape);\n      if (tokenHandler) {\n        this.generatedTokenizer.addRule(rule, (rule, tape, token) => {\n          tokenHandler(rule, tape, token, this);\n          return null;\n        });\n      } else {\n        this.generatedTokenizer.addRule(rule, () => null);\n      }\n    } else if (directive.startsWith(\"token\") || directive.startsWith(\"define\")) {\n      const isDef = directive.startsWith(\"define\");\n      const tokName = this.tokenizer.expectToken(tape, TokenType.IDENT, TokenType.STRING);\n      let label = tokName.value as string;\n      if (tokName.tag == TokenType.STRING || tokName.tag == TokenType.NUMBER) {\n        label = `\"${tokName.value}\"`;\n      }\n      const rule = this.parseRegex(tape, label, 0, directive.endsWith(\"flex\") ? \"flex\" : \"\");\n      if (isDef) {\n        // Define a \"reusable\" regex that is not a token on its own\n        this.generatedTokenizer.addVar(label, rule.expr);\n      } else {\n        const tokenHandler = this.parseTokenHandler(tape);\n        // see if we have a handler function here\n        this.generatedTokenizer.addRule(rule, tokenHandler);\n        // register it\n        this.ensureSymbol(label, true);\n      }\n    } else {\n      throw new Error(\"Invalid directive: \" + directive);\n    }\n  }\n\n  parseTokenHandler(tape: Tape): TLEX.RuleMatchHandler | null {\n    if (!this.tokenizer.consumeIf(tape, TokenType.OPEN_BRACE)) {\n      return null;\n    }\n\n    const funcName = this.tokenizer.expectToken(tape, TokenType.IDENT);\n\n    // how do we use the funcName to\n    const out = (rule: TLEX.Rule, tape: Tape, token: any, owner: any) => {\n      const handler = this.tokenHandlers[funcName.value];\n      if (!handler) throw new Error(\"Handler method not found: \" + funcName.value);\n      token = handler(token, tape, owner);\n      return token;\n    };\n\n    this.tokenizer.expectToken(tape, TokenType.CLOSE_BRACE);\n    return out;\n  }\n\n  parseDecl(tape: Tape): void {\n    const ident = this.tokenizer.expectToken(tape, TokenType.IDENT);\n    if (this.tokenizer.consumeIf(tape, TokenType.ARROW, TokenType.COLON)) {\n      const nt = this.ensureSymbol(ident.value as string, false);\n      if (nt.isTerminal) {\n        // it is a terminal so mark it as a non-term now that we\n        // know there is a declaration for it.\n        nt.isTerminal = false;\n      } else if (nt.isAuxiliary) {\n        throw new Error(\"NT is already auxiliary and cannot be reused.\");\n      }\n      for (const [rhs, action] of this.parseProductions(tape, this.grammar, nt)) {\n        const rule = this.grammar.add(nt, rhs, action);\n      }\n      this.tokenizer.expectToken(tape, TokenType.SEMI_COLON);\n    }\n  }\n\n  parseProductions(tape: Tape, grammar: Grammar, nt: TSU.Nullable<Sym>): [Str, RuleAction | null][] {\n    const out: [Str, RuleAction | null][] = [];\n    while (this.tokenizer.peek(tape) != null) {\n      const rule = this.parseProd(tape, grammar);\n      out.push(rule);\n      if (this.tokenizer.consumeIf(tape, TokenType.PIPE)) {\n        continue;\n      } else if (this.tokenizer.nextMatches(tape, TokenType.CLOSE_SQ, TokenType.CLOSE_PAREN, TokenType.SEMI_COLON)) {\n        break;\n      }\n    }\n    return out;\n  }\n\n  parseProd(tape: Tape, grammar: Grammar): [Str, null | RuleAction] {\n    const out = new Str();\n    while (true) {\n      // if we are starting with a FOLLOW symbol then return as it marks\n      // the end of this production\n      if (\n        this.tokenizer.nextMatches(\n          tape,\n          TokenType.CLOSE_PAREN,\n          TokenType.CLOSE_SQ,\n          TokenType.SEMI_COLON,\n          TokenType.PIPE,\n          TokenType.OPEN_BRACE,\n        )\n      ) {\n        break;\n        // return [out, null];\n      }\n\n      let curr: TSU.Nullable<Str> = null;\n      if (this.tokenizer.consumeIf(tape, TokenType.OPEN_PAREN)) {\n        const rules = this.parseProductions(tape, grammar, null);\n        if (rules.length == 0) {\n          // nothing\n        } else if (rules.length == 1) {\n          // TODO: Consider actions in non top level rules\n          curr = rules[0][0];\n        } else {\n          // create a new NT over this\n          // TODO: Consider actions in non top level rules\n          curr = grammar.anyof(...rules.map((r) => r[0]));\n        }\n        this.tokenizer.expectToken(tape, TokenType.CLOSE_PAREN);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.OPEN_SQ)) {\n        const rules = this.parseProductions(tape, grammar, null);\n        if (rules.length == 0) {\n          // nothing\n        } else if (rules.length == 1) {\n          // TODO: Consider actions in non top level rules\n          curr = grammar.opt(rules[0][0]);\n        } else {\n          // create a new NT over this\n          // TODO: Consider actions in non top level rules\n          curr = grammar.opt(grammar.anyof(...rules.map((r) => r[0])));\n        }\n        this.tokenizer.expectToken(tape, TokenType.CLOSE_SQ);\n      } else if (\n        this.tokenizer.nextMatches(tape, TokenType.IDENT, TokenType.STRING, TokenType.NUMBER, TokenType.REGEX)\n      ) {\n        const token = this.tokenizer.next(tape) as TLEX.Token;\n        let label = token.value as string;\n        if (token.tag == TokenType.STRING || token.tag == TokenType.NUMBER) {\n          label = `\"${token.value}\"`;\n          const pattern = str2regex(token.value);\n          const rule = TLEX.Builder.build(pattern, { tag: label, priority: 20 });\n          this.generatedTokenizer.addRule(rule);\n        } else if (token.tag == TokenType.REGEX) {\n          label = \"/\" + token.value[0] + \"/\" + token.value[1];\n          let re = token.value[0];\n          if (token.value[1].length > 0) {\n            // Flags given so create\n            re = new RegExp(token.value[0], token.value[1]);\n          }\n          const rule = TLEX.Builder.build(re, { tag: label, priority: 10 });\n          this.generatedTokenizer.addRule(rule);\n        } else {\n          // Normal\n        }\n        // See if this symbol is already registered\n        const currSym = this.ensureSymbol(label, true);\n        curr = new Str(currSym);\n      } else {\n        throw new TLEX.UnexpectedTokenError(this.tokenizer.peek(tape));\n      }\n\n      if (curr == null) {\n        throw new Error(\"Could not determine node\");\n      }\n\n      if (this.tokenizer.consumeIf(tape, TokenType.STAR)) {\n        curr = grammar.atleast0(curr, this.leftRecursive);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.PLUS)) {\n        curr = grammar.atleast1(curr, this.leftRecursive);\n      } else if (this.tokenizer.consumeIf(tape, TokenType.QMARK)) {\n        curr = grammar.opt(curr);\n      }\n      out.extend(curr);\n    }\n    let action: RuleAction | null = null;\n    if (this.tokenizer.consumeIf(tape, TokenType.OPEN_BRACE)) {\n      const next = this.tokenizer.expectToken(tape, TokenType.DOLLAR_NUM, TokenType.IDENT);\n      action = new RuleAction(next.value);\n      this.tokenizer.expectToken(tape, TokenType.CLOSE_BRACE);\n    }\n    return [out, action];\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport {\n  PTNode,\n  SimpleParser as ParserBase,\n  BeforeAddingChildCallback,\n  RuleReductionCallback,\n  NextTokenCallback,\n} from \"./parser\";\nimport { ParseError } from \"./errors\";\n\ntype Nullable<T> = TSU.Nullable<T>;\ntype NumMap<T> = TSU.NumMap<T>;\ntype StringMap<T> = TSU.StringMap<T>;\n\nexport enum LRActionType {\n  ACCEPT,\n  SHIFT,\n  REDUCE,\n  GOTO, // can *ONLY* be valid for non-terms\n}\n\nexport class LRAction {\n  // Type of action\n  tag: LRActionType;\n\n  // Next state to go to after performing the action (if valid).\n  gotoState: Nullable<number> = null;\n\n  // The rule to be used for a reduce action\n  rule: Nullable<Rule> = null;\n\n  toString(): string {\n    if (this.tag == LRActionType.ACCEPT) return \"Acc\";\n    else if (this.tag == LRActionType.SHIFT) {\n      return \"S\" + this.gotoState!;\n    } else if (this.tag == LRActionType.REDUCE) {\n      return \"R \" + this.rule!.id;\n    } else {\n      return \"\" + this.gotoState!;\n    }\n  }\n\n  equals(another: LRAction): boolean {\n    return this.tag == another.tag && this.gotoState == another.gotoState && this.rule == another.rule;\n  }\n\n  static Shift(goto: number): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.SHIFT;\n    out.gotoState = goto;\n    return out;\n  }\n\n  static Reduce(rule: Rule): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.REDUCE;\n    out.rule = rule;\n    return out;\n  }\n\n  static Goto(gotoState: number): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.GOTO;\n    out.gotoState = gotoState;\n    return out;\n  }\n\n  static Accept(): LRAction {\n    const out = new LRAction();\n    out.tag = LRActionType.ACCEPT;\n    return out;\n  }\n}\n\n/**\n * A parsing table for LR parsers.\n */\nexport class ParseTable {\n  // Records which actions have conflicts\n  conflictActions: NumMap<StringMap<boolean>> = {};\n\n  /**\n   * Maps symbol (by id) to the action;\n   */\n  actions: NumMap<NumMap<LRAction[]>> = {};\n\n  constructor(public readonly grammar: Grammar) {}\n\n  get hasConflicts(): boolean {\n    return Object.keys(this.conflictActions).length > 0;\n  }\n\n  /**\n   * Gets the action for a given sym from a given state.\n   */\n  getActions(stateId: number, next: Sym, ensure = false): LRAction[] {\n    let l1: NumMap<LRAction[]>;\n    if (stateId in this.actions) {\n      l1 = this.actions[stateId];\n    } else if (ensure) {\n      l1 = this.actions[stateId] = {};\n    } else {\n      return [];\n    }\n\n    if (next.id in l1) {\n      return l1[next.id];\n    } else if (ensure) {\n      return (l1[next.id] = []);\n    }\n    return [];\n  }\n\n  addAction(stateId: number, next: Sym, action: LRAction): this {\n    const actions = this.getActions(stateId, next, true);\n    if (actions.findIndex((ac) => ac.equals(action)) < 0) {\n      actions.push(action);\n    }\n    if (actions.length > 1) {\n      this.conflictActions[stateId] = this.conflictActions[stateId] || {};\n      this.conflictActions[stateId][next.label] = true;\n    }\n    return this;\n  }\n\n  get debugValue(): any {\n    const out: any = {};\n    for (const fromId in this.actions) {\n      out[fromId] = {};\n      for (const symId in this.actions[fromId]) {\n        const sym = this.grammar.getSymById(symId as any)!;\n        const actions = this.actions[fromId][sym.id] || [];\n        if (actions.length > 0) {\n          out[fromId][sym.label] = actions.map((a) => a.toString());\n        }\n      }\n    }\n    return out;\n  }\n}\n\nexport class ParseStack {\n  // A way of marking the kind of item that is on the stack\n  // true => isStateId\n  // false => isSymbolId\n  readonly stateStack: number[] = [];\n  readonly nodeStack: PTNode[] = [];\n\n  push(state: number, node: PTNode): void {\n    this.stateStack.push(state);\n    this.nodeStack.push(node);\n  }\n\n  /**\n   * Gets the nth item from the top of the stack.\n   */\n  top(nth = 0): [number, PTNode] {\n    return [this.stateStack[this.stateStack.length - 1 - nth], this.nodeStack[this.nodeStack.length - 1 - nth]];\n  }\n\n  pop(): [number, PTNode] {\n    const out = this.top();\n    this.stateStack.pop();\n    this.nodeStack.pop();\n    return out;\n  }\n\n  /**\n   * Pop N items from the stack.\n   */\n  popN(n = 1): void {\n    const L = this.stateStack.length;\n    this.stateStack.splice(L - n, n);\n    this.nodeStack.splice(L - n, n);\n  }\n\n  get isEmpty(): boolean {\n    return this.stateStack.length == 0 || this.nodeStack.length == 0;\n  }\n}\n\nexport type ActionResolverCallback = (\n  actions: LRAction[],\n  stack: ParseStack,\n  tokenbuffer: TLEX.TokenBuffer,\n) => LRAction;\n\nexport type RuleActionHandler = (rule: Rule, parent: PTNode, ...children: PTNode[]) => any;\n\nexport type TokenErrorCallback = (err: TLEX.TokenizerError, input: TLEX.Tape) => boolean;\n\nexport interface ParserContext {\n  buildParseTree?: boolean;\n  copySingleChild?: boolean;\n  ruleHandlers: TSU.StringMap<RuleActionHandler>;\n  beforeAddingChildNode?: BeforeAddingChildCallback;\n  onReduction?: RuleReductionCallback;\n  onNextToken?: NextTokenCallback;\n  actionResolver?: ActionResolverCallback;\n  onTokenError?: TokenErrorCallback;\n  // The owner used for tokenizer to get an insight into the context\n  // (to allow context sensitive scanning - aka \"scanner hacks\").\n  tokenizerContext: any;\n}\n\nexport class Parser extends ParserBase {\n  constructor(\n    public readonly parseTable: ParseTable,\n    config: any = {},\n  ) {\n    super();\n  }\n\n  get grammar(): Grammar {\n    return this.parseTable.grammar;\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected parseInput(input: TLEX.Tape, context?: ParserContext): Nullable<PTNode> {\n    context = context || ({} as ParserContext);\n    // Set default values for missing values\n    this.tokenbuffer.tokenizerContext = context.tokenizerContext;\n    if (context.buildParseTree != false) context.buildParseTree = true;\n    if (context.copySingleChild != false) context.copySingleChild = true;\n    let idCounter = 0;\n    const stack = new ParseStack();\n    stack.push(0, new PTNode(idCounter++, this.grammar.augStartRule.nt, null));\n    const tokenbuffer = this.tokenbuffer;\n    const g = this.grammar;\n    let output: Nullable<PTNode> = null;\n\n    /**\n     * Pick an action among several actions based on several factors (eg\n     * curr parse stack, tokenbuffer etc).\n     */\n    function resolveActions(actions: LRAction[]): LRAction {\n      if (context?.actionResolver) {\n        return context.actionResolver(actions, stack, tokenbuffer);\n      } else {\n        if (actions.length > 1) {\n          throw new Error(\"Multiple actions found.\");\n        }\n        return actions[0];\n      }\n    }\n\n    function nextToken(): TLEX.Token | null {\n      try {\n        return tokenbuffer.peek(input);\n      } catch (err /* InvalidCharacterException */) {\n        if (!context?.onTokenError || !context?.onTokenError(err as TLEX.TokenizerError, input)) {\n          // no handler or handler could do nothing so throw it up again\n          throw err;\n        }\n\n        // Handler managed to do \"something\" so retry again\n        // TODO - Check offsets were modified?\n        return nextToken();\n      }\n    }\n\n    while (true) {\n      // while (tokenbuffer.peek(input) != null || !stack.isEmpty) {\n      let token = nextToken();\n      if (token == null) {\n        if (stack.isEmpty) {\n          // no more to do\n          break;\n        }\n      } else if (context.onNextToken) {\n        token = context.onNextToken(token);\n      }\n      const nextSym = token == null ? g.Eof : this.getSym(token);\n      const nextValue = token == null ? null : token.value;\n      let [topState, topNode] = stack.top();\n      const actions = this.parseTable.getActions(topState, nextSym);\n      if (actions == null || actions.length == 0) {\n        // TODO - use a error handler here\n        throw new ParseError(`Unexpected Token: '${nextSym.label}'`, \"UnexpectedToken\", {\n          state: topState,\n          token: token,\n          nextSym: nextSym,\n        });\n      }\n\n      const action = resolveActions(actions);\n      if (action.tag == LRActionType.ACCEPT) {\n        break;\n      } else if (action.tag == LRActionType.SHIFT) {\n        tokenbuffer.next(input);\n        const newNode = new PTNode(idCounter++, nextSym, nextValue);\n        stack.push(action.gotoState!, newNode);\n      } else {\n        // reduce\n        TSU.assert(action.rule != null, \"Nonterm and ruleindex must be provided for a reduction action\");\n        const ruleLen = action.rule.rhs.length;\n\n        // here see if a rule handler exists - if it does use it\n        let newNode = new PTNode(idCounter++, action.rule.nt, null);\n        // Begin the reduction here. We are breaking the reduction into\n        // two parts:\n        //\n        // 1. Adding child nodes into the parent (reduced) node. Here\n        // the beforeAddingChildNode callback is used to modify children\n        // being added.\n        // 2. After all children have been added to give the caller a chance\n        // to handle/post-process the reduction - eg to build the semantic value.\n        //\n        // Our onReduction is a catch all to perform semantic actions.  Instead\n        // we could do rule specific ones by using the rule.action (if it exists)\n        // and only invoke the onReduction if a rule specific action does not exist.\n        //\n        // Are these \"double steps\" needed?  Can we just build parse tree, filter out\n        // child nodes and eval semantic value with a single action?\n        //\n        // Can semanticHandler do this?\n        //\n        // eg with\n        //\n        // E -> E + E { add }\n        //\n        // we could have our stack looking like;\n        //\n        // .... s1 E s2 E\n        //\n        // to be reduced and add could be called with:\n        //\n        // add(E1, E2) - as the child nodes themselves.\n        //\n        // the add handler could now do a few things:\n        //\n        // 1. Ensure all nodes are added to E as is (resulting in 3 nodes - \"E\", \"+\", \"E\")\n        // 2. Not add any nodes\n        // 3. Computing the value of E and E and the sum of those and put it in the parent E.\n        // 4. or all of the above.\n        //\n        // Doing filtering seems like a very premature usecase.  In the case of incremental\n        // parsing we may need all nodes to exist and filtering out can get in the way of that.\n        //\n        // But let us leave it for now and make any semantic handling happen *after* parse tree\n        // child node filter/transformation\n        if (context.buildParseTree) {\n          for (let i = ruleLen - 1; i >= 0; i--) {\n            const childNode: TSU.Nullable<PTNode> = stack.top(i)[1];\n            if (context.beforeAddingChildNode) {\n              for (const node of context.beforeAddingChildNode(newNode, childNode)) {\n                newNode.add(node);\n              }\n            } else if (childNode != null) {\n              newNode.add(childNode);\n            }\n          }\n        }\n        // Now apply the semantic handler if it exists\n        if (action.rule.action) {\n          // call it\n          if (action.rule.action.isFunction) {\n            // find the function associated with\n            const handlerName = action.rule.action.value;\n            const handler = context.ruleHandlers![handlerName];\n            if (!handler) throw new Error(\"Action handler not found: \" + handlerName);\n            // TODO - Replace the handler signature to take an\n            // interface that returns the nth child node (directly from\n            // the parse stack) instead of all children - this way we\n            // can even avoid building a parse tree if need be and\n            // decouple semantic actions from parse tree building\n            newNode.value = handler(action.rule, newNode, ...newNode.children);\n          } else {\n            // setting value as a child's value, eg $1, $2 etc\n            newNode.value = newNode.children[(action.rule.action.value as number) - 1].value;\n          }\n        } else if (context.onReduction) {\n          // fallback to default reduction handler\n          newNode = context.onReduction(newNode, action.rule);\n        } else if (newNode.children.length == 1 && context.copySingleChild) {\n          // If we have only 1 child set the semantic value to be child's value\n          // ie values \"bubble up\"\n          newNode.value = newNode.children[0].value;\n        }\n\n        // Perform the action reduction by popping ruleLen number of items off the stack\n        // and replace the top with our newNode\n        stack.popN(ruleLen);\n        [topState, topNode] = stack.top();\n        const newAction = resolveActions(this.parseTable.getActions(topState, action.rule.nt));\n        TSU.assert(newAction != null && newAction.gotoState != null, \"Top item does not have an action.\");\n        stack.push(newAction.gotoState, newNode);\n        output = newNode;\n      }\n    }\n    // It is possible that here no reductions have been done!\n    return output;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\n\ntype Nullable<T> = TSU.Nullable<T>;\n\n/**\n * As the parse tree is built, nodes are created and added to parents bottom up.\n * This method is called before a child node is added to its parent.  The\n * node's left-most siblings have already been added this point.\n *\n * This method is an opportunity to filter or transfor the node or even adding\n * other nodes to the parent's child list.  Note that at this point the parent\n * has *NOT* been added to its parent.\n *\n * In order to filter out the node, return null.  Otherwise return a\n * PTNode instance for the actual node to be added to the parent.\n */\nexport type BeforeAddingChildCallback = (parent: PTNode, child: PTNode) => PTNode[];\n\n/**\n * This method is called when after a rule has been reduced.  At this time\n * all the children have already been reduced (and called with this method).\n * Now is the opportunity for the parent node reduction to perform custom\n * actions.  Note that this method cannot modify the stack.  It can only be\n * used to perform things like AST building or logging etc.\n */\nexport type RuleReductionCallback = (node: PTNode, rule: Rule) => PTNode;\n\n/**\n * This method is called as soon as the next token is received from the tokenizer.\n * This allows one to filter out tokens or even transform them based on any other\n * context being maintained.\n */\nexport type NextTokenCallback = (token: TLEX.Token) => TSU.Nullable<TLEX.Token>;\n\nexport class PFNode {\n  children: this[] = [];\n  constructor(\n    public readonly id: number,\n    public readonly sym: Sym,\n    public value: any,\n    ...children: PFNode[]\n  ) {\n    this.children = (children as this[]) || [];\n  }\n\n  get childCount(): number {\n    return this.children.length;\n  }\n\n  childAt(index: number): this {\n    if (index < 0) return this.children[this.children.length + index] as this;\n    return this.children[index] as this;\n  }\n\n  get isTerminal(): boolean {\n    return this.sym.isTerminal;\n  }\n\n  add(node: this, index = -1): this {\n    if (this.isTerminal) {\n      throw new Error(`Cannot add children (${node.sym.label}) to a terminal node: ${this.sym.label}`);\n    }\n    if (index < 0) {\n      this.children.push(node);\n    } else {\n      this.children.splice(index, 0, node);\n    }\n    return this;\n  }\n\n  splice(index: number, numToDelete: number, ...nodes: this[]): this {\n    this.children.splice(index, numToDelete, ...nodes);\n    return this;\n  }\n\n  get reprString(): string {\n    /*\n    let out = `Node(${this.sym.label}, {this.value}`;\n    if (this.children.length > 0) out += \", \" + this.children.map((c) => c.reprString).join(\", \");\n    out += \")\";\n    return out;\n    */\n    return this.debugValue(false).join(\"\\n\");\n  }\n\n  debugValue(raw = true): any {\n    if (raw) {\n      const out: any = [this.sym.label];\n      if (this.value) out.push(this.value);\n      if (this.children.length > 0) out.push(this.children.map((c) => c.debugValue(raw)));\n      return out;\n    } else {\n      const out: any[] = [];\n      const value = this.value;\n      out.push(this.value == null ? this.sym.label : this.sym.label + \" - \" + this.value);\n      this.children.forEach((node) => (node.debugValue(raw) as string[]).forEach((l) => out.push(\"  \" + l)));\n      return out;\n    }\n  }\n}\n\nexport class PTNode extends PFNode {\n  parent: Nullable<PTNode> = null;\n\n  add(node: this, index = -1): this {\n    super.add(node, index);\n    node.parent = this;\n    return this;\n  }\n\n  splice(index: number, numToDelete: number, ...nodes: this[]): this {\n    for (const node of nodes) node.parent = this;\n    return super.splice(index, numToDelete, ...nodes);\n  }\n}\n\nexport abstract class ParserBase {\n  tokenbuffer: TLEX.TokenBuffer;\n\n  setTokenizer(tokenizer: TLEX.NextTokenFunc): this {\n    this.tokenbuffer = new TLEX.TokenBuffer(tokenizer, null);\n    return this;\n  }\n\n  abstract get grammar(): Grammar;\n\n  /**\n   * Converts the token to a Terminal based on the tag value.\n   */\n  getSym(token: TLEX.Token): Sym {\n    const out = this.grammar.getSym(token.tag as string);\n    if (out == null) {\n      throw new Error(\"Invalid token tag: \" + token.tag + \", Value: \" + token.value);\n    }\n    return out;\n  }\n}\n\nexport abstract class SimpleParser extends ParserBase {\n  parse(input: string | TLEX.Tape, delegate: any = null): Nullable<PTNode> {\n    if (typeof input === \"string\") {\n      input = new TLEX.Tape(input);\n    }\n    return this.parseInput(input, delegate);\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected abstract parseInput(input: TLEX.Tape, delegate: any): Nullable<PTNode>;\n}\n\nexport abstract class ParallelParser extends ParserBase {\n  parse(input: string | TLEX.Tape, delegate: any = null): PFNode[] {\n    if (typeof input === \"string\") {\n      input = new TLEX.Tape(input);\n    }\n    return this.parseInput(input, delegate);\n  }\n\n  /**\n   * Parses the input and returns the resulting root Parse Tree node.\n   */\n  protected abstract parseInput(input: TLEX.Tape, delegate: any): PFNode[];\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Sym, Grammar, Rule } from \"./grammar\";\nimport { IDSet } from \"./sets\";\n\ntype Nullable<T> = TSU.Nullable<T>;\ntype NumMap<T> = TSU.NumMap<T>;\n\nexport class LRItem {\n  id = 0;\n  readonly rule: Rule;\n  readonly position: number;\n  constructor(rule: Rule, position = 0) {\n    this.rule = rule;\n    this.position = position;\n  }\n\n  advance(): LRItem {\n    TSU.assert(this.position < this.rule.rhs.length);\n    return new LRItem(this.rule, this.position + 1);\n  }\n\n  copy(): LRItem {\n    return new LRItem(this.rule, this.position);\n  }\n\n  /**\n   * TODO - Instead of using strings as keys, can we use a unique ID?\n   * If we assume a max limit on number of non terminals in our grammar\n   * and a max limit on the number of rules per non terminal and a\n   * max limit on the size of each rule then we can uniquely identify\n   * a rule and position for a non-terminal by a single (64 bit) number\n   *\n   * We can use the following bitpacking to nominate this:\n   *\n   * <padding 16 bits><nt id 16 bits><ruleIndex 16 bits><position 16 bits>\n   */\n  get key(): string {\n    TSU.assert(!isNaN(this.rule.id), \"Rule's ID is not yet set.\");\n    return this.rule.id + \":\" + this.position;\n  }\n\n  compareTo(another: this): number {\n    let diff = this.rule.id - another.rule.id;\n    if (diff == 0) diff = this.position - another.position;\n    return diff;\n  }\n\n  equals(another: this): boolean {\n    return this.compareTo(another) == 0;\n  }\n\n  get debugString(): string {\n    const rule = this.rule;\n    const pos = this.position;\n    const pre = rule.rhs.syms.slice(0, pos).join(\" \");\n    const post = rule.rhs.syms.slice(pos).join(\" \");\n    return `${rule.id}  -  ${rule.nt} -> ${pre} • ${post}`;\n  }\n}\n\nexport class LRItemSet {\n  id = 0;\n  readonly itemGraph: LRItemGraph;\n  protected _key: Nullable<string> = null;\n  readonly values: number[];\n  protected _lookaheads: NumMap<Sym[]> = {};\n  protected _hasLookAheads = false;\n\n  constructor(ig: LRItemGraph, ...entries: number[]) {\n    this.itemGraph = ig;\n    this.values = entries;\n  }\n\n  copy(): LRItemSet {\n    const out = new LRItemSet(this.itemGraph, ...this.values);\n    out._lookaheads = { ...this._lookaheads };\n    out._hasLookAheads = this._hasLookAheads;\n    return out;\n  }\n\n  /**\n   * Adds a new look ahead symbol for a given item.\n   */\n  addLookAhead(item: LRItem, sym: Sym): boolean {\n    if (!(item.id in this._lookaheads)) {\n      this._lookaheads[item.id] = [];\n    }\n    for (const s of this._lookaheads[item.id]) if (s == sym) return false;\n    this._hasLookAheads = true;\n    this._key = null;\n    this._lookaheads[item.id].push(sym);\n    this._lookaheads[item.id].sort((s1, s2) => s1.id - s2.id);\n    return true;\n  }\n\n  /**\n   * Clears all lookaheads from this itemset.\n   */\n  clearLookAheads(): void {\n    this._lookaheads = {};\n  }\n\n  /**\n   * Gets the lookahead symbols for a given item.\n   */\n  getLookAheads(item: LRItem): ReadonlyArray<Sym> {\n    return this._lookaheads[item.id] || [];\n  }\n\n  // A way to cache the key of this item set.\n  // Keys help make the comparison of two sets easy.\n  get key(): string {\n    if (this._key == null) {\n      this._key = this.revalKey();\n    }\n    return this._key;\n  }\n\n  protected revalKey(): string {\n    if (this.hasLookAheads) {\n      this.values.sort();\n      return this.values\n        .map((itemId) => {\n          const la = this._lookaheads[itemId] || [];\n          return itemId + \"[\" + la.map((s) => s.id).join(\",\") + \"]\";\n        })\n        .join(\"/\");\n    } else {\n      this.values.sort();\n      return this.values.join(\"/\");\n    }\n  }\n\n  has(itemId: number): boolean {\n    return this.values.indexOf(itemId) >= 0;\n  }\n\n  equals(another: LRItemSet): boolean {\n    return this.key == another.key;\n  }\n\n  add(itemId: number): this {\n    if (!this.has(itemId)) {\n      this.values.push(itemId);\n      this._key = null;\n    }\n    return this;\n  }\n\n  get size(): number {\n    return this.values.length;\n  }\n\n  get debugString(): string {\n    return this.debugValue.join(\"\\n\");\n  }\n\n  get hasLookAheads(): boolean {\n    return this._hasLookAheads;\n  }\n\n  get debugValue(): any {\n    if (this.hasLookAheads) {\n      const items = this.values.map((v: number) => this.itemGraph.items.get(v));\n      // sort them by rule\n      items.sort((i1, i2) => i1.compareTo(i2));\n      // then append the look aheads\n      return items.map((item) => {\n        const las = this.getLookAheads(item)\n          .map((s) => s.label)\n          .sort((s1, s2) => s1.localeCompare(s2))\n          .join(\", \");\n        return las.length > 0 ? `${item.debugString} / ( ${las} )` : item.debugString;\n      });\n    } else {\n      const items = this.values.map((v: number) => this.itemGraph.items.get(v));\n      // sort them by rule\n      items.sort((i1, i2) => i1.compareTo(i2));\n      return items.map((i) => i.debugString);\n    }\n  }\n}\n\nexport abstract class LRItemGraph {\n  // List of all unique LRItems that can be used in this item graph.\n  // Note that since the same Item can reside in multiple sets only\n  // one is created via the newItem method and it is referred\n  // everwhere it is needed.\n\n  /**\n   * Using IDed sets of Items and ItemSets.\n   * This ensures that only one copy of an item exists\n   * \"by value\".\n   */\n  items: IDSet<LRItem>;\n  itemSets: IDSet<LRItemSet>;\n\n  // Goto sets for a set and a given transition out of it\n  gotoSets: NumMap<NumMap<LRItemSet>> = {};\n\n  abstract closure(itemSet: LRItemSet): LRItemSet;\n  abstract startSet(): LRItemSet;\n\n  constructor(public readonly grammar: Grammar) {\n    this.items = new IDSet();\n    this.itemSets = new IDSet();\n  }\n\n  protected startItem(): LRItem {\n    const startSymbol = this.grammar.startSymbol;\n    TSU.assert(startSymbol != null, \"Start symbol must be set\");\n    TSU.assert((this.grammar.augStartRule || null) != null, \"Grammar is not augmented\");\n    return this.items.ensure(new LRItem(this.grammar.augStartRule));\n  }\n\n  reset(): void {\n    this.grammar.refresh();\n    this.gotoSets = {};\n    this.items.clear();\n    this.itemSets.clear();\n    this.startSet();\n  }\n\n  refresh(): this {\n    this.reset();\n    this.grammar.refresh();\n    this.evalGotoSets();\n    return this;\n  }\n\n  /**\n   * Computes all the goto sets used to create the graph of items.\n   */\n  protected evalGotoSets(): void {\n    const out = this.itemSets;\n    for (let i = 0; i < out.size; i++) {\n      const currSet = out.get(i);\n      // This will also include the null symbol since Grammar\n      // adds Null and Eof symbols automatically\n      for (const sym of this.grammar.allSymbols) {\n        if (sym != this.grammar.Null) {\n          const gotoSet = this.goto(currSet, sym);\n          if (gotoSet.size > 0) {\n            this.setGoto(currSet, sym, gotoSet);\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Computes the GOTO set of this ItemSet for a particular symbol transitioning\n   * out of this item set.\n   */\n  goto(itemSet: LRItemSet, sym: Sym): LRItemSet {\n    const out = this.newItemSet();\n    for (const itemId of itemSet.values) {\n      const item = this.items.get(itemId);\n      // see if item.position points to \"sym\" in its rule\n      const rule = item.rule;\n      if (item.position < rule.rhs.length) {\n        if (rule.rhs.syms[item.position] == sym) {\n          // advance the item and add it\n          this.advanceItemAndAdd(item, itemSet, out);\n        }\n      }\n    }\n    // compute the closure of the new set\n    return this.closure(out);\n  }\n\n  protected advanceItemAndAdd(itemToAdvance: LRItem, fromItemSet: LRItemSet, toItemSet: LRItemSet): void {\n    const newItem = this.items.ensure(itemToAdvance.advance());\n    toItemSet.add(newItem.id);\n    // copy over the look aheads\n    for (const laSym of fromItemSet.getLookAheads(itemToAdvance)) {\n      toItemSet.addLookAhead(newItem, laSym);\n    }\n  }\n\n  protected newItemSet(...items: LRItem[]): LRItemSet {\n    return new LRItemSet(this, ...items.map((item) => item.id));\n  }\n\n  get size(): number {\n    return this.itemSets.size;\n  }\n\n  protected ensureGotoSet(fromSet: LRItemSet): NumMap<LRItemSet> {\n    if (!(fromSet.id in this.gotoSets)) {\n      this.gotoSets[fromSet.id] = {};\n    }\n    return this.gotoSets[fromSet.id];\n  }\n\n  setGoto(fromSet: LRItemSet, sym: Sym, toSet: LRItemSet): void {\n    const entries = this.ensureGotoSet(fromSet);\n    entries[sym.id] = toSet;\n  }\n\n  getGoto(fromSet: LRItemSet, sym: Sym): Nullable<LRItemSet> {\n    return (this.gotoSets[fromSet.id] || {})[sym.id] || null;\n  }\n\n  forEachGoto(itemSet: LRItemSet, visitor: (sym: Sym, nextSet: LRItemSet) => boolean | void): void {\n    const gotoSet = this.gotoSets[itemSet.id] || {};\n    for (const symid in gotoSet) {\n      const sym = this.grammar.getSymById(symid as any) as Sym;\n      const next = gotoSet[symid];\n      if (visitor(sym, next) == false) break;\n    }\n  }\n\n  gotoSetFor(itemSet: LRItemSet): NumMap<LRItemSet> {\n    return this.gotoSets[itemSet.id] || {};\n  }\n\n  get debugValue(): any {\n    const out = {} as any;\n    this.itemSets.entries.forEach((iset) => {\n      out[iset.id] = { items: [], goto: {} };\n      out[iset.id][\"items\"] = iset.debugValue;\n      const g = this.gotoSets[iset.id];\n      for (const symid in g) {\n        const sym = this.grammar.getSymById(symid as any)!;\n        out[iset.id][\"goto\"] = out[iset.id][\"goto\"] || {};\n        out[iset.id][\"goto\"][sym.label] = g[symid].id;\n      }\n    });\n    return out;\n  }\n}\n\nexport class LR0ItemGraph extends LRItemGraph {\n  /**\n   * Creates the set for the grammar.  This is done by creating an\n   * augmented rule of the form S' -> S (where S is the start symbol of\n   * the grammar) and creating the closure of this starting rule, ie:\n   *\n   * StartSet = closure({S' -> . S})\n   */\n  startSet(): LRItemSet {\n    const startItem = this.startItem();\n    const newset = this.newItemSet(startItem);\n    return this.closure(newset);\n  }\n\n  /**\n   * Computes the closure of a given item set and returns a new\n   * item set.\n   */\n  closure(itemSet: LRItemSet): LRItemSet {\n    const out = new LRItemSet(this, ...itemSet.values);\n    for (let i = 0; i < out.values.length; i++) {\n      const itemId = out.values[i];\n      const item = this.items.get(itemId)!;\n      const rule = item.rule;\n      // Evaluate the closure\n      // Cannot do anything past the end\n      if (item.position < rule.rhs.length) {\n        const sym = rule.rhs.syms[item.position];\n        if (!sym.isTerminal) {\n          for (const rule of this.grammar.rulesForNT(sym)) {\n            const newItem = this.items.ensure(new LRItem(rule, 0));\n            out.add(newItem.id);\n          }\n        }\n      }\n    }\n    return out.size == 0 ? out : this.itemSets.ensure(out);\n  }\n}\n\nexport class LR1ItemGraph extends LRItemGraph {\n  /**\n   * Overridden to include the EOF marker as the lookahead for the start state\n   *\n   * StartSet = closure({S' -> . S, $})\n   */\n  startSet(): LRItemSet {\n    const startItem = this.startItem();\n    const newset = this.newItemSet(startItem);\n    newset.addLookAhead(startItem, this.grammar.Eof);\n    return this.closure(newset);\n  }\n\n  /**\n   * Computes the closure of this item set and returns a new\n   * item set.\n   */\n  closure(itemSet: LRItemSet): LRItemSet {\n    const out = itemSet.copy();\n    for (let i = 0; i < out.values.length; i++) {\n      const itemId = out.values[i];\n      const item = this.items.get(itemId) as LRItem;\n      // Evaluate the closure\n      // Cannot do anything past the end\n      if (item.position >= item.rule.rhs.length) continue;\n      const rhs = item.rule.rhs;\n      const B = rhs.syms[item.position];\n      if (B.isTerminal) continue;\n\n      for (const lookahead of out.getLookAheads(item)) {\n        const suffix = rhs.copy().append(lookahead);\n        this.grammar.firstSets.forEachTermIn(suffix, item.position + 1, (term) => {\n          if (term != null) {\n            // For each rule [ B -> beta, term ] add it to\n            // our list of items if it doesnt already exist\n            const bRules = this.grammar.rulesForNT(B);\n            for (const br of bRules) {\n              const newItem = this.items.ensure(new LRItem(br, 0));\n              out.add(newItem.id);\n              out.addLookAhead(newItem, term);\n            }\n          }\n        });\n      }\n    }\n    return out.size == 0 ? out : this.itemSets.ensure(out);\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Grammar, Str, Sym, Rule } from \"./grammar\";\nimport { LRAction, ParseTable } from \"./lr\";\nimport { LRItem, LRItemSet, LRItemGraph, LR0ItemGraph, LR1ItemGraph } from \"./lritems\";\nimport { Goto } from \"./tests/utils\";\n\nexport function makeParseTable(g: Grammar, type = \"lr1\"): [ParseTable, LRItemGraph] {\n  switch (type) {\n    case \"lr1\":\n      return makeLRParseTable(g);\n    case \"lalr\":\n      return makeLALRParseTable(g);\n  }\n  return makeSLRParseTable(g);\n}\n\n/**\n * A SLR parse table maker.\n */\nexport function makeSLRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  const ig = makeSLRAutomaton(grammar);\n  return [makeParseTableFromLA(ig, grammar), ig];\n}\n\nexport function makeSLRAutomaton(grammar: Grammar): LRItemGraph {\n  const ig = new LR0ItemGraph(grammar).refresh();\n  for (const itemSet of ig.itemSets.entries) {\n    evalLASetsForSLRItem(grammar, ig, itemSet);\n  }\n  return ig;\n}\n\n/**\n * For a given LR(0) Item in the LR0 automaton evaluates the lookahead set\n * for an SLR1 parse table.\n *\n * The SLR lookahead is:\n *\n *    SLRLA(q, A -> w) = Follow(A)\n *\n * @param grammar\n * @param ig\n * @param itemSet\n */\nexport function evalLASetsForSLRItem(grammar: Grammar, ig: LRItemGraph, itemSet: LRItemSet): void {\n  // Look for transitions from this set\n  for (const itemId of itemSet.values) {\n    const item = ig.items.get(itemId);\n    const rule = item.rule;\n    if (item.position >= rule.rhs.length) {\n      // if sym is in follows(nt) then add the rule\n      // Reduce nt -> rule for all sym in follows(nt)\n      grammar.followSets.forEachTerm(rule.nt, (term) => {\n        if (term != null) {\n          TSU.assert(term.isTerminal);\n          itemSet.addLookAhead(item, term);\n        }\n      });\n    }\n  }\n}\n\n/**\n * A canonical LR1 parse table maker.\n */\nexport function makeLRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  const ig = new LR1ItemGraph(grammar).refresh();\n  const parseTable = makeParseTableFromLA(ig, grammar);\n  return [parseTable, ig];\n}\n\n/**\n * A LALR(1) parse table maker using Bermudez and Logothetis' (1989)\n *  \"Simple computation of LALR(1) lookahead sets\" method.\n */\nexport function makeLALRParseTable(grammar: Grammar): [ParseTable, LRItemGraph] {\n  // const [parseTable, ig] = makeSLRParseTable(grammar);\n  const [parseTable, ig] = makeSLRParseTable(grammar);\n\n  if (!parseTable.hasConflicts) {\n    return [parseTable, ig];\n  }\n\n  // This is a really simple method compared to DeRemer and Penello's method\n  // (based on relations).\n  //\n  // 1. First transform the grammar G into G' that is based on around the LR0\n  // item graph\n  const g2 = grammarFromLR0ItemGraph(ig, grammar);\n\n  // Reverse of goto sets in the LR automaton to track predecessor states.\n  const prevSets: TSU.NumMap<TSU.NumMap<Set<number>>> = {};\n\n  for (const startState in ig.gotoSets) {\n    for (const symId in ig.gotoSets[startState]) {\n      const nextSet = ig.gotoSets[startState][symId];\n      if (!(nextSet.id in prevSets)) {\n        prevSets[nextSet.id] = {};\n      }\n      if (!(symId in prevSets[nextSet.id])) {\n        prevSets[nextSet.id][symId] = new Set();\n      }\n      prevSets[nextSet.id][symId].add(startState as any as number);\n    }\n  }\n\n  // For conflict states upgrade lookahead sets based on union of follow\n  // sets of G2 for the corresponding sets\n  // LALRLA(q, A -> w) =\n  for (const startState in parseTable.conflictActions) {\n    // So here we have a startState where a symbol was extraneously added\n    // into the look ahead set.   So here recompute the lookahead set\n    // for this state\n    const itemSet = ig.itemSets.get(startState as any as number);\n    evalLASetsForLALRItem(grammar, g2, ig, itemSet, prevSets);\n  }\n\n  // Now that all look aheads have been recomputed - recreate\n  // the parse table\n  return [makeParseTableFromLA(ig, grammar), ig];\n}\n\n/**\n * Shared parse table creator for SLR/LR/LALR grammars that have lookahead\n * in the LR0 automaton.\n */\nexport function makeParseTableFromLA(ig: LRItemGraph, grammar: Grammar): ParseTable {\n  const parseTable = new ParseTable(grammar);\n  for (const itemSet of ig.itemSets.entries) {\n    // Look for transitions from this set\n    for (const itemId of itemSet.values) {\n      const item = ig.items.get(itemId);\n      const rule = item.rule;\n      if (item.position < rule.rhs.length) {\n        // possibilities of shift\n        const sym = rule.rhs.syms[item.position];\n        if (sym.isTerminal) {\n          const nextSet = ig.getGoto(itemSet, sym);\n          if (nextSet) {\n            parseTable.addAction(itemSet.id, sym, LRAction.Shift(nextSet.id));\n          }\n        }\n      } else if (!rule.nt.equals(grammar.augStartRule.nt)) {\n        // We have nt -> rule DOT / t\n        // AND nt != S'\n        // Reduce nt -> rule for t\n        const lookaheads = itemSet.getLookAheads(item);\n        for (const lookahead of lookaheads) {\n          parseTable.addAction(itemSet.id, lookahead, LRAction.Reduce(rule));\n        }\n      }\n    }\n\n    // Now create GOTO entries for (State,X) where X is a non-term\n    ig.forEachGoto(itemSet, (sym, next) => {\n      if (sym != null && !sym.isTerminal) {\n        parseTable.addAction(itemSet.id, sym, LRAction.Goto(next.id));\n      }\n    });\n\n    // If this state contains the augmented item, S' -> S . / $\n    // then add accept\n    const lr1Item = ig.items.ensure(new LRItem(grammar.augStartRule, 1));\n    itemSet.addLookAhead(lr1Item, grammar.Eof);\n    if (itemSet.has(lr1Item.id)) {\n      parseTable.addAction(itemSet.id, grammar.Eof, LRAction.Accept());\n    }\n  }\n  return parseTable;\n}\n\n/**\n * For a given LR(0) Item in the LR0 automaton evaluates the lookahead set\n * for an LALR1 parse table.\n *\n * The LALR lookahead is:\n *\n *    LALRLA(q, A -> w) = {t | [r:t] in Follow[p: A], Go[p: w] = q }\n *\n * Here [r: t] refers to a state in the augmented grammar transformed from the original\n * grammar where the nonterminals and terminals are based on the transitions in the\n * LR(0) automaton.  This augmented grammar is also passed in as a parameter.\n *\n * @param grammar     - Original grammar\n * @param augGrammar  - Augmented grammar\n * @param ig          - LR0 Automaton\n * @param itemSet     - The item set in the automaton (ie a particular state)\n *                      for which lookahead sets are to be computed.\n * @param prevSets    - A mapping where prevSets[stateI][symId] is a list of\n *                      states X1,X2...Xn where where the transition\n *                      X1[symId] = stateI, X2[symId] = stateI ...\n *                      Xn[symId] = stateI\n */\nexport function evalLASetsForLALRItem(\n  grammar: Grammar,\n  augGrammar: Grammar,\n  ig: LRItemGraph,\n  itemSet: LRItemSet,\n  prevSets: TSU.NumMap<TSU.NumMap<Set<number>>>,\n): void {\n  // find p going backwards from q spelling w\n  function findP(rule: Rule, i: number, currState: number, states: Set<number>): void {\n    if (i < 0) {\n      // we have reached the end - currState is P\n      // Ensure there is a transition from currState on rule.nt\n      const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[currState];\n      TSU.assert((transitions[rule.nt.id] || null) != null, \"Transition on rule.nt missing from start state\");\n      states.add(currState);\n    } else {\n      const sym = rule.rhs.syms[i];\n      const prevStates = prevSets[currState][sym.id] || null;\n      TSU.assert(prevStates != null, \"Prev set should not be null\");\n      prevStates.forEach((nextState) => findP(rule, i - 1, nextState, states));\n    }\n  }\n\n  itemSet.clearLookAheads();\n  // Look for transitions from this set\n  for (const itemId of itemSet.values) {\n    const item = ig.items.get(itemId);\n    const rule = item.rule;\n    if (item.position >= rule.rhs.length) {\n      // Here we have rule of the form A -> w in state q\n      //\n      // For this state we compute LALR lookaheads as:\n      //\n      // LALRLA(q, A -> w) = {t | [r:t] in Follow[p: A], Go[p: w] = q }\n      const pSet = new Set<number>();\n      findP(rule, rule.rhs.length - 1, itemSet.id, pSet);\n      pSet.forEach((p) => {\n        // Now find the NT [p: A] in the augmented grammar\n        const pALabel = `[${p}:${rule.nt.label}]`;\n        const pA = augGrammar.getSym(pALabel);\n        TSU.assert(pA != null, \"Augmented grammar symbol [p:A] not found\");\n        augGrammar.followSets.forEachTerm(pA, (term) => {\n          if (term != null && term != augGrammar.Eof) {\n            TSU.assert(term.isTerminal);\n            // This term is in the form [r: T] in the augmented grammar.\n            // Get the T from this and add to the look ahead set\n            const label = term.label.substring(term.label.indexOf(\":\") + 1, term.label.length - 1).trim();\n            const T = grammar.getSym(label);\n            TSU.assert(T != null, `T (${label}) in [r:T] cannot be null`);\n            itemSet.addLookAhead(item, T);\n          }\n        });\n      });\n    }\n  }\n}\n\n/**\n * For a grammar G and its LR0 ItemGraph, IG, returns a transformed grammar G'\n * that is based along the transitions of IG.\n *\n * For this new Grammar G' we have:\n *\n * NonTerminals N' =  { [p: A] | if Go[p: A] is defined },\n * Terminals T' =  { [p: t] | if Go[p: t] is defined },\n * Start Symbol S' = [ Start : S ]\n * Productions P' =  { [p1 : A ] -> [p1 : X1][p2 : X2]...[pn : Xn], if\n *                            [p1 : A] is in N'         AND\n *                            [pi : Xi] is in N' U T'   AND\n *                            A -> X1 X2 .. An is in P (of original grammar G)\n */\nexport function grammarFromLR0ItemGraph(ig: LR0ItemGraph, g: Grammar): Grammar {\n  const g2 = new Grammar();\n\n  function ensureG2Sym(pi: number, sym: Sym): Sym {\n    const newSymLabel = `[${pi}:${sym.label}]`;\n    const newSym = g2.ensureSym(new Sym(g2, newSymLabel, sym.isTerminal), false);\n    if (pi == 0 && g.startSymbol == sym && g.startSymbol != newSym && !sym.isTerminal) {\n      g2.startSymbol = newSym;\n    }\n    return newSym;\n  }\n\n  // Create N', T' and S'\n  for (const startState in ig.gotoSets) {\n    // transitions is a Map of symId -> ItemSet\n    const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[startState];\n    for (const symId in transitions) {\n      const sym = g.getSymById(symId as any as number)!;\n      ensureG2Sym(startState as any as number, sym);\n    }\n  }\n\n  function buildRuleFrom(startSet: number, A: Sym, rule: Rule): Str {\n    // Str to be built up for the production in the transformed grammar\n    //    -   [P1:X1][P2:X2]...[Pn:Xn]\n    let pi = startSet;\n    const newSyms = rule.rhs.syms.map((xi, index) => {\n      const nextSym = ensureG2Sym(pi, xi);\n      const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[pi];\n      const nextSet = transitions[xi.id] || null;\n      TSU.assert(nextSet != null, \"Next set transition *must* be valid\");\n      pi = nextSet.id;\n      return nextSym;\n    });\n    return new Str(...newSyms);\n  }\n\n  for (const startState in ig.gotoSets) {\n    // from P1 - for every transition that is a non terminal A\n    // find an equivalent chain of transition starting from P1 where we have\n    // [P1:X1][P2:X2]...[Pn:Xn]\n    // for All A -> X1X2...Xn in G\n    const transitions: TSU.NumMap<LRItemSet> = ig.gotoSets[startState];\n    for (const symId in transitions) {\n      const startSym = g.getSymById(symId as any as number)!;\n      const p1 = startState as any as number;\n      if (!startSym.isTerminal) {\n        const newA = ensureG2Sym(p1, startSym);\n        g.forEachRule(startSym, (rule, index) => {\n          const newRHS = buildRuleFrom(p1, startSym, rule);\n          const newRule = new Rule(newA, newRHS);\n          g2.addRule(newRule);\n        });\n      }\n    }\n  }\n  // Do another pass to evaluate P'\n  return g2;\n}\n","const ALIAS = Symbol.for('yaml.alias');\nconst DOC = Symbol.for('yaml.document');\nconst MAP = Symbol.for('yaml.map');\nconst PAIR = Symbol.for('yaml.pair');\nconst SCALAR = Symbol.for('yaml.scalar');\nconst SEQ = Symbol.for('yaml.seq');\nconst NODE_TYPE = Symbol.for('yaml.node.type');\nconst isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;\nconst isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;\nconst isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;\nconst isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;\nconst isScalar = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR;\nconst isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;\nfunction isCollection(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case MAP:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nfunction isNode(node) {\n    if (node && typeof node === 'object')\n        switch (node[NODE_TYPE]) {\n            case ALIAS:\n            case MAP:\n            case SCALAR:\n            case SEQ:\n                return true;\n        }\n    return false;\n}\nconst hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;\n\nexport { ALIAS, DOC, MAP, NODE_TYPE, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };\n","import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from './nodes/identity.js';\n\nconst BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove node');\n/**\n * Apply a visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nfunction visit(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        visit_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisit.SKIP = SKIP;\n/** Remove the current node */\nvisit.REMOVE = REMOVE;\nfunction visit_(key, node, visitor, path) {\n    const ctrl = callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visit_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = visit_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = visit_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = visit_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\n/**\n * Apply an async visitor to an AST node or document.\n *\n * Walks through the tree (depth-first) starting from `node`, calling a\n * `visitor` function with three arguments:\n *   - `key`: For sequence values and map `Pair`, the node's index in the\n *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.\n *     `null` for the root node.\n *   - `node`: The current node.\n *   - `path`: The ancestry of the current node.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `Promise`: Must resolve to one of the following values\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this node, continue with next\n *     sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current node, then continue with the next one\n *   - `Node`: Replace the current node, then continue by visiting it\n *   - `number`: While iterating the items of a sequence or map, set the index\n *     of the next step. This is useful especially if the index of the current\n *     node has changed.\n *\n * If `visitor` is a single function, it will be called with all values\n * encountered in the tree, including e.g. `null` values. Alternatively,\n * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,\n * `Alias` and `Scalar` node. To define the same visitor function for more than\n * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)\n * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most\n * specific defined one will be used for each node.\n */\nasync function visitAsync(node, visitor) {\n    const visitor_ = initVisitor(visitor);\n    if (isDocument(node)) {\n        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));\n        if (cd === REMOVE)\n            node.contents = null;\n    }\n    else\n        await visitAsync_(null, node, visitor_, Object.freeze([]));\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisitAsync.BREAK = BREAK;\n/** Do not visit the children of the current node */\nvisitAsync.SKIP = SKIP;\n/** Remove the current node */\nvisitAsync.REMOVE = REMOVE;\nasync function visitAsync_(key, node, visitor, path) {\n    const ctrl = await callVisitor(key, node, visitor, path);\n    if (isNode(ctrl) || isPair(ctrl)) {\n        replaceNode(key, path, ctrl);\n        return visitAsync_(key, ctrl, visitor, path);\n    }\n    if (typeof ctrl !== 'symbol') {\n        if (isCollection(node)) {\n            path = Object.freeze(path.concat(node));\n            for (let i = 0; i < node.items.length; ++i) {\n                const ci = await visitAsync_(i, node.items[i], visitor, path);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    node.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n        }\n        else if (isPair(node)) {\n            path = Object.freeze(path.concat(node));\n            const ck = await visitAsync_('key', node.key, visitor, path);\n            if (ck === BREAK)\n                return BREAK;\n            else if (ck === REMOVE)\n                node.key = null;\n            const cv = await visitAsync_('value', node.value, visitor, path);\n            if (cv === BREAK)\n                return BREAK;\n            else if (cv === REMOVE)\n                node.value = null;\n        }\n    }\n    return ctrl;\n}\nfunction initVisitor(visitor) {\n    if (typeof visitor === 'object' &&\n        (visitor.Collection || visitor.Node || visitor.Value)) {\n        return Object.assign({\n            Alias: visitor.Node,\n            Map: visitor.Node,\n            Scalar: visitor.Node,\n            Seq: visitor.Node\n        }, visitor.Value && {\n            Map: visitor.Value,\n            Scalar: visitor.Value,\n            Seq: visitor.Value\n        }, visitor.Collection && {\n            Map: visitor.Collection,\n            Seq: visitor.Collection\n        }, visitor);\n    }\n    return visitor;\n}\nfunction callVisitor(key, node, visitor, path) {\n    if (typeof visitor === 'function')\n        return visitor(key, node, path);\n    if (isMap(node))\n        return visitor.Map?.(key, node, path);\n    if (isSeq(node))\n        return visitor.Seq?.(key, node, path);\n    if (isPair(node))\n        return visitor.Pair?.(key, node, path);\n    if (isScalar(node))\n        return visitor.Scalar?.(key, node, path);\n    if (isAlias(node))\n        return visitor.Alias?.(key, node, path);\n    return undefined;\n}\nfunction replaceNode(key, path, node) {\n    const parent = path[path.length - 1];\n    if (isCollection(parent)) {\n        parent.items[key] = node;\n    }\n    else if (isPair(parent)) {\n        if (key === 'key')\n            parent.key = node;\n        else\n            parent.value = node;\n    }\n    else if (isDocument(parent)) {\n        parent.contents = node;\n    }\n    else {\n        const pt = isAlias(parent) ? 'alias' : 'scalar';\n        throw new Error(`Cannot replace node with ${pt} parent`);\n    }\n}\n\nexport { visit, visitAsync };\n","import { isNode } from '../nodes/identity.js';\nimport { visit } from '../visit.js';\n\nconst escapeChars = {\n    '!': '%21',\n    ',': '%2C',\n    '[': '%5B',\n    ']': '%5D',\n    '{': '%7B',\n    '}': '%7D'\n};\nconst escapeTagName = (tn) => tn.replace(/[!,[\\]{}]/g, ch => escapeChars[ch]);\nclass Directives {\n    constructor(yaml, tags) {\n        /**\n         * The directives-end/doc-start marker `---`. If `null`, a marker may still be\n         * included in the document's stringified representation.\n         */\n        this.docStart = null;\n        /** The doc-end marker `...`.  */\n        this.docEnd = false;\n        this.yaml = Object.assign({}, Directives.defaultYaml, yaml);\n        this.tags = Object.assign({}, Directives.defaultTags, tags);\n    }\n    clone() {\n        const copy = new Directives(this.yaml, this.tags);\n        copy.docStart = this.docStart;\n        return copy;\n    }\n    /**\n     * During parsing, get a Directives instance for the current document and\n     * update the stream state according to the current version's spec.\n     */\n    atDocument() {\n        const res = new Directives(this.yaml, this.tags);\n        switch (this.yaml.version) {\n            case '1.1':\n                this.atNextDocument = true;\n                break;\n            case '1.2':\n                this.atNextDocument = false;\n                this.yaml = {\n                    explicit: Directives.defaultYaml.explicit,\n                    version: '1.2'\n                };\n                this.tags = Object.assign({}, Directives.defaultTags);\n                break;\n        }\n        return res;\n    }\n    /**\n     * @param onError - May be called even if the action was successful\n     * @returns `true` on success\n     */\n    add(line, onError) {\n        if (this.atNextDocument) {\n            this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' };\n            this.tags = Object.assign({}, Directives.defaultTags);\n            this.atNextDocument = false;\n        }\n        const parts = line.trim().split(/[ \\t]+/);\n        const name = parts.shift();\n        switch (name) {\n            case '%TAG': {\n                if (parts.length !== 2) {\n                    onError(0, '%TAG directive should contain exactly two parts');\n                    if (parts.length < 2)\n                        return false;\n                }\n                const [handle, prefix] = parts;\n                this.tags[handle] = prefix;\n                return true;\n            }\n            case '%YAML': {\n                this.yaml.explicit = true;\n                if (parts.length !== 1) {\n                    onError(0, '%YAML directive should contain exactly one part');\n                    return false;\n                }\n                const [version] = parts;\n                if (version === '1.1' || version === '1.2') {\n                    this.yaml.version = version;\n                    return true;\n                }\n                else {\n                    const isValid = /^\\d+\\.\\d+$/.test(version);\n                    onError(6, `Unsupported YAML version ${version}`, isValid);\n                    return false;\n                }\n            }\n            default:\n                onError(0, `Unknown directive ${name}`, true);\n                return false;\n        }\n    }\n    /**\n     * Resolves a tag, matching handles to those defined in %TAG directives.\n     *\n     * @returns Resolved tag, which may also be the non-specific tag `'!'` or a\n     *   `'!local'` tag, or `null` if unresolvable.\n     */\n    tagName(source, onError) {\n        if (source === '!')\n            return '!'; // non-specific tag\n        if (source[0] !== '!') {\n            onError(`Not a valid tag: ${source}`);\n            return null;\n        }\n        if (source[1] === '<') {\n            const verbatim = source.slice(2, -1);\n            if (verbatim === '!' || verbatim === '!!') {\n                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);\n                return null;\n            }\n            if (source[source.length - 1] !== '>')\n                onError('Verbatim tags must end with a >');\n            return verbatim;\n        }\n        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);\n        if (!suffix)\n            onError(`The ${source} tag has no suffix`);\n        const prefix = this.tags[handle];\n        if (prefix) {\n            try {\n                return prefix + decodeURIComponent(suffix);\n            }\n            catch (error) {\n                onError(String(error));\n                return null;\n            }\n        }\n        if (handle === '!')\n            return source; // local tag\n        onError(`Could not resolve tag: ${source}`);\n        return null;\n    }\n    /**\n     * Given a fully resolved tag, returns its printable string form,\n     * taking into account current tag prefixes and defaults.\n     */\n    tagString(tag) {\n        for (const [handle, prefix] of Object.entries(this.tags)) {\n            if (tag.startsWith(prefix))\n                return handle + escapeTagName(tag.substring(prefix.length));\n        }\n        return tag[0] === '!' ? tag : `!<${tag}>`;\n    }\n    toString(doc) {\n        const lines = this.yaml.explicit\n            ? [`%YAML ${this.yaml.version || '1.2'}`]\n            : [];\n        const tagEntries = Object.entries(this.tags);\n        let tagNames;\n        if (doc && tagEntries.length > 0 && isNode(doc.contents)) {\n            const tags = {};\n            visit(doc.contents, (_key, node) => {\n                if (isNode(node) && node.tag)\n                    tags[node.tag] = true;\n            });\n            tagNames = Object.keys(tags);\n        }\n        else\n            tagNames = [];\n        for (const [handle, prefix] of tagEntries) {\n            if (handle === '!!' && prefix === 'tag:yaml.org,2002:')\n                continue;\n            if (!doc || tagNames.some(tn => tn.startsWith(prefix)))\n                lines.push(`%TAG ${handle} ${prefix}`);\n        }\n        return lines.join('\\n');\n    }\n}\nDirectives.defaultYaml = { explicit: false, version: '1.2' };\nDirectives.defaultTags = { '!!': 'tag:yaml.org,2002:' };\n\nexport { Directives };\n","import { isScalar, isCollection } from '../nodes/identity.js';\nimport { visit } from '../visit.js';\n\n/**\n * Verify that the input string is a valid anchor.\n *\n * Will throw on errors.\n */\nfunction anchorIsValid(anchor) {\n    if (/[\\x00-\\x19\\s,[\\]{}]/.test(anchor)) {\n        const sa = JSON.stringify(anchor);\n        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;\n        throw new Error(msg);\n    }\n    return true;\n}\nfunction anchorNames(root) {\n    const anchors = new Set();\n    visit(root, {\n        Value(_key, node) {\n            if (node.anchor)\n                anchors.add(node.anchor);\n        }\n    });\n    return anchors;\n}\n/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */\nfunction findNewAnchor(prefix, exclude) {\n    for (let i = 1; true; ++i) {\n        const name = `${prefix}${i}`;\n        if (!exclude.has(name))\n            return name;\n    }\n}\nfunction createNodeAnchors(doc, prefix) {\n    const aliasObjects = [];\n    const sourceObjects = new Map();\n    let prevAnchors = null;\n    return {\n        onAnchor: (source) => {\n            aliasObjects.push(source);\n            prevAnchors ?? (prevAnchors = anchorNames(doc));\n            const anchor = findNewAnchor(prefix, prevAnchors);\n            prevAnchors.add(anchor);\n            return anchor;\n        },\n        /**\n         * With circular references, the source node is only resolved after all\n         * of its child nodes are. This is why anchors are set only after all of\n         * the nodes have been created.\n         */\n        setAnchors: () => {\n            for (const source of aliasObjects) {\n                const ref = sourceObjects.get(source);\n                if (typeof ref === 'object' &&\n                    ref.anchor &&\n                    (isScalar(ref.node) || isCollection(ref.node))) {\n                    ref.node.anchor = ref.anchor;\n                }\n                else {\n                    const error = new Error('Failed to resolve repeated object (this should not happen)');\n                    error.source = source;\n                    throw error;\n                }\n            }\n        },\n        sourceObjects\n    };\n}\n\nexport { anchorIsValid, anchorNames, createNodeAnchors, findNewAnchor };\n","/**\n * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,\n * in section 24.5.1.1 \"Runtime Semantics: InternalizeJSONProperty\" of the\n * 2021 edition: https://tc39.es/ecma262/#sec-json.parse\n *\n * Includes extensions for handling Map and Set objects.\n */\nfunction applyReviver(reviver, obj, key, val) {\n    if (val && typeof val === 'object') {\n        if (Array.isArray(val)) {\n            for (let i = 0, len = val.length; i < len; ++i) {\n                const v0 = val[i];\n                const v1 = applyReviver(reviver, val, String(i), v0);\n                // eslint-disable-next-line @typescript-eslint/no-array-delete\n                if (v1 === undefined)\n                    delete val[i];\n                else if (v1 !== v0)\n                    val[i] = v1;\n            }\n        }\n        else if (val instanceof Map) {\n            for (const k of Array.from(val.keys())) {\n                const v0 = val.get(k);\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    val.delete(k);\n                else if (v1 !== v0)\n                    val.set(k, v1);\n            }\n        }\n        else if (val instanceof Set) {\n            for (const v0 of Array.from(val)) {\n                const v1 = applyReviver(reviver, val, v0, v0);\n                if (v1 === undefined)\n                    val.delete(v0);\n                else if (v1 !== v0) {\n                    val.delete(v0);\n                    val.add(v1);\n                }\n            }\n        }\n        else {\n            for (const [k, v0] of Object.entries(val)) {\n                const v1 = applyReviver(reviver, val, k, v0);\n                if (v1 === undefined)\n                    delete val[k];\n                else if (v1 !== v0)\n                    val[k] = v1;\n            }\n        }\n    }\n    return reviver.call(obj, key, val);\n}\n\nexport { applyReviver };\n","import { hasAnchor } from './identity.js';\n\n/**\n * Recursively convert any node or its contents to native JavaScript\n *\n * @param value - The input value\n * @param arg - If `value` defines a `toJSON()` method, use this\n *   as its first argument\n * @param ctx - Conversion context, originally set in Document#toJS(). If\n *   `{ keep: true }` is not set, output should be suitable for JSON\n *   stringification.\n */\nfunction toJS(value, arg, ctx) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    if (Array.isArray(value))\n        return value.map((v, i) => toJS(v, String(i), ctx));\n    if (value && typeof value.toJSON === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        if (!ctx || !hasAnchor(value))\n            return value.toJSON(arg, ctx);\n        const data = { aliasCount: 0, count: 1, res: undefined };\n        ctx.anchors.set(value, data);\n        ctx.onCreate = res => {\n            data.res = res;\n            delete ctx.onCreate;\n        };\n        const res = value.toJSON(arg, ctx);\n        if (ctx.onCreate)\n            ctx.onCreate(res);\n        return res;\n    }\n    if (typeof value === 'bigint' && !ctx?.keep)\n        return Number(value);\n    return value;\n}\n\nexport { toJS };\n","import { applyReviver } from '../doc/applyReviver.js';\nimport { NODE_TYPE, isDocument } from './identity.js';\nimport { toJS } from './toJS.js';\n\nclass NodeBase {\n    constructor(type) {\n        Object.defineProperty(this, NODE_TYPE, { value: type });\n    }\n    /** Create a copy of this node.  */\n    clone() {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /** A plain JavaScript representation of this node. */\n    toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {\n        if (!isDocument(doc))\n            throw new TypeError('A document argument is required');\n        const ctx = {\n            anchors: new Map(),\n            doc,\n            keep: true,\n            mapAsMap: mapAsMap === true,\n            mapKeyWarned: false,\n            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100\n        };\n        const res = toJS(this, '', ctx);\n        if (typeof onAnchor === 'function')\n            for (const { count, res } of ctx.anchors.values())\n                onAnchor(res, count);\n        return typeof reviver === 'function'\n            ? applyReviver(reviver, { '': res }, '', res)\n            : res;\n    }\n}\n\nexport { NodeBase };\n","import { anchorIsValid } from '../doc/anchors.js';\nimport { visit } from '../visit.js';\nimport { ALIAS, isAlias, isCollection, isPair, hasAnchor } from './identity.js';\nimport { NodeBase } from './Node.js';\nimport { toJS } from './toJS.js';\n\nclass Alias extends NodeBase {\n    constructor(source) {\n        super(ALIAS);\n        this.source = source;\n        Object.defineProperty(this, 'tag', {\n            set() {\n                throw new Error('Alias nodes cannot have tags');\n            }\n        });\n    }\n    /**\n     * Resolve the value of this alias within `doc`, finding the last\n     * instance of the `source` anchor before this node.\n     */\n    resolve(doc, ctx) {\n        let nodes;\n        if (ctx?.aliasResolveCache) {\n            nodes = ctx.aliasResolveCache;\n        }\n        else {\n            nodes = [];\n            visit(doc, {\n                Node: (_key, node) => {\n                    if (isAlias(node) || hasAnchor(node))\n                        nodes.push(node);\n                }\n            });\n            if (ctx)\n                ctx.aliasResolveCache = nodes;\n        }\n        let found = undefined;\n        for (const node of nodes) {\n            if (node === this)\n                break;\n            if (node.anchor === this.source)\n                found = node;\n        }\n        return found;\n    }\n    toJSON(_arg, ctx) {\n        if (!ctx)\n            return { source: this.source };\n        const { anchors, doc, maxAliasCount } = ctx;\n        const source = this.resolve(doc, ctx);\n        if (!source) {\n            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n            throw new ReferenceError(msg);\n        }\n        let data = anchors.get(source);\n        if (!data) {\n            // Resolve anchors for Node.prototype.toJS()\n            toJS(source, null, ctx);\n            data = anchors.get(source);\n        }\n        /* istanbul ignore if */\n        if (data?.res === undefined) {\n            const msg = 'This should not happen: Alias anchor was not resolved?';\n            throw new ReferenceError(msg);\n        }\n        if (maxAliasCount >= 0) {\n            data.count += 1;\n            if (data.aliasCount === 0)\n                data.aliasCount = getAliasCount(doc, source, anchors);\n            if (data.count * data.aliasCount > maxAliasCount) {\n                const msg = 'Excessive alias count indicates a resource exhaustion attack';\n                throw new ReferenceError(msg);\n            }\n        }\n        return data.res;\n    }\n    toString(ctx, _onComment, _onChompKeep) {\n        const src = `*${this.source}`;\n        if (ctx) {\n            anchorIsValid(this.source);\n            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {\n                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;\n                throw new Error(msg);\n            }\n            if (ctx.implicitKey)\n                return `${src} `;\n        }\n        return src;\n    }\n}\nfunction getAliasCount(doc, node, anchors) {\n    if (isAlias(node)) {\n        const source = node.resolve(doc);\n        const anchor = anchors && source && anchors.get(source);\n        return anchor ? anchor.count * anchor.aliasCount : 0;\n    }\n    else if (isCollection(node)) {\n        let count = 0;\n        for (const item of node.items) {\n            const c = getAliasCount(doc, item, anchors);\n            if (c > count)\n                count = c;\n        }\n        return count;\n    }\n    else if (isPair(node)) {\n        const kc = getAliasCount(doc, node.key, anchors);\n        const vc = getAliasCount(doc, node.value, anchors);\n        return Math.max(kc, vc);\n    }\n    return 1;\n}\n\nexport { Alias };\n","import { SCALAR } from './identity.js';\nimport { NodeBase } from './Node.js';\nimport { toJS } from './toJS.js';\n\nconst isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');\nclass Scalar extends NodeBase {\n    constructor(value) {\n        super(SCALAR);\n        this.value = value;\n    }\n    toJSON(arg, ctx) {\n        return ctx?.keep ? this.value : toJS(this.value, arg, ctx);\n    }\n    toString() {\n        return String(this.value);\n    }\n}\nScalar.BLOCK_FOLDED = 'BLOCK_FOLDED';\nScalar.BLOCK_LITERAL = 'BLOCK_LITERAL';\nScalar.PLAIN = 'PLAIN';\nScalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';\nScalar.QUOTE_SINGLE = 'QUOTE_SINGLE';\n\nexport { Scalar, isScalarValue };\n","import { Alias } from '../nodes/Alias.js';\nimport { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/identity.js';\nimport { Scalar } from '../nodes/Scalar.js';\n\nconst defaultTagPrefix = 'tag:yaml.org,2002:';\nfunction findTagObject(value, tagName, tags) {\n    if (tagName) {\n        const match = tags.filter(t => t.tag === tagName);\n        const tagObj = match.find(t => !t.format) ?? match[0];\n        if (!tagObj)\n            throw new Error(`Tag ${tagName} not found`);\n        return tagObj;\n    }\n    return tags.find(t => t.identify?.(value) && !t.format);\n}\nfunction createNode(value, tagName, ctx) {\n    if (isDocument(value))\n        value = value.contents;\n    if (isNode(value))\n        return value;\n    if (isPair(value)) {\n        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);\n        map.items.push(value);\n        return map;\n    }\n    if (value instanceof String ||\n        value instanceof Number ||\n        value instanceof Boolean ||\n        (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere\n    ) {\n        // https://tc39.es/ecma262/#sec-serializejsonproperty\n        value = value.valueOf();\n    }\n    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;\n    // Detect duplicate references to the same object & use Alias nodes for all\n    // after first. The `ref` wrapper allows for circular references to resolve.\n    let ref = undefined;\n    if (aliasDuplicateObjects && value && typeof value === 'object') {\n        ref = sourceObjects.get(value);\n        if (ref) {\n            ref.anchor ?? (ref.anchor = onAnchor(value));\n            return new Alias(ref.anchor);\n        }\n        else {\n            ref = { anchor: null, node: null };\n            sourceObjects.set(value, ref);\n        }\n    }\n    if (tagName?.startsWith('!!'))\n        tagName = defaultTagPrefix + tagName.slice(2);\n    let tagObj = findTagObject(value, tagName, schema.tags);\n    if (!tagObj) {\n        if (value && typeof value.toJSON === 'function') {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n            value = value.toJSON();\n        }\n        if (!value || typeof value !== 'object') {\n            const node = new Scalar(value);\n            if (ref)\n                ref.node = node;\n            return node;\n        }\n        tagObj =\n            value instanceof Map\n                ? schema[MAP]\n                : Symbol.iterator in Object(value)\n                    ? schema[SEQ]\n                    : schema[MAP];\n    }\n    if (onTagObj) {\n        onTagObj(tagObj);\n        delete ctx.onTagObj;\n    }\n    const node = tagObj?.createNode\n        ? tagObj.createNode(ctx.schema, value, ctx)\n        : typeof tagObj?.nodeClass?.from === 'function'\n            ? tagObj.nodeClass.from(ctx.schema, value, ctx)\n            : new Scalar(value);\n    if (tagName)\n        node.tag = tagName;\n    else if (!tagObj.default)\n        node.tag = tagObj.tag;\n    if (ref)\n        ref.node = node;\n    return node;\n}\n\nexport { createNode };\n","import { createNode } from '../doc/createNode.js';\nimport { isNode, isPair, isCollection, isScalar } from './identity.js';\nimport { NodeBase } from './Node.js';\n\nfunction collectionFromPath(schema, path, value) {\n    let v = value;\n    for (let i = path.length - 1; i >= 0; --i) {\n        const k = path[i];\n        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {\n            const a = [];\n            a[k] = v;\n            v = a;\n        }\n        else {\n            v = new Map([[k, v]]);\n        }\n    }\n    return createNode(v, undefined, {\n        aliasDuplicateObjects: false,\n        keepUndefined: false,\n        onAnchor: () => {\n            throw new Error('This should not happen, please report a bug.');\n        },\n        schema,\n        sourceObjects: new Map()\n    });\n}\n// Type guard is intentionally a little wrong so as to be more useful,\n// as it does not cover untypable empty non-string iterables (e.g. []).\nconst isEmptyPath = (path) => path == null ||\n    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);\nclass Collection extends NodeBase {\n    constructor(type, schema) {\n        super(type);\n        Object.defineProperty(this, 'schema', {\n            value: schema,\n            configurable: true,\n            enumerable: false,\n            writable: true\n        });\n    }\n    /**\n     * Create a copy of this collection.\n     *\n     * @param schema - If defined, overwrites the original's schema\n     */\n    clone(schema) {\n        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));\n        if (schema)\n            copy.schema = schema;\n        copy.items = copy.items.map(it => isNode(it) || isPair(it) ? it.clone(schema) : it);\n        if (this.range)\n            copy.range = this.range.slice();\n        return copy;\n    }\n    /**\n     * Adds a value to the collection. For `!!map` and `!!omap` the value must\n     * be a Pair instance or a `{ key, value }` object, which may not have a key\n     * that already exists in the map.\n     */\n    addIn(path, value) {\n        if (isEmptyPath(path))\n            this.add(value);\n        else {\n            const [key, ...rest] = path;\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.addIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n    /**\n     * Removes a value from the collection.\n     * @returns `true` if the item was found and removed.\n     */\n    deleteIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.delete(key);\n        const node = this.get(key, true);\n        if (isCollection(node))\n            return node.deleteIn(rest);\n        else\n            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n    }\n    /**\n     * Returns item at `key`, or `undefined` if not found. By default unwraps\n     * scalar values from their surrounding node; to disable set `keepScalar` to\n     * `true` (collections are always returned intact).\n     */\n    getIn(path, keepScalar) {\n        const [key, ...rest] = path;\n        const node = this.get(key, true);\n        if (rest.length === 0)\n            return !keepScalar && isScalar(node) ? node.value : node;\n        else\n            return isCollection(node) ? node.getIn(rest, keepScalar) : undefined;\n    }\n    hasAllNullValues(allowScalar) {\n        return this.items.every(node => {\n            if (!isPair(node))\n                return false;\n            const n = node.value;\n            return (n == null ||\n                (allowScalar &&\n                    isScalar(n) &&\n                    n.value == null &&\n                    !n.commentBefore &&\n                    !n.comment &&\n                    !n.tag));\n        });\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     */\n    hasIn(path) {\n        const [key, ...rest] = path;\n        if (rest.length === 0)\n            return this.has(key);\n        const node = this.get(key, true);\n        return isCollection(node) ? node.hasIn(rest) : false;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     */\n    setIn(path, value) {\n        const [key, ...rest] = path;\n        if (rest.length === 0) {\n            this.set(key, value);\n        }\n        else {\n            const node = this.get(key, true);\n            if (isCollection(node))\n                node.setIn(rest, value);\n            else if (node === undefined && this.schema)\n                this.set(key, collectionFromPath(this.schema, rest, value));\n            else\n                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);\n        }\n    }\n}\n\nexport { Collection, collectionFromPath, isEmptyPath };\n","/**\n * Stringifies a comment.\n *\n * Empty comment lines are left empty,\n * lines consisting of a single space are replaced by `#`,\n * and all other lines are prefixed with a `#`.\n */\nconst stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');\nfunction indentComment(comment, indent) {\n    if (/^\\n+$/.test(comment))\n        return comment.substring(1);\n    return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;\n}\nconst lineComment = (str, indent, comment) => str.endsWith('\\n')\n    ? indentComment(comment, indent)\n    : comment.includes('\\n')\n        ? '\\n' + indentComment(comment, indent)\n        : (str.endsWith(' ') ? '' : ' ') + comment;\n\nexport { indentComment, lineComment, stringifyComment };\n","const FOLD_FLOW = 'flow';\nconst FOLD_BLOCK = 'block';\nconst FOLD_QUOTED = 'quoted';\n/**\n * Tries to keep input at up to `lineWidth` characters, splitting only on spaces\n * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are\n * terminated with `\\n` and started with `indent`.\n */\nfunction foldFlowLines(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {\n    if (!lineWidth || lineWidth < 0)\n        return text;\n    if (lineWidth < minContentWidth)\n        minContentWidth = 0;\n    const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);\n    if (text.length <= endStep)\n        return text;\n    const folds = [];\n    const escapedFolds = {};\n    let end = lineWidth - indent.length;\n    if (typeof indentAtStart === 'number') {\n        if (indentAtStart > lineWidth - Math.max(2, minContentWidth))\n            folds.push(0);\n        else\n            end = lineWidth - indentAtStart;\n    }\n    let split = undefined;\n    let prev = undefined;\n    let overflow = false;\n    let i = -1;\n    let escStart = -1;\n    let escEnd = -1;\n    if (mode === FOLD_BLOCK) {\n        i = consumeMoreIndentedLines(text, i, indent.length);\n        if (i !== -1)\n            end = i + endStep;\n    }\n    for (let ch; (ch = text[(i += 1)]);) {\n        if (mode === FOLD_QUOTED && ch === '\\\\') {\n            escStart = i;\n            switch (text[i + 1]) {\n                case 'x':\n                    i += 3;\n                    break;\n                case 'u':\n                    i += 5;\n                    break;\n                case 'U':\n                    i += 9;\n                    break;\n                default:\n                    i += 1;\n            }\n            escEnd = i;\n        }\n        if (ch === '\\n') {\n            if (mode === FOLD_BLOCK)\n                i = consumeMoreIndentedLines(text, i, indent.length);\n            end = i + indent.length + endStep;\n            split = undefined;\n        }\n        else {\n            if (ch === ' ' &&\n                prev &&\n                prev !== ' ' &&\n                prev !== '\\n' &&\n                prev !== '\\t') {\n                // space surrounded by non-space can be replaced with newline + indent\n                const next = text[i + 1];\n                if (next && next !== ' ' && next !== '\\n' && next !== '\\t')\n                    split = i;\n            }\n            if (i >= end) {\n                if (split) {\n                    folds.push(split);\n                    end = split + endStep;\n                    split = undefined;\n                }\n                else if (mode === FOLD_QUOTED) {\n                    // white-space collected at end may stretch past lineWidth\n                    while (prev === ' ' || prev === '\\t') {\n                        prev = ch;\n                        ch = text[(i += 1)];\n                        overflow = true;\n                    }\n                    // Account for newline escape, but don't break preceding escape\n                    const j = i > escEnd + 1 ? i - 2 : escStart - 1;\n                    // Bail out if lineWidth & minContentWidth are shorter than an escape string\n                    if (escapedFolds[j])\n                        return text;\n                    folds.push(j);\n                    escapedFolds[j] = true;\n                    end = j + endStep;\n                    split = undefined;\n                }\n                else {\n                    overflow = true;\n                }\n            }\n        }\n        prev = ch;\n    }\n    if (overflow && onOverflow)\n        onOverflow();\n    if (folds.length === 0)\n        return text;\n    if (onFold)\n        onFold();\n    let res = text.slice(0, folds[0]);\n    for (let i = 0; i < folds.length; ++i) {\n        const fold = folds[i];\n        const end = folds[i + 1] || text.length;\n        if (fold === 0)\n            res = `\\n${indent}${text.slice(0, end)}`;\n        else {\n            if (mode === FOLD_QUOTED && escapedFolds[fold])\n                res += `${text[fold]}\\\\`;\n            res += `\\n${indent}${text.slice(fold + 1, end)}`;\n        }\n    }\n    return res;\n}\n/**\n * Presumes `i + 1` is at the start of a line\n * @returns index of last newline in more-indented block\n */\nfunction consumeMoreIndentedLines(text, i, indent) {\n    let end = i;\n    let start = i + 1;\n    let ch = text[start];\n    while (ch === ' ' || ch === '\\t') {\n        if (i < start + indent) {\n            ch = text[++i];\n        }\n        else {\n            do {\n                ch = text[++i];\n            } while (ch && ch !== '\\n');\n            end = i;\n            start = i + 1;\n            ch = text[start];\n        }\n    }\n    return end;\n}\n\nexport { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED, foldFlowLines };\n","import { Scalar } from '../nodes/Scalar.js';\nimport { foldFlowLines, FOLD_FLOW, FOLD_QUOTED, FOLD_BLOCK } from './foldFlowLines.js';\n\nconst getFoldOptions = (ctx, isBlock) => ({\n    indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,\n    lineWidth: ctx.options.lineWidth,\n    minContentWidth: ctx.options.minContentWidth\n});\n// Also checks for lines starting with %, as parsing the output as YAML 1.1 will\n// presume that's starting a new document.\nconst containsDocumentMarker = (str) => /^(%|---|\\.\\.\\.)/m.test(str);\nfunction lineLengthOverLimit(str, lineWidth, indentLength) {\n    if (!lineWidth || lineWidth < 0)\n        return false;\n    const limit = lineWidth - indentLength;\n    const strLen = str.length;\n    if (strLen <= limit)\n        return false;\n    for (let i = 0, start = 0; i < strLen; ++i) {\n        if (str[i] === '\\n') {\n            if (i - start > limit)\n                return true;\n            start = i + 1;\n            if (strLen - start <= limit)\n                return false;\n        }\n    }\n    return true;\n}\nfunction doubleQuotedString(value, ctx) {\n    const json = JSON.stringify(value);\n    if (ctx.options.doubleQuotedAsJSON)\n        return json;\n    const { implicitKey } = ctx;\n    const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    let str = '';\n    let start = 0;\n    for (let i = 0, ch = json[i]; ch; ch = json[++i]) {\n        if (ch === ' ' && json[i + 1] === '\\\\' && json[i + 2] === 'n') {\n            // space before newline needs to be escaped to not be folded\n            str += json.slice(start, i) + '\\\\ ';\n            i += 1;\n            start = i;\n            ch = '\\\\';\n        }\n        if (ch === '\\\\')\n            switch (json[i + 1]) {\n                case 'u':\n                    {\n                        str += json.slice(start, i);\n                        const code = json.substr(i + 2, 4);\n                        switch (code) {\n                            case '0000':\n                                str += '\\\\0';\n                                break;\n                            case '0007':\n                                str += '\\\\a';\n                                break;\n                            case '000b':\n                                str += '\\\\v';\n                                break;\n                            case '001b':\n                                str += '\\\\e';\n                                break;\n                            case '0085':\n                                str += '\\\\N';\n                                break;\n                            case '00a0':\n                                str += '\\\\_';\n                                break;\n                            case '2028':\n                                str += '\\\\L';\n                                break;\n                            case '2029':\n                                str += '\\\\P';\n                                break;\n                            default:\n                                if (code.substr(0, 2) === '00')\n                                    str += '\\\\x' + code.substr(2);\n                                else\n                                    str += json.substr(i, 6);\n                        }\n                        i += 5;\n                        start = i + 1;\n                    }\n                    break;\n                case 'n':\n                    if (implicitKey ||\n                        json[i + 2] === '\"' ||\n                        json.length < minMultiLineLength) {\n                        i += 1;\n                    }\n                    else {\n                        // folding will eat first newline\n                        str += json.slice(start, i) + '\\n\\n';\n                        while (json[i + 2] === '\\\\' &&\n                            json[i + 3] === 'n' &&\n                            json[i + 4] !== '\"') {\n                            str += '\\n';\n                            i += 2;\n                        }\n                        str += indent;\n                        // space after newline needs to be escaped to not be folded\n                        if (json[i + 2] === ' ')\n                            str += '\\\\';\n                        i += 1;\n                        start = i + 1;\n                    }\n                    break;\n                default:\n                    i += 1;\n            }\n    }\n    str = start ? str + json.slice(start) : json;\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));\n}\nfunction singleQuotedString(value, ctx) {\n    if (ctx.options.singleQuote === false ||\n        (ctx.implicitKey && value.includes('\\n')) ||\n        /[ \\t]\\n|\\n[ \\t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline\n    )\n        return doubleQuotedString(value, ctx);\n    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');\n    const res = \"'\" + value.replace(/'/g, \"''\").replace(/\\n+/g, `$&\\n${indent}`) + \"'\";\n    return ctx.implicitKey\n        ? res\n        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));\n}\nfunction quotedString(value, ctx) {\n    const { singleQuote } = ctx.options;\n    let qs;\n    if (singleQuote === false)\n        qs = doubleQuotedString;\n    else {\n        const hasDouble = value.includes('\"');\n        const hasSingle = value.includes(\"'\");\n        if (hasDouble && !hasSingle)\n            qs = singleQuotedString;\n        else if (hasSingle && !hasDouble)\n            qs = doubleQuotedString;\n        else\n            qs = singleQuote ? singleQuotedString : doubleQuotedString;\n    }\n    return qs(value, ctx);\n}\n// The negative lookbehind avoids a polynomial search,\n// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind\nlet blockEndNewlines;\ntry {\n    blockEndNewlines = new RegExp('(^|(?<!\\n))\\n+(?!\\n|$)', 'g');\n}\ncatch {\n    blockEndNewlines = /\\n+(?!\\n|$)/g;\n}\nfunction blockString({ comment, type, value }, ctx, onComment, onChompKeep) {\n    const { blockQuote, commentString, lineWidth } = ctx.options;\n    // 1. Block can't end in whitespace unless the last line is non-empty.\n    // 2. Strings consisting of only whitespace are best rendered explicitly.\n    if (!blockQuote || /\\n[\\t ]+$/.test(value)) {\n        return quotedString(value, ctx);\n    }\n    const indent = ctx.indent ||\n        (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');\n    const literal = blockQuote === 'literal'\n        ? true\n        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED\n            ? false\n            : type === Scalar.BLOCK_LITERAL\n                ? true\n                : !lineLengthOverLimit(value, lineWidth, indent.length);\n    if (!value)\n        return literal ? '|\\n' : '>\\n';\n    // determine chomping from whitespace at value end\n    let chomp;\n    let endStart;\n    for (endStart = value.length; endStart > 0; --endStart) {\n        const ch = value[endStart - 1];\n        if (ch !== '\\n' && ch !== '\\t' && ch !== ' ')\n            break;\n    }\n    let end = value.substring(endStart);\n    const endNlPos = end.indexOf('\\n');\n    if (endNlPos === -1) {\n        chomp = '-'; // strip\n    }\n    else if (value === end || endNlPos !== end.length - 1) {\n        chomp = '+'; // keep\n        if (onChompKeep)\n            onChompKeep();\n    }\n    else {\n        chomp = ''; // clip\n    }\n    if (end) {\n        value = value.slice(0, -end.length);\n        if (end[end.length - 1] === '\\n')\n            end = end.slice(0, -1);\n        end = end.replace(blockEndNewlines, `$&${indent}`);\n    }\n    // determine indent indicator from whitespace at value start\n    let startWithSpace = false;\n    let startEnd;\n    let startNlPos = -1;\n    for (startEnd = 0; startEnd < value.length; ++startEnd) {\n        const ch = value[startEnd];\n        if (ch === ' ')\n            startWithSpace = true;\n        else if (ch === '\\n')\n            startNlPos = startEnd;\n        else\n            break;\n    }\n    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);\n    if (start) {\n        value = value.substring(start.length);\n        start = start.replace(/\\n+/g, `$&${indent}`);\n    }\n    const indentSize = indent ? '2' : '1'; // root is at -1\n    // Leading | or > is added later\n    let header = (startWithSpace ? indentSize : '') + chomp;\n    if (comment) {\n        header += ' ' + commentString(comment.replace(/ ?[\\r\\n]+/g, ' '));\n        if (onComment)\n            onComment();\n    }\n    if (!literal) {\n        const foldedValue = value\n            .replace(/\\n+/g, '\\n$&')\n            .replace(/(?:^|\\n)([\\t ].*)(?:([\\n\\t ]*)\\n(?![\\n\\t ]))?/g, '$1$2') // more-indented lines aren't folded\n            //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent\n            .replace(/\\n+/g, `$&${indent}`);\n        let literalFallback = false;\n        const foldOptions = getFoldOptions(ctx, true);\n        if (blockQuote !== 'folded' && type !== Scalar.BLOCK_FOLDED) {\n            foldOptions.onOverflow = () => {\n                literalFallback = true;\n            };\n        }\n        const body = foldFlowLines(`${start}${foldedValue}${end}`, indent, FOLD_BLOCK, foldOptions);\n        if (!literalFallback)\n            return `>${header}\\n${indent}${body}`;\n    }\n    value = value.replace(/\\n+/g, `$&${indent}`);\n    return `|${header}\\n${indent}${start}${value}${end}`;\n}\nfunction plainString(item, ctx, onComment, onChompKeep) {\n    const { type, value } = item;\n    const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;\n    if ((implicitKey && value.includes('\\n')) ||\n        (inFlow && /[[\\]{},]/.test(value))) {\n        return quotedString(value, ctx);\n    }\n    if (/^[\\n\\t ,[\\]{}#&*!|>'\"%@`]|^[?-]$|^[?-][ \\t]|[\\n:][ \\t]|[ \\t]\\n|[\\n\\t ]#|[\\n\\t :]$/.test(value)) {\n        // not allowed:\n        // - '-' or '?'\n        // - start with an indicator character (except [?:-]) or /[?-] /\n        // - '\\n ', ': ' or ' \\n' anywhere\n        // - '#' not preceded by a non-space char\n        // - end with ' ' or ':'\n        return implicitKey || inFlow || !value.includes('\\n')\n            ? quotedString(value, ctx)\n            : blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (!implicitKey &&\n        !inFlow &&\n        type !== Scalar.PLAIN &&\n        value.includes('\\n')) {\n        // Where allowed & type not set explicitly, prefer block style for multiline strings\n        return blockString(item, ctx, onComment, onChompKeep);\n    }\n    if (containsDocumentMarker(value)) {\n        if (indent === '') {\n            ctx.forceBlockIndent = true;\n            return blockString(item, ctx, onComment, onChompKeep);\n        }\n        else if (implicitKey && indent === indentStep) {\n            return quotedString(value, ctx);\n        }\n    }\n    const str = value.replace(/\\n+/g, `$&\\n${indent}`);\n    // Verify that output will be parsed as a string, as e.g. plain numbers and\n    // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),\n    // and others in v1.1.\n    if (actualString) {\n        const test = (tag) => tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str);\n        const { compat, tags } = ctx.doc.schema;\n        if (tags.some(test) || compat?.some(test))\n            return quotedString(value, ctx);\n    }\n    return implicitKey\n        ? str\n        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));\n}\nfunction stringifyString(item, ctx, onComment, onChompKeep) {\n    const { implicitKey, inFlow } = ctx;\n    const ss = typeof item.value === 'string'\n        ? item\n        : Object.assign({}, item, { value: String(item.value) });\n    let { type } = item;\n    if (type !== Scalar.QUOTE_DOUBLE) {\n        // force double quotes on control characters & unpaired surrogates\n        if (/[\\x00-\\x08\\x0b-\\x1f\\x7f-\\x9f\\u{D800}-\\u{DFFF}]/u.test(ss.value))\n            type = Scalar.QUOTE_DOUBLE;\n    }\n    const _stringify = (_type) => {\n        switch (_type) {\n            case Scalar.BLOCK_FOLDED:\n            case Scalar.BLOCK_LITERAL:\n                return implicitKey || inFlow\n                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers\n                    : blockString(ss, ctx, onComment, onChompKeep);\n            case Scalar.QUOTE_DOUBLE:\n                return doubleQuotedString(ss.value, ctx);\n            case Scalar.QUOTE_SINGLE:\n                return singleQuotedString(ss.value, ctx);\n            case Scalar.PLAIN:\n                return plainString(ss, ctx, onComment, onChompKeep);\n            default:\n                return null;\n        }\n    };\n    let res = _stringify(type);\n    if (res === null) {\n        const { defaultKeyType, defaultStringType } = ctx.options;\n        const t = (implicitKey && defaultKeyType) || defaultStringType;\n        res = _stringify(t);\n        if (res === null)\n            throw new Error(`Unsupported default string type ${t}`);\n    }\n    return res;\n}\n\nexport { stringifyString };\n","import { anchorIsValid } from '../doc/anchors.js';\nimport { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/identity.js';\nimport { stringifyComment } from './stringifyComment.js';\nimport { stringifyString } from './stringifyString.js';\n\nfunction createStringifyContext(doc, options) {\n    const opt = Object.assign({\n        blockQuote: true,\n        commentString: stringifyComment,\n        defaultKeyType: null,\n        defaultStringType: 'PLAIN',\n        directives: null,\n        doubleQuotedAsJSON: false,\n        doubleQuotedMinMultiLineLength: 40,\n        falseStr: 'false',\n        flowCollectionPadding: true,\n        indentSeq: true,\n        lineWidth: 80,\n        minContentWidth: 20,\n        nullStr: 'null',\n        simpleKeys: false,\n        singleQuote: null,\n        trueStr: 'true',\n        verifyAliasOrder: true\n    }, doc.schema.toStringOptions, options);\n    let inFlow;\n    switch (opt.collectionStyle) {\n        case 'block':\n            inFlow = false;\n            break;\n        case 'flow':\n            inFlow = true;\n            break;\n        default:\n            inFlow = null;\n    }\n    return {\n        anchors: new Set(),\n        doc,\n        flowCollectionPadding: opt.flowCollectionPadding ? ' ' : '',\n        indent: '',\n        indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',\n        inFlow,\n        options: opt\n    };\n}\nfunction getTagObject(tags, item) {\n    if (item.tag) {\n        const match = tags.filter(t => t.tag === item.tag);\n        if (match.length > 0)\n            return match.find(t => t.format === item.format) ?? match[0];\n    }\n    let tagObj = undefined;\n    let obj;\n    if (isScalar(item)) {\n        obj = item.value;\n        let match = tags.filter(t => t.identify?.(obj));\n        if (match.length > 1) {\n            const testMatch = match.filter(t => t.test);\n            if (testMatch.length > 0)\n                match = testMatch;\n        }\n        tagObj =\n            match.find(t => t.format === item.format) ?? match.find(t => !t.format);\n    }\n    else {\n        obj = item;\n        tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);\n    }\n    if (!tagObj) {\n        const name = obj?.constructor?.name ?? (obj === null ? 'null' : typeof obj);\n        throw new Error(`Tag not resolved for ${name} value`);\n    }\n    return tagObj;\n}\n// needs to be called before value stringifier to allow for circular anchor refs\nfunction stringifyProps(node, tagObj, { anchors, doc }) {\n    if (!doc.directives)\n        return '';\n    const props = [];\n    const anchor = (isScalar(node) || isCollection(node)) && node.anchor;\n    if (anchor && anchorIsValid(anchor)) {\n        anchors.add(anchor);\n        props.push(`&${anchor}`);\n    }\n    const tag = node.tag ?? (tagObj.default ? null : tagObj.tag);\n    if (tag)\n        props.push(doc.directives.tagString(tag));\n    return props.join(' ');\n}\nfunction stringify(item, ctx, onComment, onChompKeep) {\n    if (isPair(item))\n        return item.toString(ctx, onComment, onChompKeep);\n    if (isAlias(item)) {\n        if (ctx.doc.directives)\n            return item.toString(ctx);\n        if (ctx.resolvedAliases?.has(item)) {\n            throw new TypeError(`Cannot stringify circular structure without alias nodes`);\n        }\n        else {\n            if (ctx.resolvedAliases)\n                ctx.resolvedAliases.add(item);\n            else\n                ctx.resolvedAliases = new Set([item]);\n            item = item.resolve(ctx.doc);\n        }\n    }\n    let tagObj = undefined;\n    const node = isNode(item)\n        ? item\n        : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });\n    tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node));\n    const props = stringifyProps(node, tagObj, ctx);\n    if (props.length > 0)\n        ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;\n    const str = typeof tagObj.stringify === 'function'\n        ? tagObj.stringify(node, ctx, onComment, onChompKeep)\n        : isScalar(node)\n            ? stringifyString(node, ctx, onComment, onChompKeep)\n            : node.toString(ctx, onComment, onChompKeep);\n    if (!props)\n        return str;\n    return isScalar(node) || str[0] === '{' || str[0] === '['\n        ? `${props} ${str}`\n        : `${props}\\n${ctx.indent}${str}`;\n}\n\nexport { createStringifyContext, stringify };\n","import { isScalar, isAlias, isSeq, isMap } from '../../nodes/identity.js';\nimport { Scalar } from '../../nodes/Scalar.js';\n\n// If the value associated with a merge key is a single mapping node, each of\n// its key/value pairs is inserted into the current mapping, unless the key\n// already exists in it. If the value associated with the merge key is a\n// sequence, then this sequence is expected to contain mapping nodes and each\n// of these nodes is merged in turn according to its order in the sequence.\n// Keys in mapping nodes earlier in the sequence override keys specified in\n// later mapping nodes. -- http://yaml.org/type/merge.html\nconst MERGE_KEY = '<<';\nconst merge = {\n    identify: value => value === MERGE_KEY ||\n        (typeof value === 'symbol' && value.description === MERGE_KEY),\n    default: 'key',\n    tag: 'tag:yaml.org,2002:merge',\n    test: /^<<$/,\n    resolve: () => Object.assign(new Scalar(Symbol(MERGE_KEY)), {\n        addToJSMap: addMergeToJSMap\n    }),\n    stringify: () => MERGE_KEY\n};\nconst isMergeKey = (ctx, key) => (merge.identify(key) ||\n    (isScalar(key) &&\n        (!key.type || key.type === Scalar.PLAIN) &&\n        merge.identify(key.value))) &&\n    ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default);\nfunction addMergeToJSMap(ctx, map, value) {\n    value = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (isSeq(value))\n        for (const it of value.items)\n            mergeValue(ctx, map, it);\n    else if (Array.isArray(value))\n        for (const it of value)\n            mergeValue(ctx, map, it);\n    else\n        mergeValue(ctx, map, value);\n}\nfunction mergeValue(ctx, map, value) {\n    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;\n    if (!isMap(source))\n        throw new Error('Merge sources must be maps or map aliases');\n    const srcMap = source.toJSON(null, ctx, Map);\n    for (const [key, value] of srcMap) {\n        if (map instanceof Map) {\n            if (!map.has(key))\n                map.set(key, value);\n        }\n        else if (map instanceof Set) {\n            map.add(key);\n        }\n        else if (!Object.prototype.hasOwnProperty.call(map, key)) {\n            Object.defineProperty(map, key, {\n                value,\n                writable: true,\n                enumerable: true,\n                configurable: true\n            });\n        }\n    }\n    return map;\n}\n\nexport { addMergeToJSMap, isMergeKey, merge };\n","import { warn } from '../log.js';\nimport { isMergeKey, addMergeToJSMap } from '../schema/yaml-1.1/merge.js';\nimport { createStringifyContext } from '../stringify/stringify.js';\nimport { isNode } from './identity.js';\nimport { toJS } from './toJS.js';\n\nfunction addPairToJSMap(ctx, map, { key, value }) {\n    if (isNode(key) && key.addToJSMap)\n        key.addToJSMap(ctx, map, value);\n    // TODO: Should drop this special case for bare << handling\n    else if (isMergeKey(ctx, key))\n        addMergeToJSMap(ctx, map, value);\n    else {\n        const jsKey = toJS(key, '', ctx);\n        if (map instanceof Map) {\n            map.set(jsKey, toJS(value, jsKey, ctx));\n        }\n        else if (map instanceof Set) {\n            map.add(jsKey);\n        }\n        else {\n            const stringKey = stringifyKey(key, jsKey, ctx);\n            const jsValue = toJS(value, stringKey, ctx);\n            if (stringKey in map)\n                Object.defineProperty(map, stringKey, {\n                    value: jsValue,\n                    writable: true,\n                    enumerable: true,\n                    configurable: true\n                });\n            else\n                map[stringKey] = jsValue;\n        }\n    }\n    return map;\n}\nfunction stringifyKey(key, jsKey, ctx) {\n    if (jsKey === null)\n        return '';\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\n    if (typeof jsKey !== 'object')\n        return String(jsKey);\n    if (isNode(key) && ctx?.doc) {\n        const strCtx = createStringifyContext(ctx.doc, {});\n        strCtx.anchors = new Set();\n        for (const node of ctx.anchors.keys())\n            strCtx.anchors.add(node.anchor);\n        strCtx.inFlow = true;\n        strCtx.inStringifyKey = true;\n        const strKey = key.toString(strCtx);\n        if (!ctx.mapKeyWarned) {\n            let jsonStr = JSON.stringify(strKey);\n            if (jsonStr.length > 40)\n                jsonStr = jsonStr.substring(0, 36) + '...\"';\n            warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);\n            ctx.mapKeyWarned = true;\n        }\n        return strKey;\n    }\n    return JSON.stringify(jsKey);\n}\n\nexport { addPairToJSMap };\n","function debug(logLevel, ...messages) {\n    if (logLevel === 'debug')\n        console.log(...messages);\n}\nfunction warn(logLevel, warning) {\n    if (logLevel === 'debug' || logLevel === 'warn') {\n        console.warn(warning);\n    }\n}\n\nexport { debug, warn };\n","import { createNode } from '../doc/createNode.js';\nimport { stringifyPair } from '../stringify/stringifyPair.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { NODE_TYPE, PAIR, isNode } from './identity.js';\n\nfunction createPair(key, value, ctx) {\n    const k = createNode(key, undefined, ctx);\n    const v = createNode(value, undefined, ctx);\n    return new Pair(k, v);\n}\nclass Pair {\n    constructor(key, value = null) {\n        Object.defineProperty(this, NODE_TYPE, { value: PAIR });\n        this.key = key;\n        this.value = value;\n    }\n    clone(schema) {\n        let { key, value } = this;\n        if (isNode(key))\n            key = key.clone(schema);\n        if (isNode(value))\n            value = value.clone(schema);\n        return new Pair(key, value);\n    }\n    toJSON(_, ctx) {\n        const pair = ctx?.mapAsMap ? new Map() : {};\n        return addPairToJSMap(ctx, pair, this);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        return ctx?.doc\n            ? stringifyPair(this, ctx, onComment, onChompKeep)\n            : JSON.stringify(this);\n    }\n}\n\nexport { Pair, createPair };\n","import { isCollection, isNode, isScalar, isSeq } from '../nodes/identity.js';\nimport { Scalar } from '../nodes/Scalar.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyPair({ key, value }, ctx, onComment, onChompKeep) {\n    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;\n    let keyComment = (isNode(key) && key.comment) || null;\n    if (simpleKeys) {\n        if (keyComment) {\n            throw new Error('With simple keys, key nodes cannot have comments');\n        }\n        if (isCollection(key) || (!isNode(key) && typeof key === 'object')) {\n            const msg = 'With simple keys, collection cannot be used as a key value';\n            throw new Error(msg);\n        }\n    }\n    let explicitKey = !simpleKeys &&\n        (!key ||\n            (keyComment && value == null && !ctx.inFlow) ||\n            isCollection(key) ||\n            (isScalar(key)\n                ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL\n                : typeof key === 'object'));\n    ctx = Object.assign({}, ctx, {\n        allNullValues: false,\n        implicitKey: !explicitKey && (simpleKeys || !allNullValues),\n        indent: indent + indentStep\n    });\n    let keyCommentDone = false;\n    let chompKeep = false;\n    let str = stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));\n    if (!explicitKey && !ctx.inFlow && str.length > 1024) {\n        if (simpleKeys)\n            throw new Error('With simple keys, single line scalar must not span more than 1024 characters');\n        explicitKey = true;\n    }\n    if (ctx.inFlow) {\n        if (allNullValues || value == null) {\n            if (keyCommentDone && onComment)\n                onComment();\n            return str === '' ? '?' : explicitKey ? `? ${str}` : str;\n        }\n    }\n    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {\n        str = `? ${str}`;\n        if (keyComment && !keyCommentDone) {\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        }\n        else if (chompKeep && onChompKeep)\n            onChompKeep();\n        return str;\n    }\n    if (keyCommentDone)\n        keyComment = null;\n    if (explicitKey) {\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n        str = `? ${str}\\n${indent}:`;\n    }\n    else {\n        str = `${str}:`;\n        if (keyComment)\n            str += lineComment(str, ctx.indent, commentString(keyComment));\n    }\n    let vsb, vcb, valueComment;\n    if (isNode(value)) {\n        vsb = !!value.spaceBefore;\n        vcb = value.commentBefore;\n        valueComment = value.comment;\n    }\n    else {\n        vsb = false;\n        vcb = null;\n        valueComment = null;\n        if (value && typeof value === 'object')\n            value = doc.createNode(value);\n    }\n    ctx.implicitKey = false;\n    if (!explicitKey && !keyComment && isScalar(value))\n        ctx.indentAtStart = str.length + 1;\n    chompKeep = false;\n    if (!indentSeq &&\n        indentStep.length >= 2 &&\n        !ctx.inFlow &&\n        !explicitKey &&\n        isSeq(value) &&\n        !value.flow &&\n        !value.tag &&\n        !value.anchor) {\n        // If indentSeq === false, consider '- ' as part of indentation where possible\n        ctx.indent = ctx.indent.substring(2);\n    }\n    let valueCommentDone = false;\n    const valueStr = stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));\n    let ws = ' ';\n    if (keyComment || vsb || vcb) {\n        ws = vsb ? '\\n' : '';\n        if (vcb) {\n            const cs = commentString(vcb);\n            ws += `\\n${indentComment(cs, ctx.indent)}`;\n        }\n        if (valueStr === '' && !ctx.inFlow) {\n            if (ws === '\\n' && valueComment)\n                ws = '\\n\\n';\n        }\n        else {\n            ws += `\\n${ctx.indent}`;\n        }\n    }\n    else if (!explicitKey && isCollection(value)) {\n        const vs0 = valueStr[0];\n        const nl0 = valueStr.indexOf('\\n');\n        const hasNewline = nl0 !== -1;\n        const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;\n        if (hasNewline || !flow) {\n            let hasPropsLine = false;\n            if (hasNewline && (vs0 === '&' || vs0 === '!')) {\n                let sp0 = valueStr.indexOf(' ');\n                if (vs0 === '&' &&\n                    sp0 !== -1 &&\n                    sp0 < nl0 &&\n                    valueStr[sp0 + 1] === '!') {\n                    sp0 = valueStr.indexOf(' ', sp0 + 1);\n                }\n                if (sp0 === -1 || nl0 < sp0)\n                    hasPropsLine = true;\n            }\n            if (!hasPropsLine)\n                ws = `\\n${ctx.indent}`;\n        }\n    }\n    else if (valueStr === '' || valueStr[0] === '\\n') {\n        ws = '';\n    }\n    str += ws + valueStr;\n    if (ctx.inFlow) {\n        if (valueCommentDone && onComment)\n            onComment();\n    }\n    else if (valueComment && !valueCommentDone) {\n        str += lineComment(str, ctx.indent, commentString(valueComment));\n    }\n    else if (chompKeep && onChompKeep) {\n        onChompKeep();\n    }\n    return str;\n}\n\nexport { stringifyPair };\n","import { isNode, isPair } from '../nodes/identity.js';\nimport { stringify } from './stringify.js';\nimport { lineComment, indentComment } from './stringifyComment.js';\n\nfunction stringifyCollection(collection, ctx, options) {\n    const flow = ctx.inFlow ?? collection.flow;\n    const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;\n    return stringify(collection, ctx, options);\n}\nfunction stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {\n    const { indent, options: { commentString } } = ctx;\n    const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null });\n    let chompKeep = false; // flag for the preceding node's status\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (!chompKeep && item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (!chompKeep && ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);\n            }\n        }\n        chompKeep = false;\n        let str = stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (chompKeep && comment)\n            chompKeep = false;\n        lines.push(blockItemPrefix + str);\n    }\n    let str;\n    if (lines.length === 0) {\n        str = flowChars.start + flowChars.end;\n    }\n    else {\n        str = lines[0];\n        for (let i = 1; i < lines.length; ++i) {\n            const line = lines[i];\n            str += line ? `\\n${indent}${line}` : '\\n';\n        }\n    }\n    if (comment) {\n        str += '\\n' + indentComment(commentString(comment), indent);\n        if (onComment)\n            onComment();\n    }\n    else if (chompKeep && onChompKeep)\n        onChompKeep();\n    return str;\n}\nfunction stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {\n    const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;\n    itemIndent += indentStep;\n    const itemCtx = Object.assign({}, ctx, {\n        indent: itemIndent,\n        inFlow: true,\n        type: null\n    });\n    let reqNewline = false;\n    let linesAtValue = 0;\n    const lines = [];\n    for (let i = 0; i < items.length; ++i) {\n        const item = items[i];\n        let comment = null;\n        if (isNode(item)) {\n            if (item.spaceBefore)\n                lines.push('');\n            addCommentBefore(ctx, lines, item.commentBefore, false);\n            if (item.comment)\n                comment = item.comment;\n        }\n        else if (isPair(item)) {\n            const ik = isNode(item.key) ? item.key : null;\n            if (ik) {\n                if (ik.spaceBefore)\n                    lines.push('');\n                addCommentBefore(ctx, lines, ik.commentBefore, false);\n                if (ik.comment)\n                    reqNewline = true;\n            }\n            const iv = isNode(item.value) ? item.value : null;\n            if (iv) {\n                if (iv.comment)\n                    comment = iv.comment;\n                if (iv.commentBefore)\n                    reqNewline = true;\n            }\n            else if (item.value == null && ik?.comment) {\n                comment = ik.comment;\n            }\n        }\n        if (comment)\n            reqNewline = true;\n        let str = stringify(item, itemCtx, () => (comment = null));\n        if (i < items.length - 1)\n            str += ',';\n        if (comment)\n            str += lineComment(str, itemIndent, commentString(comment));\n        if (!reqNewline && (lines.length > linesAtValue || str.includes('\\n')))\n            reqNewline = true;\n        lines.push(str);\n        linesAtValue = lines.length;\n    }\n    const { start, end } = flowChars;\n    if (lines.length === 0) {\n        return start + end;\n    }\n    else {\n        if (!reqNewline) {\n            const len = lines.reduce((sum, line) => sum + line.length + 2, 2);\n            reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;\n        }\n        if (reqNewline) {\n            let str = start;\n            for (const line of lines)\n                str += line ? `\\n${indentStep}${indent}${line}` : '\\n';\n            return `${str}\\n${indent}${end}`;\n        }\n        else {\n            return `${start}${fcPadding}${lines.join(' ')}${fcPadding}${end}`;\n        }\n    }\n}\nfunction addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {\n    if (comment && chompKeep)\n        comment = comment.replace(/^\\n+/, '');\n    if (comment) {\n        const ic = indentComment(commentString(comment), indent);\n        lines.push(ic.trimStart()); // Avoid double indent on first line\n    }\n}\n\nexport { stringifyCollection };\n","import { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { addPairToJSMap } from './addPairToJSMap.js';\nimport { Collection } from './Collection.js';\nimport { MAP, isPair, isScalar } from './identity.js';\nimport { Pair, createPair } from './Pair.js';\nimport { isScalarValue } from './Scalar.js';\n\nfunction findPair(items, key) {\n    const k = isScalar(key) ? key.value : key;\n    for (const it of items) {\n        if (isPair(it)) {\n            if (it.key === key || it.key === k)\n                return it;\n            if (isScalar(it.key) && it.key.value === k)\n                return it;\n        }\n    }\n    return undefined;\n}\nclass YAMLMap extends Collection {\n    static get tagName() {\n        return 'tag:yaml.org,2002:map';\n    }\n    constructor(schema) {\n        super(MAP, schema);\n        this.items = [];\n    }\n    /**\n     * A generic collection parsing method that can be extended\n     * to other node classes that inherit from YAMLMap\n     */\n    static from(schema, obj, ctx) {\n        const { keepUndefined, replacer } = ctx;\n        const map = new this(schema);\n        const add = (key, value) => {\n            if (typeof replacer === 'function')\n                value = replacer.call(obj, key, value);\n            else if (Array.isArray(replacer) && !replacer.includes(key))\n                return;\n            if (value !== undefined || keepUndefined)\n                map.items.push(createPair(key, value, ctx));\n        };\n        if (obj instanceof Map) {\n            for (const [key, value] of obj)\n                add(key, value);\n        }\n        else if (obj && typeof obj === 'object') {\n            for (const key of Object.keys(obj))\n                add(key, obj[key]);\n        }\n        if (typeof schema.sortMapEntries === 'function') {\n            map.items.sort(schema.sortMapEntries);\n        }\n        return map;\n    }\n    /**\n     * Adds a value to the collection.\n     *\n     * @param overwrite - If not set `true`, using a key that is already in the\n     *   collection will throw. Otherwise, overwrites the previous value.\n     */\n    add(pair, overwrite) {\n        let _pair;\n        if (isPair(pair))\n            _pair = pair;\n        else if (!pair || typeof pair !== 'object' || !('key' in pair)) {\n            // In TypeScript, this never happens.\n            _pair = new Pair(pair, pair?.value);\n        }\n        else\n            _pair = new Pair(pair.key, pair.value);\n        const prev = findPair(this.items, _pair.key);\n        const sortEntries = this.schema?.sortMapEntries;\n        if (prev) {\n            if (!overwrite)\n                throw new Error(`Key ${_pair.key} already set`);\n            // For scalars, keep the old node & its comments and anchors\n            if (isScalar(prev.value) && isScalarValue(_pair.value))\n                prev.value.value = _pair.value;\n            else\n                prev.value = _pair.value;\n        }\n        else if (sortEntries) {\n            const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);\n            if (i === -1)\n                this.items.push(_pair);\n            else\n                this.items.splice(i, 0, _pair);\n        }\n        else {\n            this.items.push(_pair);\n        }\n    }\n    delete(key) {\n        const it = findPair(this.items, key);\n        if (!it)\n            return false;\n        const del = this.items.splice(this.items.indexOf(it), 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const it = findPair(this.items, key);\n        const node = it?.value;\n        return (!keepScalar && isScalar(node) ? node.value : node) ?? undefined;\n    }\n    has(key) {\n        return !!findPair(this.items, key);\n    }\n    set(key, value) {\n        this.add(new Pair(key, value), true);\n    }\n    /**\n     * @param ctx - Conversion context, originally set in Document#toJS()\n     * @param {Class} Type - If set, forces the returned collection type\n     * @returns Instance of Type, Map, or Object\n     */\n    toJSON(_, ctx, Type) {\n        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const item of this.items)\n            addPairToJSMap(ctx, map, item);\n        return map;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        for (const item of this.items) {\n            if (!isPair(item))\n                throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);\n        }\n        if (!ctx.allNullValues && this.hasAllNullValues(false))\n            ctx = Object.assign({}, ctx, { allNullValues: true });\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '',\n            flowChars: { start: '{', end: '}' },\n            itemIndent: ctx.indent || '',\n            onChompKeep,\n            onComment\n        });\n    }\n}\n\nexport { YAMLMap, findPair };\n","import { isMap } from '../../nodes/identity.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\n\nconst map = {\n    collection: 'map',\n    default: true,\n    nodeClass: YAMLMap,\n    tag: 'tag:yaml.org,2002:map',\n    resolve(map, onError) {\n        if (!isMap(map))\n            onError('Expected a mapping for this tag');\n        return map;\n    },\n    createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)\n};\n\nexport { map };\n","import { createNode } from '../doc/createNode.js';\nimport { stringifyCollection } from '../stringify/stringifyCollection.js';\nimport { Collection } from './Collection.js';\nimport { SEQ, isScalar } from './identity.js';\nimport { isScalarValue } from './Scalar.js';\nimport { toJS } from './toJS.js';\n\nclass YAMLSeq extends Collection {\n    static get tagName() {\n        return 'tag:yaml.org,2002:seq';\n    }\n    constructor(schema) {\n        super(SEQ, schema);\n        this.items = [];\n    }\n    add(value) {\n        this.items.push(value);\n    }\n    /**\n     * Removes a value from the collection.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     *\n     * @returns `true` if the item was found and removed.\n     */\n    delete(key) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return false;\n        const del = this.items.splice(idx, 1);\n        return del.length > 0;\n    }\n    get(key, keepScalar) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            return undefined;\n        const it = this.items[idx];\n        return !keepScalar && isScalar(it) ? it.value : it;\n    }\n    /**\n     * Checks if the collection includes a value with the key `key`.\n     *\n     * `key` must contain a representation of an integer for this to succeed.\n     * It may be wrapped in a `Scalar`.\n     */\n    has(key) {\n        const idx = asItemIndex(key);\n        return typeof idx === 'number' && idx < this.items.length;\n    }\n    /**\n     * Sets a value in this collection. For `!!set`, `value` needs to be a\n     * boolean to add/remove the item from the set.\n     *\n     * If `key` does not contain a representation of an integer, this will throw.\n     * It may be wrapped in a `Scalar`.\n     */\n    set(key, value) {\n        const idx = asItemIndex(key);\n        if (typeof idx !== 'number')\n            throw new Error(`Expected a valid index, not ${key}.`);\n        const prev = this.items[idx];\n        if (isScalar(prev) && isScalarValue(value))\n            prev.value = value;\n        else\n            this.items[idx] = value;\n    }\n    toJSON(_, ctx) {\n        const seq = [];\n        if (ctx?.onCreate)\n            ctx.onCreate(seq);\n        let i = 0;\n        for (const item of this.items)\n            seq.push(toJS(item, String(i++), ctx));\n        return seq;\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        return stringifyCollection(this, ctx, {\n            blockItemPrefix: '- ',\n            flowChars: { start: '[', end: ']' },\n            itemIndent: (ctx.indent || '') + '  ',\n            onChompKeep,\n            onComment\n        });\n    }\n    static from(schema, obj, ctx) {\n        const { replacer } = ctx;\n        const seq = new this(schema);\n        if (obj && Symbol.iterator in Object(obj)) {\n            let i = 0;\n            for (let it of obj) {\n                if (typeof replacer === 'function') {\n                    const key = obj instanceof Set ? it : String(i++);\n                    it = replacer.call(obj, key, it);\n                }\n                seq.items.push(createNode(it, undefined, ctx));\n            }\n        }\n        return seq;\n    }\n}\nfunction asItemIndex(key) {\n    let idx = isScalar(key) ? key.value : key;\n    if (idx && typeof idx === 'string')\n        idx = Number(idx);\n    return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0\n        ? idx\n        : null;\n}\n\nexport { YAMLSeq };\n","import { isSeq } from '../../nodes/identity.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nconst seq = {\n    collection: 'seq',\n    default: true,\n    nodeClass: YAMLSeq,\n    tag: 'tag:yaml.org,2002:seq',\n    resolve(seq, onError) {\n        if (!isSeq(seq))\n            onError('Expected a sequence for this tag');\n        return seq;\n    },\n    createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)\n};\n\nexport { seq };\n","import { stringifyString } from '../../stringify/stringifyString.js';\n\nconst string = {\n    identify: value => typeof value === 'string',\n    default: true,\n    tag: 'tag:yaml.org,2002:str',\n    resolve: str => str,\n    stringify(item, ctx, onComment, onChompKeep) {\n        ctx = Object.assign({ actualString: true }, ctx);\n        return stringifyString(item, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { string };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nconst nullTag = {\n    identify: value => value == null,\n    createNode: () => new Scalar(null),\n    default: true,\n    tag: 'tag:yaml.org,2002:null',\n    test: /^(?:~|[Nn]ull|NULL)?$/,\n    resolve: () => new Scalar(null),\n    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)\n        ? source\n        : ctx.options.nullStr\n};\n\nexport { nullTag };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nconst boolTag = {\n    identify: value => typeof value === 'boolean',\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,\n    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),\n    stringify({ source, value }, ctx) {\n        if (source && boolTag.test.test(source)) {\n            const sv = source[0] === 't' || source[0] === 'T';\n            if (value === sv)\n                return source;\n        }\n        return value ? ctx.options.trueStr : ctx.options.falseStr;\n    }\n};\n\nexport { boolTag };\n","function stringifyNumber({ format, minFractionDigits, tag, value }) {\n    if (typeof value === 'bigint')\n        return String(value);\n    const num = typeof value === 'number' ? value : Number(value);\n    if (!isFinite(num))\n        return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf';\n    let n = Object.is(value, -0) ? '-0' : JSON.stringify(value);\n    if (!format &&\n        minFractionDigits &&\n        (!tag || tag === 'tag:yaml.org,2002:float') &&\n        /^\\d/.test(n)) {\n        let i = n.indexOf('.');\n        if (i < 0) {\n            i = n.length;\n            n += '.';\n        }\n        let d = minFractionDigits - (n.length - i - 1);\n        while (d-- > 0)\n            n += '0';\n    }\n    return n;\n}\n\nexport { stringifyNumber };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF)|\\.nan|\\.NaN|\\.NAN)$/,\n    resolve: str => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+(?:\\.[0-9]*)?)[eE][-+]?[0-9]+$/,\n    resolve: str => parseFloat(str),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:\\.[0-9]+|[0-9]+\\.[0-9]*)$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str));\n        const dot = str.indexOf('.');\n        if (dot !== -1 && str[str.length - 1] === '0')\n            node.minFractionDigits = str.length - dot - 1;\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nconst intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value) && value >= 0)\n        return prefix + value.toString(radix);\n    return stringifyNumber(node);\n}\nconst intOct = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^0o[0-7]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),\n    stringify: node => intStringify(node, 8, '0o')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: value => intIdentify(value) && value >= 0,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^0x[0-9a-fA-F]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intHex, intOct };\n","import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { boolTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intOct, int, intHex } from './int.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    boolTag,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float\n];\n\nexport { schema };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { map } from '../common/map.js';\nimport { seq } from '../common/seq.js';\n\nfunction intIdentify(value) {\n    return typeof value === 'bigint' || Number.isInteger(value);\n}\nconst stringifyJSON = ({ value }) => JSON.stringify(value);\nconst jsonScalars = [\n    {\n        identify: value => typeof value === 'string',\n        default: true,\n        tag: 'tag:yaml.org,2002:str',\n        resolve: str => str,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => value == null,\n        createNode: () => new Scalar(null),\n        default: true,\n        tag: 'tag:yaml.org,2002:null',\n        test: /^null$/,\n        resolve: () => null,\n        stringify: stringifyJSON\n    },\n    {\n        identify: value => typeof value === 'boolean',\n        default: true,\n        tag: 'tag:yaml.org,2002:bool',\n        test: /^true$|^false$/,\n        resolve: str => str === 'true',\n        stringify: stringifyJSON\n    },\n    {\n        identify: intIdentify,\n        default: true,\n        tag: 'tag:yaml.org,2002:int',\n        test: /^-?(?:0|[1-9][0-9]*)$/,\n        resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),\n        stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)\n    },\n    {\n        identify: value => typeof value === 'number',\n        default: true,\n        tag: 'tag:yaml.org,2002:float',\n        test: /^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,\n        resolve: str => parseFloat(str),\n        stringify: stringifyJSON\n    }\n];\nconst jsonError = {\n    default: true,\n    tag: '',\n    test: /^/,\n    resolve(str, onError) {\n        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);\n        return str;\n    }\n};\nconst schema = [map, seq].concat(jsonScalars, jsonError);\n\nexport { schema };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyString } from '../../stringify/stringifyString.js';\n\nconst binary = {\n    identify: value => value instanceof Uint8Array, // Buffer inherits from Uint8Array\n    default: false,\n    tag: 'tag:yaml.org,2002:binary',\n    /**\n     * Returns a Buffer in node and an Uint8Array in browsers\n     *\n     * To use the resulting buffer as an image, you'll want to do something like:\n     *\n     *   const blob = new Blob([buffer], { type: 'image/jpeg' })\n     *   document.querySelector('#photo').src = URL.createObjectURL(blob)\n     */\n    resolve(src, onError) {\n        if (typeof atob === 'function') {\n            // On IE 11, atob() can't handle newlines\n            const str = atob(src.replace(/[\\n\\r]/g, ''));\n            const buffer = new Uint8Array(str.length);\n            for (let i = 0; i < str.length; ++i)\n                buffer[i] = str.charCodeAt(i);\n            return buffer;\n        }\n        else {\n            onError('This environment does not support reading binary tags; either Buffer or atob is required');\n            return src;\n        }\n    },\n    stringify({ comment, type, value }, ctx, onComment, onChompKeep) {\n        if (!value)\n            return '';\n        const buf = value; // checked earlier by binary.identify()\n        let str;\n        if (typeof btoa === 'function') {\n            let s = '';\n            for (let i = 0; i < buf.length; ++i)\n                s += String.fromCharCode(buf[i]);\n            str = btoa(s);\n        }\n        else {\n            throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');\n        }\n        type ?? (type = Scalar.BLOCK_LITERAL);\n        if (type !== Scalar.QUOTE_DOUBLE) {\n            const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);\n            const n = Math.ceil(str.length / lineWidth);\n            const lines = new Array(n);\n            for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {\n                lines[i] = str.substr(o, lineWidth);\n            }\n            str = lines.join(type === Scalar.BLOCK_LITERAL ? '\\n' : ' ');\n        }\n        return stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);\n    }\n};\n\nexport { binary };\n","import { isSeq, isPair, isMap } from '../../nodes/identity.js';\nimport { createPair, Pair } from '../../nodes/Pair.js';\nimport { Scalar } from '../../nodes/Scalar.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\n\nfunction resolvePairs(seq, onError) {\n    if (isSeq(seq)) {\n        for (let i = 0; i < seq.items.length; ++i) {\n            let item = seq.items[i];\n            if (isPair(item))\n                continue;\n            else if (isMap(item)) {\n                if (item.items.length > 1)\n                    onError('Each pair must have its own sequence indicator');\n                const pair = item.items[0] || new Pair(new Scalar(null));\n                if (item.commentBefore)\n                    pair.key.commentBefore = pair.key.commentBefore\n                        ? `${item.commentBefore}\\n${pair.key.commentBefore}`\n                        : item.commentBefore;\n                if (item.comment) {\n                    const cn = pair.value ?? pair.key;\n                    cn.comment = cn.comment\n                        ? `${item.comment}\\n${cn.comment}`\n                        : item.comment;\n                }\n                item = pair;\n            }\n            seq.items[i] = isPair(item) ? item : new Pair(item);\n        }\n    }\n    else\n        onError('Expected a sequence for this tag');\n    return seq;\n}\nfunction createPairs(schema, iterable, ctx) {\n    const { replacer } = ctx;\n    const pairs = new YAMLSeq(schema);\n    pairs.tag = 'tag:yaml.org,2002:pairs';\n    let i = 0;\n    if (iterable && Symbol.iterator in Object(iterable))\n        for (let it of iterable) {\n            if (typeof replacer === 'function')\n                it = replacer.call(iterable, String(i++), it);\n            let key, value;\n            if (Array.isArray(it)) {\n                if (it.length === 2) {\n                    key = it[0];\n                    value = it[1];\n                }\n                else\n                    throw new TypeError(`Expected [key, value] tuple: ${it}`);\n            }\n            else if (it && it instanceof Object) {\n                const keys = Object.keys(it);\n                if (keys.length === 1) {\n                    key = keys[0];\n                    value = it[key];\n                }\n                else {\n                    throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);\n                }\n            }\n            else {\n                key = it;\n            }\n            pairs.items.push(createPair(key, value, ctx));\n        }\n    return pairs;\n}\nconst pairs = {\n    collection: 'seq',\n    default: false,\n    tag: 'tag:yaml.org,2002:pairs',\n    resolve: resolvePairs,\n    createNode: createPairs\n};\n\nexport { createPairs, pairs, resolvePairs };\n","import { isScalar, isPair } from '../../nodes/identity.js';\nimport { toJS } from '../../nodes/toJS.js';\nimport { YAMLMap } from '../../nodes/YAMLMap.js';\nimport { YAMLSeq } from '../../nodes/YAMLSeq.js';\nimport { resolvePairs, createPairs } from './pairs.js';\n\nclass YAMLOMap extends YAMLSeq {\n    constructor() {\n        super();\n        this.add = YAMLMap.prototype.add.bind(this);\n        this.delete = YAMLMap.prototype.delete.bind(this);\n        this.get = YAMLMap.prototype.get.bind(this);\n        this.has = YAMLMap.prototype.has.bind(this);\n        this.set = YAMLMap.prototype.set.bind(this);\n        this.tag = YAMLOMap.tag;\n    }\n    /**\n     * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,\n     * but TypeScript won't allow widening the signature of a child method.\n     */\n    toJSON(_, ctx) {\n        if (!ctx)\n            return super.toJSON(_);\n        const map = new Map();\n        if (ctx?.onCreate)\n            ctx.onCreate(map);\n        for (const pair of this.items) {\n            let key, value;\n            if (isPair(pair)) {\n                key = toJS(pair.key, '', ctx);\n                value = toJS(pair.value, key, ctx);\n            }\n            else {\n                key = toJS(pair, '', ctx);\n            }\n            if (map.has(key))\n                throw new Error('Ordered maps must not include duplicate keys');\n            map.set(key, value);\n        }\n        return map;\n    }\n    static from(schema, iterable, ctx) {\n        const pairs = createPairs(schema, iterable, ctx);\n        const omap = new this();\n        omap.items = pairs.items;\n        return omap;\n    }\n}\nYAMLOMap.tag = 'tag:yaml.org,2002:omap';\nconst omap = {\n    collection: 'seq',\n    identify: value => value instanceof Map,\n    nodeClass: YAMLOMap,\n    default: false,\n    tag: 'tag:yaml.org,2002:omap',\n    resolve(seq, onError) {\n        const pairs = resolvePairs(seq, onError);\n        const seenKeys = [];\n        for (const { key } of pairs.items) {\n            if (isScalar(key)) {\n                if (seenKeys.includes(key.value)) {\n                    onError(`Ordered maps must not include duplicate keys: ${key.value}`);\n                }\n                else {\n                    seenKeys.push(key.value);\n                }\n            }\n        }\n        return Object.assign(new YAMLOMap(), pairs);\n    },\n    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)\n};\n\nexport { YAMLOMap, omap };\n","import { Scalar } from '../../nodes/Scalar.js';\n\nfunction boolStringify({ value, source }, ctx) {\n    const boolObj = value ? trueTag : falseTag;\n    if (source && boolObj.test.test(source))\n        return source;\n    return value ? ctx.options.trueStr : ctx.options.falseStr;\n}\nconst trueTag = {\n    identify: value => value === true,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,\n    resolve: () => new Scalar(true),\n    stringify: boolStringify\n};\nconst falseTag = {\n    identify: value => value === false,\n    default: true,\n    tag: 'tag:yaml.org,2002:bool',\n    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,\n    resolve: () => new Scalar(false),\n    stringify: boolStringify\n};\n\nexport { falseTag, trueTag };\n","import { Scalar } from '../../nodes/Scalar.js';\nimport { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst floatNaN = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^(?:[-+]?\\.(?:inf|Inf|INF)|\\.nan|\\.NaN|\\.NAN)$/,\n    resolve: (str) => str.slice(-3).toLowerCase() === 'nan'\n        ? NaN\n        : str[0] === '-'\n            ? Number.NEGATIVE_INFINITY\n            : Number.POSITIVE_INFINITY,\n    stringify: stringifyNumber\n};\nconst floatExp = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'EXP',\n    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\\.[0-9_]*)?[eE][-+]?[0-9]+$/,\n    resolve: (str) => parseFloat(str.replace(/_/g, '')),\n    stringify(node) {\n        const num = Number(node.value);\n        return isFinite(num) ? num.toExponential() : stringifyNumber(node);\n    }\n};\nconst float = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    test: /^[-+]?(?:[0-9][0-9_]*)?\\.[0-9_]*$/,\n    resolve(str) {\n        const node = new Scalar(parseFloat(str.replace(/_/g, '')));\n        const dot = str.indexOf('.');\n        if (dot !== -1) {\n            const f = str.substring(dot + 1).replace(/_/g, '');\n            if (f[f.length - 1] === '0')\n                node.minFractionDigits = f.length;\n        }\n        return node;\n    },\n    stringify: stringifyNumber\n};\n\nexport { float, floatExp, floatNaN };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\nconst intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);\nfunction intResolve(str, offset, radix, { intAsBigInt }) {\n    const sign = str[0];\n    if (sign === '-' || sign === '+')\n        offset += 1;\n    str = str.substring(offset).replace(/_/g, '');\n    if (intAsBigInt) {\n        switch (radix) {\n            case 2:\n                str = `0b${str}`;\n                break;\n            case 8:\n                str = `0o${str}`;\n                break;\n            case 16:\n                str = `0x${str}`;\n                break;\n        }\n        const n = BigInt(str);\n        return sign === '-' ? BigInt(-1) * n : n;\n    }\n    const n = parseInt(str, radix);\n    return sign === '-' ? -1 * n : n;\n}\nfunction intStringify(node, radix, prefix) {\n    const { value } = node;\n    if (intIdentify(value)) {\n        const str = value.toString(radix);\n        return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;\n    }\n    return stringifyNumber(node);\n}\nconst intBin = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'BIN',\n    test: /^[-+]?0b[0-1_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),\n    stringify: node => intStringify(node, 2, '0b')\n};\nconst intOct = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'OCT',\n    test: /^[-+]?0[0-7_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),\n    stringify: node => intStringify(node, 8, '0')\n};\nconst int = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    test: /^[-+]?[0-9][0-9_]*$/,\n    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),\n    stringify: stringifyNumber\n};\nconst intHex = {\n    identify: intIdentify,\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'HEX',\n    test: /^[-+]?0x[0-9a-fA-F_]+$/,\n    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),\n    stringify: node => intStringify(node, 16, '0x')\n};\n\nexport { int, intBin, intHex, intOct };\n","import { isMap, isPair, isScalar } from '../../nodes/identity.js';\nimport { Pair, createPair } from '../../nodes/Pair.js';\nimport { YAMLMap, findPair } from '../../nodes/YAMLMap.js';\n\nclass YAMLSet extends YAMLMap {\n    constructor(schema) {\n        super(schema);\n        this.tag = YAMLSet.tag;\n    }\n    add(key) {\n        let pair;\n        if (isPair(key))\n            pair = key;\n        else if (key &&\n            typeof key === 'object' &&\n            'key' in key &&\n            'value' in key &&\n            key.value === null)\n            pair = new Pair(key.key, null);\n        else\n            pair = new Pair(key, null);\n        const prev = findPair(this.items, pair.key);\n        if (!prev)\n            this.items.push(pair);\n    }\n    /**\n     * If `keepPair` is `true`, returns the Pair matching `key`.\n     * Otherwise, returns the value of that Pair's key.\n     */\n    get(key, keepPair) {\n        const pair = findPair(this.items, key);\n        return !keepPair && isPair(pair)\n            ? isScalar(pair.key)\n                ? pair.key.value\n                : pair.key\n            : pair;\n    }\n    set(key, value) {\n        if (typeof value !== 'boolean')\n            throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);\n        const prev = findPair(this.items, key);\n        if (prev && !value) {\n            this.items.splice(this.items.indexOf(prev), 1);\n        }\n        else if (!prev && value) {\n            this.items.push(new Pair(key));\n        }\n    }\n    toJSON(_, ctx) {\n        return super.toJSON(_, ctx, Set);\n    }\n    toString(ctx, onComment, onChompKeep) {\n        if (!ctx)\n            return JSON.stringify(this);\n        if (this.hasAllNullValues(true))\n            return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);\n        else\n            throw new Error('Set items must all have null values');\n    }\n    static from(schema, iterable, ctx) {\n        const { replacer } = ctx;\n        const set = new this(schema);\n        if (iterable && Symbol.iterator in Object(iterable))\n            for (let value of iterable) {\n                if (typeof replacer === 'function')\n                    value = replacer.call(iterable, value, value);\n                set.items.push(createPair(value, null, ctx));\n            }\n        return set;\n    }\n}\nYAMLSet.tag = 'tag:yaml.org,2002:set';\nconst set = {\n    collection: 'map',\n    identify: value => value instanceof Set,\n    nodeClass: YAMLSet,\n    default: false,\n    tag: 'tag:yaml.org,2002:set',\n    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),\n    resolve(map, onError) {\n        if (isMap(map)) {\n            if (map.hasAllNullValues(true))\n                return Object.assign(new YAMLSet(), map);\n            else\n                onError('Set items must all have null values');\n        }\n        else\n            onError('Expected a mapping for this tag');\n        return map;\n    }\n};\n\nexport { YAMLSet, set };\n","import { stringifyNumber } from '../../stringify/stringifyNumber.js';\n\n/** Internal types handle bigint as number, because TS can't figure it out. */\nfunction parseSexagesimal(str, asBigInt) {\n    const sign = str[0];\n    const parts = sign === '-' || sign === '+' ? str.substring(1) : str;\n    const num = (n) => asBigInt ? BigInt(n) : Number(n);\n    const res = parts\n        .replace(/_/g, '')\n        .split(':')\n        .reduce((res, p) => res * num(60) + num(p), num(0));\n    return (sign === '-' ? num(-1) * res : res);\n}\n/**\n * hhhh:mm:ss.sss\n *\n * Internal types handle bigint as number, because TS can't figure it out.\n */\nfunction stringifySexagesimal(node) {\n    let { value } = node;\n    let num = (n) => n;\n    if (typeof value === 'bigint')\n        num = n => BigInt(n);\n    else if (isNaN(value) || !isFinite(value))\n        return stringifyNumber(node);\n    let sign = '';\n    if (value < 0) {\n        sign = '-';\n        value *= num(-1);\n    }\n    const _60 = num(60);\n    const parts = [value % _60]; // seconds, including ms\n    if (value < 60) {\n        parts.unshift(0); // at least one : is required\n    }\n    else {\n        value = (value - parts[0]) / _60;\n        parts.unshift(value % _60); // minutes\n        if (value >= 60) {\n            value = (value - parts[0]) / _60;\n            parts.unshift(value); // hours\n        }\n    }\n    return (sign +\n        parts\n            .map(n => String(n).padStart(2, '0'))\n            .join(':')\n            .replace(/000000\\d*$/, '') // % 60 may introduce error\n    );\n}\nconst intTime = {\n    identify: value => typeof value === 'bigint' || Number.isInteger(value),\n    default: true,\n    tag: 'tag:yaml.org,2002:int',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,\n    resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),\n    stringify: stringifySexagesimal\n};\nconst floatTime = {\n    identify: value => typeof value === 'number',\n    default: true,\n    tag: 'tag:yaml.org,2002:float',\n    format: 'TIME',\n    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*$/,\n    resolve: str => parseSexagesimal(str, false),\n    stringify: stringifySexagesimal\n};\nconst timestamp = {\n    identify: value => value instanceof Date,\n    default: true,\n    tag: 'tag:yaml.org,2002:timestamp',\n    // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part\n    // may be omitted altogether, resulting in a date format. In such a case, the time part is\n    // assumed to be 00:00:00Z (start of day, UTC).\n    test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd\n        '(?:' + // time is optional\n        '(?:t|T|[ \\\\t]+)' + // t | T | whitespace\n        '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)?\n        '(?:[ \\\\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30\n        ')?$'),\n    resolve(str) {\n        const match = str.match(timestamp.test);\n        if (!match)\n            throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd');\n        const [, year, month, day, hour, minute, second] = match.map(Number);\n        const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0;\n        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);\n        const tz = match[8];\n        if (tz && tz !== 'Z') {\n            let d = parseSexagesimal(tz, false);\n            if (Math.abs(d) < 30)\n                d *= 60;\n            date -= 60000 * d;\n        }\n        return new Date(date);\n    },\n    stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\\.000Z$/, '') ?? ''\n};\n\nexport { floatTime, intTime, timestamp };\n","import { map } from '../common/map.js';\nimport { nullTag } from '../common/null.js';\nimport { seq } from '../common/seq.js';\nimport { string } from '../common/string.js';\nimport { binary } from './binary.js';\nimport { trueTag, falseTag } from './bool.js';\nimport { floatNaN, floatExp, float } from './float.js';\nimport { intBin, intOct, int, intHex } from './int.js';\nimport { merge } from './merge.js';\nimport { omap } from './omap.js';\nimport { pairs } from './pairs.js';\nimport { set } from './set.js';\nimport { intTime, floatTime, timestamp } from './timestamp.js';\n\nconst schema = [\n    map,\n    seq,\n    string,\n    nullTag,\n    trueTag,\n    falseTag,\n    intBin,\n    intOct,\n    int,\n    intHex,\n    floatNaN,\n    floatExp,\n    float,\n    binary,\n    merge,\n    omap,\n    pairs,\n    set,\n    intTime,\n    floatTime,\n    timestamp\n];\n\nexport { schema };\n","import { map } from './common/map.js';\nimport { nullTag } from './common/null.js';\nimport { seq } from './common/seq.js';\nimport { string } from './common/string.js';\nimport { boolTag } from './core/bool.js';\nimport { floatNaN, floatExp, float } from './core/float.js';\nimport { intOct, intHex, int } from './core/int.js';\nimport { schema } from './core/schema.js';\nimport { schema as schema$1 } from './json/schema.js';\nimport { binary } from './yaml-1.1/binary.js';\nimport { merge } from './yaml-1.1/merge.js';\nimport { omap } from './yaml-1.1/omap.js';\nimport { pairs } from './yaml-1.1/pairs.js';\nimport { schema as schema$2 } from './yaml-1.1/schema.js';\nimport { set } from './yaml-1.1/set.js';\nimport { timestamp, intTime, floatTime } from './yaml-1.1/timestamp.js';\n\nconst schemas = new Map([\n    ['core', schema],\n    ['failsafe', [map, seq, string]],\n    ['json', schema$1],\n    ['yaml11', schema$2],\n    ['yaml-1.1', schema$2]\n]);\nconst tagsByName = {\n    binary,\n    bool: boolTag,\n    float,\n    floatExp,\n    floatNaN,\n    floatTime,\n    int,\n    intHex,\n    intOct,\n    intTime,\n    map,\n    merge,\n    null: nullTag,\n    omap,\n    pairs,\n    seq,\n    set,\n    timestamp\n};\nconst coreKnownTags = {\n    'tag:yaml.org,2002:binary': binary,\n    'tag:yaml.org,2002:merge': merge,\n    'tag:yaml.org,2002:omap': omap,\n    'tag:yaml.org,2002:pairs': pairs,\n    'tag:yaml.org,2002:set': set,\n    'tag:yaml.org,2002:timestamp': timestamp\n};\nfunction getTags(customTags, schemaName, addMergeTag) {\n    const schemaTags = schemas.get(schemaName);\n    if (schemaTags && !customTags) {\n        return addMergeTag && !schemaTags.includes(merge)\n            ? schemaTags.concat(merge)\n            : schemaTags.slice();\n    }\n    let tags = schemaTags;\n    if (!tags) {\n        if (Array.isArray(customTags))\n            tags = [];\n        else {\n            const keys = Array.from(schemas.keys())\n                .filter(key => key !== 'yaml11')\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown schema \"${schemaName}\"; use one of ${keys} or define customTags array`);\n        }\n    }\n    if (Array.isArray(customTags)) {\n        for (const tag of customTags)\n            tags = tags.concat(tag);\n    }\n    else if (typeof customTags === 'function') {\n        tags = customTags(tags.slice());\n    }\n    if (addMergeTag)\n        tags = tags.concat(merge);\n    return tags.reduce((tags, tag) => {\n        const tagObj = typeof tag === 'string' ? tagsByName[tag] : tag;\n        if (!tagObj) {\n            const tagName = JSON.stringify(tag);\n            const keys = Object.keys(tagsByName)\n                .map(key => JSON.stringify(key))\n                .join(', ');\n            throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);\n        }\n        if (!tags.includes(tagObj))\n            tags.push(tagObj);\n        return tags;\n    }, []);\n}\n\nexport { coreKnownTags, getTags };\n","class YAMLError extends Error {\n    constructor(name, pos, code, message) {\n        super();\n        this.name = name;\n        this.code = code;\n        this.message = message;\n        this.pos = pos;\n    }\n}\nclass YAMLParseError extends YAMLError {\n    constructor(pos, code, message) {\n        super('YAMLParseError', pos, code, message);\n    }\n}\nclass YAMLWarning extends YAMLError {\n    constructor(pos, code, message) {\n        super('YAMLWarning', pos, code, message);\n    }\n}\nconst prettifyError = (src, lc) => (error) => {\n    if (error.pos[0] === -1)\n        return;\n    error.linePos = error.pos.map(pos => lc.linePos(pos));\n    const { line, col } = error.linePos[0];\n    error.message += ` at line ${line}, column ${col}`;\n    let ci = col - 1;\n    let lineStr = src\n        .substring(lc.lineStarts[line - 1], lc.lineStarts[line])\n        .replace(/[\\n\\r]+$/, '');\n    // Trim to max 80 chars, keeping col position near the middle\n    if (ci >= 60 && lineStr.length > 80) {\n        const trimStart = Math.min(ci - 39, lineStr.length - 79);\n        lineStr = '…' + lineStr.substring(trimStart);\n        ci -= trimStart - 1;\n    }\n    if (lineStr.length > 80)\n        lineStr = lineStr.substring(0, 79) + '…';\n    // Include previous line in context if pointing at line start\n    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {\n        // Regexp won't match if start is trimmed\n        let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);\n        if (prev.length > 80)\n            prev = prev.substring(0, 79) + '…\\n';\n        lineStr = prev + lineStr;\n    }\n    if (/[^ ]/.test(lineStr)) {\n        let count = 1;\n        const end = error.linePos[1];\n        if (end?.line === line && end.col > col) {\n            count = Math.max(1, Math.min(end.col - col, 80 - ci));\n        }\n        const pointer = ' '.repeat(ci) + '^'.repeat(count);\n        error.message += `:\\n\\n${lineStr}\\n${pointer}\\n`;\n    }\n};\n\nexport { YAMLError, YAMLParseError, YAMLWarning, prettifyError };\n","const BREAK = Symbol('break visit');\nconst SKIP = Symbol('skip children');\nconst REMOVE = Symbol('remove item');\n/**\n * Apply a visitor to a CST document or item.\n *\n * Walks through the tree (depth-first) starting from the root, calling a\n * `visitor` function with two arguments when entering each item:\n *   - `item`: The current item, which included the following members:\n *     - `start: SourceToken[]` – Source tokens before the key or value,\n *       possibly including its anchor or tag.\n *     - `key?: Token | null` – Set for pair values. May then be `null`, if\n *       the key before the `:` separator is empty.\n *     - `sep?: SourceToken[]` – Source tokens between the key and the value,\n *       which should include the `:` map value indicator if `value` is set.\n *     - `value?: Token` – The value of a sequence item, or of a map pair.\n *   - `path`: The steps from the root to the current node, as an array of\n *     `['key' | 'value', number]` tuples.\n *\n * The return value of the visitor may be used to control the traversal:\n *   - `undefined` (default): Do nothing and continue\n *   - `visit.SKIP`: Do not visit the children of this token, continue with\n *      next sibling\n *   - `visit.BREAK`: Terminate traversal completely\n *   - `visit.REMOVE`: Remove the current item, then continue with the next one\n *   - `number`: Set the index of the next step. This is useful especially if\n *     the index of the current token has changed.\n *   - `function`: Define the next visitor for this item. After the original\n *     visitor is called on item entry, next visitors are called after handling\n *     a non-empty `key` and when exiting the item.\n */\nfunction visit(cst, visitor) {\n    if ('type' in cst && cst.type === 'document')\n        cst = { start: cst.start, value: cst.value };\n    _visit(Object.freeze([]), cst, visitor);\n}\n// Without the `as symbol` casts, TS declares these in the `visit`\n// namespace using `var`, but then complains about that because\n// `unique symbol` must be `const`.\n/** Terminate visit traversal completely */\nvisit.BREAK = BREAK;\n/** Do not visit the children of the current item */\nvisit.SKIP = SKIP;\n/** Remove the current item */\nvisit.REMOVE = REMOVE;\n/** Find the item at `path` from `cst` as the root */\nvisit.itemAtPath = (cst, path) => {\n    let item = cst;\n    for (const [field, index] of path) {\n        const tok = item?.[field];\n        if (tok && 'items' in tok) {\n            item = tok.items[index];\n        }\n        else\n            return undefined;\n    }\n    return item;\n};\n/**\n * Get the immediate parent collection of the item at `path` from `cst` as the root.\n *\n * Throws an error if the collection is not found, which should never happen if the item itself exists.\n */\nvisit.parentCollection = (cst, path) => {\n    const parent = visit.itemAtPath(cst, path.slice(0, -1));\n    const field = path[path.length - 1][0];\n    const coll = parent?.[field];\n    if (coll && 'items' in coll)\n        return coll;\n    throw new Error('Parent collection not found');\n};\nfunction _visit(path, item, visitor) {\n    let ctrl = visitor(item, path);\n    if (typeof ctrl === 'symbol')\n        return ctrl;\n    for (const field of ['key', 'value']) {\n        const token = item[field];\n        if (token && 'items' in token) {\n            for (let i = 0; i < token.items.length; ++i) {\n                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);\n                if (typeof ci === 'number')\n                    i = ci - 1;\n                else if (ci === BREAK)\n                    return BREAK;\n                else if (ci === REMOVE) {\n                    token.items.splice(i, 1);\n                    i -= 1;\n                }\n            }\n            if (typeof ctrl === 'function' && field === 'key')\n                ctrl = ctrl(item, path);\n        }\n    }\n    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;\n}\n\nexport { visit };\n","import { Note } from \"../core\";\n\nexport enum GamakaType {\n  // Kampitam (~)\n  // The oscilation between 2 notes - eg p , S..n S..n S..n\n  Kampitham = \"Kampitham\",\n\n  // Nokku (w)\n  Nokku = \"Nokku\",\n\n  // Spuritham (∴ / u+2234) - Stress on the second note of a jantai\n  Spuritham = \"Spuritham\",\n\n  // Prathyagatham (∵ / u+2235) - Similar to reverse of Spuritham (in descending order)\n  Prathyagatham = \"Prathyagatham\",\n\n  // Raavi (^)\n  Aahaatam_Raavi = \"Raavi\",\n\n  // Kandippu (✓)\n  // eg - Shankarabharanam's S. ,,, n , P ,,,  - where the n is subtle\n  Aahaatam_Kandippu = \"Kandippu\",\n\n  // Vali (⌒ - U+2312)\n  Vaali = \"Vaali\",\n\n  // Odukkal (x):\n  // A veena gamakam where the note itself is stretched more to get the next\n  // note effect (instead of plucking the next note itself).\n  // Not possible where plucking of strings is not possible.\n  // On voice etc it just will sound like an Eetra Jaaru.\n  Odukkal = \"Odukkal\",\n\n  // (/) Ascension from one note to another - eg S / P\n  Jaaru_Eetra = \"EetraJaaru\",\n\n  // (\\) Descending from one note to another - eg P \\ S\n  Jaaru_Irakka = \"IrakkaJaaru\",\n\n  // Orikkai (γ)\n  // eg S~~ RN N~~S.D  D~~~NP\n  Orikkai = \"Orikkai\",\n}\n\nexport class Gamaka {\n  constructor(public readonly type: GamakaType) {}\n  debugValue(): any {\n    return { type: this.type };\n  }\n}\n\nexport class JaaruGamaka extends Gamaka {\n  constructor(\n    public readonly ascending = true,\n    public readonly startingNote: null | Note = null,\n  ) {\n    super(ascending ? GamakaType.Jaaru_Eetra : GamakaType.Jaaru_Irakka);\n  }\n\n  debugValue(): any {\n    const out = { ...super.debugValue(), ascending: this.ascending };\n    if (this.startingNote) out[\"startingNote\"] = this.startingNote.debugValue();\n    return out;\n  }\n}\n\nexport function parseEmbelishment(value: string): [any, boolean] {\n  value = value.substring(1);\n  if (value == \"\") {\n    return [new Gamaka(GamakaType.Kampitham), true];\n  } else if (value == \"^\") {\n    return [new Gamaka(GamakaType.Aahaatam_Raavi), true];\n  } else if (value == \"~\") {\n    return [new Gamaka(GamakaType.Vaali), true];\n  } else if (value == \"w\" || value == \"W\") {\n    return [new Gamaka(GamakaType.Nokku), true];\n  } else if (value == \"∴\" || value == \":-\") {\n    return [new Gamaka(GamakaType.Spuritham), true];\n  } else if (value == \"∵\" || value == \"-:\") {\n    return [new Gamaka(GamakaType.Prathyagatham), true];\n  } else if (value == \"✓\" || value == \"./\" || value == \".\\\\\") {\n    return [new Gamaka(GamakaType.Aahaatam_Kandippu), true];\n  } else if (value.endsWith(\"/\")) {\n    value = value.substring(0, value.length - 1).trim();\n    return [new JaaruGamaka(true, value.length > 0 ? new Note(value) : null), true];\n  } else if (value.endsWith(\"\\\\\")) {\n    value = value.substring(0, value.length - 1);\n    return [new JaaruGamaka(false, value.length > 0 ? new Note(value) : null), true];\n  } else if (value == \"x\") {\n    return [new Gamaka(GamakaType.Odukkal), true];\n  } else if (value == \"γ\" || value == \"Y\") {\n    return [new Gamaka(GamakaType.Orikkai), true];\n  }\n  // throw new Error(\"Invalid carnatic embelishment: \" + value);\n  return [null, false];\n}\n","import { BOM, DOCUMENT, FLOW_END, SCALAR } from './cst.js';\n\n/*\nSTART -> stream\n\nstream\n  directive -> line-end -> stream\n  indent + line-end -> stream\n  [else] -> line-start\n\nline-end\n  comment -> line-end\n  newline -> .\n  input-end -> END\n\nline-start\n  doc-start -> doc\n  doc-end -> stream\n  [else] -> indent -> block-start\n\nblock-start\n  seq-item-start -> block-start\n  explicit-key-start -> block-start\n  map-value-start -> block-start\n  [else] -> doc\n\ndoc\n  line-end -> line-start\n  spaces -> doc\n  anchor -> doc\n  tag -> doc\n  flow-start -> flow -> doc\n  flow-end -> error -> doc\n  seq-item-start -> error -> doc\n  explicit-key-start -> error -> doc\n  map-value-start -> doc\n  alias -> doc\n  quote-start -> quoted-scalar -> doc\n  block-scalar-header -> line-end -> block-scalar(min) -> line-start\n  [else] -> plain-scalar(false, min) -> doc\n\nflow\n  line-end -> flow\n  spaces -> flow\n  anchor -> flow\n  tag -> flow\n  flow-start -> flow -> flow\n  flow-end -> .\n  seq-item-start -> error -> flow\n  explicit-key-start -> flow\n  map-value-start -> flow\n  alias -> flow\n  quote-start -> quoted-scalar -> flow\n  comma -> flow\n  [else] -> plain-scalar(true, 0) -> flow\n\nquoted-scalar\n  quote-end -> .\n  [else] -> quoted-scalar\n\nblock-scalar(min)\n  newline + peek(indent < min) -> .\n  [else] -> block-scalar(min)\n\nplain-scalar(is-flow, min)\n  scalar-end(is-flow) -> .\n  peek(newline + (indent < min)) -> .\n  [else] -> plain-scalar(min)\n*/\nfunction isEmpty(ch) {\n    switch (ch) {\n        case undefined:\n        case ' ':\n        case '\\n':\n        case '\\r':\n        case '\\t':\n            return true;\n        default:\n            return false;\n    }\n}\nconst hexDigits = new Set('0123456789ABCDEFabcdef');\nconst tagChars = new Set(\"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()\");\nconst flowIndicatorChars = new Set(',[]{}');\nconst invalidAnchorChars = new Set(' ,[]{}\\n\\r\\t');\nconst isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);\n/**\n * Splits an input string into lexical tokens, i.e. smaller strings that are\n * easily identifiable by `tokens.tokenType()`.\n *\n * Lexing starts always in a \"stream\" context. Incomplete input may be buffered\n * until a complete token can be emitted.\n *\n * In addition to slices of the original input, the following control characters\n * may also be emitted:\n *\n * - `\\x02` (Start of Text): A document starts with the next token\n * - `\\x18` (Cancel): Unexpected end of flow-mode (indicates an error)\n * - `\\x1f` (Unit Separator): Next token is a scalar value\n * - `\\u{FEFF}` (Byte order mark): Emitted separately outside documents\n */\nclass Lexer {\n    constructor() {\n        /**\n         * Flag indicating whether the end of the current buffer marks the end of\n         * all input\n         */\n        this.atEnd = false;\n        /**\n         * Explicit indent set in block scalar header, as an offset from the current\n         * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not\n         * explicitly set.\n         */\n        this.blockScalarIndent = -1;\n        /**\n         * Block scalars that include a + (keep) chomping indicator in their header\n         * include trailing empty lines, which are otherwise excluded from the\n         * scalar's contents.\n         */\n        this.blockScalarKeep = false;\n        /** Current input */\n        this.buffer = '';\n        /**\n         * Flag noting whether the map value indicator : can immediately follow this\n         * node within a flow context.\n         */\n        this.flowKey = false;\n        /** Count of surrounding flow collection levels. */\n        this.flowLevel = 0;\n        /**\n         * Minimum level of indentation required for next lines to be parsed as a\n         * part of the current scalar value.\n         */\n        this.indentNext = 0;\n        /** Indentation level of the current line. */\n        this.indentValue = 0;\n        /** Position of the next \\n character. */\n        this.lineEndPos = null;\n        /** Stores the state of the lexer if reaching the end of incpomplete input */\n        this.next = null;\n        /** A pointer to `buffer`; the current position of the lexer. */\n        this.pos = 0;\n    }\n    /**\n     * Generate YAML tokens from the `source` string. If `incomplete`,\n     * a part of the last line may be left as a buffer for the next call.\n     *\n     * @returns A generator of lexical tokens\n     */\n    *lex(source, incomplete = false) {\n        if (source) {\n            if (typeof source !== 'string')\n                throw TypeError('source is not a string');\n            this.buffer = this.buffer ? this.buffer + source : source;\n            this.lineEndPos = null;\n        }\n        this.atEnd = !incomplete;\n        let next = this.next ?? 'stream';\n        while (next && (incomplete || this.hasChars(1)))\n            next = yield* this.parseNext(next);\n    }\n    atLineEnd() {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (ch === ' ' || ch === '\\t')\n            ch = this.buffer[++i];\n        if (!ch || ch === '#' || ch === '\\n')\n            return true;\n        if (ch === '\\r')\n            return this.buffer[i + 1] === '\\n';\n        return false;\n    }\n    charAt(n) {\n        return this.buffer[this.pos + n];\n    }\n    continueScalar(offset) {\n        let ch = this.buffer[offset];\n        if (this.indentNext > 0) {\n            let indent = 0;\n            while (ch === ' ')\n                ch = this.buffer[++indent + offset];\n            if (ch === '\\r') {\n                const next = this.buffer[indent + offset + 1];\n                if (next === '\\n' || (!next && !this.atEnd))\n                    return offset + indent + 1;\n            }\n            return ch === '\\n' || indent >= this.indentNext || (!ch && !this.atEnd)\n                ? offset + indent\n                : -1;\n        }\n        if (ch === '-' || ch === '.') {\n            const dt = this.buffer.substr(offset, 3);\n            if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3]))\n                return -1;\n        }\n        return offset;\n    }\n    getLine() {\n        let end = this.lineEndPos;\n        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {\n            end = this.buffer.indexOf('\\n', this.pos);\n            this.lineEndPos = end;\n        }\n        if (end === -1)\n            return this.atEnd ? this.buffer.substring(this.pos) : null;\n        if (this.buffer[end - 1] === '\\r')\n            end -= 1;\n        return this.buffer.substring(this.pos, end);\n    }\n    hasChars(n) {\n        return this.pos + n <= this.buffer.length;\n    }\n    setNext(state) {\n        this.buffer = this.buffer.substring(this.pos);\n        this.pos = 0;\n        this.lineEndPos = null;\n        this.next = state;\n        return null;\n    }\n    peek(n) {\n        return this.buffer.substr(this.pos, n);\n    }\n    *parseNext(next) {\n        switch (next) {\n            case 'stream':\n                return yield* this.parseStream();\n            case 'line-start':\n                return yield* this.parseLineStart();\n            case 'block-start':\n                return yield* this.parseBlockStart();\n            case 'doc':\n                return yield* this.parseDocument();\n            case 'flow':\n                return yield* this.parseFlowCollection();\n            case 'quoted-scalar':\n                return yield* this.parseQuotedScalar();\n            case 'block-scalar':\n                return yield* this.parseBlockScalar();\n            case 'plain-scalar':\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseStream() {\n        let line = this.getLine();\n        if (line === null)\n            return this.setNext('stream');\n        if (line[0] === BOM) {\n            yield* this.pushCount(1);\n            line = line.substring(1);\n        }\n        if (line[0] === '%') {\n            let dirEnd = line.length;\n            let cs = line.indexOf('#');\n            while (cs !== -1) {\n                const ch = line[cs - 1];\n                if (ch === ' ' || ch === '\\t') {\n                    dirEnd = cs - 1;\n                    break;\n                }\n                else {\n                    cs = line.indexOf('#', cs + 1);\n                }\n            }\n            while (true) {\n                const ch = line[dirEnd - 1];\n                if (ch === ' ' || ch === '\\t')\n                    dirEnd -= 1;\n                else\n                    break;\n            }\n            const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));\n            yield* this.pushCount(line.length - n); // possible comment\n            this.pushNewline();\n            return 'stream';\n        }\n        if (this.atLineEnd()) {\n            const sp = yield* this.pushSpaces(true);\n            yield* this.pushCount(line.length - sp);\n            yield* this.pushNewline();\n            return 'stream';\n        }\n        yield DOCUMENT;\n        return yield* this.parseLineStart();\n    }\n    *parseLineStart() {\n        const ch = this.charAt(0);\n        if (!ch && !this.atEnd)\n            return this.setNext('line-start');\n        if (ch === '-' || ch === '.') {\n            if (!this.atEnd && !this.hasChars(4))\n                return this.setNext('line-start');\n            const s = this.peek(3);\n            if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {\n                yield* this.pushCount(3);\n                this.indentValue = 0;\n                this.indentNext = 0;\n                return s === '---' ? 'doc' : 'stream';\n            }\n        }\n        this.indentValue = yield* this.pushSpaces(false);\n        if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))\n            this.indentNext = this.indentValue;\n        return yield* this.parseBlockStart();\n    }\n    *parseBlockStart() {\n        const [ch0, ch1] = this.peek(2);\n        if (!ch1 && !this.atEnd)\n            return this.setNext('block-start');\n        if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) {\n            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));\n            this.indentNext = this.indentValue + 1;\n            this.indentValue += n;\n            return yield* this.parseBlockStart();\n        }\n        return 'doc';\n    }\n    *parseDocument() {\n        yield* this.pushSpaces(true);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('doc');\n        let n = yield* this.pushIndicators();\n        switch (line[n]) {\n            case '#':\n                yield* this.pushCount(line.length - n);\n            // fallthrough\n            case undefined:\n                yield* this.pushNewline();\n                return yield* this.parseLineStart();\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel = 1;\n                return 'flow';\n            case '}':\n            case ']':\n                // this is an error\n                yield* this.pushCount(1);\n                return 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'doc';\n            case '\"':\n            case \"'\":\n                return yield* this.parseQuotedScalar();\n            case '|':\n            case '>':\n                n += yield* this.parseBlockScalarHeader();\n                n += yield* this.pushSpaces(true);\n                yield* this.pushCount(line.length - n);\n                yield* this.pushNewline();\n                return yield* this.parseBlockScalar();\n            default:\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseFlowCollection() {\n        let nl, sp;\n        let indent = -1;\n        do {\n            nl = yield* this.pushNewline();\n            if (nl > 0) {\n                sp = yield* this.pushSpaces(false);\n                this.indentValue = indent = sp;\n            }\n            else {\n                sp = 0;\n            }\n            sp += yield* this.pushSpaces(true);\n        } while (nl + sp > 0);\n        const line = this.getLine();\n        if (line === null)\n            return this.setNext('flow');\n        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||\n            (indent === 0 &&\n                (line.startsWith('---') || line.startsWith('...')) &&\n                isEmpty(line[3]))) {\n            // Allowing for the terminal ] or } at the same (rather than greater)\n            // indent level as the initial [ or { is technically invalid, but\n            // failing here would be surprising to users.\n            const atFlowEndMarker = indent === this.indentNext - 1 &&\n                this.flowLevel === 1 &&\n                (line[0] === ']' || line[0] === '}');\n            if (!atFlowEndMarker) {\n                // this is an error\n                this.flowLevel = 0;\n                yield FLOW_END;\n                return yield* this.parseLineStart();\n            }\n        }\n        let n = 0;\n        while (line[n] === ',') {\n            n += yield* this.pushCount(1);\n            n += yield* this.pushSpaces(true);\n            this.flowKey = false;\n        }\n        n += yield* this.pushIndicators();\n        switch (line[n]) {\n            case undefined:\n                return 'flow';\n            case '#':\n                yield* this.pushCount(line.length - n);\n                return 'flow';\n            case '{':\n            case '[':\n                yield* this.pushCount(1);\n                this.flowKey = false;\n                this.flowLevel += 1;\n                return 'flow';\n            case '}':\n            case ']':\n                yield* this.pushCount(1);\n                this.flowKey = true;\n                this.flowLevel -= 1;\n                return this.flowLevel ? 'flow' : 'doc';\n            case '*':\n                yield* this.pushUntil(isNotAnchorChar);\n                return 'flow';\n            case '\"':\n            case \"'\":\n                this.flowKey = true;\n                return yield* this.parseQuotedScalar();\n            case ':': {\n                const next = this.charAt(1);\n                if (this.flowKey || isEmpty(next) || next === ',') {\n                    this.flowKey = false;\n                    yield* this.pushCount(1);\n                    yield* this.pushSpaces(true);\n                    return 'flow';\n                }\n            }\n            // fallthrough\n            default:\n                this.flowKey = false;\n                return yield* this.parsePlainScalar();\n        }\n    }\n    *parseQuotedScalar() {\n        const quote = this.charAt(0);\n        let end = this.buffer.indexOf(quote, this.pos + 1);\n        if (quote === \"'\") {\n            while (end !== -1 && this.buffer[end + 1] === \"'\")\n                end = this.buffer.indexOf(\"'\", end + 2);\n        }\n        else {\n            // double-quote\n            while (end !== -1) {\n                let n = 0;\n                while (this.buffer[end - 1 - n] === '\\\\')\n                    n += 1;\n                if (n % 2 === 0)\n                    break;\n                end = this.buffer.indexOf('\"', end + 1);\n            }\n        }\n        // Only looking for newlines within the quotes\n        const qb = this.buffer.substring(0, end);\n        let nl = qb.indexOf('\\n', this.pos);\n        if (nl !== -1) {\n            while (nl !== -1) {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = qb.indexOf('\\n', cs);\n            }\n            if (nl !== -1) {\n                // this is an error caused by an unexpected unindent\n                end = nl - (qb[nl - 1] === '\\r' ? 2 : 1);\n            }\n        }\n        if (end === -1) {\n            if (!this.atEnd)\n                return this.setNext('quoted-scalar');\n            end = this.buffer.length;\n        }\n        yield* this.pushToIndex(end + 1, false);\n        return this.flowLevel ? 'flow' : 'doc';\n    }\n    *parseBlockScalarHeader() {\n        this.blockScalarIndent = -1;\n        this.blockScalarKeep = false;\n        let i = this.pos;\n        while (true) {\n            const ch = this.buffer[++i];\n            if (ch === '+')\n                this.blockScalarKeep = true;\n            else if (ch > '0' && ch <= '9')\n                this.blockScalarIndent = Number(ch) - 1;\n            else if (ch !== '-')\n                break;\n        }\n        return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#');\n    }\n    *parseBlockScalar() {\n        let nl = this.pos - 1; // may be -1 if this.pos === 0\n        let indent = 0;\n        let ch;\n        loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) {\n            switch (ch) {\n                case ' ':\n                    indent += 1;\n                    break;\n                case '\\n':\n                    nl = i;\n                    indent = 0;\n                    break;\n                case '\\r': {\n                    const next = this.buffer[i + 1];\n                    if (!next && !this.atEnd)\n                        return this.setNext('block-scalar');\n                    if (next === '\\n')\n                        break;\n                } // fallthrough\n                default:\n                    break loop;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('block-scalar');\n        if (indent >= this.indentNext) {\n            if (this.blockScalarIndent === -1)\n                this.indentNext = indent;\n            else {\n                this.indentNext =\n                    this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);\n            }\n            do {\n                const cs = this.continueScalar(nl + 1);\n                if (cs === -1)\n                    break;\n                nl = this.buffer.indexOf('\\n', cs);\n            } while (nl !== -1);\n            if (nl === -1) {\n                if (!this.atEnd)\n                    return this.setNext('block-scalar');\n                nl = this.buffer.length;\n            }\n        }\n        // Trailing insufficiently indented tabs are invalid.\n        // To catch that during parsing, we include them in the block scalar value.\n        let i = nl + 1;\n        ch = this.buffer[i];\n        while (ch === ' ')\n            ch = this.buffer[++i];\n        if (ch === '\\t') {\n            while (ch === '\\t' || ch === ' ' || ch === '\\r' || ch === '\\n')\n                ch = this.buffer[++i];\n            nl = i - 1;\n        }\n        else if (!this.blockScalarKeep) {\n            do {\n                let i = nl - 1;\n                let ch = this.buffer[i];\n                if (ch === '\\r')\n                    ch = this.buffer[--i];\n                const lastChar = i; // Drop the line if last char not more indented\n                while (ch === ' ')\n                    ch = this.buffer[--i];\n                if (ch === '\\n' && i >= this.pos && i + 1 + indent > lastChar)\n                    nl = i;\n                else\n                    break;\n            } while (true);\n        }\n        yield SCALAR;\n        yield* this.pushToIndex(nl + 1, true);\n        return yield* this.parseLineStart();\n    }\n    *parsePlainScalar() {\n        const inFlow = this.flowLevel > 0;\n        let end = this.pos - 1;\n        let i = this.pos - 1;\n        let ch;\n        while ((ch = this.buffer[++i])) {\n            if (ch === ':') {\n                const next = this.buffer[i + 1];\n                if (isEmpty(next) || (inFlow && flowIndicatorChars.has(next)))\n                    break;\n                end = i;\n            }\n            else if (isEmpty(ch)) {\n                let next = this.buffer[i + 1];\n                if (ch === '\\r') {\n                    if (next === '\\n') {\n                        i += 1;\n                        ch = '\\n';\n                        next = this.buffer[i + 1];\n                    }\n                    else\n                        end = i;\n                }\n                if (next === '#' || (inFlow && flowIndicatorChars.has(next)))\n                    break;\n                if (ch === '\\n') {\n                    const cs = this.continueScalar(i + 1);\n                    if (cs === -1)\n                        break;\n                    i = Math.max(i, cs - 2); // to advance, but still account for ' #'\n                }\n            }\n            else {\n                if (inFlow && flowIndicatorChars.has(ch))\n                    break;\n                end = i;\n            }\n        }\n        if (!ch && !this.atEnd)\n            return this.setNext('plain-scalar');\n        yield SCALAR;\n        yield* this.pushToIndex(end + 1, true);\n        return inFlow ? 'flow' : 'doc';\n    }\n    *pushCount(n) {\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos += n;\n            return n;\n        }\n        return 0;\n    }\n    *pushToIndex(i, allowEmpty) {\n        const s = this.buffer.slice(this.pos, i);\n        if (s) {\n            yield s;\n            this.pos += s.length;\n            return s.length;\n        }\n        else if (allowEmpty)\n            yield '';\n        return 0;\n    }\n    *pushIndicators() {\n        switch (this.charAt(0)) {\n            case '!':\n                return ((yield* this.pushTag()) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '&':\n                return ((yield* this.pushUntil(isNotAnchorChar)) +\n                    (yield* this.pushSpaces(true)) +\n                    (yield* this.pushIndicators()));\n            case '-': // this is an error\n            case '?': // this is an error outside flow collections\n            case ':': {\n                const inFlow = this.flowLevel > 0;\n                const ch1 = this.charAt(1);\n                if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {\n                    if (!inFlow)\n                        this.indentNext = this.indentValue + 1;\n                    else if (this.flowKey)\n                        this.flowKey = false;\n                    return ((yield* this.pushCount(1)) +\n                        (yield* this.pushSpaces(true)) +\n                        (yield* this.pushIndicators()));\n                }\n            }\n        }\n        return 0;\n    }\n    *pushTag() {\n        if (this.charAt(1) === '<') {\n            let i = this.pos + 2;\n            let ch = this.buffer[i];\n            while (!isEmpty(ch) && ch !== '>')\n                ch = this.buffer[++i];\n            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);\n        }\n        else {\n            let i = this.pos + 1;\n            let ch = this.buffer[i];\n            while (ch) {\n                if (tagChars.has(ch))\n                    ch = this.buffer[++i];\n                else if (ch === '%' &&\n                    hexDigits.has(this.buffer[i + 1]) &&\n                    hexDigits.has(this.buffer[i + 2])) {\n                    ch = this.buffer[(i += 3)];\n                }\n                else\n                    break;\n            }\n            return yield* this.pushToIndex(i, false);\n        }\n    }\n    *pushNewline() {\n        const ch = this.buffer[this.pos];\n        if (ch === '\\n')\n            return yield* this.pushCount(1);\n        else if (ch === '\\r' && this.charAt(1) === '\\n')\n            return yield* this.pushCount(2);\n        else\n            return 0;\n    }\n    *pushSpaces(allowTabs) {\n        let i = this.pos - 1;\n        let ch;\n        do {\n            ch = this.buffer[++i];\n        } while (ch === ' ' || (allowTabs && ch === '\\t'));\n        const n = i - this.pos;\n        if (n > 0) {\n            yield this.buffer.substr(this.pos, n);\n            this.pos = i;\n        }\n        return n;\n    }\n    *pushUntil(test) {\n        let i = this.pos;\n        let ch = this.buffer[i];\n        while (!test(ch))\n            ch = this.buffer[++i];\n        return yield* this.pushToIndex(i, false);\n    }\n}\n\nexport { Lexer };\n","import * as TSU from \"@panyam/tsutils\";\nimport { ZERO, Atom, LeafAtom, Group } from \"./core\";\n\n/**\n * Represents an item to be positioned in collision-based layout.\n */\nexport interface CollisionLayoutItem {\n  /** Time offset as a fraction (numerator/denominator) */\n  timeOffset: TSU.Num.Fraction;\n  /** Duration of this item */\n  duration: TSU.Num.Fraction;\n  /** Width of pre-embellishments (extends left from glyph position) */\n  glyphOffset: number;\n  /** Minimum width of the item (includes all embellishments and glyph) */\n  minWidth: number;\n}\n\n/**\n * Result of collision-based layout for a single item.\n */\nexport interface CollisionLayoutResult {\n  /** The calculated x position for the item */\n  x: number;\n  /** Whether the item was pushed right due to collision */\n  wasCollision: boolean;\n}\n\n/**\n * Computes collision-based positions for a sequence of items within a container.\n *\n * ## Algorithm\n *\n * 1. Calculate ideal glyph position: `glyphX = (timeOffset / totalDuration) * containerWidth`\n * 2. Pre-embellishments extend left: `realX = glyphX - glyphOffset`\n * 3. Collision check: if `realX < prevItemEndX`, then `realX = prevItemEndX`\n * 4. Track: `prevItemEndX = realX + minWidth`\n *\n * @param items Items to position (must be in time order)\n * @param totalDuration Total duration of all items\n * @param containerWidth Width of the container to position items within\n * @returns Array of positions for each item\n */\nexport function computeCollisionLayout(\n  items: CollisionLayoutItem[],\n  totalDuration: TSU.Num.Fraction,\n  containerWidth: number,\n): CollisionLayoutResult[] {\n  const results: CollisionLayoutResult[] = [];\n  let prevItemEndX = 0;\n  let currTime = ZERO;\n\n  for (const item of items) {\n    // 1. Calculate ideal glyph position based on time offset\n    const glyphX = totalDuration.isZero ? 0 : currTime.timesNum(containerWidth).divby(totalDuration).floor;\n\n    // 2. Pre-embellishments extend left from glyph position\n    let realX = glyphX - item.glyphOffset;\n\n    // 3. Collision check: push right if overlapping previous item\n    const wasCollision = realX < prevItemEndX;\n    if (wasCollision) {\n      realX = prevItemEndX;\n    }\n\n    results.push({ x: realX, wasCollision });\n\n    // 4. Track end position for next collision check\n    prevItemEndX = realX + item.minWidth;\n\n    currTime = currTime.plus(item.duration);\n  }\n\n  return results;\n}\n\n/**\n * Base class for all renderable objects.\n *\n * Shape caches properties like bounding boxes to improve performance,\n * since bounding box calculations can be expensive. This also allows\n * testing layouts and positioning without worrying about implementation details.\n */\nexport abstract class Shape {\n  private static idCounter = 0;\n  readonly shapeId: number = Shape.idCounter++;\n\n  /**\n   * Note that x and y coordinates are not always the x and y coordinates\n   * of the bounding box.\n   * E.g., a circle's x and y coordinates are its center point and not the\n   * top left corner.\n   * These \"main\" coordinates are referred to as control coordinates.\n   */\n  protected _x: number | null = null;\n  protected _y: number | null = null;\n  protected _width: number | null = null;\n  protected _height: number | null = null;\n  protected _bbox: TSU.Geom.Rect;\n  protected _minSize: TSU.Geom.Size;\n  protected parentShape: Shape | null = null;\n  /** Child shapes contained within this shape */\n  children: Shape[] = [];\n\n  /**\n   * Gets the bounding box of this shape.\n   * Calculates it if it hasn't been calculated yet.\n   */\n  get bbox(): TSU.Geom.Rect {\n    if (!this._bbox) {\n      this._bbox = this.refreshBBox();\n    }\n    return this._bbox;\n  }\n\n  /**\n   * Gets the minimum size of this shape.\n   * This is usually the size of the bounding box.\n   */\n  get minSize(): TSU.Geom.Size {\n    if (!this._minSize) {\n      this._minSize = this.refreshMinSize();\n    }\n    return this._minSize;\n  }\n\n  /**\n   * Refreshes the bounding box of this shape.\n   * Called when the shape knows the bbox it is tracking cannot be trusted\n   * and has to be refreshed by calling native methods.\n   * @returns The refreshed bounding box\n   */\n  protected abstract refreshBBox(): TSU.Geom.Rect;\n\n  /**\n   * Refreshes the minimum size of this shape.\n   * @returns The refreshed minimum size\n   */\n  protected abstract refreshMinSize(): TSU.Geom.Size;\n\n  /**\n   * Updates the bounds of this shape.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected abstract updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null];\n\n  /**\n   * Invalidates the cached bounds of this shape.\n   * Forces recalculation of bounding box and minimum size.\n   */\n  invalidateBounds(): void {\n    this._minSize = null as unknown as TSU.Geom.Size;\n    this._bbox = null as unknown as TSU.Geom.Rect;\n  }\n\n  /**\n   * Sets the bounds of this shape.\n   *\n   * Note that null and NaN are valid values and mean the following:\n   * - null: Don't change the value\n   * - NaN: Set the value to null (use the bounding box's value)\n   *\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @param applyLayout Whether to apply layout immediately\n   * @returns The updated bounds values\n   */\n  setBounds(\n    x: number | null,\n    y: number | null,\n    w: number | null,\n    h: number | null,\n    applyLayout = false,\n  ): [number | null, number | null, number | null, number | null] {\n    if (x != null) {\n      if (isNaN(x)) {\n        this._x = null;\n      } else {\n        this._x = x;\n      }\n    }\n    if (y != null) {\n      if (isNaN(y)) {\n        this._y = null;\n      } else {\n        this._y = y;\n      }\n    }\n    if (w != null) {\n      if (isNaN(w)) {\n        this._width = null;\n      } else {\n        this._width = w;\n      }\n    }\n    if (h != null) {\n      if (isNaN(h)) {\n        this._height = null;\n      } else {\n        this._height = h;\n      }\n    }\n    const [nx, ny, nw, nh] = this.updateBounds(x, y, w, h);\n    if (nx != null) {\n      if (isNaN(nx)) {\n        this._x = null;\n      } else {\n        this._x = nx;\n      }\n    }\n    if (ny != null) {\n      if (isNaN(ny)) {\n        this._y = null;\n      } else {\n        this._y = ny;\n      }\n    }\n    if (nw != null) {\n      if (isNaN(nw)) {\n        this._width = null;\n      } else {\n        this._width = nw;\n      }\n    }\n    if (nh != null) {\n      if (isNaN(nh)) {\n        this._height = null;\n      } else {\n        this._height = nh;\n      }\n    }\n    if (applyLayout) this.refreshLayout();\n    // this.resetBBox();\n    return [nx, ny, nw, nh];\n  }\n\n  /**\n   * Checks if this shape has an explicit x coordinate.\n   */\n  get hasX(): boolean {\n    return this._x != null && !isNaN(this._x);\n  }\n\n  /**\n   * Checks if this shape has an explicit y coordinate.\n   */\n  get hasY(): boolean {\n    return this._y != null && !isNaN(this._y);\n  }\n\n  /**\n   * Checks if this shape has an explicit width.\n   */\n  get hasWidth(): boolean {\n    return this._width != null && !isNaN(this._width);\n  }\n\n  /**\n   * Checks if this shape has an explicit height.\n   */\n  get hasHeight(): boolean {\n    return this._height != null && !isNaN(this._height);\n  }\n\n  /**\n   * Gets the x coordinate within the parent's coordinate system.\n   */\n  get x(): number {\n    return this._x || 0;\n  }\n\n  /**\n   * Sets the x coordinate within the parent's coordinate system.\n   */\n  set x(x: number | null) {\n    // Here a manual x is being set - how does this interfere with the bounding box?\n    // We should _x to the new value to indicate a manual value was set.\n    // and reset bbox so that based on this x a new bbox may need to be calculated\n    this.setBounds(x == null ? NaN : x, null, null, null);\n  }\n\n  /**\n   * Gets the y coordinate within the parent's coordinate system.\n   */\n  get y(): number {\n    if (this._y != null) return this._y;\n    return 0; // this.bbox.y;\n  }\n\n  /**\n   * Sets the y coordinate within the parent's coordinate system.\n   */\n  set y(y: number | null) {\n    this.setBounds(null, y == null ? NaN : y, null, null);\n  }\n\n  /**\n   * Gets the width of this shape.\n   */\n  get width(): number {\n    if (this._width != null) return this._width;\n    return 0; // this.bbox.width;\n  }\n\n  /**\n   * Sets the width of this shape.\n   */\n  set width(w: number | null) {\n    this.setBounds(null, null, w == null ? NaN : w, null);\n  }\n\n  /**\n   * Gets the height of this shape.\n   */\n  get height(): number {\n    if (this._height != null) return this._height;\n    return 0; // this.bbox.height;\n  }\n\n  /**\n   * Sets the height of this shape.\n   */\n  set height(h: number | null) {\n    this.setBounds(null, null, null, h == null ? NaN : h);\n  }\n\n  /**\n   * Refreshes the layout of this shape.\n   * Called when bounds or other properties have changed to give the shape an\n   * opportunity to layout its children. For shapes with no children this is a no-op.\n   */\n  refreshLayout(): void {\n    // throw new Error(\"Implement this\");\n  }\n}\n\n/**\n * Represents an embellishment applied to a musical element.\n */\nexport abstract class Embelishment extends Shape {}\n\n/**\n * A shape that wraps an SVG element.\n * ElementShape provides the base class for all shapes that are rendered as SVG elements.\n */\nexport class ElementShape<T extends SVGGraphicsElement = SVGGraphicsElement> extends Shape {\n  /**\n   * Creates a new ElementShape.\n   * @param element The SVG element this shape wraps\n   */\n  constructor(public readonly element: T) {\n    super();\n  }\n\n  /**\n   * Refreshes the bounding box of this element.\n   * @returns The refreshed bounding box\n   */\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.element);\n  }\n\n  /**\n   * Refreshes the minimum size of this element.\n   * @returns The refreshed minimum size\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    return TSU.DOM.svgBBox(this.element);\n  }\n\n  /**\n   * Updates the bounds of this element.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  /**\n   * Refreshes the layout of this element.\n   * Updates the element's attributes based on the shape's properties.\n   */\n  refreshLayout(): void {\n    if (this.hasX) this.element.setAttribute(\"x\", \"\" + this._x);\n    if (this.hasY) this.element.setAttribute(\"y\", \"\" + this._y);\n  }\n}\n\n/**\n * Base class for views that represent atoms in the notation.\n * AtomView provides the visual representation of an atom.\n */\nexport abstract class AtomView extends Shape {\n  /** Nesting depth of this atom in the structure */\n  depth = 0;\n  /** Index of the role containing this atom */\n  roleIndex = 0;\n\n  // LayoutMetrics for the AtomView so all atomviews laid out on the\n  // same baseline will show up aligned vertically\n  /** Baseline position for vertical alignment */\n  baseline: number;\n  /** Ascent (space above baseline) */\n  ascent: number;\n  /** Descent (space below baseline) */\n  descent: number;\n  /** Height of capital letters */\n  capHeight: number;\n  /** Space between lines */\n  leading: number;\n\n  /**\n   * Checks if this atom view represents a leaf atom.\n   */\n  abstract isLeaf(): boolean;\n\n  abstract get totalDuration(): TSU.Num.Fraction;\n\n  /**\n   * Returns the horizontal offset from the atom's origin to where the note glyph starts.\n   * This accounts for left embellishments that appear before the note.\n   * Used by GroupView to align note glyphs at their correct time positions.\n   *\n   * Default is 0 (glyph starts at origin). Subclasses with left embellishments\n   * should override to return the width of left-side decorations.\n   */\n  get glyphOffset(): number {\n    return 0;\n  }\n\n  /**\n   * Creates the SVG elements needed for this atom view.\n   * @param parent The parent SVG element to attach to\n   */\n  abstract createElements(parent: SVGGraphicsElement): void;\n}\n\n/**\n * A view for leaf atoms (those that cannot contain other atoms).\n */\nexport abstract class LeafAtomView extends AtomView {\n  /**\n   * Creates a new LeafAtomView.\n   * @param leafAtom The leaf atom this view represents\n   */\n  constructor(public leafAtom: LeafAtom) {\n    super();\n  }\n\n  /**\n   * Leaf atom views always return true for isLeaf().\n   */\n  isLeaf(): boolean {\n    return true;\n  }\n\n  /**\n   * Gets a unique identifier for this view based on the atom's UUID.\n   */\n  get viewId(): number {\n    return this.leafAtom.uuid;\n  }\n\n  /**\n   * Returns the total duration of the atom rendered by this view.\n   */\n  get totalDuration(): TSU.Num.Fraction {\n    return this.leafAtom.duration;\n  }\n}\n\n/**\n * A view for group atoms that contain multiple child atoms.\n */\nexport abstract class GroupView extends AtomView {\n  /** Space between atoms in this group */\n  protected atomSpacing: number;\n  /** The SVG group element for this view */\n  groupElement: SVGGElement;\n  /** Views for the atoms in this group */\n  protected atomViews: AtomView[] = [];\n  private _embelishments: Embelishment[];\n  /** Whether this group represents notes by default */\n  defaultToNotes = true;\n  /** Whether this view needs layout */\n  needsLayout = true;\n  /** Scale factor for this group */\n  scaleFactor = 1.0;\n  /**\n   * When true, shows continuation markers (\",\") for atoms with duration > 1\n   * instead of just leaving empty space.\n   * Disabled by default as group bracket lines provide clearer visual boundaries.\n   */\n  showContinuationMarkers = false;\n  /** SVG elements for continuation markers */\n  protected continuationMarkerElements: SVGTextElement[] = [];\n  /** Actual content width after layout (position of last atom + its width) */\n  contentWidth = 0;\n\n  /**\n   * Creates a new GroupView.\n   * @param group The group atom this view represents\n   * @param config Optional configuration object\n   */\n  constructor(\n    public group: Group,\n    config?: any,\n  ) {\n    super();\n    this.atomSpacing = 2;\n    this.setStyles(config || {});\n  }\n\n  /**\n   * Returns the total duration of the group rendered by this view.\n   * This returns the group's actual duration (accounting for scaling),\n   * not the raw sum of child durations.\n   */\n  get totalDuration(): TSU.Num.Fraction {\n    return this.group.duration;\n  }\n\n  /**\n   * Creates the SVG elements needed for this group view.\n   * @param parent The parent SVG element to attach to\n   */\n  createElements(parent: SVGGraphicsElement): void {\n    this.groupElement = TSU.DOM.createSVGNode(\"g\", {\n      parent: parent,\n      attrs: {\n        class: \"groupViewRoot\",\n        id: \"groupViewRoot\" + this.group.uuid,\n      },\n    });\n\n    // now create child atom views for each atom in this Group\n    for (const atom of this.group.atoms.values()) {\n      const atomView = this.createAtomView(atom);\n      this.atomViews.push(atomView);\n    }\n    this.invalidateBounds();\n  }\n\n  /**\n   * Group views always return false for isLeaf().\n   */\n  isLeaf(): boolean {\n    return false;\n  }\n\n  /**\n   * Refreshes the bounding box of this group.\n   * @returns The refreshed bounding box\n   */\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.groupElement);\n  }\n\n  /**\n   * Refreshes the minimum size of this group using duration-based width calculation.\n   *\n   * ## Duration-Based Width Algorithm\n   *\n   * This algorithm ensures atoms with extended durations receive proportionally\n   * more horizontal space. For example, with `\\beatDuration(4)` and input `S 2 R G M`:\n   * - S has duration 1, R has duration 2, G has duration 1\n   * - R should visually occupy twice the horizontal space of S or G\n   *\n   * ### Algorithm Steps:\n   *\n   * 1. **Calculate width per duration unit**: For each atom, compute the visual width\n   *    needed per unit of duration: `(visualWidth + spacing) / duration`\n   *\n   * 2. **Find maximum**: Take the maximum width-per-duration across all atoms.\n   *    This ensures every atom has enough space for its visual content.\n   *\n   * 3. **Scale by total duration**: Multiply the max width-per-duration by the\n   *    group's total duration to get the final group width.\n   *\n   * ### Example:\n   * ```\n   * Atoms: S(dur=1, width=10px), R(dur=2, width=10px), G(dur=1, width=10px)\n   * Spacing: 5px\n   *\n   * Width per duration:\n   *   S: (10 + 5) / 1 = 15 px/unit\n   *   R: (10 + 5) / 2 = 7.5 px/unit\n   *   G: (10 + 5) / 1 = 15 px/unit\n   *\n   * Max width per duration: 15 px/unit\n   * Total duration: 1 + 2 + 1 = 4 units\n   * Group width: 15 * 4 = 60px\n   *\n   * Positioning:\n   *   S at x=0 (time 0/4 * 60 = 0)\n   *   R at x=15 (time 1/4 * 60 = 15)\n   *   G at x=45 (time 3/4 * 60 = 45)\n   * ```\n   *\n   * @returns The refreshed minimum size\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    let maxHeight = 0;\n\n    // Step 1: Calculate width per duration unit for each atom\n    let minWidthPerDuration = 0;\n    this.atomViews.forEach((av) => {\n      const ms = av.minSize;\n      const dur = av.totalDuration;\n      if (!dur.isZero) {\n        const durValue = dur.num / dur.den;\n        const widthPerDur = (ms.width + this.atomSpacing) / durValue;\n        // Step 2: Track maximum width per duration\n        minWidthPerDuration = Math.max(minWidthPerDuration, widthPerDur);\n      }\n      maxHeight = Math.max(maxHeight, ms.height);\n    });\n\n    // Step 3: Scale by total duration\n    const totalDuration = this.group.totalChildDuration;\n    const totalDurValue = totalDuration.num / totalDuration.den;\n    // Subtract one atomSpacing since we don't need spacing after the last atom\n    const totalWidth = Math.max(0, minWidthPerDuration * totalDurValue - this.atomSpacing);\n\n    return new TSU.Geom.Size(totalWidth * this.scaleFactor, maxHeight * this.scaleFactor);\n  }\n\n  /**\n   * Creates an atom view for a specific atom.\n   * @param atom The atom to create a view for\n   * @returns The created atom view\n   */\n  abstract createAtomView(atom: Atom): AtomView;\n\n  /**\n   * Updates the bounds of this group.\n   * @param x New x coordinate, or null to keep current value\n   * @param y New y coordinate, or null to keep current value\n   * @param w New width, or null to keep current value\n   * @param h New height, or null to keep current value\n   * @returns The updated bounds values\n   */\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  /**\n   * Refreshes the layout of this group using collision-based positioning.\n   *\n   * ## Collision-Based Layout Algorithm\n   *\n   * Atoms are positioned using time-based positioning with collision avoidance.\n   * Each atom starts at its ideal time-based position, but is pushed right if\n   * it would overlap with the previous atom (including embellishments).\n   *\n   * ### Algorithm:\n   * ```\n   * 1. Calculate ideal glyph position: glyphX = (time / totalDuration) * groupWidth\n   * 2. Pre-embellishments extend left: realX = glyphX - preEmbellishmentWidth\n   * 3. Collision check: if (realX < prevNoteEndX) realX = prevNoteEndX\n   * 4. Position the atom at realX\n   * 5. Track: prevNoteEndX = realX + atom.minSize.width\n   * ```\n   *\n   * ### Width Source Priority:\n   *\n   * 1. **Column width** (preferred): If width was set via `setBounds()` from the\n   *    grid layout system (ColAlign), use that width. This enables global alignment\n   *    across all beats in the same column.\n   *\n   * 2. **Minimum size**: Fall back to `minSize.width` calculated by `refreshMinSize()`.\n   *\n   * ### Continuation Markers:\n   *\n   * When `showContinuationMarkers` is true (default), atoms with duration > 1\n   * will have \",\" markers rendered at each additional time slot. For example,\n   * an atom with duration 2 will show \"R ,\" instead of \"R   \".\n   *\n   * ### Example (no collisions):\n   * ```\n   * Input: S R G M (equal duration, no embellishments)\n   * Group width: 60px, Total duration: 4 units\n   *\n   * Positioning:\n   *   S at x=0   (time 0/4 * 60 = 0)\n   *   R at x=15  (time 1/4 * 60 = 15)\n   *   G at x=30  (time 2/4 * 60 = 30)\n   *   M at x=45  (time 3/4 * 60 = 45)\n   * ```\n   *\n   * ### Example (with collision):\n   * ```\n   * Input: [Jaaru+S] R (S has 10px pre-embellishment, each atom 15px wide)\n   * Group width: 60px, Total duration: 2 units\n   *\n   * Without collision avoidance:\n   *   S.glyphX = 0, S.realX = 0 - 10 = -10 (clamped to 0)\n   *   R.glyphX = 30, R overlaps with S\n   *\n   * With collision avoidance:\n   *   S at x=0 (prevNoteEndX becomes 15)\n   *   R.glyphX = 30, R.realX = 30 - 0 = 30\n   *   30 >= 15, no collision, R at x=30\n   * ```\n   */\n  refreshLayout(): void {\n    let transform = \"translate(\" + this.x + \",\" + this.y + \")\";\n    if (this.scaleFactor < 1) {\n      transform += \" scale(\" + this.scaleFactor + \")\";\n    }\n    this.groupElement.setAttribute(\"transform\", transform);\n\n    // BASELINE ALIGNMENT: Position atoms at bottom of allocated height.\n    // This ensures atoms align across beats with different bracket heights.\n    // When beats in the same row have different content heights (e.g., due to\n    // nested group brackets), all beats get the same allocated height from the\n    // grid. By positioning content at the bottom, atom baselines align.\n    const unscaledContentHeight = this.minSize.height / this.scaleFactor;\n    const unscaledAllocatedHeight = this.hasHeight ? this.height / this.scaleFactor : unscaledContentHeight;\n    const currY = unscaledAllocatedHeight - unscaledContentHeight;\n\n    const totalDur = this.group.totalChildDuration;\n\n    // Width source priority: column width (for global alignment) > minSize\n    const unscaledMinWidth = this.minSize.width / this.scaleFactor;\n    const groupWidth = this.hasWidth ? this.width / this.scaleFactor : unscaledMinWidth;\n\n    // Clear existing continuation markers before re-rendering\n    this.clearContinuationMarkers();\n\n    // Position each atom using collision-based layout\n    // Atoms start at their time-based position, but are pushed right if they would\n    // overlap with the previous atom (including embellishments)\n    let currTime = ZERO;\n    let prevNoteEndX = 0;\n    this.atomViews.forEach((av, index) => {\n      // 1. Calculate ideal glyph position based on time offset\n      const glyphX = totalDur.isZero ? 0 : currTime.timesNum(groupWidth).divby(totalDur).floor;\n\n      // 2. Pre-embellishments extend left from glyph position\n      //    realX is where the atom origin should be placed\n      let realX = glyphX - av.glyphOffset;\n\n      // 3. Collision check: push right if overlapping previous atom\n      if (realX < prevNoteEndX) {\n        realX = prevNoteEndX;\n      }\n\n      // 4. Position the atom\n      av.setBounds(realX, currY, null, null, true);\n\n      // 5. Track end position for next collision check\n      // For groups, use contentWidth (actual content) instead of bbox.width (which may include extra space).\n      // For leaf atoms, use bbox.width.\n      const avWidth = (av as any).contentWidth || av.bbox.width;\n      prevNoteEndX = realX + avWidth;\n\n      // Render continuation markers for atoms with duration > 1\n      if (this.showContinuationMarkers && !totalDur.isZero) {\n        const atomDur = av.totalDuration;\n        const durValue = atomDur.num / atomDur.den;\n        if (durValue > 1) {\n          // Render one marker at each additional time slot within the atom's duration\n          const numMarkers = Math.floor(durValue) - 1;\n          for (let i = 1; i <= numMarkers; i++) {\n            // Marker time = currTime + (atomDuration * i / floor(duration))\n            const markerTime = currTime.plus(atomDur.timesNum(i).divbyNum(Math.floor(durValue)));\n            const markerX = markerTime.timesNum(groupWidth).divby(totalDur).floor;\n            this.renderContinuationMarker(markerX, currY);\n          }\n        }\n      }\n\n      currTime = currTime.plus(av.totalDuration);\n    });\n\n    // Track actual content width for bracket sizing\n    this.contentWidth = prevNoteEndX;\n\n    this.invalidateBounds();\n    for (const e of this.embelishments) e.refreshLayout();\n    this.invalidateBounds();\n  }\n\n  /**\n   * Clears all continuation marker elements.\n   */\n  protected clearContinuationMarkers(): void {\n    for (const el of this.continuationMarkerElements) {\n      el.remove();\n    }\n    this.continuationMarkerElements = [];\n  }\n\n  /**\n   * Renders a continuation marker (\",\") at the specified position.\n   * @param x X position for the marker\n   * @param y Y position for the marker\n   */\n  protected renderContinuationMarker(x: number, y: number): void {\n    const marker = TSU.DOM.createSVGNode(\"text\", {\n      parent: this.groupElement,\n      attrs: {\n        class: \"continuationMarker\",\n        x: x.toString(),\n        y: y.toString(),\n      },\n      text: \",\",\n    }) as SVGTextElement;\n    this.continuationMarkerElements.push(marker);\n  }\n\n  /**\n   * Gets the embellishments for this group.\n   */\n  get embelishments(): Embelishment[] {\n    if (!this._embelishments) {\n      this._embelishments = this.createEmbelishments();\n    }\n    return this._embelishments;\n  }\n\n  /**\n   * Creates the embellishments for this group.\n   * @returns An array of embellishments\n   */\n  protected createEmbelishments(): Embelishment[] {\n    return [];\n  }\n\n  /**\n   * Sets the styles for this group.\n   * @param config Style configuration object\n   */\n  setStyles(config: any): void {\n    if (\"atomSpacing\" in config) this.atomSpacing = config.atomSpacing;\n    if (\"showContinuationMarkers\" in config) this.showContinuationMarkers = config.showContinuationMarkers;\n    this.needsLayout = true;\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Note } from \"../core\";\nimport { BeatView } from \"../beatview\";\nimport { Embelishment, GroupView as GroupViewBase } from \"../shapes\";\nimport { LeafAtomView } from \"./atomviews\";\nimport { JaaruGamaka } from \"./gamakas\";\n\n/**\n * Embelishments specifically \"around\" a single atom view.\n */\nexport abstract class LeafAtomViewEmbelishment extends Embelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super();\n  }\n}\n\nexport class OctaveIndicator extends LeafAtomViewEmbelishment {\n  dotRadius = 1;\n  dotSpacing = 2.5;\n  dotsElem: SVGGElement;\n\n  constructor(\n    public readonly noteView: LeafAtomView,\n    public readonly note: Note,\n  ) {\n    super(noteView);\n    const rootElem = this.noteView.embRoot();\n    const numDots = Math.abs(note.octave);\n    this.dotsElem = TSU.DOM.createSVGNode(\"g\", {\n      doc: document,\n      parent: rootElem,\n      attrs: {\n        width: this.dotRadius * 2 * numDots + (numDots - 1) * this.dotSpacing,\n        height: this.dotRadius * 2,\n        source: \"atom\" + this.noteView.leafAtom.uuid,\n      },\n    });\n    let cx = 0;\n    for (let i = 0; i < numDots; i++) {\n      TSU.DOM.createSVGNode(\"circle\", {\n        doc: document,\n        parent: this.dotsElem,\n        attrs: {\n          cx: cx,\n          cy: 0,\n          r: this.dotRadius,\n          class: \"notation-octave-dot\",\n        },\n      });\n      cx += this.dotRadius + this.dotRadius + this.dotSpacing;\n    }\n  }\n\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.dotsElem);\n  }\n\n  protected refreshMinSize(): TSU.Geom.Size {\n    const numDots = Math.abs(this.note.octave);\n    return {\n      width: this.dotRadius * 2 * numDots + (numDots - 1) * this.dotSpacing,\n      height: this.dotRadius * 2,\n    };\n  }\n\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    _w: null | number,\n    _h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    if (x == null) x = this.x;\n    if (y == null) y = this.y;\n    // cannot set w/h\n    // this.bbox.x = x;\n    // this.bbox.y = y;\n    return [x, y, null, null];\n  }\n\n  refreshLayout(): void {\n    this.dotsElem.setAttribute(\"transform\", \"translate(\" + this.x + \",\" + this.y + \")\");\n  }\n}\n\n////////// Carnatic embelishments\nexport class LabelEmbelishment extends LeafAtomViewEmbelishment {\n  labelElem: SVGTextElement;\n  constructor(\n    public readonly label: string,\n    public readonly atomView: LeafAtomView,\n  ) {\n    super(atomView);\n    const rootElem = this.atomView.embRoot();\n    this.labelElem = TSU.DOM.createSVGNode(\"text\", {\n      doc: document,\n      parent: rootElem,\n      text: label,\n      attrs: {\n        source: \"atom\" + this.atomView.leafAtom.uuid,\n        class: \"notation-embelishment-label\",\n        \"dominant-baseline\": \"hanging\",\n      },\n    });\n  }\n\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.labelElem);\n  }\n\n  protected refreshMinSize(): TSU.Geom.Size {\n    return TSU.DOM.svgBBox(this.labelElem);\n  }\n\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  refreshLayout(): void {\n    this.labelElem.setAttribute(\"x\", \"\" + this.x);\n    this.labelElem.setAttribute(\"y\", \"\" + this.y);\n  }\n}\n\nexport class BeatStartLines extends Embelishment {\n  barSpacing = 10;\n  protected line: SVGLineElement;\n\n  constructor(\n    public readonly source: BeatView,\n    public readonly rootElement: SVGGraphicsElement,\n  ) {\n    super();\n    this.line = TSU.DOM.createSVGNode(\"line\", {\n      doc: document,\n      parent: this.rootElement,\n      attrs: {\n        class: \"bar-start-line\",\n      },\n    });\n  }\n\n  protected refreshBBox(): TSU.Geom.Rect {\n    return new TSU.Geom.Rect(0, 0, 0, 0);\n  }\n\n  protected refreshMinSize(): TSU.Geom.Size {\n    return new TSU.Geom.Rect(0, 0, 0, 0);\n  }\n\n  refreshLayout(): void {\n    const line = this.line;\n    const x = this.source.x - this.barSpacing;\n    line.setAttribute(\"x1\", \"\" + x);\n    line.setAttribute(\"x2\", \"\" + x);\n    const y = this.source.y + this.source.bbox.y;\n    const h = this.source.bbox.height;\n    line.setAttribute(\"y1\", \"\" + y);\n    line.setAttribute(\"y2\", \"\" + (y + h));\n  }\n\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, null, h];\n  }\n}\n\nexport class BeatEndLines extends Embelishment {\n  lineSpacing = 2;\n  protected lines: SVGLineElement[];\n\n  constructor(\n    public readonly source: BeatView,\n    public readonly rootElement: SVGGraphicsElement,\n    nLines = 1,\n  ) {\n    super();\n    this.lines = [];\n    for (let i = 0; i < nLines; i++) {\n      this.lines.push(\n        TSU.DOM.createSVGNode(\"line\", {\n          doc: document,\n          // parent: l2g,\n          parent: this.rootElement,\n          attrs: {\n            class: \"bar-end-line\",\n          },\n        }),\n      );\n    }\n  }\n\n  protected refreshBBox(): TSU.Geom.Rect {\n    return new TSU.Geom.Rect(0, 0, 0, 0);\n  }\n\n  protected refreshMinSize(): TSU.Geom.Size {\n    return new TSU.Geom.Rect(0, 0, 0, 0);\n  }\n\n  protected updatePosition(x: null | number, y: null | number): [number | null, number | null] {\n    return [x, y];\n  }\n\n  barSpacing = 0;\n\n  refreshLayout(): void {\n    // const x = this.source.width + this.barSpacing;\n    // const y = 0;\n    // const h = this.source.height;\n    const x = this.source.x + this.source.width + this.barSpacing;\n    const y = this.source.y + this.source.bbox.y;\n    const h = this.source.bbox.height;\n    let currX = x;\n    for (const line of this.lines) {\n      const lx = \"\" + currX;\n      line.setAttribute(\"x1\", lx);\n      line.setAttribute(\"x2\", lx);\n      currX += 4;\n    }\n    for (const line of this.lines) {\n      line.setAttribute(\"y1\", \"\" + y);\n      line.setAttribute(\"y2\", \"\" + (y + h));\n    }\n  }\n\n  protected updateBounds(\n    _x: null | number,\n    _y: null | number,\n    _w: null | number,\n    _h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [null, null, null, null];\n  }\n}\n\n/// Carnatic Embelishments\nexport class Kampitham extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"~\", atomView);\n  }\n}\n\nexport class Nokku extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"w\", atomView);\n  }\n}\n\nexport class Prathyagatham extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"∵\", atomView);\n  }\n}\nexport class Spuritham extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"∴\", atomView);\n  }\n}\nexport class Raavi extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"^\", atomView);\n  }\n}\nexport class Kandippu extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"✓\", atomView);\n  }\n}\n\nexport class Vaali extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"⌒\", atomView);\n  }\n}\nexport class Odukkal extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"x\", atomView);\n  }\n}\nexport class Orikkai extends LabelEmbelishment {\n  constructor(public readonly atomView: LeafAtomView) {\n    super(\"γ\", atomView);\n  }\n}\n\nexport class Jaaru extends LeafAtomViewEmbelishment {\n  pathElem: SVGPathElement;\n  constructor(\n    public readonly jaaru: JaaruGamaka,\n    public readonly atomView: LeafAtomView,\n  ) {\n    super(atomView);\n    // TODO - Create the \"fancier\" view\n    // for now represent this with just a slant line (like a slash)\n    const rootElem = this.atomView.embRoot();\n    this.pathElem = TSU.DOM.createSVGNode(\"path\", {\n      doc: document,\n      parent: rootElem,\n      attrs: {\n        source: \"atom\" + this.atomView.leafAtom.uuid,\n        class: \"notation-jaaru-path\",\n        d: this.pathAttribute(),\n      },\n    });\n  }\n\n  pathAttribute(x = 0): string {\n    const avbbox = this.atomView.glyph.minSize;\n    let y2 = 0;\n    const h2 = avbbox.height / 2;\n    const x2 = x + h2;\n    let y = this.atomView.y;\n    if (this.jaaru.ascending) {\n      y += avbbox.height;\n      y2 = y - h2;\n    } else {\n      y -= h2;\n      y2 = y + h2;\n    }\n    return [`M ${x} ${y}`, `Q ${x2} ${y} ${x2} ${y2}`].join(\" \");\n  }\n\n  protected refreshMinSize(): TSU.Geom.Size {\n    return TSU.DOM.svgBBox(this.pathElem);\n  }\n\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.pathElem);\n  }\n\n  protected updateBounds(\n    x: null | number,\n    _y: null | number,\n    _w: null | number,\n    _h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, null, null, null];\n  }\n\n  refreshLayout(): void {\n    this.pathElem.setAttribute(\"d\", this.pathAttribute(this.x));\n  }\n}\n\n/**\n * Position mode for GroupBracket - controls how the bracket interacts with embellishments.\n */\nexport type GroupBracketPositionMode = \"above-all\" | \"below-embellishments\" | \"separate-space\";\n\n/**\n * Renders a single bracket line as the top border of a GroupView container.\n * Each nested group gets its own bracket line, creating a visual effect where\n * atoms inside deeply nested groups appear to have multiple lines above them.\n *\n * For example, with notation `A B [ S R [ P D [ W X ] ] ]`:\n * - Group 1 (outermost) has 1 bracket line\n * - Group 2 has 1 bracket line (inside Group 1's bracket)\n * - Group 3 (innermost) has 1 bracket line (inside Groups 1 & 2's brackets)\n * - Atoms W X visually appear to have 3 lines above (cumulative effect)\n */\nexport class GroupBracket extends Embelishment {\n  private line: SVGLineElement | null = null;\n  private leftCircle: SVGCircleElement | null = null;\n  private rightCircle: SVGCircleElement | null = null;\n  private bracketGroup: SVGGElement | null = null;\n\n  // Configuration - exposed for experimentation\n  /** Distance above group content */\n  lineOffset = 2;\n  /** End circle radius */\n  circleRadius = 1.5;\n  /** How far line extends beyond group content on each side */\n  lineExtension = 2;\n\n  /**\n   * Position mode for embellishment interaction experimentation:\n   * - 'above-all': Bracket at very top, above all embellishments\n   * - 'below-embellishments': Bracket between glyphs and embellishments (default)\n   * - 'separate-space': Bracket in dedicated reserved space\n   */\n  positionMode: GroupBracketPositionMode = \"below-embellishments\";\n\n  constructor(public readonly groupView: GroupViewBase) {\n    super();\n\n    this.bracketGroup = TSU.DOM.createSVGNode(\"g\", {\n      doc: document,\n      parent: this.groupView.groupElement,\n      attrs: {\n        class: \"group-bracket\",\n        source: \"group\" + this.groupView.group.uuid,\n      },\n    });\n\n    this.line = TSU.DOM.createSVGNode(\"line\", {\n      doc: document,\n      parent: this.bracketGroup,\n      attrs: {\n        class: \"group-bracket-line\",\n      },\n    });\n\n    this.leftCircle = TSU.DOM.createSVGNode(\"circle\", {\n      doc: document,\n      parent: this.bracketGroup,\n      attrs: {\n        class: \"group-bracket-circle\",\n        r: String(this.circleRadius),\n      },\n    });\n\n    this.rightCircle = TSU.DOM.createSVGNode(\"circle\", {\n      doc: document,\n      parent: this.bracketGroup,\n      attrs: {\n        class: \"group-bracket-circle\",\n        r: String(this.circleRadius),\n      },\n    });\n  }\n\n  protected refreshBBox(): TSU.Geom.Rect {\n    if (!this.bracketGroup) return new TSU.Geom.Rect(0, 0, 0, 0);\n    return TSU.DOM.svgBBox(this.bracketGroup);\n  }\n\n  protected refreshMinSize(): TSU.Geom.Size {\n    // Single bracket line height contribution\n    return new TSU.Geom.Size(0, this.lineOffset + this.circleRadius);\n  }\n\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, w, h];\n  }\n\n  refreshLayout(): void {\n    if (!this.line || !this.leftCircle || !this.rightCircle) return;\n\n    const bbox = this.groupView.bbox;\n    // Use actual content width (not bbox which may include extra space)\n    const groupWidth = this.groupView.contentWidth || bbox.width;\n\n    // Calculate Y position based on position mode\n    let y: number;\n    switch (this.positionMode) {\n      case \"below-embellishments\":\n        // Position just above glyph content, below other embellishments\n        y = bbox.y + this.lineOffset - 2;\n        break;\n      case \"separate-space\":\n        // Use dedicated space at very top of group bbox\n        y = bbox.y - this.lineOffset;\n        break;\n      case \"above-all\":\n      default:\n        // Position above everything including embellishments\n        y = bbox.y - this.lineOffset;\n        break;\n    }\n\n    const x1 = -this.lineExtension;\n    const x2 = groupWidth + this.lineExtension;\n\n    this.line.setAttribute(\"x1\", String(x1));\n    this.line.setAttribute(\"y1\", String(y));\n    this.line.setAttribute(\"x2\", String(x2));\n    this.line.setAttribute(\"y2\", String(y));\n\n    this.leftCircle.setAttribute(\"cx\", String(x1));\n    this.leftCircle.setAttribute(\"cy\", String(y));\n    this.rightCircle.setAttribute(\"cx\", String(x2));\n    this.rightCircle.setAttribute(\"cy\", String(y));\n  }\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport { Atom, Group, Literal, AtomType, Note, Space, Syllable } from \"../core\";\nimport {\n  LeafAtomView as LeafAtomViewBase,\n  GroupView as GroupViewBase,\n  AtomView,\n  Embelishment,\n  ElementShape,\n} from \"../shapes\";\nimport {\n  OctaveIndicator,\n  Kampitham,\n  Nokku,\n  Spuritham,\n  Prathyagatham,\n  Orikkai,\n  Odukkal,\n  Raavi,\n  Kandippu,\n  Vaali,\n  Jaaru,\n  GroupBracket,\n} from \"./embelishments\";\nimport { GamakaType } from \"./gamakas\";\n\nexport class GroupView extends GroupViewBase {\n  /** Height reserved for bracket line (lineOffset + circleRadius + padding) */\n  static readonly BRACKET_HEIGHT = 8;\n\n  createAtomView(atom: Atom): AtomView {\n    // Propagate depth + 1 to child atoms\n    return createAtomView(this.groupElement, atom, this.defaultToNotes, 0.7, this.depth + 1);\n  }\n\n  /**\n   * Creates embellishments for this group, including the bracket line\n   * that serves as the top border of this group container.\n   */\n  protected createEmbelishments(): Embelishment[] {\n    const embelishments = super.createEmbelishments();\n    // Add bracket line for nested groups (depth >= 1)\n    if (this.depth >= 1) {\n      embelishments.push(new GroupBracket(this));\n    }\n    return embelishments;\n  }\n\n  /**\n   * Calculates the minimum size of this group, including space for the bracket line.\n   * The bracket line adds height for nested groups (depth >= 1).\n   */\n  protected refreshMinSize(): TSU.Geom.Size {\n    const baseSize = super.refreshMinSize();\n\n    // Add height for bracket line if this is a nested group\n    if (this.depth >= 1) {\n      return new TSU.Geom.Size(baseSize.width, baseSize.height + GroupView.BRACKET_HEIGHT * this.scaleFactor);\n    }\n\n    return baseSize;\n  }\n}\n\nexport abstract class LeafAtomView extends LeafAtomViewBase {\n  leftSlot: Embelishment[] = [];\n  topSlot: Embelishment[] = [];\n  rightSlot: Embelishment[] = [];\n  bottomSlot: Embelishment[] = [];\n  glyph: ElementShape;\n\n  // Spaces required before and after to accomodate for left and right slots\n  protected postSpacingSpan: SVGTSpanElement;\n  // Sometimes this.element may not be the root element if we need spacings\n  // the rootElement is the top of the chain\n  protected rootGroup: ElementShape;\n  protected rootText: ElementShape;\n\n  abstract get glyphLabel(): string;\n\n  protected refreshBBox(): TSU.Geom.Rect {\n    return TSU.DOM.svgBBox(this.rootGroup.element);\n  }\n\n  protected refreshMinSize(): TSU.Geom.Size {\n    const out = { ...this.rootText.minSize };\n    const totalWidth =\n      this.leftSlot.reduce((a, b) => a + b.minSize.width, 0) +\n      this.rightSlot.reduce((a, b) => a + b.minSize.width, 0) +\n      this.leftSlot.length + // Padding of 1\n      this.rightSlot.length; // Padding of 1\n    const totalHeight =\n      this.topSlot.reduce((a, b) => a + b.minSize.height, 0) +\n      this.bottomSlot.reduce((a, b) => a + b.minSize.height, 0);\n    out.width += totalWidth;\n    out.height += totalHeight;\n    // if (this.postSpacingSpan) out.width += this.postSpacingSpan.getBBox().width;\n    return out;\n  }\n\n  /**\n   * Returns the horizontal offset from the atom's origin to where the note glyph starts.\n   * This is the total width of left embellishments (e.g., Jaaru symbols).\n   */\n  get glyphOffset(): number {\n    return (\n      this.leftSlot.reduce((a, b) => a + b.minSize.width, 0) + this.leftSlot.length // Padding of 1 per embellishment\n    );\n  }\n\n  protected updateBounds(\n    x: null | number,\n    y: null | number,\n    w: null | number,\n    h: null | number,\n  ): [number | null, number | null, number | null, number | null] {\n    return [x, y, NaN, NaN];\n  }\n\n  protected layoutElements(): void {\n    // Lays out all the child elements locally\n    const textSize = this.rootText.minSize;\n    // assume text is at 0,0 and lay things around it\n\n    // now layout leftSlots\n    let currX = 0;\n    let currY = this.hasY ? this.y : 0;\n    // place left embelishments\n    for (const emb of this.leftSlot) {\n      emb.x = currX;\n      emb.refreshLayout();\n      currX += emb.minSize.width + 1;\n    }\n\n    // now place the text\n    const textX = currX;\n    this.rootText.x = currX;\n    this.rootText.refreshLayout();\n\n    // And right embelishments\n    currX += this.rootText.minSize.width;\n    for (const emb of this.rightSlot) {\n      emb.x = currX;\n      emb.refreshLayout();\n      currX += emb.minSize.width + 1;\n    }\n\n    // layout top and bottom if x or y has changed\n    const gminSize = this.glyph.minSize;\n\n    // top embelishments\n    const glyphX = textX + this.glyph.x;\n    const glyphY = this.glyph.y;\n    currY = glyphY - this.glyph.minSize.height + 5;\n    for (const emb of this.topSlot) {\n      const bb = emb.minSize;\n      emb.setBounds(glyphX + (gminSize.width - bb.width) / 2, currY - bb.height, null, null, true);\n      currY = emb.y;\n    }\n\n    // bottom embelishments\n    currY = glyphY + 7;\n    for (const emb of this.bottomSlot) {\n      const bb = emb.minSize;\n      emb.setBounds(glyphX + (gminSize.width - bb.width) / 2, currY, null, null, true);\n      currY = emb.y + bb.height;\n    }\n    this.invalidateBounds();\n  }\n\n  refreshLayout(): void {\n    // TODO - move this code out to refreshLayout?\n    // set the glyphs Y first so we can layout others\n    this.layoutElements();\n    this.rootGroup.element.setAttribute(\"transform\", \"translate(\" + this.x + \",\" + this.y + \")\");\n  }\n\n  protected addEmbelishment(slot: Embelishment[], emb: Embelishment): void {\n    slot.push(emb);\n    // this.addShape(emb);\n  }\n\n  /**\n   * Orders embelishments and creates their views.\n   */\n  orderEmbelishments(): void {\n    const atom = this.leafAtom;\n    if (atom.TYPE != AtomType.SYLLABLE && atom.TYPE != AtomType.NOTE) {\n      return;\n    }\n    const lit = atom as Literal;\n    if (lit.embelishments.length == 0) return;\n    for (const emb of lit.embelishments) {\n      switch (emb.type) {\n        case GamakaType.Kampitham:\n          this.addEmbelishment(this.topSlot, new Kampitham(this));\n          break;\n        case GamakaType.Nokku:\n          this.addEmbelishment(this.topSlot, new Nokku(this));\n          break;\n        case GamakaType.Spuritham:\n          this.addEmbelishment(this.topSlot, new Spuritham(this));\n          break;\n        case GamakaType.Prathyagatham:\n          this.addEmbelishment(this.topSlot, new Prathyagatham(this));\n          break;\n        case GamakaType.Orikkai:\n          this.addEmbelishment(this.topSlot, new Orikkai(this));\n          break;\n        case GamakaType.Odukkal:\n          this.addEmbelishment(this.topSlot, new Odukkal(this));\n          break;\n        case GamakaType.Aahaatam_Raavi:\n          this.addEmbelishment(this.topSlot, new Raavi(this));\n          break;\n        case GamakaType.Aahaatam_Kandippu:\n          this.addEmbelishment(this.topSlot, new Kandippu(this));\n          break;\n        case GamakaType.Vaali:\n          this.addEmbelishment(this.topSlot, new Vaali(this));\n          break;\n        case GamakaType.Jaaru_Eetra:\n        case GamakaType.Jaaru_Irakka:\n          this.addEmbelishment(this.leftSlot, new Jaaru(emb, this));\n          break;\n      }\n    }\n  }\n\n  embRoot(): SVGGraphicsElement {\n    return this.rootGroup.element;\n  }\n\n  needsRootElement(): boolean {\n    return true; // this.rightSlot.length > 0 || this.leafAtom.beforeRest;\n  }\n\n  createElements(parent: SVGGraphicsElement): void {\n    // Create the glyph element first before anything\n    // this allows embelishments to get early access to this element\n    this.createGlyphRoot(parent);\n    this.createGlyphElement();\n    // Order embelishments (without creating any views)\n    this.orderEmbelishments();\n    this.createPostSpacingElement();\n    this.invalidateBounds();\n  }\n\n  protected createGlyphRoot(parent: SVGGraphicsElement): void {\n    this.rootGroup = new ElementShape(\n      TSU.DOM.createSVGNode(\"g\", {\n        doc: document,\n        parent: parent,\n        attrs: {\n          atomid: this.leafAtom.uuid,\n          class: \"atomViewRootGroup\",\n          id: \"atomViewRootGroup\" + this.leafAtom.uuid,\n        },\n      }),\n    );\n    this.rootText = new ElementShape(\n      TSU.DOM.createSVGNode(\"text\", {\n        doc: document,\n        parent: this.rootGroup.element,\n        attrs: {\n          atomid: this.leafAtom.uuid,\n          class: \"atomViewTextRoot\",\n          id: \"atomViewTextRoot\" + this.leafAtom.uuid,\n        },\n      }),\n    );\n  }\n\n  protected createGlyphElement(): void {\n    const atom = this.leafAtom;\n    this.glyph = new ElementShape(\n      TSU.DOM.createSVGNode(\"tspan\", {\n        doc: document,\n        parent: this.rootText.element,\n        attrs: {\n          atomid: atom.uuid,\n          id: \"atomGlyph\" + atom.uuid,\n        },\n        text: this.glyphLabel, // + (note.beforeRest ? \" - \" : \" \"),\n      }),\n    );\n  }\n\n  protected createPostSpacingElement(): void {\n    if (this.leafAtom.beforeRest) {\n      this.postSpacingSpan = TSU.DOM.createSVGNode(\"tspan\", {\n        doc: document,\n        parent: this.rootText.element,\n        attrs: {\n          atomid: this.leafAtom.uuid,\n          id: \"postSpacing\" + this.leafAtom.uuid,\n        },\n        text: this.leafAtom.beforeRest ? \" - \" : \"  \",\n      });\n    }\n  }\n}\n\nclass SpaceView extends LeafAtomView {\n  get glyphLabel(): string {\n    if (this.space.isSilent) return \" \";\n    if (this.space.duration.isOne) return \",\";\n    if (this.space.duration.cmpNum(2) == 0) return \";\";\n    return \"_\";\n  }\n\n  get space(): Space {\n    return this.leafAtom as Space;\n  }\n}\n\nclass NoteView extends LeafAtomView {\n  protected shiftElement: SVGTSpanElement;\n  get glyphLabel(): string {\n    return this.note.value;\n  }\n\n  needsRootElement(): boolean {\n    return true; // this.note.shift == true || this.note.shift != 0 || super.needsRootElement();\n  }\n\n  protected createGlyphElement(): void {\n    super.createGlyphElement();\n    if (this.note.shift == true || this.note.shift != 0) {\n      this.shiftElement = TSU.DOM.createSVGNode(\"tspan\", {\n        doc: document,\n        parent: this.rootText.element,\n        attrs: {\n          atomid: this.note.uuid,\n          class: \"noteShiftTSpan\",\n          id: \"noteShift\" + this.note.uuid,\n          \"baseline-shift\": \"sub\",\n        },\n        text: (this.note.shift == true ? \"*\" : this.note.shift) + \" \",\n      });\n    }\n  }\n\n  protected moveGlyphToRoot(): void {\n    // super.moveGlyphToRoot();\n    if (this.shiftElement) {\n      this.rootGroup.element.appendChild(this.shiftElement);\n    }\n  }\n\n  orderEmbelishments(): void {\n    const note = this.note;\n    // create the embelishments if needed\n    if (note.octave > 0) {\n      this.topSlot.push(new OctaveIndicator(this, note));\n    } else if (this.note.octave < 0) {\n      this.bottomSlot.push(new OctaveIndicator(this, note));\n    }\n    super.orderEmbelishments();\n  }\n\n  get note(): Note {\n    return this.leafAtom as Note;\n  }\n}\n\nclass SyllableView extends LeafAtomView {\n  get glyphLabel(): string {\n    return this.syllable.value;\n  }\n\n  get syllable(): Syllable {\n    return this.leafAtom as Syllable;\n  }\n}\n\nexport function createAtomView(\n  parent: SVGGraphicsElement,\n  atom: Atom,\n  litDefaultsToNote = false,\n  groupViewScale = 1.0,\n  depth = 0,\n): AtomView {\n  let out: AtomView;\n  switch (atom.TYPE) {\n    // Dealing with leaf atoms\n    case AtomType.SPACE:\n      out = new SpaceView(atom as Space);\n      break;\n    case AtomType.SYLLABLE:\n      out = new SyllableView(atom as Syllable);\n      break;\n    case AtomType.NOTE:\n      out = new NoteView(atom as Note);\n      break;\n    case AtomType.LITERAL:\n      if (litDefaultsToNote) {\n        const lit = Note.fromLit(atom as Note);\n        out = new NoteView(lit);\n      } else {\n        const lit = Syllable.fromLit(atom as Syllable);\n        out = new SyllableView(lit);\n      }\n      break;\n    case AtomType.GROUP:\n      out = new GroupView(atom as Group);\n      (out as GroupView).defaultToNotes = litDefaultsToNote;\n      (out as GroupView).scaleFactor = groupViewScale;\n      break;\n    default:\n      // We should never get a group as we are iterating\n      // at leaf atom levels\n      throw new Error(\"Invalid atom type: \" + atom.TYPE);\n  }\n  out.depth = depth;\n  out.createElements(parent);\n  return out;\n}\n","import * as TSU from \"@panyam/tsutils\";\nimport * as TLEX from \"tlex\";\nimport { load as loadGrammar, TokenHandler } from \"./dsl\";\nimport { makeParseTable } from \"./ptables\";\nimport { Parser, ParseTable } from \"./lr\";\nimport { LRItemGraph } from \"./lritems\";\nimport { logParserDebug } from \"./debug\";\n\n/**\n * Configuration options for creating a parser.\n */\nexport interface ParserOptions {\n  /**\n   * Parser algorithm to use.\n   * - \"slr\": Simple LR - smallest tables, may have false conflicts\n   * - \"lalr\": Look-Ahead LR - default, good balance of power and size\n   * - \"lr1\": Canonical LR(1) - most powerful, largest tables\n   * @default \"lalr\"\n   */\n  type?: \"slr\" | \"lalr\" | \"lr1\";\n\n  /**\n   * Custom tokenizer function. If not provided, one is auto-generated\n   * from %token and inline token definitions in the grammar.\n   */\n  tokenizer?: TLEX.NextTokenFunc;\n\n  /**\n   * Enable debug output.\n   * - \"lexer\": Log tokenizer program\n   * - \"parser\": Log parse table and state transitions\n   * - \"all\": Log both lexer and parser\n   */\n  debug?: \"all\" | \"lexer\" | \"parser\" | string;\n\n  /**\n   * Use left recursion for EBNF expansions (*, +).\n   * @default true\n   */\n  leftRecursive?: boolean;\n\n  /**\n   * Prefix for auxiliary non-terminals created by EBNF expansions.\n   * @default \"$\"\n   */\n  auxNTPrefix?: string;\n\n  /**\n   * Custom token handlers for post-processing tokens.\n   */\n  tokenHandlers?: TSU.StringMap<TokenHandler>;\n}\n\n/**\n * Creates a parser from a grammar DSL string.\n *\n * This is the main entry point for creating parsers in Galore.\n *\n * @param input - Grammar definition in DSL format\n * @param params - Configuration options\n * @returns A tuple of [parser, tokenFunc, itemGraph]\n *   - parser: The LR parser instance\n *   - tokenFunc: The generated tokenizer (or null if custom provided)\n *   - itemGraph: The LR item graph (useful for debugging)\n *\n * @example\n * ```typescript\n * import { newParser } from \"galore\";\n *\n * const [parser, tokenFunc, itemGraph] = newParser(`\n *   %token NUMBER /[0-9]+/\n *   %skip /[ \\\\t\\\\n]+/\n *\n *   Expr -> Expr \"+\" Term | Term ;\n *   Term -> NUMBER ;\n * `, { type: \"lalr\" });\n *\n * const result = parser.parse(\"1 + 2\");\n * ```\n */\nexport function newLRParser(\n  input: string,\n  params: ParserOptions | null = null,\n): [Parser, null | TLEX.NextTokenFunc, LRItemGraph] {\n  const options = params || ({} as ParserOptions);\n  const [ptable, tokenFunc, itemGraph] = newParseTable(input, options);\n  const parser = new Parser(ptable);\n  if (options.tokenizer || tokenFunc) {\n    parser.setTokenizer(options.tokenizer || tokenFunc!);\n  }\n  const debug = options.debug || \"\";\n  if (debug.split(\"|\").findIndex((p: string) => p == \"all\" || p == \"parser\") >= 0) {\n    logParserDebug(parser, itemGraph);\n  }\n  return [parser, tokenFunc, itemGraph];\n}\n\n/**\n * Creates a parse table from a grammar DSL string without creating a parser.\n *\n * Useful when you need access to the parse table for analysis or visualization.\n *\n * @param input - Grammar definition in DSL format\n * @param params - Configuration options\n * @returns A tuple of [parseTable, tokenFunc, itemGraph]\n *\n * @example\n * ```typescript\n * import { newParseTable, Printers } from \"galore\";\n *\n * const [ptable, tokenFunc, itemGraph] = newParseTable(grammar, { type: \"lalr\" });\n *\n * // Check for conflicts\n * if (ptable.hasConflicts) {\n *   console.log(\"Conflicts:\", ptable.conflictActions);\n * }\n *\n * // Visualize the parse table\n * const html = Printers.parseTableToHtml(ptable, { itemGraph });\n * ```\n */\nexport function newParseTable(\n  input: string,\n  params: ParserOptions | null = null,\n): [ParseTable, null | TLEX.NextTokenFunc, LRItemGraph] {\n  const options = params || ({} as ParserOptions);\n  const [g, tokenFunc] = loadGrammar(input, options as any);\n  g.augmentStartSymbol();\n  const [ptable, itemGraph] = makeParseTable(g, options.type);\n  return [ptable, tokenFunc, itemGraph];\n}\n","import { Parser, LRAction, ParseTable } from \"./lr\";\nimport { LRItemGraph } from \"./lritems\";\n\nexport function logParserDebug(parser: Parser, itemGraph?: LRItemGraph): void {\n  const g = parser.grammar;\n  const ptable = parser.parseTable;\n  console.log(\n    \"===============================\\nGrammar (as default): \\n\",\n    g.debugValue.map((x, i) => `${i + 1}  -   ${x}`),\n    \"===============================\\nGrammar (as Bison): \\n\",\n    g.debugValue.map((x, i) => `${x.replace(\"->\", \":\")} ; \\n`).join(\"\"),\n    \"===============================\\nParseTable: \\n\",\n    JSON.stringify(mergedDebugValue(ptable, itemGraph), null, 4),\n    \"===============================\\nConflicts: \\n\",\n    ptable.conflictActions,\n  );\n}\n\nexport function mergedDebugValue(ptable: ParseTable, itemGraph?: LRItemGraph): any {\n  const merged = {} as any;\n  const ptabDV = ptable.debugValue;\n  const igDV = itemGraph?.debugValue;\n  for (const stateId in ptabDV) {\n    const actions = ptabDV[stateId];\n    if (itemGraph) {\n      const items = igDV[stateId];\n      merged[stateId] = { items: items[\"items\"], actions: actions, goto: items[\"goto\"] };\n    } else {\n      merged[stateId] = actions;\n    }\n  }\n  return merged;\n}\n"],"names":["root","factory","exports","module","define","amd","this","AtomChangeType","RoleChangeType","BlockItemChangeType","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Entity","constructor","config","TYPE","uuid","counter","_parent","_eventsEnabled","metadata","Error","enableEvents","disableEvents","eventsEnabled","parent","setParent","debugValue","type","toString","equals","another","expect","clone","out","newInstance","copyTo","TimedEntity","super","duration","assert","condition","msg","MAX_INT","Math","pow","TEvent","name","source","payload","_spawnedFrom","sourceState","cancelled","timeStamp","children","spawnedFrom","setSpawnedFrom","_rootEvent","rootEvent","spawn","child","push","State","stateData","id","enter","data","handle","event","EventEmitter","_eventHub","EventHub","eventHub","hub","oldHub","eventHubChanged","console","log","_handlers","_events","_inBatchMode","on","names","callback","_addHandler","removeOn","_removeHandler","_ensurestrings","split","map","v","trim","handlerlist","handler","forEach","evHandlers","i","length","splice","emit","evt","dispatchEvent","evtCallbacks","startBatchMode","cancelBatch","commitBatch","BATCH_EVENTS","ValueList","values","_firstChild","_lastChild","_size","pushBack","toJSON","Array","from","method","tmp","count","nextSibling","eqlFunc","size","first","tmp2","isEmpty","last","reversedValues","prevSibling","add","before","prev","pushFront","value","remove","next","popBack","popFront","Size","w","h","width","height","Rect","x","y","box","copy","union","minX","min","minY","maxX","max","maxY","unionAll","boxes","b","Browser","svgBBox","element","bbox","Geom","getBBox","IS_SAFARI","clientRect","getClientRects","parentClientRect","_a","parentElement","getBoundingClientRect","createSVGNode","nodename","ns","doc","document","attrs","text","createElementNS","createElement","appendChild","attr","setAttribute","textContent","createNode","gcdof","abs","t","IS_EXPLORER","navigator","userAgent","indexOf","IS_FIREFOX","IS_OPERA","toLowerCase","UAHasChrome","UAHasSafari","IS_CHROME","Fraction","num","den","factorized","isNaN","gcd","parse","val","parts","parseInt","isWhole","isZero","isInfinity","isOne","ceil","floor","plus","plusNum","minus","minusNum","times","timesNum","divby","divbyNum","numDivby","mod","d","floorOfD","modNum","inverse","equalsNum","cmp","cmpNum","isLT","isLTE","isLTNum","isLTENum","isGT","isGTE","isGTNum","isGTENum","f1","f2","ZERO","ONE","INFINITY","Frac","a","TSU","CycleCursor","cycle","barIndex","beatIndex","instance","currBar","bars","result","beatLengths","beatCounts","beatCount","Bar","bl","bc","assign","instanceCount","totalBeatCount","total","Cycle","p","getAtIndex","globalIndex","offset","bar","beatLength","getPosition","globalOffset","cycleNum","realOffset","barDuration","iterateBeats","startBar","startBeat","startInstance","instanceIndex","reduce","DEFAULT","AtomType","Atom","parentGroup","isContinuation","_duration","markersBefore","mbef","m","markersAfter","maft","LeafAtom","beforeRest","splitAt","spillOver","createSpilloverSpace","Space","Marker","isBefore","isSilent","Literal","embelishments","embs","e","Syllable","fromLit","lit","SYLLABLE","Note","octave","shift","NOTE","Group","atoms","durationIsSpeedMultiplier","_observers","addAtoms","addObserver","observer","removeObserver","index","notifyObservers","ADD","onAtomsAdded","INSERT","_b","onAtomsInserted","REMOVE","_c","onAtomsRemoved","a1","a2","atom","totalChildDuration","setDurationAsMultiplier","asSpeedMultiplier","setDuration","requiredDuration","targetGroup","remainingDur","durationFactor","lastChild","childDuration","newDuration","newRequiredDur","insertAtomsAt","removeAtoms","beforeAtom","adjustDuration","oldChildDuration","insertIndex","addedAtoms","REST","GROUP","LABEL","scaleFactor","removedAtoms","LayoutParams","beatDuration","_rowStartOffsets","_rowEndOffsets","_rowDurations","_totalLayoutDuration","_totalBeats","_beatLayouts","lineBreaks","layout","lineBreaksEqual","_lineBreaks","every","getBeatLocation","beat","modIndex","totalBeats","cursor","refreshLayout","beatLayouts","totalLayoutDuration","cycleIter","akb","numBeats","beats","nextCP","rd","GridModel","idCounter","lastUpdatedAt","rows","rowAligns","Map","colAligns","r","firstRow","gr","numCells","rowIndex","firstCol","minCol","fc","cellsInRow","row","cell","cells","cellsInCol","col","cellAt","addRowAlign","align","set","addColAlign","addRows","insertBefore","numRows","newRow","GridRow","defaultRowAlign","addSuccessor","getRow","setValue","cellCreator","grow","GridCell","clearCellAt","GridCellEvent","CLEARED","loc","location","oldValue","UPDATED","gridRow","colIndex","rowAlign","_rowAlign","addCell","colAlign","_colAlign","grid","c","coordOffset","maxLength","RowAlign","numCols","creator","filter","AlignedLine","needsLayout","_coordOffset","_maxLength","paddingBefore","paddingAfter","prevLines","nextLines","setMaxLength","setPadding","after","beforeAddingCell","removeCell","beforeRemovingCell","setOffset","cellView","getCellView","evalMaxLength","setBounds","changedCells","minSize","Beat","role","prevBeat","nextBeat","atomIsPlaceholder","endOffset","filled","remaining","preMarkers","curr","marker","postMarkers","allMinimalCycles","nodes","idFunc","edges","cycles","inACycle","node","startNode","visited","queue","newQueue","nextNode","edgeData","n","slice","defaultKeyFunc","IDSet","keyFunc","_entries","_entriesByKey","clear","predicate","e2","modified","l","entries","getByKey","ensure","entry","throwIfExists","has","SymbolSet","grammar","enforceSymbolType","Set","hasNull","debugString","labels","sort","join","skipAux","exp","getSymById","isAuxiliary","label","addFrom","includeNull","addTo","termid","term","isTerminal","delete","NullableSet","refresh","nonterms","beforeCount","allNonTerminals","nt","visit","rule","rulesForNT","isStrNullable","rhs","isNullable","str","fromIndex","toIndex","syms","SymSymbolSets","_count","forEachTerm","visitor","entriesFor","sym","addNull","srcEntries","destEntries","FirstSets","nullables","forEachTermIn","allNullable","j","symj","forEachRule","processRule","s","FollowSets","firstSets","g","startSymbol","Eof","Sym","auxType","precedence","assocLeft","creationId","compareTo","localeCompare","Str","append","lits","extend","strs","startIndex","endIndex","numToDelete","itemsToAdd","diff","containsAt","RuleAction","isFunction","isChildPosition","Rule","action","Grammar","make","symbolSet","allRules","_rulesForNT","_followSets","_hasNull","auxNTCount","auxNTPrefix","Null","newTerm","followSets","augStartRule","_AugStartRule","augmentStartSymbol","augSym","newNT","addRule","addTerminals","terminals","nonTerminals","auxNonTerminals","allSymbols","forEachNT","rules","getRule","getSym","findRule","production","findIndex","nonterm","ensureSym","removeRules","pred","removeSymbols","newRules","newRhs","sym2","T","NT","isNT","isAuxNT","seq","exps","normalizeRule","anyof","ensureAuxNT","opt","atleast0","leftRec","auxNT","findAuxNT","which","newAuxNT","atleast1","newAuxNTName","findAuxNTByRules","ntRules","print","options","ruleSep","includeSemiColon","lambdaSymbol","terminalDerivingSymbols","nadded","allDerive","reachableSymbols","fromSymbol","reachable","ruleIndex","leftRecursion","CharClassType","charCodeAt","NINE","lA","lZ","uA","uZ","USCORE","CharClassHelper","matches","charCode","neg","res","match","CharClassHelpers","reString","spaceChars","PropertyName","PropertyValue","RegexType","CharType","OpCode","Regex","groupIndex","groupName","groupIsSilent","ignoreCase","dotAll","multiline","setOptions","isVariable","evalREString","modifiers","StartOfInput","tag","START_OF_INPUT","reverse","EndOfInput","END_OF_INPUT","Assertion","expr","cond","negate","LookAhead","LOOK_AHEAD","LookBack","LOOK_BACK","Quant","minCount","maxCount","greedy","QUANT","isUnlimited","quant","Cat","CAT","Union","UNION","option","Char","op","CHAR","ch","matchChar","LeafChar","args","Any","AnyChar","Class","charClass","CharClass","Single","SingleChar","PropertyEscape","propNameOrId","propValueOrId","SyntaxError","PropertyEscapes","String","fromCharCode","replace","CharGroup","chars","CharRange","Intersection","Range","start","end","Var","reversed","VAR","BackNamedRef","BACK_NAMED_REF","BackRef","BackNumRef","BACK_NUM_REF","skip","priority","matchIndex","activeStates","stateCanActivate","state","needsSpecificStates","isNewLineChar","Match","groups","positions","Prog","startCondition","scIsInclusive","instrs","stateMapping","registerState","opcode","char","Instr","with","initializer","instrDebugValue","InstrDebugValue","instr","comment","Thread","gen","parentId","registers","regIncr","regId","regAcquire","regRelease","regValue","VM","getState","currState","setState","prog","forward","configs","threadCounter","currThreads","nextThreads","startPos","genForOffset","savePosition","thread","pos","tapeIndex","jumpBy","delta","jumpTo","newOffset","forkTo","startGroup","newThread","endGroup","addThread","list","tape","nextCh","lastCh","Jump","Split","newOff","Save","tracer","threadQueued","GroupStart","GroupEnd","StartingChar","MLStartingChar","prevCh","EndingChar","MLEndingChar","StartOfWord","EndOfWord","RBegin","groupStart","matchSuccess","matchEnd","recurseMatch","Begin","consume","EnsureState","states","matchCurrPos","currChCodeLower","currChCodeUpper","currChCode","hasMore","charAt","startMatching","bestMatch","stepChar","startOffset","savedPos","canAdvance","newPos","currMatch","nextMatch","stepThread","advance","threadStepped","advanceTape","End","currPriority","CIChar","AnyNonNL","currCh","Compiler","regexResolver","listener","emitGroups","emitPosition","compile","ensureInstr","ind","compileExpr","currOffset","compileChar","ml","START_OF_WORD","END_OF_WORD","compileCat","compileUnion","compileQuant","compileVar","compileBackNamedRef","compileBackNumRef","compileLookAhead","compileLookBack","cat","ne","jumps","jmp","compileAtleast0","compileAtleast1","compileOptional","l1","l3","l2","la","begin","lb","TokenizerError","message","setPrototypeOf","UnexpectedTokenError","foundToken","expectedTokens","TapeInterface","hasIndex","toUpperCase","charCodeAtLower","charCodeAtUpper","Tape","input","_rawInput","content","substring","TapeHelper","advanceAfter","pattern","ensureNoPrefixSlash","advanceTo","lastIndex","currStart","numSlashes","prefix","success","Token","lookahead","lookback","isOneOf","expected","tok","TokenBuffer","nextToken","tokenizerContext","buffer","peek","nth","matchFunc","nextAction","token","consumeIf","expectToken","ensureToken","nextMatches","GroupCounter","current","isSpace","RegexParser","unicode","reduceLeft","stack","throwError","refNum","gtPos","clPos","parseCharGroup","rest","parseGroup","parseQuant","nchars","parseChar","depth","subExpr","currch","endch","parseEscapeChar","parseSingleChar","parsePropertyEscape","clEnd","eqPos","propStr","propName","propValue","WORD_CHAR","DIGITS","SPACES","hexSeq","hexVal","ucodeSeq","ucodeVal","sub","advanceIf","ignoreSpaces","obCount","ignoreSpaces2","foundComma","p1","p2","part1","part2","foundEq","build","exprFromJSRE","exprFromFlexRE","parser","FlexREParser","error","re","isRegExp","JSREParser","flexRE","strings","keys","raw","BaseTokenizer","_prog","_vm","onError","onMatchHandlers","matchHandlersByValue","variables","compiler","findRuleByValue","getVar","addVar","regex","currValue","find","onMatch","Builder","sortedRules","sortRules","vm","r1","r2","Tokenizer","reset","owner","startChar","err","gi","toToken","tokenize","tokens","DefaultTape","SINGLE_QUOTE_STRING","DOUBLE_QUOTE_STRING","JS_REGEX","str2regex","TokenType","NodeType","LRActionType","Loader","leftRecursive","generatedTokenizer","TLEX","regexSyntax","symbolsByLabel","newSymbolCallback","tokenHandlers","symbolForLabel","registerSymbol","ensureSymbol","assumedTerminal","currSym","et","lexer","ARROW","OPEN_SQ","CLOSE_SQ","OPEN_PAREN","CLOSE_PAREN","OPEN_BRACE","CLOSE_BRACE","STAR","PLUS","QMARK","SEMI_COLON","COLON","PIPE","COMMENT","STRING","REGEX","flags","NUMBER","PCT_IDENT","DOLLAR_NUM","DOLLAR_IDENT","IDENT","tokenizer","ntFunc","parseGrammar","parseRegex","syntax","tokPattern","RegExp","patternStr","peeked","parseDecl","parseDirective","directive","startsWith","endsWith","tokenHandler","parseTokenHandler","isDef","tokName","funcName","ident","parseProductions","parseProd","PFNode","childCount","childAt","reprString","PTNode","ParserBase","setTokenizer","tokenbuffer","SimpleParser","delegate","parseInput","ParseError","LRAction","gotoState","ACCEPT","SHIFT","REDUCE","Shift","goto","Reduce","Goto","GOTO","Accept","ParseTable","conflictActions","actions","hasConflicts","getActions","stateId","addAction","ac","fromId","symId","ParseStack","stateStack","nodeStack","top","pop","popN","L","Parser","parseTable","context","buildParseTree","copySingleChild","output","resolveActions","actionResolver","onTokenError","onNextToken","nextSym","nextValue","topState","topNode","newNode","ruleLen","childNode","beforeAddingChildNode","handlerName","ruleHandlers","onReduction","newAction","LRItem","position","pre","post","LRItemSet","ig","_key","_lookaheads","_hasLookAheads","itemGraph","addLookAhead","item","s1","s2","clearLookAheads","getLookAheads","revalKey","hasLookAheads","itemId","items","i1","i2","las","LRItemGraph","gotoSets","itemSets","startItem","startSet","evalGotoSets","currSet","gotoSet","setGoto","itemSet","newItemSet","advanceItemAndAdd","closure","itemToAdvance","fromItemSet","toItemSet","newItem","laSym","ensureGotoSet","fromSet","toSet","getGoto","forEachGoto","symid","gotoSetFor","iset","LR0ItemGraph","newset","LR1ItemGraph","B","suffix","bRules","br","makeSLRParseTable","evalLASetsForSLRItem","makeSLRAutomaton","makeParseTableFromLA","nextSet","lookaheads","lr1Item","evalLASetsForLALRItem","augGrammar","prevSets","findP","prevStates","nextState","pSet","pALabel","pA","ALIAS","Symbol","for","DOC","MAP","PAIR","SCALAR","SEQ","NODE_TYPE","isAlias","isDocument","isMap","isPair","isScalar","isSeq","isCollection","isNode","hasAnchor","anchor","BREAK","SKIP","visitor_","initVisitor","visit_","contents","freeze","path","ctrl","callVisitor","replaceNode","concat","ci","ck","cv","async","visitAsync","visitAsync_","Collection","Node","Value","Alias","Scalar","Seq","Pair","pt","escapeChars","escapeTagName","tn","Directives","yaml","tags","docStart","docEnd","defaultYaml","defaultTags","atDocument","version","atNextDocument","explicit","line","test","tagName","verbatim","decodeURIComponent","tagString","lines","tagEntries","tagNames","some","anchorIsValid","sa","JSON","stringify","applyReviver","reviver","isArray","len","v0","v1","undefined","k","toJS","arg","ctx","aliasCount","anchors","onCreate","keep","Number","NodeBase","create","getPrototypeOf","getOwnPropertyDescriptors","range","mapAsMap","maxAliasCount","onAnchor","TypeError","mapKeyWarned","resolve","found","aliasResolveCache","_arg","ReferenceError","getAliasCount","_onComment","_onChompKeep","src","verifyAliasOrder","implicitKey","kc","vc","isScalarValue","schema","Boolean","BigInt","valueOf","aliasDuplicateObjects","onTagObj","sourceObjects","ref","tagObj","format","identify","findTagObject","iterator","nodeClass","default","collectionFromPath","isInteger","keepUndefined","BLOCK_FOLDED","BLOCK_LITERAL","PLAIN","QUOTE_DOUBLE","QUOTE_SINGLE","configurable","writable","it","addIn","done","isEmptyPath","deleteIn","getIn","keepScalar","hasAllNullValues","allowScalar","commentBefore","hasIn","setIn","stringifyComment","indentComment","indent","lineComment","includes","FOLD_FLOW","FOLD_BLOCK","FOLD_QUOTED","foldFlowLines","mode","indentAtStart","lineWidth","minContentWidth","onFold","onOverflow","endStep","folds","escapedFolds","overflow","escStart","escEnd","consumeMoreIndentedLines","fold","getFoldOptions","isBlock","containsDocumentMarker","doubleQuotedString","json","doubleQuotedAsJSON","minMultiLineLength","doubleQuotedMinMultiLineLength","code","substr","singleQuotedString","singleQuote","quotedString","qs","hasDouble","hasSingle","blockEndNewlines","blockString","onComment","onChompKeep","blockQuote","commentString","forceBlockIndent","literal","indentLength","limit","strLen","lineLengthOverLimit","chomp","endStart","endNlPos","startEnd","startWithSpace","startNlPos","header","foldedValue","literalFallback","foldOptions","body","stringifyString","inFlow","ss","_stringify","_type","actualString","indentStep","compat","plainString","defaultKeyType","defaultStringType","directives","resolvedAliases","testMatch","getTagObject","props","stringifyProps","MERGE_KEY","merge","description","addToJSMap","addMergeToJSMap","mergeValue","srcMap","addPairToJSMap","isMergeKey","jsKey","stringKey","strCtx","falseStr","flowCollectionPadding","indentSeq","nullStr","simpleKeys","trueStr","toStringOptions","collectionStyle","repeat","createStringifyContext","inStringifyKey","strKey","jsonStr","warning","logLevel","warn","stringifyKey","jsValue","createPair","_","allNullValues","keyComment","explicitKey","vsb","vcb","valueComment","keyCommentDone","chompKeep","spaceBefore","flow","valueCommentDone","valueStr","ws","vs0","nl0","hasNewline","hasPropsLine","sp0","stringifyPair","stringifyCollection","collection","stringifyFlowCollection","stringifyBlockCollection","blockItemPrefix","flowChars","itemIndent","itemCtx","addCommentBefore","ik","fcPadding","reqNewline","linesAtValue","iv","sum","ic","trimStart","findPair","YAMLMap","replacer","sortMapEntries","pair","overwrite","_pair","sortEntries","Type","YAMLSeq","idx","asItemIndex","string","nullTag","boolTag","stringifyNumber","minFractionDigits","isFinite","is","floatNaN","NaN","NEGATIVE_INFINITY","POSITIVE_INFINITY","floatExp","parseFloat","toExponential","intIdentify","intResolve","radix","intAsBigInt","intStringify","_onError","dot","stringifyJSON","binary","Uint8Array","atob","buf","btoa","resolvePairs","cn","createPairs","iterable","pairs","YAMLOMap","bind","omap","seenKeys","boolStringify","trueTag","falseTag","float","f","sign","intBin","intOct","int","intHex","YAMLSet","keepPair","parseSexagesimal","asBigInt","stringifySexagesimal","_60","unshift","padStart","intTime","floatTime","timestamp","Date","year","month","day","hour","minute","second","millisec","date","UTC","tz","toISOString","schema$1","schema$2","cst","_visit","field","GamakaType","itemAtPath","parentCollection","coll","Shape","shapeId","_x","_y","_width","_height","parentShape","_bbox","refreshBBox","_minSize","refreshMinSize","invalidateBounds","applyLayout","nx","ny","nw","nh","updateBounds","hasX","hasY","hasWidth","hasHeight","Embelishment","ElementShape","AtomView","roleIndex","glyphOffset","LeafAtomView","leafAtom","isLeaf","viewId","totalDuration","GroupView","group","atomViews","defaultToNotes","showContinuationMarkers","continuationMarkerElements","contentWidth","atomSpacing","setStyles","createElements","groupElement","class","atomView","createAtomView","maxHeight","minWidthPerDuration","av","ms","dur","durValue","widthPerDur","totalDurValue","totalWidth","transform","unscaledContentHeight","currY","totalDur","unscaledMinWidth","groupWidth","clearContinuationMarkers","currTime","prevNoteEndX","realX","avWidth","atomDur","numMarkers","markerX","renderContinuationMarker","el","_embelishments","createEmbelishments","LeafAtomViewEmbelishment","OctaveIndicator","noteView","note","dotRadius","dotSpacing","rootElem","embRoot","numDots","dotsElem","cx","cy","_w","_h","LabelEmbelishment","labelElem","Kampitham","Nokku","Prathyagatham","Spuritham","Raavi","Kandippu","Vaali","Odukkal","Orikkai","Jaaru","jaaru","pathElem","pathAttribute","avbbox","glyph","y2","h2","x2","ascending","GroupBracket","groupView","leftCircle","rightCircle","bracketGroup","lineOffset","circleRadius","lineExtension","positionMode","x1","GroupViewBase","litDefaultsToNote","groupViewScale","SPACE","SpaceView","SyllableView","NoteView","LITERAL","baseSize","BRACKET_HEIGHT","LeafAtomViewBase","leftSlot","topSlot","rightSlot","bottomSlot","rootGroup","rootText","totalHeight","layoutElements","currX","emb","textX","gminSize","glyphX","glyphY","bb","addEmbelishment","slot","orderEmbelishments","Aahaatam_Raavi","Aahaatam_Kandippu","Jaaru_Eetra","Jaaru_Irakka","needsRootElement","createGlyphRoot","createGlyphElement","createPostSpacingElement","atomid","glyphLabel","postSpacingSpan","space","shiftElement","moveGlyphToRoot","syllable","params","ptable","tokenFunc","eparser","debug","loadGrammar","makeLRParseTable","g2","ensureG2Sym","pi","newSymLabel","newSym","startState","transitions","buildRuleFrom","A","newSyms","xi","startSym","newA","newRHS","newRule","grammarFromLR0ItemGraph","makeLALRParseTable","makeParseTable","newParseTable","merged","ptabDV","igDV","mergedDebugValue","logParserDebug","G","toEmbelishment","parseEmbelishment","errors","toCommandName","_tape","_owner","toBoolean","toNumber","toMarker","markerText","toOctavedNote","toRoleSelector","toLineAnnotation","toSingleLineRawString","toMultiLineRawString","endPat","endPos","toFrontMatter"],"ignoreList":[],"sourceRoot":""}